Index: .hgignore
===================================================================
--- .hgignore	(revision 944)
+++ .hgignore	(revision 610)
@@ -23,5 +23,4 @@
 lemon/stamp-h2
 doc/Doxyfile
-doc/references.dox
 cmake/version.cmake
 .dirstamp
Index: AUTHORS
===================================================================
--- AUTHORS	(revision 1148)
+++ AUTHORS	(revision 320)
@@ -1,3 +1,3 @@
-The main developers of release series 1.x are
+The authors of the 1.x series are
 
  * Balazs Dezso <deba@inf.elte.hu>
@@ -6,9 +6,9 @@
  * Akos Ladanyi <ladanyi@tmit.bme.hu>
 
-For more complete list of contributors, please visit the history of
-the LEMON source code repository: http://lemon.cs.elte.hu/hg/lemon
+For more details on the actual contribution, please visit the history
+of the main LEMON source repository: http://lemon.cs.elte.hu/hg/lemon
 
-Moreover, this version is heavily based on version 0.x of LEMON. Here
-is the list of people who contributed to those versions.
+Moreover, this version is heavily based on the 0.x series of
+LEMON. Here is the list of people who contributed to those versions.
 
  * Mihaly Barasz <klao@cs.elte.hu>
@@ -24,3 +24,3 @@
 
 Again, please visit the history of the old LEMON repository for more
-details: http://lemon.cs.elte.hu/hg/lemon-0.x
+details: http://lemon.cs.elte.hu/svn/lemon/trunk
Index: CMakeLists.txt
===================================================================
--- CMakeLists.txt	(revision 1346)
+++ CMakeLists.txt	(revision 791)
@@ -1,22 +1,6 @@
-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")
 PROJECT(${PROJECT_NAME})
-
-INCLUDE(FindPythonInterp)
-INCLUDE(FindWget)
 
 IF(EXISTS ${PROJECT_SOURCE_DIR}/cmake/version.cmake)
@@ -26,44 +10,13 @@
 ELSE()
   EXECUTE_PROCESS(
-    COMMAND
-    hg log -r. --template "{latesttag}"
+    COMMAND hg id -i
     WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
-    OUTPUT_VARIABLE HG_REVISION_TAG
+    OUTPUT_VARIABLE HG_REVISION
     ERROR_QUIET
     OUTPUT_STRIP_TRAILING_WHITESPACE
   )
-  EXECUTE_PROCESS(
-    COMMAND
-    hg log -r. --template "{latesttagdistance}"
-    WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
-    OUTPUT_VARIABLE HG_REVISION_DIST
-    ERROR_QUIET
-    OUTPUT_STRIP_TRAILING_WHITESPACE
-  )
-  EXECUTE_PROCESS(
-    COMMAND
-    hg log -r. --template "{node|short}"
-    WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
-    OUTPUT_VARIABLE HG_REVISION_ID
-    ERROR_QUIET
-    OUTPUT_STRIP_TRAILING_WHITESPACE
-  )
-
-  IF(HG_REVISION_TAG STREQUAL "")
-    SET(HG_REVISION_ID "hg-tip")
-  ELSE()
-    IF(HG_REVISION_TAG STREQUAL "null")
-      SET(HG_REVISION_TAG "trunk")
-    ELSEIF(HG_REVISION_TAG MATCHES "^r")
-      STRING(SUBSTRING ${HG_REVISION_TAG} 1 -1 HG_REVISION_TAG)
-    ENDIF()
-    IF(HG_REVISION_DIST STREQUAL "0")
-      SET(HG_REVISION ${HG_REVISION_TAG})
-    ELSE()
-      SET(HG_REVISION
-	"${HG_REVISION_TAG}+${HG_REVISION_DIST}-${HG_REVISION_ID}")
-    ENDIF()
+  IF(HG_REVISION STREQUAL "")
+    SET(HG_REVISION "hg-tip")
   ENDIF()
-
   SET(LEMON_VERSION ${HG_REVISION} CACHE STRING "LEMON version string.")
 ENDIF()
@@ -75,172 +28,7 @@
 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.")
-SET(LEMON_ENABLE_ILOG YES CACHE STRING "Enable ILOG (CPLEX) solver backend.")
-SET(LEMON_ENABLE_COIN YES CACHE STRING "Enable COIN solver backend.")
-SET(LEMON_ENABLE_SOPLEX YES CACHE STRING "Enable SoPlex solver backend.")
-
-IF(LEMON_ENABLE_GLPK) 
-  FIND_PACKAGE(GLPK 4.33)
-ENDIF(LEMON_ENABLE_GLPK)
-IF(LEMON_ENABLE_ILOG)
-  FIND_PACKAGE(ILOG)
-ENDIF(LEMON_ENABLE_ILOG)
-IF(LEMON_ENABLE_COIN)
-  FIND_PACKAGE(COIN)
-ENDIF(LEMON_ENABLE_COIN)
-IF(LEMON_ENABLE_SOPLEX)
-  FIND_PACKAGE(SOPLEX)
-ENDIF(LEMON_ENABLE_SOPLEX)
-
-IF(GLPK_FOUND)
-  SET(LEMON_HAVE_LP TRUE)
-  SET(LEMON_HAVE_MIP TRUE)
-  SET(LEMON_HAVE_GLPK TRUE)
-ENDIF(GLPK_FOUND)
-IF(ILOG_FOUND)
-  SET(LEMON_HAVE_LP TRUE)
-  SET(LEMON_HAVE_MIP TRUE)
-  SET(LEMON_HAVE_CPLEX TRUE)
-ENDIF(ILOG_FOUND)
-IF(COIN_FOUND)
-  SET(LEMON_HAVE_LP TRUE)
-  SET(LEMON_HAVE_MIP TRUE)
-  SET(LEMON_HAVE_CLP TRUE)
-  SET(LEMON_HAVE_CBC TRUE)
-ENDIF(COIN_FOUND)
-IF(SOPLEX_FOUND)
-  SET(LEMON_HAVE_LP TRUE)
-  SET(LEMON_HAVE_SOPLEX TRUE)
-ENDIF(SOPLEX_FOUND)
-
-IF(ILOG_FOUND)
-  SET(DEFAULT_LP "CPLEX")
-  SET(DEFAULT_MIP "CPLEX")
-ELSEIF(COIN_FOUND)
-  SET(DEFAULT_LP "CLP")
-  SET(DEFAULT_MIP "CBC")
-ELSEIF(GLPK_FOUND)
-  SET(DEFAULT_LP "GLPK")
-  SET(DEFAULT_MIP "GLPK")
-ELSEIF(SOPLEX_FOUND)
-  SET(DEFAULT_LP "SOPLEX")
-ENDIF()
-
-IF(NOT LEMON_DEFAULT_LP OR
-    (NOT ILOG_FOUND AND (LEMON_DEFAULT_LP STREQUAL "CPLEX")) OR
-    (NOT COIN_FOUND AND (LEMON_DEFAULT_LP STREQUAL "CLP")) OR
-    (NOT GLPK_FOUND AND (LEMON_DEFAULT_LP STREQUAL "GLPK")) OR
-    (NOT SOPLEX_FOUND AND (LEMON_DEFAULT_LP STREQUAL "SOPLEX")))
-  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
-    (NOT ILOG_FOUND AND (LEMON_DEFAULT_MIP STREQUAL "CPLEX")) OR
-    (NOT COIN_FOUND AND (LEMON_DEFAULT_MIP STREQUAL "CBC")) OR
-    (NOT GLPK_FOUND AND (LEMON_DEFAULT_MIP STREQUAL "GLPK")))
-  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()
-
-
-IF(DEFINED ENV{LEMON_CXX_WARNING})
-  SET(CXX_WARNING $ENV{LEMON_CXX_WARNING})
-ELSE()
-  IF(CMAKE_COMPILER_IS_GNUCXX)
-    SET(CXX_WARNING "-Wall -W -Wunused -Wformat=2 -Wctor-dtor-privacy -Wnon-virtual-dtor -Wno-char-subscripts -Wwrite-strings -Wno-char-subscripts -Wreturn-type -Wcast-qual -Wcast-align -Wsign-promo -Woverloaded-virtual -fno-strict-aliasing -Wold-style-cast -Wno-unknown-pragmas")
-    SET(CMAKE_CXX_FLAGS_DEBUG CACHE STRING "-ggdb")
-    SET(CMAKE_C_FLAGS_DEBUG CACHE STRING "-ggdb")
-  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")
-
-    # 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
-    # C4800: 'type' : forcing value to bool 'true' or 'false'
-    #        (performance warning)
-    # C4996: 'function': was declared deprecated
-  ELSE()
-    SET(CXX_WARNING "-Wall")
-  ENDIF()
-ENDIF()
-SET(LEMON_CXX_WARNING_FLAGS ${CXX_WARNING} CACHE STRING "LEMON warning flags.")
-
-SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${LEMON_CXX_WARNING_FLAGS}")
-
-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."
-    )
-  SET( CMAKE_C_FLAGS_MAINTAINER "/WX ${CMAKE_CXX_FLAGS_DEBUG}" CACHE STRING
-    "Flags used by the C compiler during maintainer builds."
-    )
-  SET( CMAKE_EXE_LINKER_FLAGS_MAINTAINER
-    "${CMAKE_EXE_LINKER_FLAGS_DEBUG}" CACHE STRING
-    "Flags used for linking binaries during maintainer builds."
-    )
-  SET( CMAKE_SHARED_LINKER_FLAGS_MAINTAINER
-    "${CMAKE_SHARED_LINKER_FLAGS_DEBUG}" CACHE STRING
-    "Flags used by the shared libraries linker during maintainer builds."
-    )
-ELSE()
-  SET( CMAKE_CXX_FLAGS_MAINTAINER "-Werror -ggdb -O0" CACHE STRING
-    "Flags used by the C++ compiler during maintainer builds."
-    )
-  SET( CMAKE_C_FLAGS_MAINTAINER "-Werror -O0" CACHE STRING
-    "Flags used by the C compiler during maintainer builds."
-    )
-  SET( CMAKE_EXE_LINKER_FLAGS_MAINTAINER
-    "${CMAKE_EXE_LINKER_FLAGS_DEBUG}" CACHE STRING
-    "Flags used for linking binaries during maintainer builds."
-    )
-  SET( CMAKE_SHARED_LINKER_FLAGS_MAINTAINER
-    "${CMAKE_SHARED_LINKER_FLAGS_DEBUG}" CACHE STRING
-    "Flags used by the shared libraries linker during maintainer builds."
-    )
-ENDIF()
-
-MARK_AS_ADVANCED(
-    CMAKE_CXX_FLAGS_MAINTAINER
-    CMAKE_C_FLAGS_MAINTAINER
-    CMAKE_EXE_LINKER_FLAGS_MAINTAINER
-    CMAKE_SHARED_LINKER_FLAGS_MAINTAINER )
-
-IF(CMAKE_CONFIGURATION_TYPES)
-  LIST(APPEND CMAKE_CONFIGURATION_TYPES Maintainer)
-  LIST(REMOVE_DUPLICATES CMAKE_CONFIGURATION_TYPES)
-  SET(CMAKE_CONFIGURATION_TYPES "${CMAKE_CONFIGURATION_TYPES}" CACHE STRING
-      "Add the configurations that we need"
-      FORCE)
- endif()
-
-IF(NOT CMAKE_BUILD_TYPE)
-  SET(CMAKE_BUILD_TYPE "Release")
-ENDIF()
-
-SET( CMAKE_BUILD_TYPE "${CMAKE_BUILD_TYPE}" CACHE STRING
-    "Choose the type of build, options are: None(CMAKE_CXX_FLAGS or CMAKE_C_FLAGS used) Debug Release RelWithDebInfo MinSizeRel Maintainer."
-    FORCE )
-
-SET_DIRECTORY_PROPERTIES(PROPERTIES
-  COMPILE_DEFINITIONS_DEBUG "LEMON_ENABLE_DEBUG"
-  COMPILE_DEFINITIONS_MAINTAINER "LEMON_ENABLE_DEBUG"
-)
+FIND_PACKAGE(GLPK 4.33)
+FIND_PACKAGE(CPLEX)
+FIND_PACKAGE(COIN)
 
 INCLUDE(CheckTypeSize)
@@ -248,45 +36,10 @@
 SET(LEMON_HAVE_LONG_LONG ${HAVE_LONG_LONG})
 
-INCLUDE(FindThreads)
-
-IF(NOT LEMON_THREADING)
-  IF(CMAKE_USE_PTHREADS_INIT)
-    SET(LEMON_THREADING "Pthread")
-  ELSEIF(CMAKE_USE_WIN32_THREADS_INIT)
-    SET(LEMON_THREADING "Win32")
-  ELSE()
-    SET(LEMON_THREADING "None")
-  ENDIF()
-ENDIF()
-
-SET( LEMON_THREADING "${LEMON_THREADING}" CACHE STRING
-  "Choose the threading library, options are: Pthread Win32 None."
-  FORCE )
-
-IF(LEMON_THREADING STREQUAL "Pthread")
-  SET(LEMON_USE_PTHREAD TRUE)
-ELSEIF(LEMON_THREADING STREQUAL "Win32")
-  SET(LEMON_USE_WIN32_THREADS TRUE)
-ENDIF()
+INCLUDE(FindPythonInterp)
 
 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")
-  ADD_CUSTOM_TARGET(check ALL COMMAND ${CMAKE_CTEST_COMMAND})
-ELSE()
-  ADD_CUSTOM_TARGET(check COMMAND ${CMAKE_CTEST_COMMAND})
-ENDIF()
-
 ADD_SUBDIRECTORY(lemon)
 IF(${CMAKE_SOURCE_DIR} STREQUAL ${PROJECT_SOURCE_DIR})
-  ADD_SUBDIRECTORY(contrib)
   ADD_SUBDIRECTORY(demo)
   ADD_SUBDIRECTORY(tools)
@@ -312,32 +65,5 @@
 ENDIF()
 
-CONFIGURE_FILE(
-  ${PROJECT_SOURCE_DIR}/cmake/version.cmake.in
-  ${PROJECT_BINARY_DIR}/cmake/version.cmake
-  @ONLY
-)
-
-SET(ARCHIVE_BASE_NAME ${CMAKE_PROJECT_NAME})
-STRING(TOLOWER ${ARCHIVE_BASE_NAME} ARCHIVE_BASE_NAME)
-SET(ARCHIVE_NAME ${ARCHIVE_BASE_NAME}-${PROJECT_VERSION})
-ADD_CUSTOM_TARGET(dist
-  COMMAND cmake -E remove_directory ${ARCHIVE_NAME}
-  COMMAND hg archive ${ARCHIVE_NAME}
-  COMMAND cmake -E copy cmake/version.cmake ${ARCHIVE_NAME}/cmake/version.cmake
-  COMMAND tar -czf ${ARCHIVE_BASE_NAME}-nodoc-${PROJECT_VERSION}.tar.gz ${ARCHIVE_NAME}
-  COMMAND zip -r ${ARCHIVE_BASE_NAME}-nodoc-${PROJECT_VERSION}.zip ${ARCHIVE_NAME}
-  COMMAND cmake -E copy_directory doc/html ${ARCHIVE_NAME}/doc/html
-  COMMAND tar -czf ${ARCHIVE_NAME}.tar.gz ${ARCHIVE_NAME}
-  COMMAND zip -r ${ARCHIVE_NAME}.zip ${ARCHIVE_NAME}
-  COMMAND cmake -E copy_directory doc/html ${ARCHIVE_BASE_NAME}-doc-${PROJECT_VERSION}
-  COMMAND tar -czf ${ARCHIVE_BASE_NAME}-doc-${PROJECT_VERSION}.tar.gz ${ARCHIVE_BASE_NAME}-doc-${PROJECT_VERSION}
-  COMMAND zip -r ${ARCHIVE_BASE_NAME}-doc-${PROJECT_VERSION}.zip ${ARCHIVE_BASE_NAME}-doc-${PROJECT_VERSION}
-  COMMAND cmake -E remove_directory ${ARCHIVE_NAME}
-  COMMAND cmake -E remove_directory ${ARCHIVE_BASE_NAME}-doc-${PROJECT_VERSION}
-  DEPENDS html
-  WORKING_DIRECTORY ${PROJECT_BINARY_DIR})
-
-# CPACK config (Basically for NSIS)
-IF(${CMAKE_SOURCE_DIR} STREQUAL ${PROJECT_SOURCE_DIR})
+IF(${CMAKE_SOURCE_DIR} STREQUAL ${PROJECT_SOURCE_DIR} AND WIN32)
   SET(CPACK_PACKAGE_NAME ${PROJECT_NAME})
   SET(CPACK_PACKAGE_VENDOR "EGRES")
Index: INSTALL
===================================================================
--- INSTALL	(revision 1233)
+++ INSTALL	(revision 615)
@@ -2,166 +2,174 @@
 =========================
 
-This file contains instructions for building and installing LEMON from
-source on Linux. The process on Windows is similar.
+Since you are reading this I assume you already obtained one of the release
+tarballs and successfully extracted it. The latest version of LEMON is
+available at our web page (http://lemon.cs.elte.hu/).
 
-Note that it is not necessary to install LEMON in order to use
-it. Instead, you can easily integrate it with your own code
-directly. For instructions, see
-https://lemon.cs.elte.hu/trac/lemon/wiki/HowToCompile
-
+LEMON provides two different build environments, one is based on "autotool",
+while the other is based on "cmake". This file contains instructions only for
+the former one, which is the recommended build environment on Linux, Mac OSX
+and other unices or if you use Cygwin on Windows. For cmake installation
+instructions visit http://lemon.cs.elte.hu.
 
 In order to install LEMON from the extracted source tarball you have to
 issue the following commands:
 
-   1. Step into the root of the source directory.
+   1. `cd lemon-x.y.z'
 
-      $ cd lemon-x.y.z
+      This command changes to the directory which was created when you
+      extracted the sources. The x.y.z part is a version number.
 
-   2. Create a build subdirectory and step into it.
+   2. `./configure'
 
-      $ mkdir build
-      $ cd build
+      This command runs the configure shell script, which does some checks and
+      creates the makefiles.
 
-   3. Perform system checks and create the makefiles.
+   3. `make'
 
-      $ cmake ..
+      This command compiles the non-template part of LEMON into libemon.a
+      file. It also compiles the programs in the tools subdirectory by
+      default.
 
-   4. Build LEMON.
+   4. `make check'
 
-      $ make 
+      This step is optional, but recommended. It runs the test programs that
+      we developed for LEMON to check whether the library works properly on
+      your platform.
 
-      This command compiles the non-template part of LEMON into
-      libemon.a file. It also compiles the programs in the 'tools' and
-      'demo' subdirectories.
-
-   5. [Optional] Compile and run the self-tests.
-
-      $ make check
-
-   5. [Optional] Generate the user documentation.
-
-      $ make html
-
-      The release tarballs already include the documentation.
-
-      Note that for this step you need to have the following tools
-      installed: Python, Doxygen, Graphviz, Ghostscript, LaTeX.
-
-   6. [Optional] Install LEMON
-
-      $ make install
+   5. `make install'
 
       This command installs LEMON under /usr/local (you will need root
-      privileges to be able to do that). If you want to install it to
-      some other location, then pass the
-      -DCMAKE_INSTALL_PREFIX=DIRECTORY flag to cmake in Step 3.
-      For example:
-      
-      $ cmake -DCMAKE_INSTALL_PREFIX=/home/username/lemon'
+      privileges to be able to do that). If you want to install it to some
+      other location, then pass the --prefix=DIRECTORY flag to configure in
+      step 2. For example: `./configure --prefix=/home/username/lemon'.
+
+   6. `make install-html'
+
+      This command installs the documentation under share/doc/lemon/docs. The
+      generated documentation is included in the tarball. If you want to
+      generate it yourself, then run `make html'. Note that for this you need
+      to have the following programs installed: Doxygen, Graphviz, Ghostscript,
+      Latex.
+
 
 Configure Options and Variables
 ===============================
 
-In Step 3, you can customize the build process by passing options to CMAKE.
+In step 2 you can customize the actions of configure by setting variables
+and passing options to it. This can be done like this:
+`./configure [OPTION]... [VARIABLE=VALUE]...'
 
-$ cmake [OPTIONS] ..
+Below you will find some useful variables and options (see `./configure --help'
+for more):
 
-You find a list of the most useful options below.
+CXX='comp'
 
--DCMAKE_INSTALL_PREFIX=PREFIX
+  Change the C++ compiler to 'comp'.
+
+CXXFLAGS='flags'
+
+  Pass the 'flags' to the compiler. For example CXXFLAGS='-O3 -march=pentium-m'
+  turns on generation of aggressively optimized Pentium-M specific code.
+
+--prefix=PREFIX
 
   Set the installation prefix to PREFIX. By default it is /usr/local.
 
--DCMAKE_BUILD_TYPE=[Release|Debug|Maintainer|...]
+--enable-tools
 
-  This sets the compiler options. The choices are the following
+   Build the programs in the tools subdirectory (default).
 
-  'Release': A strong optimization is turned on (-O3 with gcc). This
-    is the default setting and we strongly recommend using this for
-    the final compilation.
+--disable-tools
 
-  'Debug': Optimization is turned off and debug info is added (-O0
-    -ggdb with gcc). If is recommended during the development.
+   Do not build the programs in the tools subdirectory.
 
-  'Maintainer': The same as 'Debug' but the compiler warnings are
-    converted to errors (-Werror with gcc). In addition, 'make' will
-    also automatically compile and execute the test codes. It is the
-    best way of ensuring that LEMON codebase is clean and safe.
+--with-glpk[=PREFIX]
 
-  'RelWithDebInfo': Optimized build with debug info.
+   Enable GLPK support (default). You should specify the prefix too if
+   you installed GLPK to some non-standard location (e.g. your home
+   directory). If it is not found, GLPK support will be disabled.
 
-  'MinSizeRel': Size optimized build (-Os with gcc)
+--with-glpk-includedir=DIR
 
--DTEST_WITH_VALGRIND=YES
+   The directory where the GLPK header files are located. This is only
+   useful when the GLPK headers and libraries are not under the same
+   prefix (which is unlikely).
 
-  Using this, the test codes will be executed using valgrind. It is a
-  very effective way of identifying indexing problems and memory leaks.
+--with-glpk-libdir=DIR
 
--DCMAKE_CXX_COMPILER=path-to-compiler
+   The directory where the GLPK libraries are located. This is only
+   useful when the GLPK headers and libraries are not under the same
+   prefix (which is unlikely).
 
-  Change the compiler to be used.
+--without-glpk
 
--DBUILD_SHARED_LIBS=TRUE
+   Disable GLPK support.
 
-  Build shared library instead of static one. Think twice if you
-  really want to use this option.
+--with-cplex[=PREFIX]
 
--DLEMON_DOC_SOURCE_BROWSER=YES
+   Enable CPLEX support (default). You should specify the prefix too
+   if you installed CPLEX to some non-standard location
+   (e.g. /opt/ilog/cplex75). If it is not found, CPLEX support will be
+   disabled.
 
-  Include the browsable cross referenced LEMON source code into the
-  doc. It makes the doc quite bloated, but may be useful for
-  developing LEMON itself.
+--with-cplex-includedir=DIR
 
--DLEMON_DOC_USE_MATHJAX=YES
+   The directory where the CPLEX header files are located. This is
+   only useful when the CPLEX headers and libraries are not under the
+   same prefix (e.g.  /usr/local/cplex/cplex75/include).
 
-  Use MathJax (http://mathjax.org) for rendering the math formulae in
-  the doc.  It of much higher quality compared to the default LaTeX
-  generated static images and it allows copy&paste of the formulae to
-  LaTeX, Open Office, MS Word etc. documents.
+--with-cplex-libdir=DIR
 
-  On the other hand, it needs either Internet access or a locally
-  installed version of MathJax to properly render the doc.
+   The directory where the CPLEX libraries are located. This is only
+   useful when the CPLEX headers and libraries are not under the same
+   prefix (e.g.
+   /usr/local/cplex/cplex75/lib/i86_linux2_glibc2.2_gcc3.0/static_pic_mt).
 
--DLEMON_DOC_MATHJAX_RELPATH=DIRECTORY
-  
-  The location of the MathJax library. It defaults to
-  http://www.mathjax.org/mathjax, which necessitates Internet access
-  for proper rendering. The easiest way to make it usable offline is
-  to set this parameter to 'mathjax' and copy all files of the MathJax
-  library into the 'doc/html/mathjax' subdirectory of the build
-  location.
+--without-cplex
 
-  See http://docs.mathjax.org/en/latest/installation.html for more details.
+   Disable CPLEX support.
 
-  
--DLEMON_ENABLE_GLPK=NO
--DLEMON_ENABLE_COIN=NO
--DLEMON_ENABLE_ILOG=NO
+--with-soplex[=PREFIX]
 
-  Enable optional third party libraries. They are all enabled by default. 
+   Enable SoPlex support (default). You should specify the prefix too if
+   you installed SoPlex to some non-standard location (e.g. your home
+   directory). If it is not found, SoPlex support will be disabled.
 
--DLEMON_DEFAULT_LP=GLPK
+--with-soplex-includedir=DIR
 
-  Sets the default LP solver backend. The supported values are
-  CPLEX, CLP and GLPK. By default, it is set to the first one which
-  is enabled and succesfully discovered.
+   The directory where the SoPlex header files are located. This is only
+   useful when the SoPlex headers and libraries are not under the same
+   prefix (which is unlikely).
 
--DLEMON_DEFAULT_MIP=GLPK
+--with-soplex-libdir=DIR
 
-  Sets the default MIP solver backend. The supported values are
-  CPLEX, CBC and GLPK. By default, it is set to the first one which
-  is enabled and succesfully discovered.
+   The directory where the SoPlex libraries are located. This is only
+   useful when the SoPlex headers and libraries are not under the same
+   prefix (which is unlikely).
 
--DGLPK_ROOT_DIR=DIRECTORY
--DCOIN_ROOT_DIR=DIRECTORY
--DILOG_ROOT_DIR=DIRECTORY
+--without-soplex
 
-  Root directory prefixes of optional third party libraries.
+   Disable SoPlex support.
 
-Makefile Variables
-==================
+--with-coin[=PREFIX]
 
-make VERBOSE=1
+   Enable support for COIN-OR solvers (CLP and CBC). You should
+   specify the prefix too. (by default, COIN-OR tools install
+   themselves to the source code directory). This command enables the
+   solvers that are actually found.
 
-   This results in a more verbose output by showing the full
-   compiler and linker commands.
+--with-coin-includedir=DIR
+
+   The directory where the COIN-OR header files are located. This is
+   only useful when the COIN-OR headers and libraries are not under
+   the same prefix (which is unlikely).
+
+--with-coin-libdir=DIR
+
+   The directory where the COIN-OR libraries are located. This is only
+   useful when the COIN-OR headers and libraries are not under the
+   same prefix (which is unlikely).
+
+--without-coin
+
+   Disable COIN-OR support.
Index: LICENSE
===================================================================
--- LICENSE	(revision 1148)
+++ LICENSE	(revision 600)
@@ -2,5 +2,5 @@
 copyright/license.
 
-Copyright (C) 2003-2012 Egervary Jeno Kombinatorikus Optimalizalasi
+Copyright (C) 2003-2009 Egervary Jeno Kombinatorikus Optimalizalasi
 Kutatocsoport (Egervary Combinatorial Optimization Research Group,
 EGRES).
Index: Makefile.am
===================================================================
--- Makefile.am	(revision 840)
+++ Makefile.am	(revision 840)
@@ -0,0 +1,80 @@
+ACLOCAL_AMFLAGS = -I m4
+
+AM_CXXFLAGS = $(WARNINGCXXFLAGS)
+
+AM_CPPFLAGS = -I$(top_srcdir) -I$(top_builddir)
+LDADD = $(top_builddir)/lemon/libemon.la
+
+EXTRA_DIST = \
+	AUTHORS \
+	LICENSE \
+	m4/lx_check_cplex.m4 \
+	m4/lx_check_glpk.m4 \
+	m4/lx_check_soplex.m4 \
+	m4/lx_check_coin.m4 \
+	CMakeLists.txt \
+	cmake/FindGhostscript.cmake \
+	cmake/FindCPLEX.cmake \
+	cmake/FindGLPK.cmake \
+	cmake/FindCOIN.cmake \
+	cmake/LEMONConfig.cmake.in \
+	cmake/version.cmake.in \
+	cmake/version.cmake \
+	cmake/nsis/lemon.ico \
+	cmake/nsis/uninstall.ico
+
+pkgconfigdir = $(libdir)/pkgconfig
+lemondir = $(pkgincludedir)
+bitsdir = $(lemondir)/bits
+conceptdir = $(lemondir)/concepts
+pkgconfig_DATA =
+lib_LTLIBRARIES =
+lemon_HEADERS =
+bits_HEADERS =
+concept_HEADERS =
+noinst_HEADERS =
+noinst_PROGRAMS =
+bin_PROGRAMS =
+check_PROGRAMS =
+dist_bin_SCRIPTS =
+TESTS =
+XFAIL_TESTS =
+
+include lemon/Makefile.am
+include test/Makefile.am
+include doc/Makefile.am
+include tools/Makefile.am
+include scripts/Makefile.am
+
+DIST_SUBDIRS = demo
+
+demo:
+	$(MAKE) $(AM_MAKEFLAGS) -C demo
+
+MRPROPERFILES = \
+	aclocal.m4 \
+	config.h.in \
+	config.h.in~ \
+	configure \
+	Makefile.in \
+	build-aux/config.guess \
+	build-aux/config.sub \
+	build-aux/depcomp \
+	build-aux/install-sh \
+	build-aux/ltmain.sh \
+	build-aux/missing \
+	doc/doxygen.log
+
+mrproper:
+	$(MAKE) $(AM_MAKEFLAGS) maintainer-clean
+	-rm -f $(MRPROPERFILES)
+
+dist-bz2: dist
+	zcat $(PACKAGE)-$(VERSION).tar.gz | \
+	bzip2 --best -c > $(PACKAGE)-$(VERSION).tar.bz2
+
+distcheck-bz2: distcheck
+	zcat $(PACKAGE)-$(VERSION).tar.gz | \
+	bzip2 --best -c > $(PACKAGE)-$(VERSION).tar.bz2
+
+.PHONY: demo mrproper dist-bz2 distcheck-bz2
Index: NEWS
===================================================================
--- NEWS	(revision 1281)
+++ NEWS	(revision 712)
@@ -1,180 +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
-
-        This is major feature release
-
-        * New algorithms
-          * Bellman-Ford algorithm (#51)
-          * Minimum mean cycle algorithms (#179)
-            * Karp, Hartman-Orlin and Howard algorithms
-          * New minimum cost flow algorithms (#180)
-            * Cost Scaling algorithms
-            * Capacity Scaling algorithm
-            * Cycle-Canceling algorithms
-          * Planarity related algorithms (#62)
-            * Planarity checking algorithm
-            * Planar embedding algorithm
-            * Schnyder's planar drawing algorithm
-            * Coloring planar graphs with five or six colors
-          * Fractional matching algorithms (#314)
-        * New data structures
-          * StaticDigraph structure (#68)
-          * Several new priority queue structures (#50, #301)
-            * Fibonacci, Radix, Bucket, Pairing, Binomial
-              D-ary and fourary heaps (#301)
-          * Iterable map structures (#73)
-        * Other new tools and functionality
-          * Map utility functions (#320)
-          * Reserve functions are added to ListGraph and SmartGraph (#311)
-          * A resize() function is added to HypercubeGraph (#311)
-          * A count() function is added to CrossRefMap (#302)
-          * Support for multiple targets in Suurballe using fullInit() (#181)
-          * Traits class and named parameters for Suurballe (#323)
-          * Separate reset() and resetParams() functions in NetworkSimplex
-            to handle graph changes (#327)
-          * tolerance() functions are added to HaoOrlin (#306)
-        * Implementation improvements
-          * Improvements in weighted matching algorithms (#314)
-            * Jumpstart initialization
-          * ArcIt iteration is based on out-arc lists instead of in-arc lists
-            in ListDigraph (#311)
-          * Faster add row operation in CbcMip (#203)
-          * Better implementation for split() in ListDigraph (#311)
-          * ArgParser can also throw exception instead of exit(1) (#332)
-        * Miscellaneous
-          * A simple interactive bootstrap script
-          * Doc improvements (#62,#180,#299,#302,#303,#304,#307,#311,#331,#315,
-                #316,#319)
-            * BibTeX references in the doc (#184)
-          * Optionally use valgrind when running tests
-          * Also check ReferenceMapTag in concept checks (#312)
-          * dimacs-solver uses long long type by default.
-        * Several bugfixes (compared to release 1.1):
-          #295: Suppress MSVC warnings using pragmas
-          ----: Various CMAKE related improvements
-                * Remove duplications from doc/CMakeLists.txt
-                * Rename documentation install folder from 'docs' to 'html'
-                * Add tools/CMakeLists.txt to the tarball
-                * Generate and install LEMONConfig.cmake
-                * Change the label of the html project in Visual Studio
-                * Fix the check for the 'long long' type
-                * Put the version string into config.h
-                * Minor CMake improvements
-                * Set the version to 'hg-tip' if everything fails
-          #311: Add missing 'explicit' keywords
-          #302: Fix the implementation and doc of CrossRefMap
-          #308: Remove duplicate list_graph.h entry from source list
-          #307: Bugfix in Preflow and Circulation
-          #305: Bugfix and extension in the rename script
-          #312: Also check ReferenceMapTag in concept checks
-          #250: Bugfix in pathSource() and pathTarget()
-          #321: Use pathCopy(from,to) instead of copyPath(to,from)
-          #322: Distribure LEMONConfig.cmake.in
-          #330: Bug fix in map_extender.h
-          #336: Fix the date field comment of graphToEps() output
-          #323: Bug fix in Suurballe
-          #335: Fix clear() function in ExtendFindEnum
-          #337: Use void* as the LPX object pointer
-          #317: Fix (and improve) error message in mip_test.cc
-                Remove unnecessary OsiCbc dependency
-          #356: Allow multiple executions of weighted matching algorithms (#356)
-
 2009-05-13 Version 1.1 released
 
@@ -251,5 +73,5 @@
           ----: Add missing unistd.h include to time_measure.h
           #204: Compilation bug fixed in graph_to_eps.h with VS2005
-          #214,#215: windows.h should never be included by LEMON headers
+          #214,#215: windows.h should never be included by lemon headers
           #230: Build systems check the availability of 'long long' type
           #229: Default implementation of Tolerance<> is used for integer types
@@ -273,50 +95,50 @@
 2008-10-13 Version 1.0 released
 
-        This is the first stable release of LEMON. Compared to the 0.x
-        release series, it features a considerably smaller but more
-        matured set of tools. The API has also completely revised and
-        changed in several places.
+	This is the first stable release of LEMON. Compared to the 0.x
+	release series, it features a considerably smaller but more
+	matured set of tools. The API has also completely revised and
+	changed in several places.
 
-        * The major name changes compared to the 0.x series (see the
+	* The major name changes compared to the 0.x series (see the
           Migration Guide in the doc for more details)
           * Graph -> Digraph, UGraph -> Graph
           * Edge -> Arc, UEdge -> Edge
-          * source(UEdge)/target(UEdge) -> u(Edge)/v(Edge)
-        * Other improvements
-          * Better documentation
-          * Reviewed and cleaned up codebase
-          * CMake based build system (along with the autotools based one)
-        * Contents of the library (ported from 0.x)
-          * Algorithms
-            * breadth-first search (bfs.h)
-            * depth-first search (dfs.h)
-            * Dijkstra's algorithm (dijkstra.h)
-            * Kruskal's algorithm (kruskal.h)
-          * Data structures
-            * graph data structures (list_graph.h, smart_graph.h)
-            * path data structures (path.h)
-            * binary heap data structure (bin_heap.h)
-            * union-find data structures (unionfind.h)
-            * miscellaneous property maps (maps.h)
-            * two dimensional vector and bounding box (dim2.h)
+	  * source(UEdge)/target(UEdge) -> u(Edge)/v(Edge)
+	* Other improvements
+	  * Better documentation
+	  * Reviewed and cleaned up codebase
+	  * CMake based build system (along with the autotools based one)
+	* Contents of the library (ported from 0.x)
+	  * Algorithms
+       	    * breadth-first search (bfs.h)
+       	    * depth-first search (dfs.h)
+       	    * Dijkstra's algorithm (dijkstra.h)
+       	    * Kruskal's algorithm (kruskal.h)
+    	  * Data structures
+       	    * graph data structures (list_graph.h, smart_graph.h)
+       	    * path data structures (path.h)
+       	    * binary heap data structure (bin_heap.h)
+       	    * union-find data structures (unionfind.h)
+       	    * miscellaneous property maps (maps.h)
+       	    * two dimensional vector and bounding box (dim2.h)
           * Concepts
-            * graph structure concepts (concepts/digraph.h, concepts/graph.h,
+       	    * graph structure concepts (concepts/digraph.h, concepts/graph.h,
               concepts/graph_components.h)
-            * concepts for other structures (concepts/heap.h, concepts/maps.h,
-              concepts/path.h)
-          * Tools
-            * Mersenne twister random number generator (random.h)
-            * tools for measuring cpu and wall clock time (time_measure.h)
-            * tools for counting steps and events (counter.h)
-            * tool for parsing command line arguments (arg_parser.h)
-            * tool for visualizing graphs (graph_to_eps.h)
-            * tools for reading and writing data in LEMON Graph Format
+       	    * concepts for other structures (concepts/heap.h, concepts/maps.h,
+	      concepts/path.h)
+    	  * Tools
+       	    * Mersenne twister random number generator (random.h)
+       	    * tools for measuring cpu and wall clock time (time_measure.h)
+       	    * tools for counting steps and events (counter.h)
+       	    * tool for parsing command line arguments (arg_parser.h)
+       	    * tool for visualizing graphs (graph_to_eps.h)
+       	    * tools for reading and writing data in LEMON Graph Format
               (lgf_reader.h, lgf_writer.h)
             * tools to handle the anomalies of calculations with
-              floating point numbers (tolerance.h)
+	      floating point numbers (tolerance.h)
             * tools to manage RGB colors (color.h)
-          * Infrastructure
-            * extended assertion handling (assert.h)
-            * exception classes and error handling (error.h)
-            * concept checking (concept_check.h)
-            * commonly used mathematical constants (math.h)
+    	  * Infrastructure
+       	    * extended assertion handling (assert.h)
+       	    * exception classes and error handling (error.h)
+      	    * concept checking (concept_check.h)
+       	    * commonly used mathematical constants (math.h)
Index: README
===================================================================
--- README	(revision 921)
+++ README	(revision 705)
@@ -18,8 +18,4 @@
    Copying, distribution and modification conditions and terms.
 
-NEWS
-
-   News and version history.
-
 INSTALL
 
@@ -38,8 +34,4 @@
    Some example programs to make you easier to get familiar with LEMON.
 
-scripts/
-
-   Scripts that make it easier to develop LEMON.
-
 test/
 
Index: cmake/FindCOIN.cmake
===================================================================
--- cmake/FindCOIN.cmake	(revision 1232)
+++ cmake/FindCOIN.cmake	(revision 681)
@@ -6,61 +6,40 @@
 FIND_LIBRARY(COIN_CBC_LIBRARY
   NAMES Cbc libCbc
-  HINTS ${COIN_ROOT_DIR}/lib/coin
   HINTS ${COIN_ROOT_DIR}/lib
 )
 FIND_LIBRARY(COIN_CBC_SOLVER_LIBRARY
   NAMES CbcSolver libCbcSolver
-  HINTS ${COIN_ROOT_DIR}/lib/coin
   HINTS ${COIN_ROOT_DIR}/lib
 )
 FIND_LIBRARY(COIN_CGL_LIBRARY
   NAMES Cgl libCgl
-  HINTS ${COIN_ROOT_DIR}/lib/coin
   HINTS ${COIN_ROOT_DIR}/lib
 )
 FIND_LIBRARY(COIN_CLP_LIBRARY
   NAMES Clp libClp
-  HINTS ${COIN_ROOT_DIR}/lib/coin
   HINTS ${COIN_ROOT_DIR}/lib
 )
 FIND_LIBRARY(COIN_COIN_UTILS_LIBRARY
   NAMES CoinUtils libCoinUtils
-  HINTS ${COIN_ROOT_DIR}/lib/coin
   HINTS ${COIN_ROOT_DIR}/lib
 )
 FIND_LIBRARY(COIN_OSI_LIBRARY
   NAMES Osi libOsi
-  HINTS ${COIN_ROOT_DIR}/lib/coin
   HINTS ${COIN_ROOT_DIR}/lib
 )
 FIND_LIBRARY(COIN_OSI_CBC_LIBRARY
   NAMES OsiCbc libOsiCbc
-  HINTS ${COIN_ROOT_DIR}/lib/coin
   HINTS ${COIN_ROOT_DIR}/lib
 )
 FIND_LIBRARY(COIN_OSI_CLP_LIBRARY
   NAMES OsiClp libOsiClp
-  HINTS ${COIN_ROOT_DIR}/lib/coin
   HINTS ${COIN_ROOT_DIR}/lib
 )
 FIND_LIBRARY(COIN_OSI_VOL_LIBRARY
   NAMES OsiVol libOsiVol
-  HINTS ${COIN_ROOT_DIR}/lib/coin
   HINTS ${COIN_ROOT_DIR}/lib
 )
 FIND_LIBRARY(COIN_VOL_LIBRARY
   NAMES Vol libVol
-  HINTS ${COIN_ROOT_DIR}/lib/coin
-  HINTS ${COIN_ROOT_DIR}/lib
-)
-
-FIND_LIBRARY(COIN_ZLIB_LIBRARY
-  NAMES z libz
-  HINTS ${COIN_ROOT_DIR}/lib/coin
-  HINTS ${COIN_ROOT_DIR}/lib
-)
-FIND_LIBRARY(COIN_BZ2_LIBRARY
-  NAMES bz2 libbz2
-  HINTS ${COIN_ROOT_DIR}/lib/coin
   HINTS ${COIN_ROOT_DIR}/lib
 )
@@ -77,19 +56,13 @@
   COIN_OSI_CBC_LIBRARY
   COIN_OSI_CLP_LIBRARY
-  # COIN_OSI_VOL_LIBRARY
-  # COIN_VOL_LIBRARY
+  COIN_OSI_VOL_LIBRARY
+  COIN_VOL_LIBRARY
 )
 
 IF(COIN_FOUND)
   SET(COIN_INCLUDE_DIRS ${COIN_INCLUDE_DIR})
-  SET(COIN_CLP_LIBRARIES "${COIN_CLP_LIBRARY};${COIN_COIN_UTILS_LIBRARY};${COIN_ZLIB_LIBRARY};${COIN_BZ2_LIBRARY}")
-  IF(COIN_ZLIB_LIBRARY)
-    SET(COIN_CLP_LIBRARIES "${COIN_CLP_LIBRARIES};${COIN_ZLIB_LIBRARY}")
-  ENDIF(COIN_ZLIB_LIBRARY)
-   IF(COIN_BZ2_LIBRARY)
-    SET(COIN_CLP_LIBRARIES "${COIN_CLP_LIBRARIES};${COIN_BZ2_LIBRARY}")
-  ENDIF(COIN_BZ2_LIBRARY)
-  SET(COIN_CBC_LIBRARIES "${COIN_CBC_LIBRARY};${COIN_CBC_SOLVER_LIBRARY};${COIN_CGL_LIBRARY};${COIN_OSI_LIBRARY};${COIN_OSI_CBC_LIBRARY};${COIN_OSI_CLP_LIBRARY};${COIN_ZLIB_LIBRARY};${COIN_BZ2_LIBRARY};${COIN_CLP_LIBRARIES}")
-  SET(COIN_LIBRARIES ${COIN_CBC_LIBRARIES})
+  SET(COIN_LIBRARIES "${COIN_CBC_LIBRARY};${COIN_CBC_SOLVER_LIBRARY};${COIN_CGL_LIBRARY};${COIN_CLP_LIBRARY};${COIN_COIN_UTILS_LIBRARY};${COIN_OSI_LIBRARY};${COIN_OSI_CBC_LIBRARY};${COIN_OSI_CLP_LIBRARY};${COIN_OSI_VOL_LIBRARY};${COIN_VOL_LIBRARY}")
+  SET(COIN_CLP_LIBRARIES "${COIN_CLP_LIBRARY};${COIN_COIN_UTILS_LIBRARY}")
+  SET(COIN_CBC_LIBRARIES ${COIN_LIBRARIES})
 ENDIF(COIN_FOUND)
 
@@ -106,5 +79,10 @@
   COIN_OSI_VOL_LIBRARY
   COIN_VOL_LIBRARY
-  COIN_ZLIB_LIBRARY
-  COIN_BZ2_LIBRARY
 )
+
+IF(COIN_FOUND)
+  SET(LEMON_HAVE_LP TRUE)
+  SET(LEMON_HAVE_MIP TRUE)
+  SET(LEMON_HAVE_CLP TRUE)
+  SET(LEMON_HAVE_CBC TRUE)
+ENDIF(COIN_FOUND)
Index: cmake/FindCPLEX.cmake
===================================================================
--- cmake/FindCPLEX.cmake	(revision 683)
+++ cmake/FindCPLEX.cmake	(revision 683)
@@ -0,0 +1,38 @@
+SET(CPLEX_ROOT_DIR "" CACHE PATH "CPLEX root directory")
+
+FIND_PATH(CPLEX_INCLUDE_DIR
+  ilcplex/cplex.h
+  PATHS "C:/ILOG/CPLEX91/include"
+  PATHS "/opt/ilog/cplex91/include"
+  HINTS ${CPLEX_ROOT_DIR}/include
+)
+FIND_LIBRARY(CPLEX_LIBRARY
+  cplex91
+  PATHS "C:/ILOG/CPLEX91/lib/msvc7/stat_mda"
+  PATHS "/opt/ilog/cplex91/bin"
+  HINTS ${CPLEX_ROOT_DIR}/bin
+)
+
+INCLUDE(FindPackageHandleStandardArgs)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(CPLEX DEFAULT_MSG CPLEX_LIBRARY CPLEX_INCLUDE_DIR)
+
+FIND_PATH(CPLEX_BIN_DIR
+  cplex91.dll
+  PATHS "C:/ILOG/CPLEX91/bin/x86_win32"
+)
+
+IF(CPLEX_FOUND)
+  SET(CPLEX_INCLUDE_DIRS ${CPLEX_INCLUDE_DIR})
+  SET(CPLEX_LIBRARIES ${CPLEX_LIBRARY})
+  IF(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+    SET(CPLEX_LIBRARIES "${CPLEX_LIBRARIES};m;pthread")
+  ENDIF(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+ENDIF(CPLEX_FOUND)
+
+MARK_AS_ADVANCED(CPLEX_LIBRARY CPLEX_INCLUDE_DIR CPLEX_BIN_DIR)
+
+IF(CPLEX_FOUND)
+  SET(LEMON_HAVE_LP TRUE)
+  SET(LEMON_HAVE_MIP TRUE)
+  SET(LEMON_HAVE_CPLEX TRUE)
+ENDIF(CPLEX_FOUND)
Index: cmake/FindGLPK.cmake
===================================================================
--- cmake/FindGLPK.cmake	(revision 1232)
+++ cmake/FindGLPK.cmake	(revision 685)
@@ -54,2 +54,8 @@
 
 MARK_AS_ADVANCED(GLPK_LIBRARY GLPK_INCLUDE_DIR GLPK_BIN_DIR)
+
+IF(GLPK_FOUND)
+  SET(LEMON_HAVE_LP TRUE)
+  SET(LEMON_HAVE_MIP TRUE)
+  SET(LEMON_HAVE_GLPK TRUE)
+ENDIF(GLPK_FOUND)
Index: ake/FindILOG.cmake
===================================================================
--- cmake/FindILOG.cmake	(revision 1331)
+++ 	(revision )
@@ -1,106 +1,0 @@
-FIND_PATH(ILOG_ROOT_DIR
-  NAMES cplex
-  DOC "CPLEX STUDIO root directory"
-  PATHS /opt/ibm/ILOG /usr/local/ibm/ILOG /usr/local/ILOG /usr/local/ilog
-  PATHS "$ENV{HOME}/ILOG" "$ENV{HOME}/.local/ILOG"
-  PATHS "$ENV{HOME}/ibm/ILOG" "$ENV{HOME}/.local/ibm/ILOG"
-  PATHS "C:/Program Files/IBM/ILOG" 
-  PATH_SUFFIXES "CPLEX_Studio126" "CPLEX_Studio125"
-  "CPLEX_Studio124" "CPLEX_Studio123" "CPLEX_Studio122"
-  NO_DEFAULT_PATH
-)
-
-IF(WIN32)
-  IF(MSVC_VERSION STREQUAL "1400")
-    SET(ILOG_WIN_COMPILER "windows_vs2005")
-  ELSEIF(MSVC_VERSION STREQUAL "1500")
-    SET(ILOG_WIN_COMPILER "windows_vs2008")
-  ELSEIF(MSVC_VERSION STREQUAL "1600")
-    SET(ILOG_WIN_COMPILER "windows_vs2010")
-  ELSE()
-    SET(ILOG_WIN_COMPILER "windows_vs2008")
-  ENDIF()
-  IF(CMAKE_CL_64)
-    SET(ILOG_WIN_COMPILER "x64_${ILOG_WIN_COMPILER}")
-    SET(ILOG_WIN_PLATFORM "x64_win32")
-  ELSE()
-    SET(ILOG_WIN_COMPILER "x86_${ILOG_WIN_COMPILER}")
-    SET(ILOG_WIN_PLATFORM "x86_win32")
-  ENDIF()
-ENDIF()
-
-FIND_PATH(ILOG_CPLEX_ROOT_DIR
-  NAMES include/ilcplex
-  HINTS ${ILOG_ROOT_DIR}/cplex ${ILOG_ROOT_DIR}/cplex121
-  ${ILOG_ROOT_DIR}/cplex122 ${ILOG_ROOT_DIR}/cplex123
-  DOC "CPLEX root directory"
-  NO_DEFAULT_PATH
-)
-
-FIND_PATH(ILOG_CONCERT_ROOT_DIR
-  NAMES include/ilconcert
-  HINTS ${ILOG_ROOT_DIR}/concert ${ILOG_ROOT_DIR}/concert29
-  DOC "CONCERT root directory"
-  NO_DEFAULT_PATH
-)
-
-FIND_PATH(ILOG_CPLEX_INCLUDE_DIR
-  ilcplex/cplex.h
-  HINTS ${ILOG_CPLEX_ROOT_DIR}/include
-  NO_DEFAULT_PATH
-)
-
-FIND_PATH(ILOG_CONCERT_INCLUDE_DIR
-  ilconcert/ilobasic.h
-  HINTS ${ILOG_CONCERT_ROOT_DIR}/include
-  NO_DEFAULT_PATH
-)
-
-FIND_LIBRARY(ILOG_CPLEX_LIBRARY
-  cplex cplex121 cplex122 cplex123 cplex124
-  HINTS ${ILOG_CPLEX_ROOT_DIR}/lib/x86_sles10_4.1/static_pic
-  ${ILOG_CPLEX_ROOT_DIR}/lib/x86-64_sles10_4.1/static_pic
-  ${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
-  )
-
-FIND_LIBRARY(ILOG_CONCERT_LIBRARY
-  concert
-  HINTS ${ILOG_CONCERT_ROOT_DIR}/lib/x86_sles10_4.1/static_pic
-  ${ILOG_CONCERT_ROOT_DIR}/lib/x86-64_sles10_4.1/static_pic
-  ${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
-  )
-
-FIND_FILE(ILOG_CPLEX_DLL
-  cplex121.dll cplex122.dll cplex123.dll cplex124.dll
-  HINTS ${ILOG_CPLEX_ROOT_DIR}/bin/${ILOG_WIN_PLATFORM}
-  NO_DEFAULT_PATH
-  )
-
-INCLUDE(FindPackageHandleStandardArgs)
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(ILOG
-  DEFAULT_MSG ILOG_CPLEX_LIBRARY ILOG_CPLEX_INCLUDE_DIR
-  )
-
-IF(ILOG_FOUND)
-  SET(ILOG_INCLUDE_DIRS ${ILOG_CPLEX_INCLUDE_DIR} ${ILOG_CONCERT_INCLUDE_DIR})
-  SET(ILOG_LIBRARIES ${ILOG_CPLEX_LIBRARY} ${ILOG_CONCERT_LIBRARY})
-  IF(CMAKE_SYSTEM_NAME STREQUAL "Linux")
-    # SET(CPLEX_LIBRARIES "${CPLEX_LIBRARIES};m;pthread")
-    SET(ILOG_LIBRARIES ${ILOG_LIBRARIES} "m" "pthread")
-  ENDIF(CMAKE_SYSTEM_NAME STREQUAL "Linux")
-ENDIF(ILOG_FOUND)
-
-MARK_AS_ADVANCED(
-  ILOG_CPLEX_LIBRARY ILOG_CPLEX_INCLUDE_DIR ILOG_CPLEX_DLL
-  ILOG_CONCERT_LIBRARY ILOG_CONCERT_INCLUDE_DIR ILOG_CONCERT_DLL
-  )
Index: ake/FindSOPLEX.cmake
===================================================================
--- cmake/FindSOPLEX.cmake	(revision 1264)
+++ 	(revision )
@@ -1,23 +1,0 @@
-SET(SOPLEX_ROOT_DIR "" CACHE PATH "SoPlex root directory")
-
-FIND_PATH(SOPLEX_INCLUDE_DIR
-  soplex.h
-  HINTS ${SOPLEX_ROOT_DIR}/src
-)
-FIND_LIBRARY(SOPLEX_LIBRARY
-  soplex
-  HINTS ${SOPLEX_ROOT_DIR}/lib
-)
-
-INCLUDE(FindPackageHandleStandardArgs)
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(SOPLEX DEFAULT_MSG SOPLEX_LIBRARY SOPLEX_INCLUDE_DIR)
-
-IF(SOPLEX_FOUND)
-  SET(SOPLEX_INCLUDE_DIRS ${SOPLEX_INCLUDE_DIR})
-  SET(SOPLEX_LIBRARIES ${SOPLEX_LIBRARY})
-  IF(CMAKE_SYSTEM_NAME STREQUAL "Linux")
-    SET(SOPLEX_LIBRARIES "${SOPLEX_LIBRARIES};z")
-  ENDIF(CMAKE_SYSTEM_NAME STREQUAL "Linux")
-ENDIF(SOPLEX_FOUND)
-
-MARK_AS_ADVANCED(SOPLEX_LIBRARY SOPLEX_INCLUDE_DIR)
Index: cmake/version.cmake.in
===================================================================
--- cmake/version.cmake.in	(revision 1135)
+++ cmake/version.cmake.in	(revision 725)
@@ -1,1 +1,1 @@
-SET(LEMON_VERSION "@LEMON_VERSION@" CACHE STRING "LEMON version string.")
+SET(LEMON_VERSION "@PACKAGE_VERSION@" CACHE STRING "LEMON version string.")
Index: configure.ac
===================================================================
--- configure.ac	(revision 840)
+++ configure.ac	(revision 840)
@@ -0,0 +1,156 @@
+dnl Process this file with autoconf to produce a configure script.
+
+dnl Version information.
+m4_define([lemon_version_number],
+          [m4_normalize(esyscmd([echo ${LEMON_VERSION}]))])
+dnl m4_define([lemon_version_number], [])
+m4_define([lemon_hg_path], [m4_normalize(esyscmd([./scripts/chg-len.py]))])
+m4_define([lemon_hg_revision], [m4_normalize(esyscmd([hg id -i 2> /dev/null]))])
+m4_define([lemon_version], [ifelse(lemon_version_number(),
+                           [],
+                           [ifelse(lemon_hg_revision(),
+                           [],
+                           [hg-tip],
+                           [lemon_hg_path().lemon_hg_revision()])],
+                           [lemon_version_number()])])
+
+AC_PREREQ([2.59])
+AC_INIT([LEMON], [lemon_version()], [lemon-user@lemon.cs.elte.hu], [lemon])
+AC_CONFIG_AUX_DIR([build-aux])
+AC_CONFIG_MACRO_DIR([m4])
+AM_INIT_AUTOMAKE([-Wall -Werror foreign subdir-objects nostdinc])
+AC_CONFIG_SRCDIR([lemon/list_graph.h])
+AC_CONFIG_HEADERS([config.h lemon/config.h])
+
+AC_DEFINE([LEMON_VERSION], [lemon_version()], [The version string])
+
+dnl Do compilation tests using the C++ compiler.
+AC_LANG([C++])
+
+dnl Check the existence of long long type.
+AC_CHECK_TYPE(long long, [long_long_found=yes], [long_long_found=no])
+if test x"$long_long_found" = x"yes"; then
+  AC_DEFINE([LEMON_HAVE_LONG_LONG], [1], [Define to 1 if you have long long.])
+fi
+
+dnl Checks for programs.
+AC_PROG_CXX
+AC_PROG_CXXCPP
+AC_PROG_INSTALL
+AC_DISABLE_SHARED
+AC_PROG_LIBTOOL
+
+AC_CHECK_PROG([doxygen_found],[doxygen],[yes],[no])
+AC_CHECK_PROG([python_found],[python],[yes],[no])
+AC_CHECK_PROG([gs_found],[gs],[yes],[no])
+
+dnl Detect Intel compiler.
+AC_MSG_CHECKING([whether we are using the Intel C++ compiler])
+AC_COMPILE_IFELSE([#ifndef __INTEL_COMPILER
+choke me
+#endif], [ICC=[yes]], [ICC=[no]])
+if test x"$ICC" = x"yes"; then
+  AC_MSG_RESULT([yes])
+else
+  AC_MSG_RESULT([no])
+fi
+
+dnl Set custom compiler flags when using g++.
+if test "$GXX" = yes -a "$ICC" = no; then
+  WARNINGCXXFLAGS="-Wall -W -Wall -W -Wunused -Wformat=2 -Wctor-dtor-privacy -Wnon-virtual-dtor -Wno-char-subscripts -Wwrite-strings -Wno-char-subscripts -Wreturn-type -Wcast-qual -Wcast-align -Wsign-promo -Woverloaded-virtual -ansi -fno-strict-aliasing -Wold-style-cast -Wno-unknown-pragmas"
+fi
+AC_SUBST([WARNINGCXXFLAGS])
+
+dnl Checks for libraries.
+LX_CHECK_GLPK
+LX_CHECK_CPLEX
+LX_CHECK_SOPLEX
+LX_CHECK_COIN
+
+AM_CONDITIONAL([HAVE_LP], [test x"$lx_lp_found" = x"yes"])
+AM_CONDITIONAL([HAVE_MIP], [test x"$lx_mip_found" = x"yes"])
+
+dnl Disable/enable building the binary tools.
+AC_ARG_ENABLE([tools],
+AS_HELP_STRING([--enable-tools], [build additional tools @<:@default@:>@])
+AS_HELP_STRING([--disable-tools], [do not build additional tools]),
+              [], [enable_tools=yes])
+AC_MSG_CHECKING([whether to build the additional tools])
+if test x"$enable_tools" != x"no"; then
+  AC_MSG_RESULT([yes])
+else
+  AC_MSG_RESULT([no])
+fi
+AM_CONDITIONAL([WANT_TOOLS], [test x"$enable_tools" != x"no"])
+
+dnl Support for running test cases using valgrind.
+use_valgrind=no
+AC_ARG_ENABLE([valgrind],
+AS_HELP_STRING([--enable-valgrind], [use valgrind when running tests]),
+              [use_valgrind=yes])
+
+if [[ "$use_valgrind" = "yes" ]]; then
+  AC_CHECK_PROG(HAVE_VALGRIND, valgrind, yes, no)
+
+  if [[ "$HAVE_VALGRIND" = "no" ]]; then
+    AC_MSG_ERROR([Valgrind not found in PATH.])
+  fi
+fi
+AM_CONDITIONAL(USE_VALGRIND, [test "$use_valgrind" = "yes"])
+
+dnl Checks for header files.
+AC_CHECK_HEADERS(limits.h sys/time.h sys/times.h unistd.h)
+
+dnl Checks for typedefs, structures, and compiler characteristics.
+AC_C_CONST
+AC_C_INLINE
+AC_TYPE_SIZE_T
+AC_HEADER_TIME
+AC_STRUCT_TM
+
+dnl Checks for library functions.
+AC_HEADER_STDC
+AC_CHECK_FUNCS(gettimeofday times ctime_r)
+
+dnl Add dependencies on files generated by configure.
+AC_SUBST([CONFIG_STATUS_DEPENDENCIES],
+  ['$(top_srcdir)/doc/Doxyfile.in $(top_srcdir)/lemon/lemon.pc.in $(top_srcdir)/cmake/version.cmake.in'])
+
+AC_CONFIG_FILES([
+Makefile
+demo/Makefile
+cmake/version.cmake
+doc/Doxyfile
+lemon/lemon.pc
+])
+
+AC_OUTPUT
+
+echo
+echo '****************************** SUMMARY ******************************'
+echo
+echo Package version............... : $PACKAGE-$VERSION
+echo
+echo C++ compiler.................. : $CXX
+echo C++ compiles flags............ : $WARNINGCXXFLAGS $CXXFLAGS
+echo
+echo Compiler supports long long... : $long_long_found
+echo
+echo GLPK support.................. : $lx_glpk_found
+echo CPLEX support................. : $lx_cplex_found
+echo SOPLEX support................ : $lx_soplex_found
+echo CLP support................... : $lx_clp_found
+echo CBC support................... : $lx_cbc_found
+echo
+echo Build additional tools........ : $enable_tools
+echo Use valgrind for tests........ : $use_valgrind
+echo
+echo The packace will be installed in
+echo -n '  '
+echo $prefix.
+echo
+echo '*********************************************************************'
+
+echo
+echo Configure complete, now type \'make\' and then \'make install\'.
+echo
Index: ntrib/CMakeLists.txt
===================================================================
--- contrib/CMakeLists.txt	(revision 1031)
+++ 	(revision )
@@ -1,19 +1,0 @@
-INCLUDE_DIRECTORIES(
-  ${PROJECT_SOURCE_DIR}
-  ${PROJECT_BINARY_DIR}
-)
-
-LINK_DIRECTORIES(
-  ${PROJECT_BINARY_DIR}/lemon
-)
-
-# Uncomment (and adjust) the following two lines. 'myprog' is the name
-# of the final executable ('.exe' will automatically be added to the
-# name on Windows) and 'myprog-main.cc' is the source code it is
-# compiled from. You can add more source files separated by
-# whitespaces. Moreover, you can add multiple similar blocks if you
-# want to build more than one executables.
-
-# ADD_EXECUTABLE(myprog myprog-main.cc)
-# TARGET_LINK_LIBRARIES(myprog lemon)
-
Index: demo/Makefile.am
===================================================================
--- demo/Makefile.am	(revision 611)
+++ demo/Makefile.am	(revision 611)
@@ -0,0 +1,17 @@
+AM_CXXFLAGS = $(WARNINGCXXFLAGS)
+
+AM_CPPFLAGS = -I$(top_srcdir) -I$(top_builddir)
+LDADD = $(top_builddir)/lemon/libemon.la
+
+EXTRA_DIST = \
+	CMakeLists.txt \
+	digraph.lgf
+
+noinst_PROGRAMS = \
+	arg_parser_demo \
+	graph_to_eps_demo \
+	lgf_demo
+
+arg_parser_demo_SOURCES = arg_parser_demo.cc
+graph_to_eps_demo_SOURCES = graph_to_eps_demo.cc
+lgf_demo_SOURCES = lgf_demo.cc
Index: demo/arg_parser_demo.cc
===================================================================
--- demo/arg_parser_demo.cc	(revision 956)
+++ demo/arg_parser_demo.cc	(revision 463)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -66,16 +66,7 @@
     .other("...");
 
-  // Throw an exception when problems occurs. The default behavior is to
-  // exit(1) on these cases, but this makes Valgrind falsely warn
-  // about memory leaks.
-  ap.throwOnProblems();
-
   // Perform the parsing process
   // (in case of any error it terminates the program)
-  // The try {} construct is necessary only if the ap.trowOnProblems()
-  // setting is in use.
-  try {
-    ap.parse();
-  } catch (ArgParserException &) { return 1; }
+  ap.parse();
 
   // Check each option if it has been given and print its value
Index: doc/CMakeLists.txt
===================================================================
--- doc/CMakeLists.txt	(revision 1251)
+++ doc/CMakeLists.txt	(revision 791)
@@ -3,13 +3,4 @@
 SET(abs_top_srcdir ${PROJECT_SOURCE_DIR})
 SET(abs_top_builddir ${PROJECT_BINARY_DIR})
-
-SET(LEMON_DOC_SOURCE_BROWSER "NO" CACHE STRING "Include source into the doc (YES/NO).")
-SET(LEMON_DOC_USE_MATHJAX "NO" CACHE STRING "Use MathJax to display math formulae (YES/NO).")
-SET(LEMON_DOC_MATHJAX_RELPATH "http://www.mathjax.org/mathjax" CACHE STRING "MathJax library location.")
-
-SET(LEMON_DOC_LIBSTDC++_URL
-  "http://gcc.gnu.org/onlinedocs/gcc-4.7.3/libstdc++/api"
-  CACHE STRING "GCC libstdc++ doxygen doc url.")
-
 
 CONFIGURE_FILE(
@@ -19,19 +10,4 @@
 )
 
-CONFIGURE_FILE(
-  ${PROJECT_SOURCE_DIR}/doc/mainpage.dox.in
-  ${PROJECT_BINARY_DIR}/doc/mainpage.dox
-  @ONLY
-)
-
-# Copy doc from source (if exists)
-IF(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/html AND 
-    NOT EXISTS ${CMAKE_CURRENT_BINARY_DIR}/html/index.html)
-  MESSAGE(STATUS "Copy doc from source tree")
-  EXECUTE_PROCESS(
-    COMMAND cmake -E copy_directory ${CMAKE_CURRENT_SOURCE_DIR}/html ${CMAKE_CURRENT_BINARY_DIR}/html
-    )
-ENDIF()
-
 IF(DOXYGEN_EXECUTABLE AND PYTHONINTERP_FOUND AND GHOSTSCRIPT_EXECUTABLE)
   FILE(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html/)
@@ -40,21 +16,18 @@
     COMMAND ${CMAKE_COMMAND} -E remove_directory gen-images
     COMMAND ${CMAKE_COMMAND} -E make_directory gen-images
-    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r20 -sOutputFile=gen-images/grid_graph.png ${CMAKE_CURRENT_SOURCE_DIR}/images/grid_graph.eps
-    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r32 -sOutputFile=gen-images/adaptors2.png ${CMAKE_CURRENT_SOURCE_DIR}/images/adaptors2.eps
-    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r32 -sOutputFile=gen-images/connected_components.png ${CMAKE_CURRENT_SOURCE_DIR}/images/connected_components.eps
-    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r32 -sOutputFile=gen-images/strongly_connected_components.png ${CMAKE_CURRENT_SOURCE_DIR}/images/strongly_connected_components.eps
-    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r32 -sOutputFile=gen-images/node_biconnected_components.png ${CMAKE_CURRENT_SOURCE_DIR}/images/node_biconnected_components.eps
-    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r32 -sOutputFile=gen-images/edge_biconnected_components.png ${CMAKE_CURRENT_SOURCE_DIR}/images/edge_biconnected_components.eps
-    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r32 -sOutputFile=gen-images/bipartite_partitions.png ${CMAKE_CURRENT_SOURCE_DIR}/images/bipartite_partitions.eps
-    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r24 -sOutputFile=gen-images/matching.png ${CMAKE_CURRENT_SOURCE_DIR}/images/matching.eps
-    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r24 -sOutputFile=gen-images/bipartite_matching.png ${CMAKE_CURRENT_SOURCE_DIR}/images/bipartite_matching.eps
-    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r40 -sOutputFile=gen-images/planar.png ${CMAKE_CURRENT_SOURCE_DIR}/images/planar.eps
-    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r24 -sOutputFile=gen-images/tsp.png ${CMAKE_CURRENT_SOURCE_DIR}/images/tsp.eps
-    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r8 -sOutputFile=gen-images/nodeshape_0.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_0.eps
-    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r8 -sOutputFile=gen-images/nodeshape_1.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_1.eps
-    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r8 -sOutputFile=gen-images/nodeshape_2.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_2.eps
-    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r8 -sOutputFile=gen-images/nodeshape_3.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_3.eps
-    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r8 -sOutputFile=gen-images/nodeshape_4.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_4.eps
+    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/bipartite_matching.png ${CMAKE_CURRENT_SOURCE_DIR}/images/bipartite_matching.eps
+    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/bipartite_partitions.png ${CMAKE_CURRENT_SOURCE_DIR}/images/bipartite_partitions.eps
+    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/connected_components.png ${CMAKE_CURRENT_SOURCE_DIR}/images/connected_components.eps
+    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/edge_biconnected_components.png ${CMAKE_CURRENT_SOURCE_DIR}/images/edge_biconnected_components.eps
+    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/grid_graph.png ${CMAKE_CURRENT_SOURCE_DIR}/images/grid_graph.eps
+    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/node_biconnected_components.png ${CMAKE_CURRENT_SOURCE_DIR}/images/node_biconnected_components.eps
+    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/nodeshape_0.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_0.eps
+    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/nodeshape_1.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_1.eps
+    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/nodeshape_2.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_2.eps
+    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/nodeshape_3.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_3.eps
+    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/nodeshape_4.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_4.eps
+    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/strongly_connected_components.png ${CMAKE_CURRENT_SOURCE_DIR}/images/strongly_connected_components.eps
     COMMAND ${CMAKE_COMMAND} -E remove_directory html
+    COMMAND ${PYTHON_EXECUTABLE} ${PROJECT_SOURCE_DIR}/scripts/bib2dox.py ${CMAKE_CURRENT_SOURCE_DIR}/references.bib >references.dox
     COMMAND ${DOXYGEN_EXECUTABLE} Doxyfile
     WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
@@ -78,9 +51,2 @@
 
 ENDIF()
-
-IF(WGET_FOUND)
-ADD_CUSTOM_TARGET(update-external-tags
-  COMMAND ${WGET_EXECUTABLE} -N ${LEMON_DOC_LIBSTDC++_URL}/libstdc++.tag
-  WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
-  )
-ENDIF()
Index: doc/Doxyfile.in
===================================================================
--- doc/Doxyfile.in	(revision 1354)
+++ doc/Doxyfile.in	(revision 803)
@@ -1,3 +1,3 @@
-# Doxyfile 1.7.3
+# Doxyfile 1.5.9
 
 #---------------------------------------------------------------------------
@@ -5,8 +5,6 @@
 #---------------------------------------------------------------------------
 DOXYFILE_ENCODING      = UTF-8
-PROJECT_NAME           = 
-PROJECT_NUMBER         = 
-PROJECT_BRIEF          =
-PROJECT_LOGO           =
+PROJECT_NAME           = @PACKAGE_NAME@
+PROJECT_NUMBER         = @PACKAGE_VERSION@
 OUTPUT_DIRECTORY       = 
 CREATE_SUBDIRS         = NO
@@ -20,5 +18,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
@@ -32,5 +30,4 @@
 OPTIMIZE_FOR_FORTRAN   = NO
 OPTIMIZE_OUTPUT_VHDL   = NO
-EXTENSION_MAPPING      =
 BUILTIN_STL_SUPPORT    = YES
 CPP_CLI_SUPPORT        = NO
@@ -40,4 +37,5 @@
 SUBGROUPING            = YES
 TYPEDEF_HIDES_STRUCT   = NO
+SYMBOL_CACHE_SIZE      = 0
 #---------------------------------------------------------------------------
 # Build related configuration options
@@ -57,12 +55,9 @@
 HIDE_SCOPE_NAMES       = YES
 SHOW_INCLUDE_FILES     = YES
-FORCE_LOCAL_INCLUDES   = NO
 INLINE_INFO            = YES
 SORT_MEMBER_DOCS       = NO
 SORT_BRIEF_DOCS        = NO
-SORT_MEMBERS_CTORS_1ST = NO
 SORT_GROUP_NAMES       = NO
 SORT_BY_SCOPE_NAME     = NO
-STRICT_PROTO_MATCHING  = NO
 GENERATE_TODOLIST      = YES
 GENERATE_TESTLIST      = YES
@@ -72,9 +67,9 @@
 MAX_INITIALIZER_LINES  = 5
 SHOW_USED_FILES        = NO
+SHOW_DIRECTORIES       = YES
 SHOW_FILES             = YES
 SHOW_NAMESPACES        = YES
 FILE_VERSION_FILTER    = 
-LAYOUT_FILE            = "@abs_top_srcdir@/doc/DoxygenLayout.xml"
-CITE_BIB_FILES         = "@abs_top_srcdir@/doc/references.bib"
+LAYOUT_FILE            = DoxygenLayout.xml
 #---------------------------------------------------------------------------
 # configuration options related to warning and progress messages
@@ -95,8 +90,7 @@
                          "@abs_top_srcdir@/lemon/concepts" \
                          "@abs_top_srcdir@/demo" \
-                         "@abs_top_srcdir@/contrib" \
                          "@abs_top_srcdir@/tools" \
                          "@abs_top_srcdir@/test/test_tools.h" \
-                         "@abs_top_builddir@/doc/mainpage.dox"
+                         "@abs_top_builddir@/doc/references.dox"
 INPUT_ENCODING         = UTF-8
 FILE_PATTERNS          = *.h \
@@ -118,9 +112,8 @@
 FILTER_PATTERNS        = 
 FILTER_SOURCE_FILES    = NO
-FILTER_SOURCE_PATTERNS =
 #---------------------------------------------------------------------------
 # configuration options related to source browsing
 #---------------------------------------------------------------------------
-SOURCE_BROWSER         = @LEMON_DOC_SOURCE_BROWSER@
+SOURCE_BROWSER         = NO
 INLINE_SOURCES         = NO
 STRIP_CODE_COMMENTS    = YES
@@ -145,14 +138,9 @@
 HTML_FOOTER            = 
 HTML_STYLESHEET        = 
-HTML_COLORSTYLE_HUE    = 220
-HTML_COLORSTYLE_SAT    = 100
-HTML_COLORSTYLE_GAMMA  = 80
-HTML_TIMESTAMP         = YES
-HTML_DYNAMIC_SECTIONS  = YES
+HTML_ALIGN_MEMBERS     = YES
+HTML_DYNAMIC_SECTIONS  = NO
 GENERATE_DOCSET        = NO
 DOCSET_FEEDNAME        = "Doxygen generated docs"
 DOCSET_BUNDLE_ID       = org.doxygen.Project
-DOCSET_PUBLISHER_ID    = org.doxygen.Publisher
-DOCSET_PUBLISHER_NAME  = Publisher
 GENERATE_HTMLHELP      = NO
 CHM_FILE               = 
@@ -166,21 +154,10 @@
 QHP_NAMESPACE          = org.doxygen.Project
 QHP_VIRTUAL_FOLDER     = doc
-QHP_CUST_FILTER_NAME   =
-QHP_CUST_FILTER_ATTRS  =
-QHP_SECT_FILTER_ATTRS  =
 QHG_LOCATION           = 
-GENERATE_ECLIPSEHELP   = NO
-ECLIPSE_DOC_ID         = org.doxygen.Project
 DISABLE_INDEX          = NO
 ENUM_VALUES_PER_LINE   = 4
 GENERATE_TREEVIEW      = NO
 TREEVIEW_WIDTH         = 250
-EXT_LINKS_IN_WINDOW    = NO
 FORMULA_FONTSIZE       = 10
-FORMULA_TRANSPARENT    = YES
-USE_MATHJAX            = @LEMON_DOC_USE_MATHJAX@
-MATHJAX_RELPATH        = @LEMON_DOC_MATHJAX_RELPATH@
-SEARCHENGINE           = YES
-SERVER_BASED_SEARCH    = NO
 #---------------------------------------------------------------------------
 # configuration options related to the LaTeX output
@@ -199,5 +176,4 @@
 LATEX_BATCHMODE        = NO
 LATEX_HIDE_INDICES     = NO
-LATEX_SOURCE_CODE      = NO
 #---------------------------------------------------------------------------
 # configuration options related to the RTF output
@@ -221,4 +197,6 @@
 GENERATE_XML           = NO
 XML_OUTPUT             = xml
+XML_SCHEMA             = 
+XML_DTD                = 
 XML_PROGRAMLISTING     = YES
 #---------------------------------------------------------------------------
@@ -246,7 +224,7 @@
 SKIP_FUNCTION_MACROS   = YES
 #---------------------------------------------------------------------------
-# Configuration::additions related to external references
-#---------------------------------------------------------------------------
-TAGFILES               = "@abs_top_builddir@/doc/libstdc++.tag = @LEMON_DOC_LIBSTDC++_URL@"
+# Options related to the search engine   
+#---------------------------------------------------------------------------
+TAGFILES               = "@abs_top_srcdir@/doc/libstdc++.tag = http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/  "
 GENERATE_TAGFILE       = html/lemon.tag
 ALLEXTERNALS           = NO
@@ -260,6 +238,5 @@
 HIDE_UNDOC_RELATIONS   = YES
 HAVE_DOT               = YES
-DOT_NUM_THREADS        = 0
-DOT_FONTNAME           = 
+DOT_FONTNAME           = FreeSans
 DOT_FONTSIZE           = 10
 DOT_FONTPATH           = 
@@ -278,5 +255,4 @@
 DOT_PATH               = 
 DOTFILE_DIRS           = 
-MSCFILE_DIRS           =
 DOT_GRAPH_MAX_NODES    = 50
 MAX_DOT_GRAPH_DEPTH    = 0
@@ -285,2 +261,6 @@
 GENERATE_LEGEND        = YES
 DOT_CLEANUP            = YES
+#---------------------------------------------------------------------------
+# Configuration::additions related to the search engine   
+#---------------------------------------------------------------------------
+SEARCHENGINE           = NO
Index: doc/DoxygenLayout.xml
===================================================================
--- doc/DoxygenLayout.xml	(revision 1251)
+++ doc/DoxygenLayout.xml	(revision 316)
@@ -3,21 +3,22 @@
   <navindex>
     <tab type="mainpage" visible="yes" title=""/>
-    <tab type="modules" visible="yes" title="" intro=""/>
+    <tab type="modules" visible="yes" title=""/>
     <tab type="classes" visible="yes" title="">
-      <tab type="classes" visible="yes" title="" intro=""/>
-      <tab type="classindex" visible="$ALPHABETICAL_INDEX" title=""/>
-      <tab type="hierarchy" visible="yes" title="" intro=""/>
-      <tab type="classmembers" visible="yes" title="" intro=""/>
+      <tab type="classes" visible="yes" title=""/>
+      <tab type="classindex" visible="$ALPHABETICAL_INDEX" title=""/> 
+      <tab type="hierarchy" visible="yes" title=""/>
+      <tab type="classmembers" visible="yes" title=""/>
     </tab>
     <tab type="namespaces" visible="yes" title="">
-      <tab type="namespaces" visible="yes" title="" intro=""/>
-      <tab type="namespacemembers" visible="yes" title="" intro=""/>
+      <tab type="namespaces" visible="yes" title=""/>
+      <tab type="namespacemembers" visible="yes" title=""/>
     </tab>
     <tab type="files" visible="yes" title="">
-      <tab type="files" visible="yes" title="" intro=""/>
-      <tab type="globals" visible="yes" title="" intro=""/>
+      <tab type="files" visible="yes" title=""/>
+      <tab type="globals" visible="yes" title=""/>
     </tab>
-    <tab type="examples" visible="yes" title="" intro=""/>
-    <tab type="pages" visible="yes" title="" intro=""/>
+    <tab type="dirs" visible="yes" title=""/>
+    <tab type="examples" visible="yes" title=""/>  
+    <tab type="pages" visible="yes" title=""/>
   </navindex>
 
Index: doc/Makefile.am
===================================================================
--- doc/Makefile.am	(revision 791)
+++ doc/Makefile.am	(revision 791)
@@ -0,0 +1,121 @@
+EXTRA_DIST += \
+	doc/Doxyfile.in \
+	doc/DoxygenLayout.xml \
+	doc/coding_style.dox \
+	doc/dirs.dox \
+	doc/groups.dox \
+	doc/lgf.dox \
+	doc/license.dox \
+	doc/mainpage.dox \
+	doc/migration.dox \
+	doc/min_cost_flow.dox \
+	doc/named-param.dox \
+	doc/namespaces.dox \
+	doc/html \
+	doc/CMakeLists.txt
+
+DOC_EPS_IMAGES18 = \
+	grid_graph.eps \
+	nodeshape_0.eps \
+	nodeshape_1.eps \
+	nodeshape_2.eps \
+	nodeshape_3.eps \
+	nodeshape_4.eps
+
+DOC_EPS_IMAGES27 = \
+	bipartite_matching.eps \
+	bipartite_partitions.eps \
+	connected_components.eps \
+	edge_biconnected_components.eps \
+	node_biconnected_components.eps \
+	strongly_connected_components.eps
+
+DOC_EPS_IMAGES = \
+	$(DOC_EPS_IMAGES18) \
+	$(DOC_EPS_IMAGES27)
+
+DOC_PNG_IMAGES = \
+	$(DOC_EPS_IMAGES:%.eps=doc/gen-images/%.png)
+
+EXTRA_DIST += $(DOC_EPS_IMAGES:%=doc/images/%)
+
+doc/html:
+	$(MAKE) $(AM_MAKEFLAGS) html
+
+GS_COMMAND=gs -dNOPAUSE -dBATCH -q -dEPSCrop -dTextAlphaBits=4 -dGraphicsAlphaBits=4
+
+$(DOC_EPS_IMAGES18:%.eps=doc/gen-images/%.png): doc/gen-images/%.png: doc/images/%.eps
+	-mkdir doc/gen-images
+	if test ${gs_found} = yes; then \
+	  $(GS_COMMAND) -sDEVICE=pngalpha -r18 -sOutputFile=$@ $<; \
+	else \
+	  echo; \
+	  echo "Ghostscript not found."; \
+	  echo; \
+	  exit 1; \
+	fi
+
+$(DOC_EPS_IMAGES27:%.eps=doc/gen-images/%.png): doc/gen-images/%.png: doc/images/%.eps
+	-mkdir doc/gen-images
+	if test ${gs_found} = yes; then \
+	  $(GS_COMMAND) -sDEVICE=pngalpha -r27 -sOutputFile=$@ $<; \
+	else \
+	  echo; \
+	  echo "Ghostscript not found."; \
+	  echo; \
+	  exit 1; \
+	fi
+
+references.dox: doc/references.bib
+	if test ${python_found} = yes; then \
+	  cd doc; \
+	  python @abs_top_srcdir@/scripts/bib2dox.py @abs_top_builddir@/$< >$@; \
+	  cd ..; \
+	else \
+	  echo; \
+	  echo "Python not found."; \
+	  echo; \
+	  exit 1; \
+	fi
+
+html-local: $(DOC_PNG_IMAGES) references.dox
+	if test ${doxygen_found} = yes; then \
+	  cd doc; \
+	  doxygen Doxyfile; \
+	  cd ..; \
+	else \
+	  echo; \
+	  echo "Doxygen not found."; \
+	  echo; \
+	  exit 1; \
+	fi
+
+clean-local:
+	-rm -rf doc/html
+	-rm -f doc/doxygen.log
+	-rm -f $(DOC_PNG_IMAGES)
+	-rm -rf doc/gen-images
+
+update-external-tags:
+	wget -O doc/libstdc++.tag.tmp http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/libstdc++.tag && \
+	mv doc/libstdc++.tag.tmp doc/libstdc++.tag || \
+	rm doc/libstdc++.tag.tmp
+
+install-html-local: doc/html
+	@$(NORMAL_INSTALL)
+	$(mkinstalldirs) $(DESTDIR)$(htmldir)/html
+	for p in doc/html/*.{html,css,png,map,gif,tag} ; do \
+	  f="`echo $$p | sed -e 's|^.*/||'`"; \
+	  echo " $(INSTALL_DATA) $$p $(DESTDIR)$(htmldir)/html/$$f"; \
+	  $(INSTALL_DATA) $$p $(DESTDIR)$(htmldir)/html/$$f; \
+	done
+
+uninstall-local:
+	@$(NORMAL_UNINSTALL)
+	for p in doc/html/*.{html,css,png,map,gif,tag} ; do \
+	  f="`echo $$p | sed -e 's|^.*/||'`"; \
+	  echo " rm -f $(DESTDIR)$(htmldir)/html/$$f"; \
+	  rm -f $(DESTDIR)$(htmldir)/html/$$f; \
+	done
+
+.PHONY: update-external-tags
Index: doc/coding_style.dox
===================================================================
--- doc/coding_style.dox	(revision 1270)
+++ doc/coding_style.dox	(revision 463)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -99,8 +99,8 @@
 \subsection pri-loc-var Private member variables
 
-Private member variables should start with underscore.
+Private member variables should start with underscore
 
 \code
-_start_with_underscore
+_start_with_underscores
 \endcode
 
Index: doc/dirs.dox
===================================================================
--- doc/dirs.dox	(revision 1270)
+++ doc/dirs.dox	(revision 463)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -32,17 +32,4 @@
 documentation.
 */
-
-/**
-\dir contrib
-\brief Directory for user contributed source codes.
-
-You can place your own C++ code using LEMON into this directory, which
-will compile to an executable along with LEMON when you build the
-library. This is probably the easiest way of compiling short to medium
-codes, for this does require neither a LEMON installed system-wide nor
-adding several paths to the compiler.
-
-Please have a look at <tt>contrib/CMakeLists.txt</tt> for
-instruction on how to add your own files into the build process.  */
 
 /**
Index: doc/groups.dox
===================================================================
--- doc/groups.dox	(revision 1351)
+++ doc/groups.dox	(revision 879)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -113,12 +113,4 @@
 detailed documentation of particular adaptors.
 
-Since the adaptor classes conform to the \ref graph_concepts "graph concepts",
-an adaptor can even be applied to another one.
-The following image illustrates a situation when a \ref SubDigraph adaptor
-is applied on a digraph and \ref Undirector is applied on the subgraph.
-
-\image html adaptors2.png
-\image latex adaptors2.eps "Using graph adaptors" width=\textwidth
-
 The behavior of graph adaptors can be very different. Some of them keep
 capabilities of the original graph while in other cases this would be
@@ -272,4 +264,12 @@
 
 /**
+@defgroup matrices Matrices
+@ingroup datas
+\brief Two dimensional data storages implemented in LEMON.
+
+This group contains two dimensional data storages implemented in LEMON.
+*/
+
+/**
 @defgroup auxdat Auxiliary Data Structures
 @ingroup datas
@@ -318,5 +318,5 @@
 This group contains the common graph search algorithms, namely
 \e breadth-first \e search (BFS) and \e depth-first \e search (DFS)
-\cite clrs01algorithms.
+\ref clrs01algorithms.
 */
 
@@ -327,5 +327,5 @@
 
 This group contains the algorithms for finding shortest paths in digraphs
-\cite clrs01algorithms.
+\ref clrs01algorithms.
 
  - \ref Dijkstra algorithm for finding shortest paths from a source node
@@ -349,5 +349,5 @@
 
 This group contains the algorithms for finding minimum cost spanning
-trees and arborescences \cite clrs01algorithms.
+trees and arborescences \ref clrs01algorithms.
 */
 
@@ -358,5 +358,5 @@
 
 This group contains the algorithms for finding maximum flows and
-feasible circulations \cite clrs01algorithms, \cite amo93networkflows.
+feasible circulations \ref clrs01algorithms, \ref amo93networkflows.
 
 The \e maximum \e flow \e problem is to find a flow of maximum value between
@@ -374,11 +374,11 @@
 LEMON contains several algorithms for solving maximum flow problems:
 - \ref EdmondsKarp Edmonds-Karp algorithm
-  \cite edmondskarp72theoretical.
+  \ref edmondskarp72theoretical.
 - \ref Preflow Goldberg-Tarjan's preflow push-relabel algorithm
-  \cite goldberg88newapproach.
+  \ref goldberg88newapproach.
 - \ref DinitzSleatorTarjan Dinitz's blocking flow algorithm with dynamic trees
-  \cite dinic70algorithm, \cite sleator83dynamic.
+  \ref dinic70algorithm, \ref sleator83dynamic.
 - \ref GoldbergTarjan !Preflow push-relabel algorithm with dynamic trees
-  \cite goldberg88newapproach, \cite sleator83dynamic.
+  \ref goldberg88newapproach, \ref sleator83dynamic.
 
 In most cases the \ref Preflow algorithm provides the
@@ -387,5 +387,5 @@
 problem of maximum flow.
 
-\ref Circulation is a preflow push-relabel algorithm implemented directly
+\ref Circulation is a preflow push-relabel algorithm implemented directly 
 for finding feasible circulations, which is a somewhat different problem,
 but it is strongly related to maximum flow.
@@ -400,39 +400,23 @@
 
 This group contains the algorithms for finding minimum cost flows and
-circulations \cite amo93networkflows. For more information about this
-problem and its dual solution, see: \ref min_cost_flow
+circulations \ref amo93networkflows. For more information about this
+problem and its dual solution, see \ref min_cost_flow
 "Minimum Cost Flow Problem".
 
 LEMON contains several algorithms for this problem.
  - \ref NetworkSimplex Primal Network Simplex algorithm with various
-   pivot strategies \cite dantzig63linearprog, \cite kellyoneill91netsimplex.
+   pivot strategies \ref dantzig63linearprog, \ref kellyoneill91netsimplex.
  - \ref CostScaling Cost Scaling algorithm based on push/augment and
-   relabel operations \cite goldberg90approximation, \cite goldberg97efficient,
-   \cite bunnagel98efficient.
+   relabel operations \ref goldberg90approximation, \ref goldberg97efficient,
+   \ref bunnagel98efficient.
  - \ref CapacityScaling Capacity Scaling algorithm based on the successive
-   shortest path method \cite edmondskarp72theoretical.
+   shortest path method \ref edmondskarp72theoretical.
  - \ref CycleCanceling Cycle-Canceling algorithms, two of which are
-   strongly polynomial \cite klein67primal, \cite goldberg89cyclecanceling.
-
-In general, \ref NetworkSimplex and \ref CostScaling are the most efficient
-implementations.
-\ref NetworkSimplex is usually the fastest on relatively small graphs (up to
-several thousands of nodes) and on dense graphs, while \ref CostScaling is
-typically more efficient on large graphs (e.g. hundreds of thousands of
-nodes or above), especially if they are sparse.
-However, other algorithms could be faster in special cases.
+   strongly polynomial \ref klein67primal, \ref goldberg89cyclecanceling.
+
+In general NetworkSimplex is the most efficient implementation,
+but in special cases other algorithms could be faster.
 For example, if the total supply and/or capacities are rather small,
-\ref CapacityScaling is usually the fastest algorithm
-(without effective scaling).
-
-These classes are intended to be used with integer-valued input data
-(capacities, supply values, and costs), except for \ref CapacityScaling,
-which is capable of handling real-valued arc costs (other numerical
-data are required to be integer).
-
-For more details about these implementations and for a comprehensive
-experimental study, see the paper \cite KiralyKovacs12MCF.
-It also compares these codes to other publicly available
-minimum cost flow solvers.
+CapacityScaling is usually the fastest algorithm (without effective scaling).
 */
 
@@ -473,5 +457,5 @@
 
 This group contains the algorithms for finding minimum mean cycles
-\cite amo93networkflows, \cite karp78characterization.
+\ref clrs01algorithms, \ref amo93networkflows.
 
 The \e minimum \e mean \e cycle \e problem is to find a directed cycle
@@ -489,15 +473,17 @@
 
 LEMON contains three algorithms for solving the minimum mean cycle problem:
-- \ref KarpMmc Karp's original algorithm \cite karp78characterization.
-- \ref HartmannOrlinMmc Hartmann-Orlin's algorithm, which is an improved
-  version of Karp's algorithm \cite hartmann93finding.
-- \ref HowardMmc Howard's policy iteration algorithm
-  \cite dasdan98minmeancycle, \cite dasdan04experimental.
-
-In practice, the \ref HowardMmc "Howard" algorithm turned out to be by far the
-most efficient one, though the best known theoretical bound on its running
-time is exponential.
-Both \ref KarpMmc "Karp" and \ref HartmannOrlinMmc "Hartmann-Orlin" algorithms
-run in time O(nm) and use space O(n<sup>2</sup>+m).
+- \ref Karp "Karp"'s original algorithm \ref amo93networkflows,
+  \ref dasdan98minmeancycle.
+- \ref HartmannOrlin "Hartmann-Orlin"'s algorithm, which is an improved
+  version of Karp's algorithm \ref dasdan98minmeancycle.
+- \ref Howard "Howard"'s policy iteration algorithm
+  \ref dasdan98minmeancycle.
+
+In practice, the Howard algorithm proved to be by far the most efficient
+one, though the best known theoretical bound on its running time is
+exponential.
+Both Karp and HartmannOrlin algorithms run in time O(ne) and use space
+O(n<sup>2</sup>+e), but the latter one is typically faster due to the
+applied early termination scheme.
 */
 
@@ -537,14 +523,7 @@
   Edmond's blossom shrinking algorithm for calculating maximum weighted
   perfect matching in general graphs.
-- \ref MaxFractionalMatching Push-relabel algorithm for calculating
-  maximum cardinality fractional matching in general graphs.
-- \ref MaxWeightedFractionalMatching Augmenting path algorithm for calculating
-  maximum weighted fractional matching in general graphs.
-- \ref MaxWeightedPerfectFractionalMatching
-  Augmenting path algorithm for calculating maximum weighted
-  perfect fractional matching in general graphs.
-
-\image html matching.png
-\image latex matching.eps "Min Cost Perfect Matching" width=\textwidth
+
+\image html bipartite_matching.png
+\image latex bipartite_matching.eps "Bipartite Matching" width=\textwidth
 */
 
@@ -562,34 +541,5 @@
 
 /**
-@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\f$.
-
-*/
-
-/**
-@defgroup planar Planar Embedding and Drawing
+@defgroup planar Planarity Embedding and Drawing
 @ingroup algs
 \brief Algorithms for planarity checking, embedding and drawing
@@ -603,41 +553,5 @@
 
 /**
-@defgroup tsp Traveling Salesman Problem
-@ingroup algs
-\brief Algorithms for the symmetric traveling salesman problem
-
-This group contains basic heuristic algorithms for the the symmetric
-\e traveling \e salesman \e problem (TSP).
-Given an \ref FullGraph "undirected full graph" with a cost map on its edges,
-the problem is to find a shortest possible tour that visits each node exactly
-once (i.e. the minimum cost Hamiltonian cycle).
-
-These TSP algorithms are intended to be used with a \e metric \e cost
-\e function, i.e. the edge costs should satisfy the triangle inequality.
-Otherwise the algorithms could yield worse results.
-
-LEMON provides five well-known heuristics for solving symmetric TSP:
- - \ref NearestNeighborTsp Neareast neighbor algorithm
- - \ref GreedyTsp Greedy algorithm
- - \ref InsertionTsp Insertion heuristic (with four selection methods)
- - \ref ChristofidesTsp Christofides algorithm
- - \ref Opt2Tsp 2-opt algorithm
-
-\ref NearestNeighborTsp, \ref GreedyTsp, and \ref InsertionTsp are the fastest
-solution methods. Furthermore, \ref InsertionTsp is usually quite effective.
-
-\ref ChristofidesTsp is somewhat slower, but it has the best guaranteed
-approximation factor: 3/2.
-
-\ref Opt2Tsp usually provides the best results in practice, but
-it is the slowest method. It can also be used to improve given tours,
-for example, the results of other algorithms.
-
-\image html tsp.png
-\image latex tsp.eps "Traveling salesman problem" width=\textwidth
-*/
-
-/**
-@defgroup approx_algs Approximation Algorithms
+@defgroup approx Approximation Algorithms
 @ingroup algs
 \brief Approximation algorithms.
@@ -645,8 +559,4 @@
 This group contains the approximation and heuristic algorithms
 implemented in LEMON.
-
-<b>Maximum Clique Problem</b>
-  - \ref GrossoLocatelliPullanMc An efficient heuristic algorithm of
-    Grosso, Locatelli, and Pullan.
 */
 
@@ -678,6 +588,6 @@
 high-level interface.
 
-The currently supported solvers are \cite glpk, \cite clp, \cite cbc,
-\cite cplex, \cite soplex.
+The currently supported solvers are \ref glpk, \ref clp, \ref cbc,
+\ref cplex, \ref soplex.
 */
 
@@ -766,6 +676,4 @@
 This group contains general \c EPS drawing methods and special
 graph exporting tools.
-
-\image html graph_to_eps.png
 */
 
Index: c/images/adaptors1.eps
===================================================================
--- doc/images/adaptors1.eps	(revision 1218)
+++ 	(revision )
@@ -1,303 +1,0 @@
-%!PS-Adobe-2.0 EPSF-2.0
-%%Title: adaptors1.fig
-%%Creator: fig2dev Version 3.2 Patchlevel 5
-%%CreationDate: Sun Feb 21 18:51:21 2010
-%%For: Peter@KOVACSPETER (PÃ©ter,U-KOVACSPETER\Peter,S-1-5-21-1774138250-1299389707-1938712334-1001)
-%%BoundingBox: 0 0 787 372
-%Magnification: 1.0000
-%%EndComments
-/$F2psDict 200 dict def
-$F2psDict begin
-$F2psDict /mtrx matrix put
-/col-1 {0 setgray} bind def
-/col0 {0.000 0.000 0.000 srgb} bind def
-/col1 {0.000 0.000 1.000 srgb} bind def
-/col2 {0.000 1.000 0.000 srgb} bind def
-/col3 {0.000 1.000 1.000 srgb} bind def
-/col4 {1.000 0.000 0.000 srgb} bind def
-/col5 {1.000 0.000 1.000 srgb} bind def
-/col6 {1.000 1.000 0.000 srgb} bind def
-/col7 {1.000 1.000 1.000 srgb} bind def
-/col8 {0.000 0.000 0.560 srgb} bind def
-/col9 {0.000 0.000 0.690 srgb} bind def
-/col10 {0.000 0.000 0.820 srgb} bind def
-/col11 {0.530 0.810 1.000 srgb} bind def
-/col12 {0.000 0.560 0.000 srgb} bind def
-/col13 {0.000 0.690 0.000 srgb} bind def
-/col14 {0.000 0.820 0.000 srgb} bind def
-/col15 {0.000 0.560 0.560 srgb} bind def
-/col16 {0.000 0.690 0.690 srgb} bind def
-/col17 {0.000 0.820 0.820 srgb} bind def
-/col18 {0.560 0.000 0.000 srgb} bind def
-/col19 {0.690 0.000 0.000 srgb} bind def
-/col20 {0.820 0.000 0.000 srgb} bind def
-/col21 {0.560 0.000 0.560 srgb} bind def
-/col22 {0.690 0.000 0.690 srgb} bind def
-/col23 {0.820 0.000 0.820 srgb} bind def
-/col24 {0.500 0.190 0.000 srgb} bind def
-/col25 {0.630 0.250 0.000 srgb} bind def
-/col26 {0.750 0.380 0.000 srgb} bind def
-/col27 {1.000 0.500 0.500 srgb} bind def
-/col28 {1.000 0.630 0.630 srgb} bind def
-/col29 {1.000 0.750 0.750 srgb} bind def
-/col30 {1.000 0.880 0.880 srgb} bind def
-/col31 {1.000 0.840 0.000 srgb} bind def
-
-end
-save
-newpath 0 372 moveto 0 0 lineto 787 0 lineto 787 372 lineto closepath clip newpath
--14.2 385.4 translate
-1 -1 scale
-
-/cp {closepath} bind def
-/ef {eofill} bind def
-/gr {grestore} bind def
-/gs {gsave} bind def
-/sa {save} bind def
-/rs {restore} bind def
-/l {lineto} bind def
-/m {moveto} bind def
-/rm {rmoveto} bind def
-/n {newpath} bind def
-/s {stroke} bind def
-/sh {show} bind def
-/slc {setlinecap} bind def
-/slj {setlinejoin} bind def
-/slw {setlinewidth} bind def
-/srgb {setrgbcolor} bind def
-/rot {rotate} bind def
-/sc {scale} bind def
-/sd {setdash} bind def
-/ff {findfont} bind def
-/sf {setfont} bind def
-/scf {scalefont} bind def
-/sw {stringwidth} bind def
-/tr {translate} bind def
-/tnt {dup dup currentrgbcolor
-  4 -2 roll dup 1 exch sub 3 -1 roll mul add
-  4 -2 roll dup 1 exch sub 3 -1 roll mul add
-  4 -2 roll dup 1 exch sub 3 -1 roll mul add srgb}
-  bind def
-/shd {dup dup currentrgbcolor 4 -2 roll mul 4 -2 roll mul
-  4 -2 roll mul srgb} bind def
- /DrawEllipse {
-	/endangle exch def
-	/startangle exch def
-	/yrad exch def
-	/xrad exch def
-	/y exch def
-	/x exch def
-	/savematrix mtrx currentmatrix def
-	x y tr xrad yrad sc 0 0 1 startangle endangle arc
-	closepath
-	savematrix setmatrix
-	} def
-
-/$F2psBegin {$F2psDict begin /$F2psEnteredState save def} def
-/$F2psEnd {$F2psEnteredState restore end} def
-
-$F2psBegin
-10 setmiterlimit
-0 slj 0 slc
- 0.06299 0.06299 sc
-%
-% Fig objects follow
-%
-% 
-% here starts figure with depth 60
-% Polyline
-0 slj
-0 slc
-15.000 slw
-gs  clippath
-6319 5229 m 6442 5564 l 6527 5533 l 6403 5198 l 6403 5198 l 6424 5383 l 6319 5229 l cp
-eoclip
-n 5850 3825 m
- 6480 5535 l gs col0 s gr gr
-
-% arrowhead
-75.000 slw
-n 6319 5229 m 6424 5383 l 6403 5198 l 6319 5229 l  cp gs 0.00 setgray ef gr  col0 s
-% Polyline
-15.000 slw
-gs  clippath
-5417 4044 m 5746 3905 l 5711 3822 l 5382 3961 l 5382 3961 l 5566 3933 l 5417 4044 l cp
-eoclip
-n 1575 5625 m
- 5715 3870 l gs col0 s gr gr
-
-% arrowhead
-75.000 slw
-n 5417 4044 m 5566 3933 l 5382 3961 l 5417 4044 l  cp gs 0.00 setgray ef gr  col0 s
-% Polyline
-15.000 slw
-gs  clippath
-3897 3780 m 3540 3780 l 3540 3870 l 3897 3870 l 3897 3870 l 3717 3825 l 3897 3780 l cp
-eoclip
-n 5625 3825 m
- 3555 3825 l gs col0 s gr gr
-
-% arrowhead
-75.000 slw
-n 3897 3780 m 3717 3825 l 3897 3870 l 3897 3780 l  cp gs 0.00 setgray ef gr  col0 s
-% Polyline
-15.000 slw
-gs  clippath
-3075 4188 m 3327 3936 l 3263 3872 l 3011 4124 l 3011 4124 l 3171 4029 l 3075 4188 l cp
-eoclip
-n 1575 5625 m
- 3285 3915 l gs col0 s gr gr
-
-% arrowhead
-75.000 slw
-n 3075 4188 m 3171 4029 l 3011 4124 l 3075 4188 l  cp gs 0.00 setgray ef gr  col0 s
-% Polyline
-15.000 slw
-gs  clippath
-3528 2520 m 3885 2520 l 3885 2430 l 3528 2430 l 3528 2430 l 3708 2475 l 3528 2520 l cp
-eoclip
-n 1800 2475 m
- 3870 2475 l gs col0 s gr gr
-
-% arrowhead
-75.000 slw
-n 3528 2520 m 3708 2475 l 3528 2430 l 3528 2520 l  cp gs 0.00 setgray ef gr  col0 s
-% Polyline
-15.000 slw
-gs  clippath
-4304 2156 m 4052 2408 l 4116 2472 l 4368 2220 l 4368 2220 l 4209 2316 l 4304 2156 l cp
-eoclip
-n 5850 675 m
- 4095 2430 l gs col0 s gr gr
-
-% arrowhead
-75.000 slw
-n 4304 2156 m 4209 2316 l 4368 2220 l 4304 2156 l  cp gs 0.00 setgray ef gr  col0 s
-% Polyline
-15.000 slw
-gs  clippath
-6319 2079 m 6442 2414 l 6527 2383 l 6403 2048 l 6403 2048 l 6424 2233 l 6319 2079 l cp
-eoclip
-n 5850 675 m
- 6480 2385 l gs col0 s gr gr
-
-% arrowhead
-75.000 slw
-n 6319 2079 m 6424 2233 l 6403 2048 l 6319 2079 l  cp gs 0.00 setgray ef gr  col0 s
-% Polyline
-15.000 slw
-gs  clippath
-5417 894 m 5746 755 l 5711 672 l 5382 811 l 5382 811 l 5566 783 l 5417 894 l cp
-eoclip
-n 1575 2475 m
- 5715 720 l gs col0 s gr gr
-
-% arrowhead
-75.000 slw
-n 5417 894 m 5566 783 l 5382 811 l 5417 894 l  cp gs 0.00 setgray ef gr  col0 s
-% Polyline
-15.000 slw
-gs  clippath
-3528 5670 m 3885 5670 l 3885 5580 l 3528 5580 l 3528 5580 l 3708 5625 l 3528 5670 l cp
-eoclip
-n 1800 5625 m
- 3870 5625 l gs col0 s gr gr
-
-% arrowhead
-75.000 slw
-n 3528 5670 m 3708 5625 l 3528 5580 l 3528 5670 l  cp gs 0.00 setgray ef gr  col0 s
-% Polyline
-15.000 slw
-gs  clippath
-4572 5580 m 4215 5580 l 4215 5670 l 4572 5670 l 4572 5670 l 4392 5625 l 4572 5580 l cp
-eoclip
-n 6300 5625 m
- 4230 5625 l gs col0 s gr gr
-
-% arrowhead
-75.000 slw
-n 4572 5580 m 4392 5625 l 4572 5670 l 4572 5580 l  cp gs 0.00 setgray ef gr  col0 s
-% Polyline
-15.000 slw
-gs  clippath
-4304 5306 m 4052 5558 l 4116 5622 l 4368 5370 l 4368 5370 l 4209 5466 l 4304 5306 l cp
-eoclip
-n 5850 3825 m
- 4095 5580 l gs col0 s gr gr
-
-% arrowhead
-75.000 slw
-n 4304 5306 m 4209 5466 l 4368 5370 l 4304 5306 l  cp gs 0.00 setgray ef gr  col0 s
-% here ends figure;
-% 
-% here starts figure with depth 50
-% Ellipse
-15.000 slw
-n 3375 3825 225 112 0 360 DrawEllipse gs 1.00 setgray ef gr gs col0 s gr
-
-% Ellipse
-n 5850 3825 225 112 0 360 DrawEllipse gs 1.00 setgray ef gr gs col0 s gr
-
-% Polyline
-0 slj
-0 slc
-n 247 2947 m 2947 247 l 9697 247 l 6997 2947 l
- 247 2947 l  cp gs col0 s gr 
-% Polyline
-n 247 6097 m 2947 3397 l 9697 3397 l 6997 6097 l
- 247 6097 l  cp gs col0 s gr 
-% Ellipse
-n 1575 2475 225 112 0 360 DrawEllipse gs 1.00 setgray ef gr gs col0 s gr
-
-% Ellipse
-n 4050 2475 225 112 0 360 DrawEllipse gs 1.00 setgray ef gr gs col0 s gr
-
-% Ellipse
-n 6525 2475 225 112 0 360 DrawEllipse gs 1.00 setgray ef gr gs col0 s gr
-
-% Ellipse
-n 5850 675 225 112 0 360 DrawEllipse gs 1.00 setgray ef gr gs col0 s gr
-
-% Ellipse
-n 1575 5625 225 112 0 360 DrawEllipse gs 1.00 setgray ef gr gs col0 s gr
-
-% Ellipse
-n 4050 5625 225 112 0 360 DrawEllipse gs 1.00 setgray ef gr gs col0 s gr
-
-% Ellipse
-n 6525 5625 225 112 0 360 DrawEllipse gs 1.00 setgray ef gr gs col0 s gr
-
-% here ends figure;
-% 
-% here starts figure with depth 40
-/Helvetica ff 480.00 scf sf
-8280 2610 m
-gs 1 -1 sc (SubDigraph adaptor) col0 sh gr
-% Polyline
-0 slj
-0 slc
-7.500 slw
- [15 45] 45 sd
-n 4050 2610 m
- 4050 5625 l gs col0 s gr  [] 0 sd
-% Polyline
- [15 45] 45 sd
-n 5850 810 m
- 5850 3825 l gs col0 s gr  [] 0 sd
-% Polyline
- [15 45] 45 sd
-n 6525 2610 m
- 6525 5625 l gs col0 s gr  [] 0 sd
-/Helvetica ff 480.00 scf sf
-8280 5760 m
-gs 1 -1 sc (Original digraph) col0 sh gr
-% Polyline
- [15 45] 45 sd
-n 1575 2610 m
- 1575 5625 l gs col0 s gr  [] 0 sd
-% here ends figure;
-$F2psEnd
-rs
-showpage
-%%Trailer
-%EOF
Index: c/images/adaptors2.eps
===================================================================
--- doc/images/adaptors2.eps	(revision 1218)
+++ 	(revision )
@@ -1,349 +1,0 @@
-%!PS-Adobe-2.0 EPSF-2.0
-%%Title: adaptors2.fig
-%%Creator: fig2dev Version 3.2 Patchlevel 5
-%%CreationDate: Sun Feb 21 18:51:31 2010
-%%For: Peter@KOVACSPETER (PÃ©ter,U-KOVACSPETER\Peter,S-1-5-21-1774138250-1299389707-1938712334-1001)
-%%BoundingBox: 0 0 787 570
-%Magnification: 1.0000
-%%EndComments
-/$F2psDict 200 dict def
-$F2psDict begin
-$F2psDict /mtrx matrix put
-/col-1 {0 setgray} bind def
-/col0 {0.000 0.000 0.000 srgb} bind def
-/col1 {0.000 0.000 1.000 srgb} bind def
-/col2 {0.000 1.000 0.000 srgb} bind def
-/col3 {0.000 1.000 1.000 srgb} bind def
-/col4 {1.000 0.000 0.000 srgb} bind def
-/col5 {1.000 0.000 1.000 srgb} bind def
-/col6 {1.000 1.000 0.000 srgb} bind def
-/col7 {1.000 1.000 1.000 srgb} bind def
-/col8 {0.000 0.000 0.560 srgb} bind def
-/col9 {0.000 0.000 0.690 srgb} bind def
-/col10 {0.000 0.000 0.820 srgb} bind def
-/col11 {0.530 0.810 1.000 srgb} bind def
-/col12 {0.000 0.560 0.000 srgb} bind def
-/col13 {0.000 0.690 0.000 srgb} bind def
-/col14 {0.000 0.820 0.000 srgb} bind def
-/col15 {0.000 0.560 0.560 srgb} bind def
-/col16 {0.000 0.690 0.690 srgb} bind def
-/col17 {0.000 0.820 0.820 srgb} bind def
-/col18 {0.560 0.000 0.000 srgb} bind def
-/col19 {0.690 0.000 0.000 srgb} bind def
-/col20 {0.820 0.000 0.000 srgb} bind def
-/col21 {0.560 0.000 0.560 srgb} bind def
-/col22 {0.690 0.000 0.690 srgb} bind def
-/col23 {0.820 0.000 0.820 srgb} bind def
-/col24 {0.500 0.190 0.000 srgb} bind def
-/col25 {0.630 0.250 0.000 srgb} bind def
-/col26 {0.750 0.380 0.000 srgb} bind def
-/col27 {1.000 0.500 0.500 srgb} bind def
-/col28 {1.000 0.630 0.630 srgb} bind def
-/col29 {1.000 0.750 0.750 srgb} bind def
-/col30 {1.000 0.880 0.880 srgb} bind def
-/col31 {1.000 0.840 0.000 srgb} bind def
-
-end
-save
-newpath 0 570 moveto 0 0 lineto 787 0 lineto 787 570 lineto closepath clip newpath
--14.2 583.9 translate
-1 -1 scale
-
-/cp {closepath} bind def
-/ef {eofill} bind def
-/gr {grestore} bind def
-/gs {gsave} bind def
-/sa {save} bind def
-/rs {restore} bind def
-/l {lineto} bind def
-/m {moveto} bind def
-/rm {rmoveto} bind def
-/n {newpath} bind def
-/s {stroke} bind def
-/sh {show} bind def
-/slc {setlinecap} bind def
-/slj {setlinejoin} bind def
-/slw {setlinewidth} bind def
-/srgb {setrgbcolor} bind def
-/rot {rotate} bind def
-/sc {scale} bind def
-/sd {setdash} bind def
-/ff {findfont} bind def
-/sf {setfont} bind def
-/scf {scalefont} bind def
-/sw {stringwidth} bind def
-/tr {translate} bind def
-/tnt {dup dup currentrgbcolor
-  4 -2 roll dup 1 exch sub 3 -1 roll mul add
-  4 -2 roll dup 1 exch sub 3 -1 roll mul add
-  4 -2 roll dup 1 exch sub 3 -1 roll mul add srgb}
-  bind def
-/shd {dup dup currentrgbcolor 4 -2 roll mul 4 -2 roll mul
-  4 -2 roll mul srgb} bind def
- /DrawEllipse {
-	/endangle exch def
-	/startangle exch def
-	/yrad exch def
-	/xrad exch def
-	/y exch def
-	/x exch def
-	/savematrix mtrx currentmatrix def
-	x y tr xrad yrad sc 0 0 1 startangle endangle arc
-	closepath
-	savematrix setmatrix
-	} def
-
-/$F2psBegin {$F2psDict begin /$F2psEnteredState save def} def
-/$F2psEnd {$F2psEnteredState restore end} def
-
-$F2psBegin
-10 setmiterlimit
-0 slj 0 slc
- 0.06299 0.06299 sc
-%
-% Fig objects follow
-%
-% 
-% here starts figure with depth 60
-% Polyline
-0 slj
-0 slc
-15.000 slw
-gs  clippath
-5417 4044 m 5746 3905 l 5711 3822 l 5382 3961 l 5382 3961 l 5566 3933 l 5417 4044 l cp
-eoclip
-n 1575 5625 m
- 5715 3870 l gs col0 s gr gr
-
-% arrowhead
-75.000 slw
-n 5417 4044 m 5566 3933 l 5382 3961 l 5417 4044 l  cp gs 0.00 setgray ef gr  col0 s
-% Polyline
-15.000 slw
-gs  clippath
-5417 7194 m 5746 7055 l 5711 6972 l 5382 7111 l 5382 7111 l 5566 7083 l 5417 7194 l cp
-eoclip
-n 1575 8775 m
- 5715 7020 l gs col0 s gr gr
-
-% arrowhead
-75.000 slw
-n 5417 7194 m 5566 7083 l 5382 7111 l 5417 7194 l  cp gs 0.00 setgray ef gr  col0 s
-% Polyline
-15.000 slw
-gs  clippath
-6319 8379 m 6442 8714 l 6527 8683 l 6403 8348 l 6403 8348 l 6424 8533 l 6319 8379 l cp
-eoclip
-n 5850 6975 m
- 6480 8685 l gs col0 s gr gr
-
-% arrowhead
-75.000 slw
-n 6319 8379 m 6424 8533 l 6403 8348 l 6319 8379 l  cp gs 0.00 setgray ef gr  col0 s
-% Polyline
-15.000 slw
-gs  clippath
-4304 8456 m 4052 8708 l 4116 8772 l 4368 8520 l 4368 8520 l 4209 8616 l 4304 8456 l cp
-eoclip
-n 5850 6975 m
- 4095 8730 l gs col0 s gr gr
-
-% arrowhead
-75.000 slw
-n 4304 8456 m 4209 8616 l 4368 8520 l 4304 8456 l  cp gs 0.00 setgray ef gr  col0 s
-% Polyline
-15.000 slw
-gs  clippath
-4572 8730 m 4215 8730 l 4215 8820 l 4572 8820 l 4572 8820 l 4392 8775 l 4572 8730 l cp
-eoclip
-n 6300 8775 m
- 4230 8775 l gs col0 s gr gr
-
-% arrowhead
-75.000 slw
-n 4572 8730 m 4392 8775 l 4572 8820 l 4572 8730 l  cp gs 0.00 setgray ef gr  col0 s
-% Polyline
-15.000 slw
-gs  clippath
-3528 8820 m 3885 8820 l 3885 8730 l 3528 8730 l 3528 8730 l 3708 8775 l 3528 8820 l cp
-eoclip
-n 1800 8775 m
- 3870 8775 l gs col0 s gr gr
-
-% arrowhead
-75.000 slw
-n 3528 8820 m 3708 8775 l 3528 8730 l 3528 8820 l  cp gs 0.00 setgray ef gr  col0 s
-% Polyline
-15.000 slw
-n 1800 2475 m
- 3870 2475 l gs col0 s gr 
-% Polyline
-n 1575 2475 m
- 5715 720 l gs col0 s gr 
-% Polyline
-n 5850 675 m
- 4095 2430 l gs col0 s gr 
-% Polyline
-n 5850 675 m
- 6480 2385 l gs col0 s gr 
-% Polyline
-gs  clippath
-3075 7338 m 3327 7086 l 3263 7022 l 3011 7274 l 3011 7274 l 3171 7179 l 3075 7338 l cp
-eoclip
-n 1575 8775 m
- 3285 7065 l gs col0 s gr gr
-
-% arrowhead
-75.000 slw
-n 3075 7338 m 3171 7179 l 3011 7274 l 3075 7338 l  cp gs 0.00 setgray ef gr  col0 s
-% Polyline
-15.000 slw
-gs  clippath
-3528 5670 m 3885 5670 l 3885 5580 l 3528 5580 l 3528 5580 l 3708 5625 l 3528 5670 l cp
-eoclip
-n 1800 5625 m
- 3870 5625 l gs col0 s gr gr
-
-% arrowhead
-75.000 slw
-n 3528 5670 m 3708 5625 l 3528 5580 l 3528 5670 l  cp gs 0.00 setgray ef gr  col0 s
-% Polyline
-15.000 slw
-gs  clippath
-4304 5306 m 4052 5558 l 4116 5622 l 4368 5370 l 4368 5370 l 4209 5466 l 4304 5306 l cp
-eoclip
-n 5850 3825 m
- 4095 5580 l gs col0 s gr gr
-
-% arrowhead
-75.000 slw
-n 4304 5306 m 4209 5466 l 4368 5370 l 4304 5306 l  cp gs 0.00 setgray ef gr  col0 s
-% Polyline
-15.000 slw
-gs  clippath
-6319 5229 m 6442 5564 l 6527 5533 l 6403 5198 l 6403 5198 l 6424 5383 l 6319 5229 l cp
-eoclip
-n 5850 3825 m
- 6480 5535 l gs col0 s gr gr
-
-% arrowhead
-75.000 slw
-n 6319 5229 m 6424 5383 l 6403 5198 l 6319 5229 l  cp gs 0.00 setgray ef gr  col0 s
-% Polyline
-15.000 slw
-gs  clippath
-3897 6930 m 3540 6930 l 3540 7020 l 3897 7020 l 3897 7020 l 3717 6975 l 3897 6930 l cp
-eoclip
-n 5625 6975 m
- 3555 6975 l gs col0 s gr gr
-
-% arrowhead
-75.000 slw
-n 3897 6930 m 3717 6975 l 3897 7020 l 3897 6930 l  cp gs 0.00 setgray ef gr  col0 s
-% here ends figure;
-% 
-% here starts figure with depth 50
-% Polyline
-0 slj
-0 slc
-15.000 slw
-n 247 6097 m 2947 3397 l 9697 3397 l 6997 6097 l
- 247 6097 l  cp gs col0 s gr 
-% Polyline
-n 247 9247 m 2947 6547 l 9697 6547 l 6997 9247 l
- 247 9247 l  cp gs col0 s gr 
-% Ellipse
-n 4050 2475 225 112 0 360 DrawEllipse gs 1.00 setgray ef gr gs col0 s gr
-
-% Ellipse
-n 6525 2475 225 112 0 360 DrawEllipse gs 1.00 setgray ef gr gs col0 s gr
-
-% Ellipse
-n 1575 2475 225 112 0 360 DrawEllipse gs 1.00 setgray ef gr gs col0 s gr
-
-% Ellipse
-n 5850 675 225 112 0 360 DrawEllipse gs 1.00 setgray ef gr gs col0 s gr
-
-% Ellipse
-n 1575 5625 225 112 0 360 DrawEllipse gs 1.00 setgray ef gr gs col0 s gr
-
-% Ellipse
-n 4050 5625 225 112 0 360 DrawEllipse gs 1.00 setgray ef gr gs col0 s gr
-
-% Ellipse
-n 6525 5625 225 112 0 360 DrawEllipse gs 1.00 setgray ef gr gs col0 s gr
-
-% Ellipse
-n 5850 3825 225 112 0 360 DrawEllipse gs 1.00 setgray ef gr gs col0 s gr
-
-% Ellipse
-n 1575 8775 225 112 0 360 DrawEllipse gs 1.00 setgray ef gr gs col0 s gr
-
-% Ellipse
-n 4050 8775 225 112 0 360 DrawEllipse gs 1.00 setgray ef gr gs col0 s gr
-
-% Ellipse
-n 3375 6975 225 112 0 360 DrawEllipse gs 1.00 setgray ef gr gs col0 s gr
-
-% Ellipse
-n 6525 8775 225 112 0 360 DrawEllipse gs 1.00 setgray ef gr gs col0 s gr
-
-% Ellipse
-n 5850 6975 225 112 0 360 DrawEllipse gs 1.00 setgray ef gr gs col0 s gr
-
-% Polyline
-n 247 2947 m 2947 247 l 9697 247 l 6997 2947 l
- 247 2947 l  cp gs col0 s gr 
-% here ends figure;
-% 
-% here starts figure with depth 40
-/Helvetica ff 480.00 scf sf
-8280 8910 m
-gs 1 -1 sc (Original digraph) col0 sh gr
-% Polyline
-0 slj
-0 slc
-7.500 slw
- [15 45] 45 sd
-n 5850 810 m
- 5850 3825 l gs col0 s gr  [] 0 sd
-% Polyline
- [15 45] 45 sd
-n 6525 2610 m
- 6525 5625 l gs col0 s gr  [] 0 sd
-% Polyline
- [15 45] 45 sd
-n 4050 2610 m
- 4050 5625 l gs col0 s gr  [] 0 sd
-% Polyline
- [15 45] 45 sd
-n 1575 2610 m
- 1575 5625 l gs col0 s gr  [] 0 sd
-% Polyline
- [15 45] 45 sd
-n 5850 3960 m
- 5850 6975 l gs col0 s gr  [] 0 sd
-% Polyline
- [15 45] 45 sd
-n 6525 5760 m
- 6525 8775 l gs col0 s gr  [] 0 sd
-% Polyline
- [15 45] 45 sd
-n 4050 5760 m
- 4050 8775 l gs col0 s gr  [] 0 sd
-/Helvetica ff 480.00 scf sf
-8280 2610 m
-gs 1 -1 sc (Undirector adaptor) col0 sh gr
-/Helvetica ff 480.00 scf sf
-8280 5760 m
-gs 1 -1 sc (SubDigraph adaptor) col0 sh gr
-% Polyline
- [15 45] 45 sd
-n 1575 5760 m
- 1575 8775 l gs col0 s gr  [] 0 sd
-% here ends figure;
-$F2psEnd
-rs
-showpage
-%%Trailer
-%EOF
Index: doc/images/bipartite_partitions.eps
===================================================================
--- doc/images/bipartite_partitions.eps	(revision 1213)
+++ doc/images/bipartite_partitions.eps	(revision 634)
@@ -1,5 +1,5 @@
 %!PS-Adobe-2.0 EPSF-2.0
 %%Creator: LEMON, graphToEps()
-%%CreationDate: Fri Mar  8 00:18:43 2013
+%%CreationDate: Tue Nov 15 16:51:43 2005
 %%BoundingBox: 0 0 842 596
 %%EndComments
@@ -54,60 +54,60 @@
 %Edges:
 gsave
-513.857 -446.322 296.569 -487.43 79.2808 -528.539 0 0 0 7.00153 lb
-513.857 -446.322 575.52 -315.656 637.183 -184.989 0 0 0 7.00153 lb
-393.468 566.711 494.771 434.577 596.074 302.442 0 0 0 7.00153 lb
-393.468 566.711 155.625 579.925 -82.2171 593.138 0 0 0 7.00153 lb
-393.468 566.711 251.056 450.726 108.644 334.741 0 0 0 7.00153 lb
-869.153 52.8539 732.613 177.648 596.074 302.442 0 0 0 7.00153 lb
-869.153 52.8539 753.168 -66.0676 637.183 -184.989 0 0 0 7.00153 lb
--82.2171 593.138 -91.0261 346.487 -99.8351 99.8351 0 0 0 7.00153 lb
--663.61 546.157 -753.168 394.936 -842.726 243.715 0 0 0 7.00153 lb
--663.61 546.157 -574.052 437.513 -484.494 328.869 0 0 0 7.00153 lb
--1077.63 161.498 -960.178 202.606 -842.726 243.715 0 0 0 7.00153 lb
--1077.63 161.498 -968.987 66.0674 -860.344 -29.3633 0 0 0 7.00153 lb
--1177.47 -234.906 -1029.18 -381.722 -880.898 -528.539 0 0 0 7.00153 lb
--1177.47 -234.906 -1018.91 -132.135 -860.344 -29.3633 0 0 0 7.00153 lb
--880.898 -528.539 -744.359 -387.595 -607.82 -246.651 0 0 0 7.00153 lb
--499.175 -499.175 -355.295 -475.685 -211.415 -452.194 0 0 0 7.00153 lb
--499.175 -499.175 -553.498 -372.913 -607.82 -246.651 0 0 0 7.00153 lb
--499.175 -499.175 -386.587 -315.087 -274 -131 0 0 0 7.00153 lb
-79.2808 -528.539 -66.0671 -490.366 -211.415 -452.194 0 0 0 7.00153 lb
-637.183 -184.989 421.363 -253.993 205.543 -322.996 0 0 0 7.00153 lb
-205.543 -322.996 162.966 -226.097 120.389 -129.198 0 0 0 7.00153 lb
-399.34 88.0898 259.865 -20.5541 120.389 -129.198 0 0 0 7.00153 lb
-399.34 88.0898 253.992 211.415 108.644 334.741 0 0 0 7.00153 lb
--842.726 243.715 -471.281 171.775 -99.8351 99.8351 0 0 0 7.00153 lb
--842.726 243.715 -558.363 56.3575 -274 -131 0 0 0 7.00153 lb
--860.344 -29.3633 -734.082 -138.007 -607.82 -246.651 0 0 0 7.00153 lb
--211.415 -452.194 -45.513 -290.696 120.389 -129.198 0 0 0 7.00153 lb
--99.8351 99.8351 4.40445 217.288 108.644 334.741 0 0 0 7.00153 lb
--99.8351 99.8351 -292.165 214.352 -484.494 328.869 0 0 0 7.00153 lb
-120.389 -129.198 -76.8055 -130.099 -274 -131 0 0 0 7.00153 lb
+513.857 -446.322 296.569 -487.43 79.2808 -528.539 0 0 0 2 lb
+513.857 -446.322 575.52 -315.655 637.183 -184.989 0 0 0 2 lb
+393.468 566.711 494.771 434.577 596.074 302.442 0 0 0 2 lb
+393.468 566.711 155.625 579.925 -82.2171 593.138 0 0 0 2 lb
+393.468 566.711 251.056 450.726 108.644 334.741 0 0 0 2 lb
+869.153 52.8539 732.613 177.648 596.074 302.442 0 0 0 2 lb
+869.153 52.8539 753.168 -66.0676 637.183 -184.989 0 0 0 2 lb
+-82.2171 593.138 -91.0261 346.487 -99.8351 99.8351 0 0 0 2 lb
+-663.61 546.157 -753.168 394.936 -842.726 243.715 0 0 0 2 lb
+-663.61 546.157 -574.052 437.513 -484.494 328.869 0 0 0 2 lb
+-1077.63 161.498 -960.178 202.606 -842.726 243.715 0 0 0 2 lb
+-1077.63 161.498 -968.987 66.0674 -860.344 -29.3633 0 0 0 2 lb
+-1177.47 -234.906 -1029.18 -381.722 -880.898 -528.539 0 0 0 2 lb
+-1177.47 -234.906 -1018.91 -132.135 -860.344 -29.3633 0 0 0 2 lb
+-880.898 -528.539 -744.359 -387.595 -607.82 -246.651 0 0 0 2 lb
+-499.175 -499.175 -355.295 -475.685 -211.415 -452.194 0 0 0 2 lb
+-499.175 -499.175 -553.498 -372.913 -607.82 -246.651 0 0 0 2 lb
+-499.175 -499.175 -386.587 -315.087 -274 -131 0 0 0 2 lb
+79.2808 -528.539 -66.0671 -490.366 -211.415 -452.194 0 0 0 2 lb
+637.183 -184.989 421.363 -253.993 205.543 -322.996 0 0 0 2 lb
+205.543 -322.996 162.966 -226.097 120.389 -129.198 0 0 0 2 lb
+399.34 88.0898 259.865 -20.5541 120.389 -129.198 0 0 0 2 lb
+399.34 88.0898 253.992 211.415 108.644 334.741 0 0 0 2 lb
+-842.726 243.715 -471.281 171.775 -99.8351 99.8351 0 0 0 2 lb
+-842.726 243.715 -558.363 56.3575 -274 -131 0 0 0 2 lb
+-860.344 -29.3633 -734.082 -138.007 -607.82 -246.651 0 0 0 2 lb
+-211.415 -452.194 -45.513 -290.696 120.389 -129.198 0 0 0 2 lb
+-99.8351 99.8351 4.40445 217.288 108.644 334.741 0 0 0 2 lb
+-99.8351 99.8351 -292.165 214.352 -484.494 328.869 0 0 0 2 lb
+120.389 -129.198 -76.8055 -130.099 -274 -131 0 0 0 2 lb
 grestore
 %Nodes:
 gsave
--274 -131 23.3384 1 0 0 nc
--607.82 -246.651 23.3384 1 0 0 nc
--484.494 328.869 23.3384 0 0 1 nc
-108.644 334.741 23.3384 0 0 1 nc
-120.389 -129.198 23.3384 0 0 1 nc
--99.8351 99.8351 23.3384 1 0 0 nc
--211.415 -452.194 23.3384 1 0 0 nc
--860.344 -29.3633 23.3384 0 0 1 nc
--842.726 243.715 23.3384 0 0 1 nc
-399.34 88.0898 23.3384 1 0 0 nc
-205.543 -322.996 23.3384 1 0 0 nc
-637.183 -184.989 23.3384 0 0 1 nc
-79.2808 -528.539 23.3384 0 0 1 nc
--499.175 -499.175 23.3384 0 0 1 nc
--880.898 -528.539 23.3384 0 0 1 nc
--1177.47 -234.906 23.3384 1 0 0 nc
--1077.63 161.498 23.3384 1 0 0 nc
--663.61 546.157 23.3384 1 0 0 nc
--82.2171 593.138 23.3384 0 0 1 nc
-596.074 302.442 23.3384 0 0 1 nc
-869.153 52.8539 23.3384 1 0 0 nc
-393.468 566.711 23.3384 1 0 0 nc
-513.857 -446.322 23.3384 1 0 0 nc
+-274 -131 20 1 0 0 nc
+-607.82 -246.651 20 1 0 0 nc
+-484.494 328.869 20 0 0 1 nc
+108.644 334.741 20 0 0 1 nc
+120.389 -129.198 20 0 0 1 nc
+-99.8351 99.8351 20 1 0 0 nc
+-211.415 -452.194 20 1 0 0 nc
+-860.344 -29.3633 20 0 0 1 nc
+-842.726 243.715 20 0 0 1 nc
+399.34 88.0898 20 1 0 0 nc
+205.543 -322.996 20 1 0 0 nc
+637.183 -184.989 20 0 0 1 nc
+79.2808 -528.539 20 0 0 1 nc
+-499.175 -499.175 20 0 0 1 nc
+-880.898 -528.539 20 0 0 1 nc
+-1177.47 -234.906 20 1 0 0 nc
+-1077.63 161.498 20 1 0 0 nc
+-663.61 546.157 20 1 0 0 nc
+-82.2171 593.138 20 0 0 1 nc
+596.074 302.442 20 0 0 1 nc
+869.153 52.8539 20 1 0 0 nc
+393.468 566.711 20 1 0 0 nc
+513.857 -446.322 20 1 0 0 nc
 grestore
 grestore
Index: doc/images/connected_components.eps
===================================================================
--- doc/images/connected_components.eps	(revision 1213)
+++ doc/images/connected_components.eps	(revision 634)
@@ -1,5 +1,5 @@
 %!PS-Adobe-2.0 EPSF-2.0
 %%Creator: LEMON, graphToEps()
-%%CreationDate: Fri Mar  8 00:18:43 2013
+%%CreationDate: Fri Nov  4 13:47:12 2005
 %%BoundingBox: 0 0 842 596
 %%EndComments
@@ -54,105 +54,105 @@
 %Edges:
 gsave
-574.035 177.301 622.149 225.748 670.264 274.195 0 0 0 6.25356 lb
-694.579 115.483 682.421 194.839 670.264 274.195 0 0 0 6.25356 lb
-280.402 10.3938 246.402 -6.60595 212.403 -23.6057 0 0 0 6.25356 lb
-280.402 10.3938 283.493 -18.9695 286.584 -48.3327 0 0 0 6.25356 lb
-212.403 -23.6057 249.493 -35.9692 286.584 -48.3327 0 0 0 6.25356 lb
-286.584 -48.3327 326.765 -79.2414 366.947 -110.15 0 0 0 6.25356 lb
-286.584 -48.3327 278.857 -111.695 271.13 -175.058 0 0 0 6.25356 lb
-438.037 -88.514 417.946 -142.604 397.855 -196.694 0 0 0 6.25356 lb
-438.037 -88.514 402.492 -99.332 366.947 -110.15 0 0 0 6.25356 lb
-397.855 -196.694 382.401 -153.422 366.947 -110.15 0 0 0 6.25356 lb
-366.947 -110.15 319.038 -142.604 271.13 -175.058 0 0 0 6.25356 lb
-271.13 -175.058 274.221 -213.694 277.311 -252.33 0 0 0 6.25356 lb
-271.13 -175.058 238.675 -190.512 206.221 -205.967 0 0 0 6.25356 lb
-277.311 -252.33 241.766 -229.149 206.221 -205.967 0 0 0 6.25356 lb
--840.856 -246.718 -804.351 -66.7145 -767.847 113.289 0 0 0 6.25356 lb
--579.033 445.603 -673.44 279.446 -767.847 113.289 0 0 0 6.25356 lb
--579.033 445.603 -524.906 302.104 -470.779 158.605 0 0 0 6.25356 lb
--767.847 113.289 -619.313 135.947 -470.779 158.605 0 0 0 6.25356 lb
-906.312 201.403 946.592 42.798 986.873 -115.807 0 0 0 6.25356 lb
-906.312 201.403 834.562 91.8901 762.812 -17.6227 0 0 0 6.25356 lb
-986.873 -115.807 874.842 -66.7148 762.812 -17.6227 0 0 0 6.25356 lb
--470.779 158.605 -390.218 50.3508 -309.657 -57.9033 0 0 0 6.25356 lb
-422.945 521.129 208.955 541.269 -5.03507 561.41 0 0 0 6.25356 lb
-422.945 521.129 376.371 417.911 329.797 314.692 0 0 0 6.25356 lb
-422.945 521.129 474.554 276.928 526.164 32.7279 0 0 0 6.25356 lb
--5.03507 561.41 -36.5042 440.568 -67.9734 319.727 0 0 0 6.25356 lb
-329.797 314.692 130.912 317.209 -67.9734 319.727 0 0 0 6.25356 lb
--67.9734 319.727 229.095 176.227 526.164 32.7279 0 0 0 6.25356 lb
-762.812 -17.6227 644.488 7.5526 526.164 32.7279 0 0 0 6.25356 lb
-762.812 -17.6227 746.448 -162.381 730.084 -307.139 0 0 0 6.25356 lb
-526.164 32.7279 470.779 -128.394 415.393 -289.516 0 0 0 6.25356 lb
-730.084 -307.139 572.738 -298.327 415.393 -289.516 0 0 0 6.25356 lb
-415.393 -289.516 173.71 -318.468 -67.9734 -347.42 0 0 0 6.25356 lb
--67.9734 -347.42 -188.815 -202.662 -309.657 -57.9033 0 0 0 6.25356 lb
--67.9734 -347.42 -195.758 -390.692 -323.543 -433.964 0 0 0 6.25356 lb
--309.657 -57.9033 -424.775 -160.272 -539.894 -262.64 0 0 0 6.25356 lb
--323.543 -433.964 -431.719 -348.302 -539.894 -262.64 0 0 0 6.25356 lb
--26.6953 -19.9585 44.8558 -96.8093 116.407 -173.66 0 0 0 6.25356 lb
--26.6953 -19.9585 87.2563 9.19185 201.208 38.3422 0 0 0 6.25356 lb
--26.6953 -19.9585 -144.622 43.6422 -262.548 107.243 0 0 0 6.25356 lb
--26.6953 -19.9585 -20.0703 56.8923 -13.4452 133.743 0 0 0 6.25356 lb
-116.407 -173.66 158.808 -67.6589 201.208 38.3422 0 0 0 6.25356 lb
--262.548 107.243 -137.997 120.493 -13.4452 133.743 0 0 0 6.25356 lb
--262.548 107.243 -221.472 176.144 -180.397 245.045 0 0 0 6.25356 lb
--13.4452 133.743 -96.9211 189.394 -180.397 245.045 0 0 0 6.25356 lb
--180.397 245.045 -113.509 338.465 -132.697 451.748 0 0 0 6.25356 lb
--180.397 245.045 -199.585 358.328 -132.697 451.748 0 0 0 6.25356 lb
--416.25 345.746 -274.474 398.747 -132.697 451.748 0 0 0 6.25356 lb
--416.25 345.746 -393.725 457.048 -371.2 568.349 0 0 0 6.25356 lb
--132.697 451.748 -251.948 510.048 -371.2 568.349 0 0 0 6.25356 lb
-670.264 274.195 629.188 409.347 588.113 544.499 0 0 0 6.25356 lb
-670.264 274.195 797.466 341.771 924.667 409.347 0 0 0 6.25356 lb
-588.113 544.499 756.39 476.923 924.667 409.347 0 0 0 6.25356 lb
--689.204 -237.261 -587.735 -114.393 -567.302 43.6423 0 0 0 6.25356 lb
--689.204 -237.261 -668.771 -79.2259 -567.302 43.6423 0 0 0 6.25356 lb
+574.035 177.301 622.149 225.748 670.264 274.195 0 0 0 2 lb
+694.579 115.483 682.421 194.839 670.264 274.195 0 0 0 2 lb
+280.402 10.3938 246.402 -6.60595 212.403 -23.6057 0 0 0 2 lb
+280.402 10.3938 283.493 -18.9695 286.584 -48.3327 0 0 0 2 lb
+212.403 -23.6057 249.493 -35.9692 286.584 -48.3327 0 0 0 2 lb
+286.584 -48.3327 326.765 -79.2414 366.947 -110.15 0 0 0 2 lb
+286.584 -48.3327 278.857 -111.695 271.13 -175.058 0 0 0 2 lb
+438.037 -88.514 417.946 -142.604 397.855 -196.694 0 0 0 2 lb
+438.037 -88.514 402.492 -99.332 366.947 -110.15 0 0 0 2 lb
+397.855 -196.694 382.401 -153.422 366.947 -110.15 0 0 0 2 lb
+366.947 -110.15 319.038 -142.604 271.13 -175.058 0 0 0 2 lb
+271.13 -175.058 274.221 -213.694 277.311 -252.33 0 0 0 2 lb
+271.13 -175.058 238.675 -190.512 206.221 -205.967 0 0 0 2 lb
+277.311 -252.33 241.766 -229.149 206.221 -205.967 0 0 0 2 lb
+-840.856 -246.718 -804.351 -66.7145 -767.847 113.289 0 0 0 2 lb
+-579.033 445.603 -673.44 279.446 -767.847 113.289 0 0 0 2 lb
+-579.033 445.603 -524.906 302.104 -470.779 158.605 0 0 0 2 lb
+-767.847 113.289 -619.313 135.947 -470.779 158.605 0 0 0 2 lb
+906.312 201.403 946.592 42.798 986.873 -115.807 0 0 0 2 lb
+906.312 201.403 834.562 91.8901 762.812 -17.6227 0 0 0 2 lb
+986.873 -115.807 874.842 -66.7148 762.812 -17.6227 0 0 0 2 lb
+-470.779 158.605 -390.218 50.3508 -309.657 -57.9033 0 0 0 2 lb
+422.945 521.129 208.955 541.269 -5.03507 561.41 0 0 0 2 lb
+422.945 521.129 376.371 417.911 329.797 314.692 0 0 0 2 lb
+422.945 521.129 474.554 276.928 526.164 32.7279 0 0 0 2 lb
+-5.03507 561.41 -36.5042 440.568 -67.9734 319.727 0 0 0 2 lb
+329.797 314.692 130.912 317.209 -67.9734 319.727 0 0 0 2 lb
+-67.9734 319.727 229.095 176.227 526.164 32.7279 0 0 0 2 lb
+762.812 -17.6227 644.488 7.5526 526.164 32.7279 0 0 0 2 lb
+762.812 -17.6227 746.448 -162.381 730.084 -307.139 0 0 0 2 lb
+526.164 32.7279 470.779 -128.394 415.393 -289.516 0 0 0 2 lb
+730.084 -307.139 572.738 -298.327 415.393 -289.516 0 0 0 2 lb
+415.393 -289.516 173.71 -318.468 -67.9734 -347.42 0 0 0 2 lb
+-67.9734 -347.42 -188.815 -202.662 -309.657 -57.9033 0 0 0 2 lb
+-67.9734 -347.42 -195.758 -390.692 -323.543 -433.964 0 0 0 2 lb
+-309.657 -57.9033 -424.775 -160.272 -539.894 -262.64 0 0 0 2 lb
+-323.543 -433.964 -431.719 -348.302 -539.894 -262.64 0 0 0 2 lb
+-26.6953 -19.9585 44.8558 -96.8093 116.407 -173.66 0 0 0 2 lb
+-26.6953 -19.9585 87.2563 9.19185 201.208 38.3422 0 0 0 2 lb
+-26.6953 -19.9585 -144.622 43.6422 -262.548 107.243 0 0 0 2 lb
+-26.6953 -19.9585 -20.0703 56.8923 -13.4452 133.743 0 0 0 2 lb
+116.407 -173.66 158.808 -67.6589 201.208 38.3422 0 0 0 2 lb
+-262.548 107.243 -137.997 120.493 -13.4452 133.743 0 0 0 2 lb
+-262.548 107.243 -221.472 176.144 -180.397 245.045 0 0 0 2 lb
+-13.4452 133.743 -96.9211 189.394 -180.397 245.045 0 0 0 2 lb
+-180.397 245.045 -142.256 345.099 -132.697 451.748 0 0 0 2 lb
+-180.397 245.045 -170.838 351.694 -132.697 451.748 0 0 0 2 lb
+-416.25 345.746 -274.474 398.747 -132.697 451.748 0 0 0 2 lb
+-416.25 345.746 -393.725 457.048 -371.2 568.349 0 0 0 2 lb
+-132.697 451.748 -251.948 510.048 -371.2 568.349 0 0 0 2 lb
+670.264 274.195 629.188 409.347 588.113 544.499 0 0 0 2 lb
+670.264 274.195 797.466 341.771 924.667 409.347 0 0 0 2 lb
+588.113 544.499 756.39 476.923 924.667 409.347 0 0 0 2 lb
+-689.204 -237.261 -614.799 -102.648 -567.302 43.6423 0 0 0 2 lb
+-689.204 -237.261 -641.707 -90.9706 -567.302 43.6423 0 0 0 2 lb
 grestore
 %Nodes:
 gsave
--567.302 43.6423 20.8452 0 0 0 nc
--689.204 -237.261 20.8452 0 0 0 nc
-924.667 409.347 20.8452 1 0 0 nc
-588.113 544.499 20.8452 1 0 0 nc
-670.264 274.195 20.8452 1 0 0 nc
--371.2 568.349 20.8452 0 1 0 nc
--132.697 451.748 20.8452 0 1 0 nc
--416.25 345.746 20.8452 0 1 0 nc
--180.397 245.045 20.8452 0 1 0 nc
--13.4452 133.743 20.8452 0 1 0 nc
--262.548 107.243 20.8452 0 1 0 nc
-201.208 38.3422 20.8452 0 1 0 nc
-116.407 -173.66 20.8452 0 1 0 nc
--26.6953 -19.9585 20.8452 0 1 0 nc
--539.894 -262.64 20.8452 0 0 1 nc
--323.543 -433.964 20.8452 0 0 1 nc
--309.657 -57.9033 20.8452 0 0 1 nc
--67.9734 -347.42 20.8452 0 0 1 nc
-415.393 -289.516 20.8452 0 0 1 nc
-730.084 -307.139 20.8452 0 0 1 nc
-526.164 32.7279 20.8452 0 0 1 nc
-762.812 -17.6227 20.8452 0 0 1 nc
--67.9734 319.727 20.8452 0 0 1 nc
-329.797 314.692 20.8452 0 0 1 nc
--5.03507 561.41 20.8452 0 0 1 nc
-422.945 521.129 20.8452 0 0 1 nc
--470.779 158.605 20.8452 0 0 1 nc
-986.873 -115.807 20.8452 0 0 1 nc
-906.312 201.403 20.8452 0 0 1 nc
--767.847 113.289 20.8452 0 0 1 nc
--579.033 445.603 20.8452 0 0 1 nc
--840.856 -246.718 20.8452 0 0 1 nc
-206.221 -205.967 20.8452 1 1 0 nc
-277.311 -252.33 20.8452 1 1 0 nc
-271.13 -175.058 20.8452 1 1 0 nc
-366.947 -110.15 20.8452 1 1 0 nc
-397.855 -196.694 20.8452 1 1 0 nc
-438.037 -88.514 20.8452 1 1 0 nc
-286.584 -48.3327 20.8452 1 1 0 nc
-212.403 -23.6057 20.8452 1 1 0 nc
-280.402 10.3938 20.8452 1 1 0 nc
-694.579 115.483 20.8452 1 0 0 nc
-574.035 177.301 20.8452 1 0 0 nc
+-567.302 43.6423 20 0 0 0 nc
+-689.204 -237.261 20 0 0 0 nc
+924.667 409.347 20 1 0 0 nc
+588.113 544.499 20 1 0 0 nc
+670.264 274.195 20 1 0 0 nc
+-371.2 568.349 20 0 1 0 nc
+-132.697 451.748 20 0 1 0 nc
+-416.25 345.746 20 0 1 0 nc
+-180.397 245.045 20 0 1 0 nc
+-13.4452 133.743 20 0 1 0 nc
+-262.548 107.243 20 0 1 0 nc
+201.208 38.3422 20 0 1 0 nc
+116.407 -173.66 20 0 1 0 nc
+-26.6953 -19.9585 20 0 1 0 nc
+-539.894 -262.64 20 0 0 1 nc
+-323.543 -433.964 20 0 0 1 nc
+-309.657 -57.9033 20 0 0 1 nc
+-67.9734 -347.42 20 0 0 1 nc
+415.393 -289.516 20 0 0 1 nc
+730.084 -307.139 20 0 0 1 nc
+526.164 32.7279 20 0 0 1 nc
+762.812 -17.6227 20 0 0 1 nc
+-67.9734 319.727 20 0 0 1 nc
+329.797 314.692 20 0 0 1 nc
+-5.03507 561.41 20 0 0 1 nc
+422.945 521.129 20 0 0 1 nc
+-470.779 158.605 20 0 0 1 nc
+986.873 -115.807 20 0 0 1 nc
+906.312 201.403 20 0 0 1 nc
+-767.847 113.289 20 0 0 1 nc
+-579.033 445.603 20 0 0 1 nc
+-840.856 -246.718 20 0 0 1 nc
+206.221 -205.967 20 1 1 0 nc
+277.311 -252.33 20 1 1 0 nc
+271.13 -175.058 20 1 1 0 nc
+366.947 -110.15 20 1 1 0 nc
+397.855 -196.694 20 1 1 0 nc
+438.037 -88.514 20 1 1 0 nc
+286.584 -48.3327 20 1 1 0 nc
+212.403 -23.6057 20 1 1 0 nc
+280.402 10.3938 20 1 1 0 nc
+694.579 115.483 20 1 0 0 nc
+574.035 177.301 20 1 0 0 nc
 grestore
 grestore
Index: doc/images/edge_biconnected_components.eps
===================================================================
--- doc/images/edge_biconnected_components.eps	(revision 1213)
+++ doc/images/edge_biconnected_components.eps	(revision 634)
@@ -1,5 +1,5 @@
 %!PS-Adobe-2.0 EPSF-2.0
 %%Creator: LEMON, graphToEps()
-%%CreationDate: Fri Mar  8 00:18:43 2013
+%%CreationDate: Fri Nov  4 13:47:12 2005
 %%BoundingBox: 0 0 842 596
 %%EndComments
@@ -54,105 +54,105 @@
 %Edges:
 gsave
-574.035 177.301 622.149 225.748 670.264 274.195 1 0 0 6.25356 lb
-694.579 115.483 682.421 194.839 670.264 274.195 1 0 0 6.25356 lb
-280.402 10.3938 246.402 -6.60595 212.403 -23.6057 0 0 1 6.25356 lb
-280.402 10.3938 283.493 -18.9695 286.584 -48.3327 0 0 1 6.25356 lb
-212.403 -23.6057 249.493 -35.9692 286.584 -48.3327 0 0 1 6.25356 lb
-286.584 -48.3327 326.765 -79.2414 366.947 -110.15 0 0 1 6.25356 lb
-286.584 -48.3327 278.857 -111.695 271.13 -175.058 0 0 1 6.25356 lb
-438.037 -88.514 417.946 -142.604 397.855 -196.694 0 0 1 6.25356 lb
-438.037 -88.514 402.492 -99.332 366.947 -110.15 0 0 1 6.25356 lb
-397.855 -196.694 382.401 -153.422 366.947 -110.15 0 0 1 6.25356 lb
-366.947 -110.15 319.038 -142.604 271.13 -175.058 0 0 1 6.25356 lb
-271.13 -175.058 274.221 -213.694 277.311 -252.33 0 0 1 6.25356 lb
-271.13 -175.058 238.675 -190.512 206.221 -205.967 0 0 1 6.25356 lb
-277.311 -252.33 241.766 -229.149 206.221 -205.967 0 0 1 6.25356 lb
--840.856 -246.718 -804.351 -66.7145 -767.847 113.289 1 0 0 6.25356 lb
--579.033 445.603 -673.44 279.446 -767.847 113.289 0 0 1 6.25356 lb
--579.033 445.603 -524.906 302.104 -470.779 158.605 0 0 1 6.25356 lb
--767.847 113.289 -619.313 135.947 -470.779 158.605 0 0 1 6.25356 lb
-906.312 201.403 946.592 42.798 986.873 -115.807 0 0 1 6.25356 lb
-906.312 201.403 834.562 91.8901 762.812 -17.6227 0 0 1 6.25356 lb
-986.873 -115.807 874.842 -66.7148 762.812 -17.6227 0 0 1 6.25356 lb
--470.779 158.605 -390.218 50.3508 -309.657 -57.9033 1 0 0 6.25356 lb
-422.945 521.129 208.955 541.269 -5.03507 561.41 0 0 1 6.25356 lb
-422.945 521.129 376.371 417.911 329.797 314.692 0 0 1 6.25356 lb
-422.945 521.129 474.554 276.928 526.164 32.7279 0 0 1 6.25356 lb
--5.03507 561.41 -36.5042 440.568 -67.9734 319.727 0 0 1 6.25356 lb
-329.797 314.692 130.912 317.209 -67.9734 319.727 0 0 1 6.25356 lb
--67.9734 319.727 229.095 176.227 526.164 32.7279 0 0 1 6.25356 lb
-762.812 -17.6227 644.488 7.5526 526.164 32.7279 0 0 1 6.25356 lb
-762.812 -17.6227 746.448 -162.381 730.084 -307.139 0 0 1 6.25356 lb
-526.164 32.7279 470.779 -128.394 415.393 -289.516 0 0 1 6.25356 lb
-730.084 -307.139 572.738 -298.327 415.393 -289.516 0 0 1 6.25356 lb
-415.393 -289.516 173.71 -318.468 -67.9734 -347.42 1 0 0 6.25356 lb
--67.9734 -347.42 -188.815 -202.662 -309.657 -57.9033 0 0 1 6.25356 lb
--67.9734 -347.42 -195.758 -390.692 -323.543 -433.964 0 0 1 6.25356 lb
--309.657 -57.9033 -424.775 -160.272 -539.894 -262.64 0 0 1 6.25356 lb
--323.543 -433.964 -431.719 -348.302 -539.894 -262.64 0 0 1 6.25356 lb
--26.6953 -19.9585 44.8558 -96.8093 116.407 -173.66 0 0 1 6.25356 lb
--26.6953 -19.9585 87.2563 9.19185 201.208 38.3422 0 0 1 6.25356 lb
--26.6953 -19.9585 -144.622 43.6422 -262.548 107.243 0 0 1 6.25356 lb
--26.6953 -19.9585 -20.0703 56.8923 -13.4452 133.743 0 0 1 6.25356 lb
-116.407 -173.66 158.808 -67.6589 201.208 38.3422 0 0 1 6.25356 lb
--262.548 107.243 -137.997 120.493 -13.4452 133.743 0 0 1 6.25356 lb
--262.548 107.243 -221.472 176.144 -180.397 245.045 0 0 1 6.25356 lb
--13.4452 133.743 -96.9211 189.394 -180.397 245.045 0 0 1 6.25356 lb
--180.397 245.045 -113.509 338.465 -132.697 451.748 0 0 1 6.25356 lb
--180.397 245.045 -199.585 358.328 -132.697 451.748 0 0 1 6.25356 lb
--416.25 345.746 -274.474 398.747 -132.697 451.748 0 0 1 6.25356 lb
--416.25 345.746 -393.725 457.048 -371.2 568.349 0 0 1 6.25356 lb
--132.697 451.748 -251.948 510.048 -371.2 568.349 0 0 1 6.25356 lb
-670.264 274.195 629.188 409.347 588.113 544.499 0 0 1 6.25356 lb
-670.264 274.195 797.466 341.771 924.667 409.347 0 0 1 6.25356 lb
-588.113 544.499 756.39 476.923 924.667 409.347 0 0 1 6.25356 lb
--689.204 -237.261 -587.735 -114.393 -567.302 43.6423 0 0 1 6.25356 lb
--689.204 -237.261 -668.771 -79.2259 -567.302 43.6423 0 0 1 6.25356 lb
+574.035 177.301 622.149 225.748 670.264 274.195 1 0 0 2 lb
+694.579 115.483 682.421 194.839 670.264 274.195 1 0 0 2 lb
+280.402 10.3938 246.402 -6.60595 212.403 -23.6057 0 0 1 2 lb
+280.402 10.3938 283.493 -18.9695 286.584 -48.3327 0 0 1 2 lb
+212.403 -23.6057 249.493 -35.9692 286.584 -48.3327 0 0 1 2 lb
+286.584 -48.3327 326.765 -79.2414 366.947 -110.15 0 0 1 2 lb
+286.584 -48.3327 278.857 -111.695 271.13 -175.058 0 0 1 2 lb
+438.037 -88.514 417.946 -142.604 397.855 -196.694 0 0 1 2 lb
+438.037 -88.514 402.492 -99.332 366.947 -110.15 0 0 1 2 lb
+397.855 -196.694 382.401 -153.422 366.947 -110.15 0 0 1 2 lb
+366.947 -110.15 319.038 -142.604 271.13 -175.058 0 0 1 2 lb
+271.13 -175.058 274.221 -213.694 277.311 -252.33 0 0 1 2 lb
+271.13 -175.058 238.675 -190.512 206.221 -205.967 0 0 1 2 lb
+277.311 -252.33 241.766 -229.149 206.221 -205.967 0 0 1 2 lb
+-840.856 -246.718 -804.351 -66.7145 -767.847 113.289 1 0 0 2 lb
+-579.033 445.603 -673.44 279.446 -767.847 113.289 0 0 1 2 lb
+-579.033 445.603 -524.906 302.104 -470.779 158.605 0 0 1 2 lb
+-767.847 113.289 -619.313 135.947 -470.779 158.605 0 0 1 2 lb
+906.312 201.403 946.592 42.798 986.873 -115.807 0 0 1 2 lb
+906.312 201.403 834.562 91.8901 762.812 -17.6227 0 0 1 2 lb
+986.873 -115.807 874.842 -66.7148 762.812 -17.6227 0 0 1 2 lb
+-470.779 158.605 -390.218 50.3508 -309.657 -57.9033 1 0 0 2 lb
+422.945 521.129 208.955 541.269 -5.03507 561.41 0 0 1 2 lb
+422.945 521.129 376.371 417.911 329.797 314.692 0 0 1 2 lb
+422.945 521.129 474.554 276.928 526.164 32.7279 0 0 1 2 lb
+-5.03507 561.41 -36.5042 440.568 -67.9734 319.727 0 0 1 2 lb
+329.797 314.692 130.912 317.209 -67.9734 319.727 0 0 1 2 lb
+-67.9734 319.727 229.095 176.227 526.164 32.7279 0 0 1 2 lb
+762.812 -17.6227 644.488 7.5526 526.164 32.7279 0 0 1 2 lb
+762.812 -17.6227 746.448 -162.381 730.084 -307.139 0 0 1 2 lb
+526.164 32.7279 470.779 -128.394 415.393 -289.516 0 0 1 2 lb
+730.084 -307.139 572.738 -298.327 415.393 -289.516 0 0 1 2 lb
+415.393 -289.516 173.71 -318.468 -67.9734 -347.42 1 0 0 2 lb
+-67.9734 -347.42 -188.815 -202.662 -309.657 -57.9033 0 0 1 2 lb
+-67.9734 -347.42 -195.758 -390.692 -323.543 -433.964 0 0 1 2 lb
+-309.657 -57.9033 -424.775 -160.272 -539.894 -262.64 0 0 1 2 lb
+-323.543 -433.964 -431.719 -348.302 -539.894 -262.64 0 0 1 2 lb
+-26.6953 -19.9585 44.8558 -96.8093 116.407 -173.66 0 0 1 2 lb
+-26.6953 -19.9585 87.2563 9.19185 201.208 38.3422 0 0 1 2 lb
+-26.6953 -19.9585 -144.622 43.6422 -262.548 107.243 0 0 1 2 lb
+-26.6953 -19.9585 -20.0703 56.8923 -13.4452 133.743 0 0 1 2 lb
+116.407 -173.66 158.808 -67.6589 201.208 38.3422 0 0 1 2 lb
+-262.548 107.243 -137.997 120.493 -13.4452 133.743 0 0 1 2 lb
+-262.548 107.243 -221.472 176.144 -180.397 245.045 0 0 1 2 lb
+-13.4452 133.743 -96.9211 189.394 -180.397 245.045 0 0 1 2 lb
+-180.397 245.045 -142.256 345.099 -132.697 451.748 0 0 1 2 lb
+-180.397 245.045 -170.838 351.694 -132.697 451.748 0 0 1 2 lb
+-416.25 345.746 -274.474 398.747 -132.697 451.748 0 0 1 2 lb
+-416.25 345.746 -393.725 457.048 -371.2 568.349 0 0 1 2 lb
+-132.697 451.748 -251.948 510.048 -371.2 568.349 0 0 1 2 lb
+670.264 274.195 629.188 409.347 588.113 544.499 0 0 1 2 lb
+670.264 274.195 797.466 341.771 924.667 409.347 0 0 1 2 lb
+588.113 544.499 756.39 476.923 924.667 409.347 0 0 1 2 lb
+-689.204 -237.261 -614.799 -102.648 -567.302 43.6423 0 0 1 2 lb
+-689.204 -237.261 -641.707 -90.9706 -567.302 43.6423 0 0 1 2 lb
 grestore
 %Nodes:
 gsave
--567.302 43.6423 20.8452 0 0 0 nc
--689.204 -237.261 20.8452 0 0 0 nc
-924.667 409.347 20.8452 0 0 1 nc
-588.113 544.499 20.8452 0 0 1 nc
-670.264 274.195 20.8452 0 0 1 nc
--371.2 568.349 20.8452 1 1 0 nc
--132.697 451.748 20.8452 1 1 0 nc
--416.25 345.746 20.8452 1 1 0 nc
--180.397 245.045 20.8452 1 1 0 nc
--13.4452 133.743 20.8452 1 1 0 nc
--262.548 107.243 20.8452 1 1 0 nc
-201.208 38.3422 20.8452 1 1 0 nc
-116.407 -173.66 20.8452 1 1 0 nc
--26.6953 -19.9585 20.8452 1 1 0 nc
--539.894 -262.64 20.8452 0 0.5 0 nc
--323.543 -433.964 20.8452 0 0.5 0 nc
--309.657 -57.9033 20.8452 0 0.5 0 nc
--67.9734 -347.42 20.8452 0 0.5 0 nc
-415.393 -289.516 20.8452 0.5 0 0 nc
-730.084 -307.139 20.8452 0.5 0 0 nc
-526.164 32.7279 20.8452 0.5 0 0 nc
-762.812 -17.6227 20.8452 0.5 0 0 nc
--67.9734 319.727 20.8452 0.5 0 0 nc
-329.797 314.692 20.8452 0.5 0 0 nc
--5.03507 561.41 20.8452 0.5 0 0 nc
-422.945 521.129 20.8452 0.5 0 0 nc
--470.779 158.605 20.8452 0 1 1 nc
-986.873 -115.807 20.8452 0.5 0 0 nc
-906.312 201.403 20.8452 0.5 0 0 nc
--767.847 113.289 20.8452 0 1 1 nc
--579.033 445.603 20.8452 0 1 1 nc
--840.856 -246.718 20.8452 1 0 1 nc
-206.221 -205.967 20.8452 0 0 0.5 nc
-277.311 -252.33 20.8452 0 0 0.5 nc
-271.13 -175.058 20.8452 0 0 0.5 nc
-366.947 -110.15 20.8452 0 0 0.5 nc
-397.855 -196.694 20.8452 0 0 0.5 nc
-438.037 -88.514 20.8452 0 0 0.5 nc
-286.584 -48.3327 20.8452 0 0 0.5 nc
-212.403 -23.6057 20.8452 0 0 0.5 nc
-280.402 10.3938 20.8452 0 0 0.5 nc
-694.579 115.483 20.8452 1 0 0 nc
-574.035 177.301 20.8452 0 1 0 nc
+-567.302 43.6423 20 0 0 0 nc
+-689.204 -237.261 20 0 0 0 nc
+924.667 409.347 20 0 0 1 nc
+588.113 544.499 20 0 0 1 nc
+670.264 274.195 20 0 0 1 nc
+-371.2 568.349 20 1 1 0 nc
+-132.697 451.748 20 1 1 0 nc
+-416.25 345.746 20 1 1 0 nc
+-180.397 245.045 20 1 1 0 nc
+-13.4452 133.743 20 1 1 0 nc
+-262.548 107.243 20 1 1 0 nc
+201.208 38.3422 20 1 1 0 nc
+116.407 -173.66 20 1 1 0 nc
+-26.6953 -19.9585 20 1 1 0 nc
+-539.894 -262.64 20 0 0.5 0 nc
+-323.543 -433.964 20 0 0.5 0 nc
+-309.657 -57.9033 20 0 0.5 0 nc
+-67.9734 -347.42 20 0 0.5 0 nc
+415.393 -289.516 20 0.5 0 0 nc
+730.084 -307.139 20 0.5 0 0 nc
+526.164 32.7279 20 0.5 0 0 nc
+762.812 -17.6227 20 0.5 0 0 nc
+-67.9734 319.727 20 0.5 0 0 nc
+329.797 314.692 20 0.5 0 0 nc
+-5.03507 561.41 20 0.5 0 0 nc
+422.945 521.129 20 0.5 0 0 nc
+-470.779 158.605 20 0 1 1 nc
+986.873 -115.807 20 0.5 0 0 nc
+906.312 201.403 20 0.5 0 0 nc
+-767.847 113.289 20 0 1 1 nc
+-579.033 445.603 20 0 1 1 nc
+-840.856 -246.718 20 1 0 1 nc
+206.221 -205.967 20 0 0 0.5 nc
+277.311 -252.33 20 0 0 0.5 nc
+271.13 -175.058 20 0 0 0.5 nc
+366.947 -110.15 20 0 0 0.5 nc
+397.855 -196.694 20 0 0 0.5 nc
+438.037 -88.514 20 0 0 0.5 nc
+286.584 -48.3327 20 0 0 0.5 nc
+212.403 -23.6057 20 0 0 0.5 nc
+280.402 10.3938 20 0 0 0.5 nc
+694.579 115.483 20 1 0 0 nc
+574.035 177.301 20 0 1 0 nc
 grestore
 grestore
Index: c/images/matching.eps
===================================================================
--- doc/images/matching.eps	(revision 943)
+++ 	(revision )
@@ -1,130 +1,0 @@
-%!PS-Adobe-2.0 EPSF-2.0
-%%Creator: LEMON, graphToEps()
-%%CreationDate: Sun Mar 14 09:08:34 2010
-%%BoundingBox: -353 -264 559 292
-%%EndComments
-/lb { setlinewidth setrgbcolor newpath moveto
-      4 2 roll 1 index 1 index curveto stroke } bind def
-/l { setlinewidth setrgbcolor newpath moveto lineto stroke } bind def
-/c { newpath dup 3 index add 2 index moveto 0 360 arc closepath } bind def
-/sq { newpath 2 index 1 index add 2 index 2 index add moveto
-      2 index 1 index sub 2 index 2 index add lineto
-      2 index 1 index sub 2 index 2 index sub lineto
-      2 index 1 index add 2 index 2 index sub lineto
-      closepath pop pop pop} bind def
-/di { newpath 2 index 1 index add 2 index moveto
-      2 index             2 index 2 index add lineto
-      2 index 1 index sub 2 index             lineto
-      2 index             2 index 2 index sub lineto
-      closepath pop pop pop} bind def
-/nc { 0 0 0 setrgbcolor 5 index 5 index 5 index c fill
-     setrgbcolor 1.1 div c fill
-   } bind def
-/nsq { 0 0 0 setrgbcolor 5 index 5 index 5 index sq fill
-     setrgbcolor 1.1 div sq fill
-   } bind def
-/ndi { 0 0 0 setrgbcolor 5 index 5 index 5 index di fill
-     setrgbcolor 1.1 div di fill
-   } bind def
-/nfemale { 0 0 0 setrgbcolor 3 index 0.0909091 1.5 mul mul setlinewidth
-  newpath 5 index 5 index moveto 5 index 5 index 5 index 3.01 mul sub
-  lineto 5 index 4 index .7 mul sub 5 index 5 index 2.2 mul sub moveto
-  5 index 4 index .7 mul add 5 index 5 index 2.2 mul sub lineto stroke
-  5 index 5 index 5 index c fill
-  setrgbcolor 1.1 div c fill
-  } bind def
-/nmale {
-  0 0 0 setrgbcolor 3 index 0.0909091 1.5 mul mul setlinewidth
-  newpath 5 index 5 index moveto
-  5 index 4 index 1 mul 1.5 mul add
-  5 index 5 index 3 sqrt 1.5 mul mul add
-  1 index 1 index lineto
-  1 index 1 index 7 index sub moveto
-  1 index 1 index lineto
-  exch 5 index 3 sqrt .5 mul mul sub exch 5 index .5 mul sub lineto
-  stroke
-  5 index 5 index 5 index c fill
-  setrgbcolor 1.1 div c fill
-  } bind def
-/arrl 1 def
-/arrw 0.3 def
-/lrl { 2 index mul exch 2 index mul exch rlineto pop} bind def
-/arr { setrgbcolor /y1 exch def /x1 exch def /dy exch def /dx exch def
-       /w exch def /len exch def
-       newpath x1 dy w 2 div mul add y1 dx w 2 div mul sub moveto
-       len w sub arrl sub dx dy lrl
-       arrw dy dx neg lrl
-       dx arrl w add mul dy w 2 div arrw add mul sub
-       dy arrl w add mul dx w 2 div arrw add mul add rlineto
-       dx arrl w add mul neg dy w 2 div arrw add mul sub
-       dy arrl w add mul neg dx w 2 div arrw add mul add rlineto
-       arrw dy dx neg lrl
-       len w sub arrl sub neg dx dy lrl
-       closepath fill } bind def
-/cshow { 2 index 2 index moveto dup stringwidth pop
-         neg 2 div fosi .35 mul neg rmoveto show pop pop} def
-
-gsave
-%Arcs:
-gsave
-140.321 266.249 -327.729 150.06 0 0 0 4.99223 l
-82.1207 -238.726 -245.288 -110.743 0 0 0 4.99223 l
-336.635 -229.036 533.603 13.109 0 0 0 4.99223 l
-53.8598 -45.8071 -245.288 -110.743 0 0 0 4.99223 l
--75.5617 118.579 -327.729 150.06 0 0 0 4.99223 l
--327.729 150.06 -245.288 -110.743 1 0 0 11.9813 l
-533.603 13.109 218.184 -84.2955 0 0 0 4.99223 l
-39.87 175.035 141.163 67.2575 0 0 0 4.99223 l
-53.8598 -45.8071 -75.5617 118.579 0 0 0 4.99223 l
--102.406 -141.267 82.1207 -238.726 0 0 0 4.99223 l
-399.144 166.894 533.603 13.109 1 0 0 11.9813 l
-39.87 175.035 140.321 266.249 1 0 0 11.9813 l
-399.144 166.894 140.321 266.249 0 0 0 4.99223 l
-399.144 166.894 141.163 67.2575 0 0 0 4.99223 l
-53.8598 -45.8071 204.765 -173.77 0 0 0 4.99223 l
-82.1207 -238.726 204.765 -173.77 0 0 0 4.99223 l
-258.227 61.658 399.144 166.894 0 0 0 4.99223 l
-53.8598 -45.8071 -102.406 -141.267 1 0 0 11.9813 l
-175.073 -37.4477 141.163 67.2575 0 0 0 4.99223 l
-258.227 61.658 380 0 0 0 0 4.99223 l
-34.6739 40.8267 -75.5617 118.579 1 0 0 11.9813 l
-380 0 533.603 13.109 0 0 0 4.99223 l
-175.073 -37.4477 380 0 0 0 0 4.99223 l
-218.184 -84.2955 204.765 -173.77 0 0 0 4.99223 l
-53.8598 -45.8071 34.6739 40.8267 0 0 0 4.99223 l
-167.905 -213.988 82.1207 -238.726 1 0 0 11.9813 l
-336.635 -229.036 204.765 -173.77 1 0 0 11.9813 l
-336.635 -229.036 167.905 -213.988 0 0 0 4.99223 l
-329.08 -26.3098 218.184 -84.2955 0 0 0 4.99223 l
-39.87 175.035 -75.5617 118.579 0 0 0 4.99223 l
-53.8598 -45.8071 175.073 -37.4477 0 0 0 4.99223 l
-34.6739 40.8267 141.163 67.2575 0 0 0 4.99223 l
-258.227 61.658 141.163 67.2575 1 0 0 11.9813 l
-175.073 -37.4477 218.184 -84.2955 1 0 0 11.9813 l
-380 0 329.08 -26.3098 1 0 0 11.9813 l
-grestore
-%Nodes:
-gsave
--245.288 -110.743 14.9767 1 1 1 nc
-204.765 -173.77 14.9767 1 1 1 nc
--327.729 150.06 14.9767 1 1 1 nc
--75.5617 118.579 14.9767 1 1 1 nc
-218.184 -84.2955 14.9767 1 1 1 nc
-140.321 266.249 14.9767 1 1 1 nc
-141.163 67.2575 14.9767 1 1 1 nc
-82.1207 -238.726 14.9767 1 1 1 nc
-329.08 -26.3098 14.9767 1 1 1 nc
--102.406 -141.267 14.9767 1 1 1 nc
-533.603 13.109 14.9767 1 1 1 nc
-167.905 -213.988 14.9767 1 1 1 nc
-336.635 -229.036 14.9767 1 1 1 nc
-380 0 14.9767 1 1 1 nc
-399.144 166.894 14.9767 1 1 1 nc
-34.6739 40.8267 14.9767 1 1 1 nc
-39.87 175.035 14.9767 1 1 1 nc
-175.073 -37.4477 14.9767 1 1 1 nc
-53.8598 -45.8071 14.9767 1 1 1 nc
-258.227 61.658 14.9767 1 1 1 nc
-grestore
-grestore
-showpage
Index: doc/images/node_biconnected_components.eps
===================================================================
--- doc/images/node_biconnected_components.eps	(revision 1213)
+++ doc/images/node_biconnected_components.eps	(revision 634)
@@ -1,5 +1,5 @@
 %!PS-Adobe-2.0 EPSF-2.0
 %%Creator: LEMON, graphToEps()
-%%CreationDate: Fri Mar  8 00:18:43 2013
+%%CreationDate: Fri Nov  4 13:47:12 2005
 %%BoundingBox: 0 0 842 596
 %%EndComments
@@ -54,105 +54,105 @@
 %Edges:
 gsave
-574.035 177.301 622.149 225.748 670.264 274.195 0 1 0 6.25356 lb
-694.579 115.483 682.421 194.839 670.264 274.195 1 0 0 6.25356 lb
-280.402 10.3938 246.402 -6.60595 212.403 -23.6057 1 1 0.5 6.25356 lb
-280.402 10.3938 283.493 -18.9695 286.584 -48.3327 1 1 0.5 6.25356 lb
-212.403 -23.6057 249.493 -35.9692 286.584 -48.3327 1 1 0.5 6.25356 lb
-286.584 -48.3327 326.765 -79.2414 366.947 -110.15 1 0.5 1 6.25356 lb
-286.584 -48.3327 278.857 -111.695 271.13 -175.058 1 0.5 1 6.25356 lb
-438.037 -88.514 417.946 -142.604 397.855 -196.694 0.5 0.5 1 6.25356 lb
-438.037 -88.514 402.492 -99.332 366.947 -110.15 0.5 0.5 1 6.25356 lb
-397.855 -196.694 382.401 -153.422 366.947 -110.15 0.5 0.5 1 6.25356 lb
-366.947 -110.15 319.038 -142.604 271.13 -175.058 1 0.5 1 6.25356 lb
-271.13 -175.058 274.221 -213.694 277.311 -252.33 0.5 1 1 6.25356 lb
-271.13 -175.058 238.675 -190.512 206.221 -205.967 0.5 1 1 6.25356 lb
-277.311 -252.33 241.766 -229.149 206.221 -205.967 0.5 1 1 6.25356 lb
--840.856 -246.718 -804.351 -66.7145 -767.847 113.289 0 0.5 0 6.25356 lb
--579.033 445.603 -673.44 279.446 -767.847 113.289 0 0 0.5 6.25356 lb
--579.033 445.603 -524.906 302.104 -470.779 158.605 0 0 0.5 6.25356 lb
--767.847 113.289 -619.313 135.947 -470.779 158.605 0 0 0.5 6.25356 lb
-906.312 201.403 946.592 42.798 986.873 -115.807 0 0.5 0.5 6.25356 lb
-906.312 201.403 834.562 91.8901 762.812 -17.6227 0 0.5 0.5 6.25356 lb
-986.873 -115.807 874.842 -66.7148 762.812 -17.6227 0 0.5 0.5 6.25356 lb
--470.779 158.605 -390.218 50.3508 -309.657 -57.9033 0.5 0.5 0 6.25356 lb
-422.945 521.129 208.955 541.269 -5.03507 561.41 0.5 0 0.5 6.25356 lb
-422.945 521.129 376.371 417.911 329.797 314.692 0.5 0 0.5 6.25356 lb
-422.945 521.129 474.554 276.928 526.164 32.7279 0.5 0 0.5 6.25356 lb
--5.03507 561.41 -36.5042 440.568 -67.9734 319.727 0.5 0 0.5 6.25356 lb
-329.797 314.692 130.912 317.209 -67.9734 319.727 0.5 0 0.5 6.25356 lb
--67.9734 319.727 229.095 176.227 526.164 32.7279 0.5 0 0.5 6.25356 lb
-762.812 -17.6227 644.488 7.5526 526.164 32.7279 0.5 0.5 0.5 6.25356 lb
-762.812 -17.6227 746.448 -162.381 730.084 -307.139 0.5 0.5 0.5 6.25356 lb
-526.164 32.7279 470.779 -128.394 415.393 -289.516 0.5 0.5 0.5 6.25356 lb
-730.084 -307.139 572.738 -298.327 415.393 -289.516 0.5 0.5 0.5 6.25356 lb
-415.393 -289.516 173.71 -318.468 -67.9734 -347.42 1 0.5 0.5 6.25356 lb
--67.9734 -347.42 -188.815 -202.662 -309.657 -57.9033 0.5 1 0.5 6.25356 lb
--67.9734 -347.42 -195.758 -390.692 -323.543 -433.964 0.5 1 0.5 6.25356 lb
--309.657 -57.9033 -424.775 -160.272 -539.894 -262.64 0.5 1 0.5 6.25356 lb
--323.543 -433.964 -431.719 -348.302 -539.894 -262.64 0.5 1 0.5 6.25356 lb
--26.6953 -19.9585 44.8558 -96.8093 116.407 -173.66 1 1 0 6.25356 lb
--26.6953 -19.9585 87.2563 9.19185 201.208 38.3422 1 1 0 6.25356 lb
--26.6953 -19.9585 -144.622 43.6422 -262.548 107.243 1 0 1 6.25356 lb
--26.6953 -19.9585 -20.0703 56.8923 -13.4452 133.743 1 0 1 6.25356 lb
-116.407 -173.66 158.808 -67.6589 201.208 38.3422 1 1 0 6.25356 lb
--262.548 107.243 -137.997 120.493 -13.4452 133.743 1 0 1 6.25356 lb
--262.548 107.243 -221.472 176.144 -180.397 245.045 1 0 1 6.25356 lb
--13.4452 133.743 -96.9211 189.394 -180.397 245.045 1 0 1 6.25356 lb
--180.397 245.045 -113.509 338.465 -132.697 451.748 0 1 1 6.25356 lb
--180.397 245.045 -199.585 358.328 -132.697 451.748 0 1 1 6.25356 lb
--416.25 345.746 -274.474 398.747 -132.697 451.748 0.5 0 0 6.25356 lb
--416.25 345.746 -393.725 457.048 -371.2 568.349 0.5 0 0 6.25356 lb
--132.697 451.748 -251.948 510.048 -371.2 568.349 0.5 0 0 6.25356 lb
-670.264 274.195 629.188 409.347 588.113 544.499 0 0 1 6.25356 lb
-670.264 274.195 797.466 341.771 924.667 409.347 0 0 1 6.25356 lb
-588.113 544.499 756.39 476.923 924.667 409.347 0 0 1 6.25356 lb
--689.204 -237.261 -587.735 -114.393 -567.302 43.6423 0 0 0 6.25356 lb
--689.204 -237.261 -668.771 -79.2259 -567.302 43.6423 0 0 0 6.25356 lb
+574.035 177.301 622.149 225.748 670.264 274.195 0 1 0 5 lb
+694.579 115.483 682.421 194.839 670.264 274.195 1 0 0 5 lb
+280.402 10.3938 246.402 -6.60595 212.403 -23.6057 1 1 0.5 5 lb
+280.402 10.3938 283.493 -18.9695 286.584 -48.3327 1 1 0.5 5 lb
+212.403 -23.6057 249.493 -35.9692 286.584 -48.3327 1 1 0.5 5 lb
+286.584 -48.3327 326.765 -79.2414 366.947 -110.15 1 0.5 1 5 lb
+286.584 -48.3327 278.857 -111.695 271.13 -175.058 1 0.5 1 5 lb
+438.037 -88.514 417.946 -142.604 397.855 -196.694 0.5 0.5 1 5 lb
+438.037 -88.514 402.492 -99.332 366.947 -110.15 0.5 0.5 1 5 lb
+397.855 -196.694 382.401 -153.422 366.947 -110.15 0.5 0.5 1 5 lb
+366.947 -110.15 319.038 -142.604 271.13 -175.058 1 0.5 1 5 lb
+271.13 -175.058 274.221 -213.694 277.311 -252.33 0.5 1 1 5 lb
+271.13 -175.058 238.675 -190.512 206.221 -205.967 0.5 1 1 5 lb
+277.311 -252.33 241.766 -229.149 206.221 -205.967 0.5 1 1 5 lb
+-840.856 -246.718 -804.351 -66.7145 -767.847 113.289 0 0.5 0 5 lb
+-579.033 445.603 -673.44 279.446 -767.847 113.289 0 0 0.5 5 lb
+-579.033 445.603 -524.906 302.104 -470.779 158.605 0 0 0.5 5 lb
+-767.847 113.289 -619.313 135.947 -470.779 158.605 0 0 0.5 5 lb
+906.312 201.403 946.592 42.798 986.873 -115.807 0 0.5 0.5 5 lb
+906.312 201.403 834.562 91.8901 762.812 -17.6227 0 0.5 0.5 5 lb
+986.873 -115.807 874.842 -66.7148 762.812 -17.6227 0 0.5 0.5 5 lb
+-470.779 158.605 -390.218 50.3508 -309.657 -57.9033 0.5 0.5 0 5 lb
+422.945 521.129 208.955 541.269 -5.03507 561.41 0.5 0 0.5 5 lb
+422.945 521.129 376.371 417.911 329.797 314.692 0.5 0 0.5 5 lb
+422.945 521.129 474.554 276.928 526.164 32.7279 0.5 0 0.5 5 lb
+-5.03507 561.41 -36.5042 440.568 -67.9734 319.727 0.5 0 0.5 5 lb
+329.797 314.692 130.912 317.209 -67.9734 319.727 0.5 0 0.5 5 lb
+-67.9734 319.727 229.095 176.227 526.164 32.7279 0.5 0 0.5 5 lb
+762.812 -17.6227 644.488 7.5526 526.164 32.7279 0.5 0.5 0.5 5 lb
+762.812 -17.6227 746.448 -162.381 730.084 -307.139 0.5 0.5 0.5 5 lb
+526.164 32.7279 470.779 -128.394 415.393 -289.516 0.5 0.5 0.5 5 lb
+730.084 -307.139 572.738 -298.327 415.393 -289.516 0.5 0.5 0.5 5 lb
+415.393 -289.516 173.71 -318.468 -67.9734 -347.42 1 0.5 0.5 5 lb
+-67.9734 -347.42 -188.815 -202.662 -309.657 -57.9033 0.5 1 0.5 5 lb
+-67.9734 -347.42 -195.758 -390.692 -323.543 -433.964 0.5 1 0.5 5 lb
+-309.657 -57.9033 -424.775 -160.272 -539.894 -262.64 0.5 1 0.5 5 lb
+-323.543 -433.964 -431.719 -348.302 -539.894 -262.64 0.5 1 0.5 5 lb
+-26.6953 -19.9585 44.8558 -96.8093 116.407 -173.66 1 1 0 5 lb
+-26.6953 -19.9585 87.2563 9.19185 201.208 38.3422 1 1 0 5 lb
+-26.6953 -19.9585 -144.622 43.6422 -262.548 107.243 1 0 1 5 lb
+-26.6953 -19.9585 -20.0703 56.8923 -13.4452 133.743 1 0 1 5 lb
+116.407 -173.66 158.808 -67.6589 201.208 38.3422 1 1 0 5 lb
+-262.548 107.243 -137.997 120.493 -13.4452 133.743 1 0 1 5 lb
+-262.548 107.243 -221.472 176.144 -180.397 245.045 1 0 1 5 lb
+-13.4452 133.743 -96.9211 189.394 -180.397 245.045 1 0 1 5 lb
+-180.397 245.045 -140.307 344.649 -132.697 451.748 0 1 1 5 lb
+-180.397 245.045 -172.787 352.144 -132.697 451.748 0 1 1 5 lb
+-416.25 345.746 -274.474 398.747 -132.697 451.748 0.5 0 0 5 lb
+-416.25 345.746 -393.725 457.048 -371.2 568.349 0.5 0 0 5 lb
+-132.697 451.748 -251.948 510.048 -371.2 568.349 0.5 0 0 5 lb
+670.264 274.195 629.188 409.347 588.113 544.499 0 0 1 5 lb
+670.264 274.195 797.466 341.771 924.667 409.347 0 0 1 5 lb
+588.113 544.499 756.39 476.923 924.667 409.347 0 0 1 5 lb
+-689.204 -237.261 -612.964 -103.444 -567.302 43.6423 0 0 0 5 lb
+-689.204 -237.261 -643.542 -90.1744 -567.302 43.6423 0 0 0 5 lb
 grestore
 %Nodes:
 gsave
--567.302 43.6423 20.8452 0 0 1 nc
--689.204 -237.261 20.8452 0 0 1 nc
-924.667 409.347 20.8452 0 0 1 nc
-588.113 544.499 20.8452 0 0 1 nc
-670.264 274.195 20.8452 1 0 0 nc
--371.2 568.349 20.8452 0 0 1 nc
--132.697 451.748 20.8452 1 0 0 nc
--416.25 345.746 20.8452 0 0 1 nc
--180.397 245.045 20.8452 1 0 0 nc
--13.4452 133.743 20.8452 0 0 1 nc
--262.548 107.243 20.8452 0 0 1 nc
-201.208 38.3422 20.8452 0 0 1 nc
-116.407 -173.66 20.8452 0 0 1 nc
--26.6953 -19.9585 20.8452 1 0 0 nc
--539.894 -262.64 20.8452 0 0 1 nc
--323.543 -433.964 20.8452 0 0 1 nc
--309.657 -57.9033 20.8452 1 0 0 nc
--67.9734 -347.42 20.8452 1 0 0 nc
-415.393 -289.516 20.8452 1 0 0 nc
-730.084 -307.139 20.8452 0 0 1 nc
-526.164 32.7279 20.8452 1 0 0 nc
-762.812 -17.6227 20.8452 1 0 0 nc
--67.9734 319.727 20.8452 0 0 1 nc
-329.797 314.692 20.8452 0 0 1 nc
--5.03507 561.41 20.8452 0 0 1 nc
-422.945 521.129 20.8452 0 0 1 nc
--470.779 158.605 20.8452 1 0 0 nc
-986.873 -115.807 20.8452 0 0 1 nc
-906.312 201.403 20.8452 0 0 1 nc
--767.847 113.289 20.8452 1 0 0 nc
--579.033 445.603 20.8452 0 0 1 nc
--840.856 -246.718 20.8452 0 0 1 nc
-206.221 -205.967 20.8452 0 0 1 nc
-277.311 -252.33 20.8452 0 0 1 nc
-271.13 -175.058 20.8452 1 0 0 nc
-366.947 -110.15 20.8452 1 0 0 nc
-397.855 -196.694 20.8452 0 0 1 nc
-438.037 -88.514 20.8452 0 0 1 nc
-286.584 -48.3327 20.8452 1 0 0 nc
-212.403 -23.6057 20.8452 0 0 1 nc
-280.402 10.3938 20.8452 0 0 1 nc
-694.579 115.483 20.8452 0 0 1 nc
-574.035 177.301 20.8452 0 0 1 nc
+-567.302 43.6423 20 0 0 1 nc
+-689.204 -237.261 20 0 0 1 nc
+924.667 409.347 20 0 0 1 nc
+588.113 544.499 20 0 0 1 nc
+670.264 274.195 20 1 0 0 nc
+-371.2 568.349 20 0 0 1 nc
+-132.697 451.748 20 1 0 0 nc
+-416.25 345.746 20 0 0 1 nc
+-180.397 245.045 20 1 0 0 nc
+-13.4452 133.743 20 0 0 1 nc
+-262.548 107.243 20 0 0 1 nc
+201.208 38.3422 20 0 0 1 nc
+116.407 -173.66 20 0 0 1 nc
+-26.6953 -19.9585 20 1 0 0 nc
+-539.894 -262.64 20 0 0 1 nc
+-323.543 -433.964 20 0 0 1 nc
+-309.657 -57.9033 20 1 0 0 nc
+-67.9734 -347.42 20 1 0 0 nc
+415.393 -289.516 20 1 0 0 nc
+730.084 -307.139 20 0 0 1 nc
+526.164 32.7279 20 1 0 0 nc
+762.812 -17.6227 20 1 0 0 nc
+-67.9734 319.727 20 0 0 1 nc
+329.797 314.692 20 0 0 1 nc
+-5.03507 561.41 20 0 0 1 nc
+422.945 521.129 20 0 0 1 nc
+-470.779 158.605 20 1 0 0 nc
+986.873 -115.807 20 0 0 1 nc
+906.312 201.403 20 0 0 1 nc
+-767.847 113.289 20 1 0 0 nc
+-579.033 445.603 20 0 0 1 nc
+-840.856 -246.718 20 0 0 1 nc
+206.221 -205.967 20 0 0 1 nc
+277.311 -252.33 20 0 0 1 nc
+271.13 -175.058 20 1 0 0 nc
+366.947 -110.15 20 1 0 0 nc
+397.855 -196.694 20 0 0 1 nc
+438.037 -88.514 20 0 0 1 nc
+286.584 -48.3327 20 1 0 0 nc
+212.403 -23.6057 20 0 0 1 nc
+280.402 10.3938 20 0 0 1 nc
+694.579 115.483 20 0 0 1 nc
+574.035 177.301 20 0 0 1 nc
 grestore
 grestore
Index: c/images/planar.eps
===================================================================
--- doc/images/planar.eps	(revision 895)
+++ 	(revision )
@@ -1,181 +1,0 @@
-%!PS-Adobe-2.0 EPSF-2.0
-%%Creator: LEMON, graphToEps()
-%%CreationDate: Fri Oct 19 18:32:32 2007
-%%BoundingBox: 0 0 596 842
-%%DocumentPaperSizes: a4
-%%EndComments
-/lb { setlinewidth setrgbcolor newpath moveto
-      4 2 roll 1 index 1 index curveto stroke } bind def
-/l { setlinewidth setrgbcolor newpath moveto lineto stroke } bind def
-/c { newpath dup 3 index add 2 index moveto 0 360 arc closepath } bind def
-/sq { newpath 2 index 1 index add 2 index 2 index add moveto
-      2 index 1 index sub 2 index 2 index add lineto
-      2 index 1 index sub 2 index 2 index sub lineto
-      2 index 1 index add 2 index 2 index sub lineto
-      closepath pop pop pop} bind def
-/di { newpath 2 index 1 index add 2 index moveto
-      2 index             2 index 2 index add lineto
-      2 index 1 index sub 2 index             lineto
-      2 index             2 index 2 index sub lineto
-      closepath pop pop pop} bind def
-/nc { 0 0 0 setrgbcolor 5 index 5 index 5 index c fill
-     setrgbcolor 1.1 div c fill
-   } bind def
-/nsq { 0 0 0 setrgbcolor 5 index 5 index 5 index sq fill
-     setrgbcolor 1.1 div sq fill
-   } bind def
-/ndi { 0 0 0 setrgbcolor 5 index 5 index 5 index di fill
-     setrgbcolor 1.1 div di fill
-   } bind def
-/nfemale { 0 0 0 setrgbcolor 3 index 0.0909091 1.5 mul mul setlinewidth
-  newpath 5 index 5 index moveto 5 index 5 index 5 index 3.01 mul sub
-  lineto 5 index 4 index .7 mul sub 5 index 5 index 2.2 mul sub moveto
-  5 index 4 index .7 mul add 5 index 5 index 2.2 mul sub lineto stroke
-  5 index 5 index 5 index c fill
-  setrgbcolor 1.1 div c fill
-  } bind def
-/nmale {
-  0 0 0 setrgbcolor 3 index 0.0909091 1.5 mul mul setlinewidth
-  newpath 5 index 5 index moveto
-  5 index 4 index 1 mul 1.5 mul add
-  5 index 5 index 3 sqrt 1.5 mul mul add
-  1 index 1 index lineto
-  1 index 1 index 7 index sub moveto
-  1 index 1 index lineto
-  exch 5 index 3 sqrt .5 mul mul sub exch 5 index .5 mul sub lineto
-  stroke
-  5 index 5 index 5 index c fill
-  setrgbcolor 1.1 div c fill
-  } bind def
-/arrl 1 def
-/arrw 0.3 def
-/lrl { 2 index mul exch 2 index mul exch rlineto pop} bind def
-/arr { setrgbcolor /y1 exch def /x1 exch def /dy exch def /dx exch def
-       /w exch def /len exch def
-       newpath x1 dy w 2 div mul add y1 dx w 2 div mul sub moveto
-       len w sub arrl sub dx dy lrl
-       arrw dy dx neg lrl
-       dx arrl w add mul dy w 2 div arrw add mul sub
-       dy arrl w add mul dx w 2 div arrw add mul add rlineto
-       dx arrl w add mul neg dy w 2 div arrw add mul sub
-       dy arrl w add mul neg dx w 2 div arrw add mul add rlineto
-       arrw dy dx neg lrl
-       len w sub arrl sub neg dx dy lrl
-       closepath fill } bind def
-/cshow { 2 index 2 index moveto dup stringwidth pop
-         neg 2 div fosi .35 mul neg rmoveto show pop pop} def
-
-gsave
-15 138.307 translate
-12.7843 dup scale
-90 rotate
-0.608112 -43.6081 translate
-%Edges:
-gsave
-9 31 9.5 30.5 10 30 0 0 0 0.091217 lb
-9 31 5.5 34.5 2 38 0 0 0 0.091217 lb
-9 31 25.5 16 42 1 0 0 0 0.091217 lb
-3 40 23 20.5 43 1 0 0 0 0.091217 lb
-3 40 22.5 20.5 42 1 0 0 0 0.091217 lb
-3 40 2.5 40.5 2 41 0 0 0 0.091217 lb
-13 25 10.5 24.5 8 24 0 0 0 0.091217 lb
-13 25 12 27 11 29 0 0 0 0.091217 lb
-3 4 2.5 3 2 2 0 0 0 0.091217 lb
-3 4 4.5 3 6 2 0 0 0 0.091217 lb
-6 25 7 24.5 8 24 0 0 0 0.091217 lb
-6 25 6 24.5 6 24 0 0 0 0.091217 lb
-34 2 33.5 2 33 2 0 0 0 0.091217 lb
-34 2 35 2 36 2 0 0 0 0.091217 lb
-6 8 16 9 26 10 0 0 0 0.091217 lb
-6 8 6 10.5 6 13 0 0 0 0.091217 lb
-6 8 6 7.5 6 7 0 0 0 0.091217 lb
-26 10 27.5 8.5 29 7 0 0 0 0.091217 lb
-26 10 27.5 9 29 8 0 0 0 0.091217 lb
-10 30 10.5 29.5 11 29 0 0 0 0.091217 lb
-8 24 7 23.5 6 23 0 0 0 0.091217 lb
-8 24 8 24.5 8 25 0 0 0 0.091217 lb
-33 2 32.5 2 32 2 0 0 0 0.091217 lb
-29 7 17.5 7 6 7 0 0 0 0.091217 lb
-2 2 1.5 22 1 42 0 0 0 0.091217 lb
-2 2 3.5 2 5 2 0 0 0 0.091217 lb
-21 15 13.5 14.5 6 14 0 0 0 0.091217 lb
-21 15 21 15.5 21 16 0 0 0 0.091217 lb
-1 42 0.5 42.5 0 43 0 0 0 0.091217 lb
-1 42 1.5 41.5 2 41 0 0 0 0.091217 lb
-6 15 6 15.5 6 16 0 0 0 0.091217 lb
-6 15 6 14.5 6 14 0 0 0 0.091217 lb
-43 1 22 0.5 1 0 0 0 0 0.091217 lb
-31 2 18.5 2 6 2 0 0 0 0.091217 lb
-31 2 31.5 2 32 2 0 0 0 0.091217 lb
-6 24 6 23.5 6 23 0 0 0 0.091217 lb
-6 16 6 16.5 6 17 0 0 0 0.091217 lb
-6 23 6 20 6 17 0 0 0 0.091217 lb
-6 2 5.5 2 5 2 0 0 0 0.091217 lb
-6 2 6 4.5 6 7 0 0 0 0.091217 lb
-0 43 0.5 21.5 1 0 0 0 0 0.091217 lb
-1 1 19.5 1.5 38 2 0 0 0 0.091217 lb
-1 1 1 0.5 1 0 0 0 0 0.091217 lb
-2 38 5.5 31.5 9 25 0 0 0 0.091217 lb
-25 13 15.5 13 6 13 0 0 0 0.091217 lb
-25 13 15.5 13.5 6 14 0 0 0 0.091217 lb
-8 25 8.5 25 9 25 0 0 0 0.091217 lb
-11 29 24.5 15.5 38 2 0 0 0 0.091217 lb
-6 17 11.5 18 17 19 0 0 0 0.091217 lb
-16 23 26.5 12.5 37 2 0 0 0 0.091217 lb
-16 23 18.5 19.5 21 16 0 0 0 0.091217 lb
-36 2 36.5 2 37 2 0 0 0 0.091217 lb
-36 2 32.5 5 29 8 0 0 0 0.091217 lb
-6 13 6 13.5 6 14 0 0 0 0.091217 lb
-37 2 37.5 2 38 2 0 0 0 0.091217 lb
-21 16 19 17.5 17 19 0 0 0 0.091217 lb
-grestore
-%Nodes:
-gsave
-29 8 0.304556 1 1 1 nc
-2 41 0.304556 1 1 1 nc
-6 7 0.304556 1 1 1 nc
-5 2 0.304556 1 1 1 nc
-17 19 0.304556 1 1 1 nc
-21 16 0.304556 1 1 1 nc
-1 0 0.304556 1 1 1 nc
-9 25 0.304556 1 1 1 nc
-6 14 0.304556 1 1 1 nc
-42 1 0.304556 1 1 1 nc
-38 2 0.304556 1 1 1 nc
-37 2 0.304556 1 1 1 nc
-6 13 0.304556 1 1 1 nc
-36 2 0.304556 1 1 1 nc
-16 23 0.304556 1 1 1 nc
-6 17 0.304556 1 1 1 nc
-11 29 0.304556 1 1 1 nc
-8 25 0.304556 1 1 1 nc
-32 2 0.304556 1 1 1 nc
-25 13 0.304556 1 1 1 nc
-2 38 0.304556 1 1 1 nc
-1 1 0.304556 1 1 1 nc
-0 43 0.304556 1 1 1 nc
-6 2 0.304556 1 1 1 nc
-6 23 0.304556 1 1 1 nc
-6 16 0.304556 1 1 1 nc
-6 24 0.304556 1 1 1 nc
-31 2 0.304556 1 1 1 nc
-43 1 0.304556 1 1 1 nc
-6 15 0.304556 1 1 1 nc
-1 42 0.304556 1 1 1 nc
-21 15 0.304556 1 1 1 nc
-2 2 0.304556 1 1 1 nc
-29 7 0.304556 1 1 1 nc
-33 2 0.304556 1 1 1 nc
-8 24 0.304556 1 1 1 nc
-10 30 0.304556 1 1 1 nc
-26 10 0.304556 1 1 1 nc
-6 8 0.304556 1 1 1 nc
-34 2 0.304556 1 1 1 nc
-6 25 0.304556 1 1 1 nc
-3 4 0.304556 1 1 1 nc
-13 25 0.304556 1 1 1 nc
-3 40 0.304556 1 1 1 nc
-9 31 0.304556 1 1 1 nc
-grestore
-grestore
-showpage
Index: doc/images/strongly_connected_components.eps
===================================================================
--- doc/images/strongly_connected_components.eps	(revision 1213)
+++ doc/images/strongly_connected_components.eps	(revision 634)
@@ -1,5 +1,5 @@
 %!PS-Adobe-2.0 EPSF-2.0
 %%Creator: LEMON, graphToEps()
-%%CreationDate: Fri Mar  8 00:22:15 2013
+%%CreationDate: Fri Nov  4 13:47:12 2005
 %%BoundingBox: 0 0 842 596
 %%EndComments
@@ -54,126 +54,126 @@
 %Edges:
 gsave
-4.56973 setlinewidth 0 0 1 setrgbcolor newpath
+2 setlinewidth 0 0 1 setrgbcolor newpath
 218.178 27.2723 moveto
-195.849 -31.0725 190.033 -46.2697 176.306 -82.1369 curveto stroke
-newpath 163.235 -116.291 moveto 165.206 -77.8889 lineto 187.405 -86.3849 lineto closepath fill
-4.56973 setlinewidth 0 0 1 setrgbcolor newpath
+192.373 -40.1551 188.622 -49.9556 169.228 -100.631 curveto stroke
+newpath 164.939 -111.838 moveto 165.492 -99.2013 lineto 172.964 -102.061 lineto closepath fill
+2 setlinewidth 0 0 1 setrgbcolor newpath
 44.8044 15.5841 moveto
-109.705 19.9594 126.016 21.0591 166.493 23.7879 curveto stroke
-newpath 202.98 26.2477 moveto 167.292 11.9299 lineto 165.694 35.6458 lineto closepath fill
-4.56973 setlinewidth 1 0 0 setrgbcolor newpath
+119.293 20.6059 129.775 21.3125 186.25 25.1199 curveto stroke
+newpath 198.223 25.927 moveto 186.519 21.1289 lineto 185.981 29.1108 lineto closepath fill
+2 setlinewidth 1 0 0 setrgbcolor newpath
 218.178 27.2723 moveto
-281.264 -80.3935 289.87 -95.0808 338.092 -177.379 curveto stroke
-newpath 356.579 -208.932 moveto 327.837 -183.388 lineto 348.346 -171.371 lineto closepath fill
-4.56973 setlinewidth 0 0 1 setrgbcolor newpath
+285.395 -87.4449 290.763 -96.6058 348.102 -194.464 curveto stroke
+newpath 354.169 -204.818 moveto 344.651 -196.487 lineto 351.554 -192.442 lineto closepath fill
+2 setlinewidth 0 0 1 setrgbcolor newpath
 157.79 -130.517 moveto
-114.446 -74.4692 104.358 -61.4239 76.4943 -25.394 curveto stroke
-newpath 54.1228 3.53455 moveto 85.8959 -18.1234 lineto 67.0928 -32.6646 lineto closepath fill
-4.56973 setlinewidth 1 0 0 setrgbcolor newpath
+108.71 -67.0521 102.27 -58.7243 64.3804 -9.72954 curveto stroke
+newpath 57.0394 -0.236898 moveto 67.5446 -7.28254 lineto 61.2162 -12.1765 lineto closepath fill
+2 setlinewidth 1 0 0 setrgbcolor newpath
 -105.193 -261.035 moveto
--39.4801 -139.85 -31.344 -124.846 20.1113 -29.9539 curveto stroke
-newpath 37.5434 2.19358 moveto 30.559 -35.6192 lineto 9.66361 -24.2886 lineto closepath fill
-4.56973 setlinewidth 0 0 1 setrgbcolor newpath
+-35.6576 -132.801 -30.5923 -123.459 29.5506 -12.5464 curveto stroke
+newpath 35.2708 -1.99743 moveto 33.0669 -14.4531 lineto 26.0343 -10.6397 lineto closepath fill
+2 setlinewidth 0 0 1 setrgbcolor newpath
 -465.576 -42.8564 moveto
--550.335 -27.1603 -566.8 -24.1113 -625.027 -13.3286 curveto stroke
-newpath -660.985 -6.66971 moveto -622.863 -1.64245 lineto -627.191 -25.0148 lineto closepath fill
-4.56973 setlinewidth 0 0 1 setrgbcolor newpath
+-559.078 -25.5413 -569.47 -23.6169 -644.498 -9.72286 curveto stroke
+newpath -656.297 -7.5378 moveto -643.77 -5.78973 lineto -645.226 -13.656 lineto closepath fill
+2 setlinewidth 0 0 1 setrgbcolor newpath
 -574.666 -153.893 moveto
--535.911 -114.447 -524.692 -103.027 -501.88 -79.8085 curveto stroke
-newpath -476.251 -53.7222 moveto -493.402 -88.1377 lineto -510.358 -71.4793 lineto closepath fill
-4.56973 setlinewidth 1 0 0 setrgbcolor newpath
+-528.842 -107.252 -521.515 -99.794 -488.002 -65.683 curveto stroke
+newpath -479.592 -57.123 moveto -485.149 -68.4863 lineto -490.856 -62.8797 lineto closepath fill
+2 setlinewidth 1 0 0 setrgbcolor newpath
 -490.901 120.777 moveto
--481.623 60.8277 -479.143 44.8049 -473.499 8.33636 curveto stroke
-newpath -467.906 -27.8032 moveto -485.244 6.51862 lineto -461.754 10.1541 lineto closepath fill
-4.56973 setlinewidth 0 0 1 setrgbcolor newpath
+-480.122 51.1328 -478.519 40.7713 -470.47 -11.2329 curveto stroke
+newpath -468.635 -23.0917 moveto -474.423 -11.8447 lineto -466.517 -10.6212 lineto closepath fill
+2 setlinewidth 0 0 1 setrgbcolor newpath
 -675.963 -3.89604 moveto
--637.405 -60.9909 -628.201 -74.6206 -603.658 -110.963 curveto stroke
-newpath -583.191 -141.27 moveto -613.507 -117.615 lineto -593.808 -104.312 lineto closepath fill
-4.56973 setlinewidth 0 0 1 setrgbcolor newpath
+-632.116 -68.8235 -626.228 -77.5422 -592.575 -127.374 curveto stroke
+newpath -585.859 -137.319 moveto -595.89 -129.612 lineto -589.26 -125.135 lineto closepath fill
+2 setlinewidth 0 0 1 setrgbcolor newpath
 -490.901 120.777 moveto
--439.75 208.465 -431.238 223.057 -394.278 286.417 curveto stroke
-newpath -375.851 318.006 moveto -384.012 280.429 lineto -404.543 292.406 lineto closepath fill
-4.56973 setlinewidth 0 0 1 setrgbcolor newpath
+-435.445 215.844 -430.107 224.995 -384.3 303.522 curveto stroke
+newpath -378.253 313.887 moveto -380.845 301.507 lineto -387.755 305.537 lineto closepath fill
+2 setlinewidth 0 0 1 setrgbcolor newpath
 -266.879 114.933 moveto
--358.311 117.318 -375.109 117.756 -439.117 119.426 curveto stroke
-newpath -475.674 120.38 moveto -438.807 131.307 lineto -439.426 107.545 lineto closepath fill
-4.56973 setlinewidth 0 0 1 setrgbcolor newpath
+-367.067 117.547 -377.642 117.822 -458.912 119.943 curveto stroke
+newpath -470.908 120.255 moveto -458.807 123.941 lineto -459.016 115.944 lineto closepath fill
+2 setlinewidth 0 0 1 setrgbcolor newpath
 -368.176 331.163 moveto
--326.156 241.466 -318.997 226.186 -288.855 161.843 curveto stroke
-newpath -273.341 128.727 moveto -299.617 156.801 lineto -278.092 166.885 lineto closepath fill
-4.56973 setlinewidth 1 0 0 setrgbcolor newpath
+-322.511 233.685 -318.018 224.095 -280.454 143.911 curveto stroke
+newpath -275.364 133.044 moveto -284.076 142.214 lineto -276.832 145.608 lineto closepath fill
+2 setlinewidth 1 0 0 setrgbcolor newpath
 -266.879 114.933 moveto
--226.764 227.755 -221.069 243.774 -190.728 329.107 curveto stroke
-newpath -178.477 363.564 moveto -179.53 325.126 lineto -201.926 333.089 lineto closepath fill
-4.56973 setlinewidth 0 0 1 setrgbcolor newpath
+-224.004 235.52 -220.448 245.52 -184.094 347.765 curveto stroke
+newpath -180.074 359.072 moveto -180.325 346.425 lineto -187.863 349.105 lineto closepath fill
+2 setlinewidth 0 0 1 setrgbcolor newpath
 -251.294 -335.059 moveto
--198.044 -308.079 -183.61 -300.766 -151.402 -284.448 curveto stroke
-newpath -118.781 -267.92 moveto -146.031 -295.049 lineto -156.774 -273.846 lineto closepath fill
-4.56973 setlinewidth 0 0 1 setrgbcolor newpath
+-189.25 -303.624 -179.902 -298.887 -133.738 -275.498 curveto stroke
+newpath -123.034 -270.074 moveto -131.93 -279.066 lineto -135.546 -271.93 lineto closepath fill
+2 setlinewidth 0 0 1 setrgbcolor newpath
 -389.604 -136.361 moveto
--332.039 -219.059 -322.392 -232.919 -280.889 -292.543 curveto stroke
-newpath -259.996 -322.557 moveto -290.643 -299.333 lineto -271.134 -285.753 lineto closepath fill
-4.56973 setlinewidth 1 0 0 setrgbcolor newpath
+-327.15 -226.083 -321.098 -234.777 -269.576 -308.795 curveto stroke
+newpath -262.72 -318.644 moveto -272.859 -311.081 lineto -266.293 -306.51 lineto closepath fill
+2 setlinewidth 1 0 0 setrgbcolor newpath
 5.84406 175.322 moveto
--70.5724 261.706 -81.8227 274.423 -139.051 339.116 curveto stroke
-newpath -163.281 366.507 moveto -130.149 346.991 lineto -147.953 331.242 lineto closepath fill
-4.56973 setlinewidth 0 0 1 setrgbcolor newpath
+-76.0754 267.926 -83.1051 275.873 -152.172 353.948 curveto stroke
+newpath -160.122 362.936 moveto -149.176 356.598 lineto -155.168 351.298 lineto closepath fill
+2 setlinewidth 0 0 1 setrgbcolor newpath
 169.478 311.683 moveto
-103.641 256.819 90.7821 246.103 45.6398 208.485 curveto stroke
-newpath 17.546 185.074 moveto 38.0313 217.615 lineto 53.2483 199.355 lineto closepath fill
-4.56973 setlinewidth 0 0 1 setrgbcolor newpath
+96.8003 251.119 88.6819 244.353 30.4273 195.808 curveto stroke
+newpath 21.2086 188.126 moveto 27.8666 198.881 lineto 32.988 192.735 lineto closepath fill
+2 setlinewidth 0 0 1 setrgbcolor newpath
 342.851 111.037 moveto
-269.224 196.246 258.132 209.083 203.347 272.486 curveto stroke
-newpath 179.437 300.157 moveto 212.34 280.257 lineto 194.354 264.716 lineto closepath fill
-4.56973 setlinewidth 0 0 1 setrgbcolor newpath
+263.766 202.563 256.831 210.589 190.4 287.47 curveto stroke
+newpath 182.554 296.55 moveto 193.427 290.085 lineto 187.373 284.855 lineto closepath fill
+2 setlinewidth 0 0 1 setrgbcolor newpath
 5.84406 175.322 moveto
-155.419 146.79 172.221 143.585 291.966 120.743 curveto stroke
-newpath 327.888 113.891 moveto 289.739 109.069 lineto 294.193 132.418 lineto closepath fill
-4.56973 setlinewidth 0 0 1 setrgbcolor newpath
+163.16 145.314 173.605 143.321 311.418 117.033 curveto stroke
+newpath 323.205 114.784 moveto 310.668 113.104 lineto 312.167 120.962 lineto closepath fill
+2 setlinewidth 0 0 1 setrgbcolor newpath
 342.851 111.037 moveto
-490.978 6.99574 505.015 -2.86383 627.727 -89.0547 curveto stroke
-newpath 657.653 -110.074 moveto 620.896 -98.7802 lineto 634.558 -79.3291 lineto closepath fill
-4.56973 setlinewidth 0 0 1 setrgbcolor newpath
+497.255 2.58683 505.964 -3.53033 643.932 -100.436 curveto stroke
+newpath 653.752 -107.334 moveto 641.633 -103.71 lineto 646.231 -97.163 lineto closepath fill
+2 setlinewidth 0 0 1 setrgbcolor newpath
 364.28 -222.074 moveto
-354.807 -74.8128 353.709 -57.7536 346.177 59.3416 curveto stroke
-newpath 343.829 95.836 moveto 358.037 60.1045 lineto 334.316 58.5786 lineto closepath fill
-4.56973 setlinewidth 0 0 1 setrgbcolor newpath
+354.298 -66.9063 353.616 -56.2971 344.905 79.1029 curveto stroke
+newpath 344.135 91.0781 moveto 348.897 79.3597 lineto 340.914 78.8461 lineto closepath fill
+2 setlinewidth 0 0 1 setrgbcolor newpath
 670.118 -118.829 moveto
-535.595 -164.241 519.412 -169.704 413.361 -205.505 curveto stroke
-newpath 378.712 -217.202 moveto 409.559 -194.245 lineto 417.162 -216.766 lineto closepath fill
-4.56973 setlinewidth 1 0 0 setrgbcolor newpath
+528.037 -166.793 517.967 -170.192 394.599 -211.839 curveto stroke
+newpath 383.229 -215.677 moveto 393.32 -208.049 lineto 395.878 -215.629 lineto closepath fill
+2 setlinewidth 1 0 0 setrgbcolor newpath
 -105.193 -261.035 moveto
-110.939 -243.099 128.069 -241.677 312.655 -226.358 curveto stroke
-newpath 349.1 -223.334 moveto 313.638 -238.202 lineto 311.672 -214.514 lineto closepath fill
-4.56973 setlinewidth 0 0 1 setrgbcolor newpath
+118.401 -242.479 129.015 -241.598 332.39 -224.721 curveto stroke
+newpath 344.348 -223.728 moveto 332.72 -228.707 lineto 332.059 -220.734 lineto closepath fill
+2 setlinewidth 0 0 1 setrgbcolor newpath
 -105.193 -261.035 moveto
--156.746 -168.566 -164.987 -153.784 -202.693 -86.1539 curveto stroke
-newpath -220.5 -54.2129 moveto -192.312 -80.3665 lineto -213.073 -91.9413 lineto closepath fill
-4.56973 setlinewidth 0 0 1 setrgbcolor newpath
+-160.867 -161.176 -166.028 -151.918 -212.336 -68.858 curveto stroke
+newpath -218.179 -58.3769 moveto -208.842 -66.9102 lineto -215.829 -70.8058 lineto closepath fill
+2 setlinewidth 0 0 1 setrgbcolor newpath
 -227.918 -40.9084 moveto
--290.327 -77.7521 -304.558 -86.1532 -344.995 -110.026 curveto stroke
-newpath -376.487 -128.617 moveto -351.037 -99.7914 lineto -338.953 -120.26 lineto closepath fill
+-298.35 -82.4884 -307.42 -87.8432 -362.048 -120.093 curveto stroke
+newpath -372.381 -126.193 moveto -364.081 -116.648 lineto -360.014 -123.537 lineto closepath fill
 grestore
 %Nodes:
 gsave
--389.604 -136.361 15.2324 0 1 0 nc
--227.918 -40.9084 15.2324 0 1 0 nc
--105.193 -261.035 15.2324 0 1 0 nc
-364.28 -222.074 15.2324 1 1 0 nc
-670.118 -118.829 15.2324 1 1 0 nc
-342.851 111.037 15.2324 1 1 0 nc
-5.84406 175.322 15.2324 1 1 0 nc
-169.478 311.683 15.2324 1 1 0 nc
--173.374 377.916 15.2324 1 0 1 nc
--251.294 -335.059 15.2324 0 1 0 nc
--266.879 114.933 15.2324 0 0 0 nc
--368.176 331.163 15.2324 0 0 0 nc
--490.901 120.777 15.2324 0 0 0 nc
--574.666 -153.893 15.2324 1 0 0 nc
--675.963 -3.89604 15.2324 1 0 0 nc
--465.576 -42.8564 15.2324 1 0 0 nc
-44.8044 15.5841 15.2324 0 0 1 nc
-157.79 -130.517 15.2324 0 0 1 nc
-218.178 27.2723 15.2324 0 0 1 nc
+-389.604 -136.361 20 0 1 0 nc
+-227.918 -40.9084 20 0 1 0 nc
+-105.193 -261.035 20 0 1 0 nc
+364.28 -222.074 20 1 1 0 nc
+670.118 -118.829 20 1 1 0 nc
+342.851 111.037 20 1 1 0 nc
+5.84406 175.322 20 1 1 0 nc
+169.478 311.683 20 1 1 0 nc
+-173.374 377.916 20 1 0 1 nc
+-251.294 -335.059 20 0 1 0 nc
+-266.879 114.933 20 0 0 0 nc
+-368.176 331.163 20 0 0 0 nc
+-490.901 120.777 20 0 0 0 nc
+-574.666 -153.893 20 1 0 0 nc
+-675.963 -3.89604 20 1 0 0 nc
+-465.576 -42.8564 20 1 0 0 nc
+44.8044 15.5841 20 0 0 1 nc
+157.79 -130.517 20 0 0 1 nc
+218.178 27.2723 20 0 0 1 nc
 grestore
 grestore
Index: c/images/tsp.eps
===================================================================
--- doc/images/tsp.eps	(revision 1200)
+++ 	(revision )
@@ -1,229 +1,0 @@
-%!PS-Adobe-2.0 EPSF-2.0
-%%Creator: LEMON, graphToEps()
-%%CreationDate: Tue Jun 15 00:58:57 2010
-%%BoundingBox: 31 41 649 709
-%%EndComments
-/lb { setlinewidth setrgbcolor newpath moveto
-      4 2 roll 1 index 1 index curveto stroke } bind def
-/l { setlinewidth setrgbcolor newpath moveto lineto stroke } bind def
-/c { newpath dup 3 index add 2 index moveto 0 360 arc closepath } bind def
-/sq { newpath 2 index 1 index add 2 index 2 index add moveto
-      2 index 1 index sub 2 index 2 index add lineto
-      2 index 1 index sub 2 index 2 index sub lineto
-      2 index 1 index add 2 index 2 index sub lineto
-      closepath pop pop pop} bind def
-/di { newpath 2 index 1 index add 2 index moveto
-      2 index             2 index 2 index add lineto
-      2 index 1 index sub 2 index             lineto
-      2 index             2 index 2 index sub lineto
-      closepath pop pop pop} bind def
-/nc { 0 0 0 setrgbcolor 5 index 5 index 5 index c fill
-     setrgbcolor 1.1 div c fill
-   } bind def
-/nsq { 0 0 0 setrgbcolor 5 index 5 index 5 index sq fill
-     setrgbcolor 1.1 div sq fill
-   } bind def
-/ndi { 0 0 0 setrgbcolor 5 index 5 index 5 index di fill
-     setrgbcolor 1.1 div di fill
-   } bind def
-/nfemale { 0 0 0 setrgbcolor 3 index 0.0909091 1.5 mul mul setlinewidth
-  newpath 5 index 5 index moveto 5 index 5 index 5 index 3.01 mul sub
-  lineto 5 index 4 index .7 mul sub 5 index 5 index 2.2 mul sub moveto
-  5 index 4 index .7 mul add 5 index 5 index 2.2 mul sub lineto stroke
-  5 index 5 index 5 index c fill
-  setrgbcolor 1.1 div c fill
-  } bind def
-/nmale {
-  0 0 0 setrgbcolor 3 index 0.0909091 1.5 mul mul setlinewidth
-  newpath 5 index 5 index moveto
-  5 index 4 index 1 mul 1.5 mul add
-  5 index 5 index 3 sqrt 1.5 mul mul add
-  1 index 1 index lineto
-  1 index 1 index 7 index sub moveto
-  1 index 1 index lineto
-  exch 5 index 3 sqrt .5 mul mul sub exch 5 index .5 mul sub lineto
-  stroke
-  5 index 5 index 5 index c fill
-  setrgbcolor 1.1 div c fill
-  } bind def
-/arrl 1 def
-/arrw 0.3 def
-/lrl { 2 index mul exch 2 index mul exch rlineto pop} bind def
-/arr { setrgbcolor /y1 exch def /x1 exch def /dy exch def /dx exch def
-       /w exch def /len exch def
-       newpath x1 dy w 2 div mul add y1 dx w 2 div mul sub moveto
-       len w sub arrl sub dx dy lrl
-       arrw dy dx neg lrl
-       dx arrl w add mul dy w 2 div arrw add mul sub
-       dy arrl w add mul dx w 2 div arrw add mul add rlineto
-       dx arrl w add mul neg dy w 2 div arrw add mul sub
-       dy arrl w add mul neg dx w 2 div arrw add mul add rlineto
-       arrw dy dx neg lrl
-       len w sub arrl sub neg dx dy lrl
-       closepath fill } bind def
-/cshow { 2 index 2 index moveto dup stringwidth pop
-         neg 2 div fosi .35 mul neg rmoveto show pop pop} def
-
-gsave
-10 dup scale
-%Arcs:
-gsave
-27 68 37 69 0 0 1 0.513798 l
-37 69 27 68 0 0 1 0.513798 l
-8 52 5 64 0 0 1 0.513798 l
-5 64 8 52 0 0 1 0.513798 l
-16 57 25 55 0 0 1 0.513798 l
-25 55 16 57 0 0 1 0.513798 l
-43 67 37 69 0 0 1 0.513798 l
-37 69 43 67 0 0 1 0.513798 l
-42 57 43 67 0 0 1 0.513798 l
-43 67 42 57 0 0 1 0.513798 l
-62 42 61 33 0 0 1 0.513798 l
-61 33 62 42 0 0 1 0.513798 l
-62 42 58 48 0 0 1 0.513798 l
-58 48 62 42 0 0 1 0.513798 l
-58 27 61 33 0 0 1 0.513798 l
-61 33 58 27 0 0 1 0.513798 l
-57 58 62 63 0 0 1 0.513798 l
-62 63 57 58 0 0 1 0.513798 l
-13 13 21 10 0 0 1 0.513798 l
-21 10 13 13 0 0 1 0.513798 l
-13 13 5 6 0 0 1 0.513798 l
-5 6 13 13 0 0 1 0.513798 l
-17 33 7 38 0 0 1 0.513798 l
-7 38 17 33 0 0 1 0.513798 l
-46 10 59 15 0 0 1 0.513798 l
-59 15 46 10 0 0 1 0.513798 l
-46 10 39 10 0 0 1 0.513798 l
-39 10 46 10 0 0 1 0.513798 l
-27 23 21 10 0 0 1 0.513798 l
-21 10 27 23 0 0 1 0.513798 l
-52 41 56 37 0 0 1 0.513798 l
-56 37 52 41 0 0 1 0.513798 l
-62 63 63 69 0 0 1 0.513798 l
-63 69 62 63 0 0 1 0.513798 l
-36 16 39 10 0 0 1 0.513798 l
-39 10 36 16 0 0 1 0.513798 l
-36 16 30 15 0 0 1 0.513798 l
-30 15 36 16 0 0 1 0.513798 l
-12 42 7 38 0 0 1 0.513798 l
-7 38 12 42 0 0 1 0.513798 l
-12 42 8 52 0 0 1 0.513798 l
-8 52 12 42 0 0 1 0.513798 l
-32 22 30 15 0 0 1 0.513798 l
-30 15 32 22 0 0 1 0.513798 l
-5 25 10 17 0 0 1 0.513798 l
-10 17 5 25 0 0 1 0.513798 l
-5 25 17 33 0 0 1 0.513798 l
-17 33 5 25 0 0 1 0.513798 l
-45 35 48 28 0 0 1 0.513798 l
-48 28 45 35 0 0 1 0.513798 l
-31 32 25 32 0 0 1 0.513798 l
-25 32 31 32 0 0 1 0.513798 l
-31 32 32 39 0 0 1 0.513798 l
-32 39 31 32 0 0 1 0.513798 l
-42 41 38 46 0 0 1 0.513798 l
-38 46 42 41 0 0 1 0.513798 l
-42 41 52 41 0 0 1 0.513798 l
-52 41 42 41 0 0 1 0.513798 l
-5 6 10 17 0 0 1 0.513798 l
-10 17 5 6 0 0 1 0.513798 l
-51 21 59 15 0 0 1 0.513798 l
-59 15 51 21 0 0 1 0.513798 l
-51 21 58 27 0 0 1 0.513798 l
-58 27 51 21 0 0 1 0.513798 l
-52 33 56 37 0 0 1 0.513798 l
-56 37 52 33 0 0 1 0.513798 l
-52 33 48 28 0 0 1 0.513798 l
-48 28 52 33 0 0 1 0.513798 l
-31 62 25 55 0 0 1 0.513798 l
-25 55 31 62 0 0 1 0.513798 l
-31 62 27 68 0 0 1 0.513798 l
-27 68 31 62 0 0 1 0.513798 l
-17 63 5 64 0 0 1 0.513798 l
-5 64 17 63 0 0 1 0.513798 l
-17 63 16 57 0 0 1 0.513798 l
-16 57 17 63 0 0 1 0.513798 l
-21 47 30 40 0 0 1 0.513798 l
-30 40 21 47 0 0 1 0.513798 l
-21 47 30 48 0 0 1 0.513798 l
-30 48 21 47 0 0 1 0.513798 l
-40 30 45 35 0 0 1 0.513798 l
-45 35 40 30 0 0 1 0.513798 l
-40 30 32 22 0 0 1 0.513798 l
-32 22 40 30 0 0 1 0.513798 l
-32 39 30 40 0 0 1 0.513798 l
-30 40 32 39 0 0 1 0.513798 l
-20 26 25 32 0 0 1 0.513798 l
-25 32 20 26 0 0 1 0.513798 l
-20 26 27 23 0 0 1 0.513798 l
-27 23 20 26 0 0 1 0.513798 l
-52 64 63 69 0 0 1 0.513798 l
-63 69 52 64 0 0 1 0.513798 l
-52 64 42 57 0 0 1 0.513798 l
-42 57 52 64 0 0 1 0.513798 l
-49 49 58 48 0 0 1 0.513798 l
-58 48 49 49 0 0 1 0.513798 l
-49 49 57 58 0 0 1 0.513798 l
-57 58 49 49 0 0 1 0.513798 l
-37 52 38 46 0 0 1 0.513798 l
-38 46 37 52 0 0 1 0.513798 l
-37 52 30 48 0 0 1 0.513798 l
-30 48 37 52 0 0 1 0.513798 l
-grestore
-%Nodes:
-gsave
-30 40 0.856329 1 1 1 nc
-56 37 0.856329 1 1 1 nc
-48 28 0.856329 1 1 1 nc
-25 55 0.856329 1 1 1 nc
-25 32 0.856329 1 1 1 nc
-32 39 0.856329 1 1 1 nc
-39 10 0.856329 1 1 1 nc
-30 15 0.856329 1 1 1 nc
-5 64 0.856329 1 1 1 nc
-21 10 0.856329 1 1 1 nc
-10 17 0.856329 1 1 1 nc
-5 6 0.856329 1 1 1 nc
-59 15 0.856329 1 1 1 nc
-45 35 0.856329 1 1 1 nc
-32 22 0.856329 1 1 1 nc
-63 69 0.856329 1 1 1 nc
-62 63 0.856329 1 1 1 nc
-61 33 0.856329 1 1 1 nc
-46 10 0.856329 1 1 1 nc
-38 46 0.856329 1 1 1 nc
-37 69 0.856329 1 1 1 nc
-58 27 0.856329 1 1 1 nc
-58 48 0.856329 1 1 1 nc
-43 67 0.856329 1 1 1 nc
-30 48 0.856329 1 1 1 nc
-27 68 0.856329 1 1 1 nc
-7 38 0.856329 1 1 1 nc
-8 52 0.856329 1 1 1 nc
-16 57 0.856329 1 1 1 nc
-42 57 0.856329 1 1 1 nc
-62 42 0.856329 1 1 1 nc
-57 58 0.856329 1 1 1 nc
-13 13 0.856329 1 1 1 nc
-17 33 0.856329 1 1 1 nc
-27 23 0.856329 1 1 1 nc
-52 41 0.856329 1 1 1 nc
-36 16 0.856329 1 1 1 nc
-12 42 0.856329 1 1 1 nc
-5 25 0.856329 1 1 1 nc
-31 32 0.856329 1 1 1 nc
-42 41 0.856329 1 1 1 nc
-51 21 0.856329 1 1 1 nc
-52 33 0.856329 1 1 1 nc
-31 62 0.856329 1 1 1 nc
-17 63 0.856329 1 1 1 nc
-21 47 0.856329 1 1 1 nc
-40 30 0.856329 1 1 1 nc
-20 26 0.856329 1 1 1 nc
-52 64 0.856329 1 1 1 nc
-49 49 0.856329 1 1 1 nc
-37 52 0.856329 1 1 1 nc
-grestore
-grestore
-showpage
Index: doc/lgf.dox
===================================================================
--- doc/lgf.dox	(revision 1270)
+++ doc/lgf.dox	(revision 463)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -64,21 +64,4 @@
 \endcode
 
-The \e LGF files can also contain bipartite graphs, in this case a
-\c \@red_nodes and a \c \@blue_nodes sections describe the node set of the
-graph. If a map is in both of these sections, then it can be used as a
-regular node map.
-
-\code
- @red_nodes
- label  only_red_map   name
- 1      "cherry"       "John"
- 2      "Santa Claus"  "Jack"
- 3      "blood"        "Jason"
- @blue_nodes
- label  name
- 4      "Elisabeth"
- 5      "Eve"
-\endcode
-
 The \c \@arcs section is very similar to the \c \@nodes section,
 it again starts with a header line describing the names of the maps,
@@ -96,19 +79,8 @@
 \endcode
 
-If there is no map in the \c \@arcs section at all, then it must be
-indicated by a sole '-' sign in the first line.
-
-\code
- @arcs
-         -
- 1   2
- 1   3
- 2   3
-\endcode
-
 The \c \@edges is just a synonym of \c \@arcs. The \@arcs section can
 also store the edge set of an undirected graph. In such case there is
 a conventional method for store arc maps in the file, if two columns
-have the same caption with \c '+' and \c '-' prefix, then these columns
+has the same caption with \c '+' and \c '-' prefix, then these columns
 can be regarded as the values of an arc map.
 
Index: doc/mainpage.dox
===================================================================
--- doc/mainpage.dox	(revision 802)
+++ doc/mainpage.dox	(revision 802)
@@ -0,0 +1,57 @@
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library.
+ *
+ * Copyright (C) 2003-2009
+ * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
+ * (Egervary Research Group on Combinatorial Optimization, EGRES).
+ *
+ * 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.
+ *
+ */
+
+/**
+\mainpage LEMON Documentation
+
+\section intro Introduction
+
+<b>LEMON</b> stands for <i><b>L</b>ibrary for <b>E</b>fficient <b>M</b>odeling
+and <b>O</b>ptimization in <b>N</b>etworks</i>.
+It is a C++ template library providing efficient implementation of common
+data structures and algorithms with focus on combinatorial optimization
+problems in graphs and networks.
+
+<b>
+LEMON is an <a class="el" href="http://opensource.org/">open&nbsp;source</a>
+project.
+You are free to use it in your commercial or
+non-commercial applications under very permissive
+\ref license "license terms".
+</b>
+
+The project is maintained by the 
+<a href="http://www.cs.elte.hu/egres/">Egerv&aacute;ry Research Group on
+Combinatorial Optimization</a> \ref egres
+at the Operations Research Department of the
+<a href="http://www.elte.hu/">E&ouml;tv&ouml;s Lor&aacute;nd University,
+Budapest</a>, Hungary.
+LEMON is also a member of the <a href="http://www.coin-or.org/">COIN-OR</a>
+initiative \ref coinor.
+
+\section howtoread How to Read the Documentation
+
+If you would like to get to know the library, see
+<a class="el" href="http://lemon.cs.elte.hu/pub/tutorial/">LEMON Tutorial</a>.
+
+If you know what you are looking for, then try to find it under the
+<a class="el" href="modules.html">Modules</a> section.
+
+If you are a user of the old (0.x) series of LEMON, please check out the
+\ref migration "Migration Guide" for the backward incompatibilities.
+*/
Index: c/mainpage.dox.in
===================================================================
--- doc/mainpage.dox.in	(revision 1221)
+++ 	(revision )
@@ -1,61 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2010
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * 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.
- *
- */
-
-/**
-\mainpage @PACKAGE_NAME@ @PACKAGE_VERSION@ Documentation
-
-\section intro Introduction
-
-<b>LEMON</b> stands for <i><b>L</b>ibrary for <b>E</b>fficient <b>M</b>odeling
-and <b>O</b>ptimization in <b>N</b>etworks</i>.
-It is a C++ template library providing efficient implementations of common
-data structures and algorithms with focus on combinatorial optimization
-tasks connected mainly with graphs and networks \cite DezsoJuttnerKovacs11Lemon.
-
-<b>
-LEMON is an <a class="el" href="http://opensource.org/">open&nbsp;source</a>
-project.
-You are free to use it in your commercial or
-non-commercial applications under very permissive
-\ref license "license terms".
-</b>
-
-The project is maintained by the
-<a href="http://www.cs.elte.hu/egres/">Egerv&aacute;ry Research Group on
-Combinatorial Optimization</a> \cite egres
-at the Operations Research Department of the
-<a href="http://www.elte.hu/en/">E&ouml;tv&ouml;s Lor&aacute;nd University</a>,
-Budapest, Hungary.
-LEMON is also a member of the <a href="http://www.coin-or.org/">COIN-OR</a>
-initiative \cite coinor.
-
-\section howtoread How to Read the Documentation
-
-If you would like to get to know the library, see
-<a class="el" href="http://lemon.cs.elte.hu/pub/tutorial/">LEMON Tutorial</a>.
-
-If you are interested in starting to use the library, see the <a class="el"
-href="http://lemon.cs.elte.hu/trac/lemon/wiki/InstallGuide/">Installation
-Guide</a>.
-
-If you know what you are looking for, then try to find it under the
-<a class="el" href="modules.html">Modules</a> section.
-
-If you are a user of the old (0.x) series of LEMON, please check out the
-\ref migration "Migration Guide" for the backward incompatibilities.
-*/
Index: doc/min_cost_flow.dox
===================================================================
--- doc/min_cost_flow.dox	(revision 1270)
+++ doc/min_cost_flow.dox	(revision 835)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -27,5 +27,5 @@
 minimum total cost from a set of supply nodes to a set of demand nodes
 in a network with capacity constraints (lower and upper bounds)
-and arc costs \cite amo93networkflows.
+and arc costs \ref amo93networkflows.
 
 Formally, let \f$G=(V,A)\f$ be a digraph, \f$lower: A\rightarrow\mathbf{R}\f$,
@@ -82,5 +82,5 @@
    - if \f$\sum_{uv\in A} f(uv) - \sum_{vu\in A} f(vu) \neq sup(u)\f$,
      then \f$\pi(u)=0\f$.
-
+ 
 Here \f$cost^\pi(uv)\f$ denotes the \e reduced \e cost of the arc
 \f$uv\in A\f$ with respect to the potential function \f$\pi\f$, i.e.
@@ -102,5 +102,5 @@
 \f[ lower(uv) \leq f(uv) \leq upper(uv) \quad \forall uv\in A \f]
 
-However, if the sum of the supply values is zero, then these two problems
+However if the sum of the supply values is zero, then these two problems
 are equivalent.
 The \ref min_cost_flow_algs "algorithms" in LEMON support the general
@@ -120,5 +120,5 @@
 \f[ lower(uv) \leq f(uv) \leq upper(uv) \quad \forall uv\in A \f]
 
-It means that the total demand must be less or equal to the
+It means that the total demand must be less or equal to the 
 total supply (i.e. \f$\sum_{u\in V} sup(u)\f$ must be zero or
 positive) and all the demands have to be satisfied, but there
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 1351)
+++ doc/references.bib	(revision 802)
@@ -5,5 +5,6 @@
   title =        {{LEMON} -- {L}ibrary for {E}fficient {M}odeling and
                   {O}ptimization in {N}etworks},
-  howpublished = {\url{http://lemon.cs.elte.hu/}}
+  howpublished = {\url{http://lemon.cs.elte.hu/}},
+  year =         2009
 }
 
@@ -20,26 +21,4 @@
                   {O}perations {R}esearch},
   url =          {http://www.coin-or.org/}
-}
-
-
-%%%%% Papers related to LEMON %%%%%
-
-@article{DezsoJuttnerKovacs11Lemon,
-  author =       {B. Dezs{\H o} and A. J\"uttner and P. Kov\'acs},
-  title =        {{LEMON} -- an open source {C++} graph template library},
-  journal =      {Electronic Notes in Theoretical Computer Science},
-  volume =       {264},
-  pages =        {23--45},
-  year =         {2011},
-  note =         {Proc. 2nd Workshop on Generative Technologies}
-}
-
-@article{KiralyKovacs12MCF,
-  author =       {Z. Kir\'aly and P. Kov\'acs},
-  title =        {Efficient implementations of minimum-cost flow algorithms},
-  journal =      {Acta Universitatis Sapientiae, Informatica},
-  year =         {2012},
-  volume =       {4},
-  pages =        {67--118}
 }
 
@@ -233,14 +212,4 @@
   volume =       23,
   pages =        {309-311}
-}
-
-@article{hartmann93finding,
-  author =       {Mark Hartmann and James B. Orlin},
-  title =        {Finding minimum cost to time ratio cycles with small
-                  integral transit times},
-  journal =      {Networks},
-  year =         1993,
-  volume =       23,
-  pages =        {567-574}
 }
 
@@ -257,15 +226,4 @@
 }
 
-@article{dasdan04experimental,
-  author =       {Ali Dasdan},
-  title =        {Experimental analysis of the fastest optimum cycle
-                  ratio and mean algorithms},
-  journal =      {ACM Trans. Des. Autom. Electron. Syst.},
-  year =         2004,
-  volume =       9,
-  issue =        4,
-  pages =        {385-418}
-} 
-
 
 %%%%% Minimum cost flow algorithms %%%%%
@@ -340,31 +298,4 @@
   address =      {Dublin, Ireland},
   year =         1991,
-  month =        sep
-}
-
-%%%%% Other algorithms %%%%%
-
-@article{grosso08maxclique,
-  author =       {Andrea Grosso and Marco Locatelli and Wayne Pullan},
-  title =        {Simple ingredients leading to very efficient
-                  heuristics for the maximum clique problem},
-  journal =      {Journal of Heuristics},
-  year =         2008,
-  volume =       14,
-  number =       6,
-  pages =        {587--612}
-}
-
-@article{cordella2004sub,
-  title =	 {A (sub) graph isomorphism algorithm for matching
-                  large graphs},
-  author =	 {Cordella, Luigi P and Foggia, Pasquale and Sansone,
-                  Carlo and Vento, Mario},
-  journal =	 {Pattern Analysis and Machine Intelligence, IEEE
-                  Transactions on},
-  volume =	 26,
-  number =	 10,
-  pages =	 {1367--1372},
-  year =	 2004,
-  publisher =	 {IEEE}
-}
+  month =        sep,
+}
Index: lemon/CMakeLists.txt
===================================================================
--- lemon/CMakeLists.txt	(revision 1315)
+++ lemon/CMakeLists.txt	(revision 726)
@@ -5,12 +5,6 @@
 
 CONFIGURE_FILE(
-  ${CMAKE_CURRENT_SOURCE_DIR}/config.h.in
+  ${CMAKE_CURRENT_SOURCE_DIR}/config.h.cmake
   ${CMAKE_CURRENT_BINARY_DIR}/config.h
-)
-
-CONFIGURE_FILE(
-  ${CMAKE_CURRENT_SOURCE_DIR}/lemon.pc.in
-  ${CMAKE_CURRENT_BINARY_DIR}/lemon.pc
-  @ONLY
 )
 
@@ -37,5 +31,5 @@
 IF(LEMON_HAVE_CPLEX)
   SET(LEMON_SOURCES ${LEMON_SOURCES} cplex.cc)
-  INCLUDE_DIRECTORIES(${ILOG_INCLUDE_DIRS})
+  INCLUDE_DIRECTORIES(${CPLEX_INCLUDE_DIRS})
 ENDIF()
 
@@ -50,17 +44,7 @@
 ENDIF()
 
-IF(LEMON_HAVE_SOPLEX)
-  SET(LEMON_SOURCES ${LEMON_SOURCES} soplex.cc)
-  INCLUDE_DIRECTORIES(${SOPLEX_INCLUDE_DIRS})
-ENDIF()
-
 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()
 
@@ -68,5 +52,4 @@
   TARGETS lemon
   ARCHIVE DESTINATION lib
-  LIBRARY DESTINATION lib
   COMPONENT library
 )
@@ -84,8 +67,2 @@
   COMPONENT headers
 )
-
-INSTALL(
-  FILES ${CMAKE_CURRENT_BINARY_DIR}/lemon.pc
-  DESTINATION lib/pkgconfig
-)
-
Index: lemon/Makefile.am
===================================================================
--- lemon/Makefile.am	(revision 888)
+++ lemon/Makefile.am	(revision 888)
@@ -0,0 +1,149 @@
+EXTRA_DIST += \
+	lemon/lemon.pc.in \
+	lemon/CMakeLists.txt \
+	lemon/config.h.cmake
+
+pkgconfig_DATA += lemon/lemon.pc
+
+lib_LTLIBRARIES += lemon/libemon.la
+
+lemon_libemon_la_SOURCES = \
+	lemon/arg_parser.cc \
+	lemon/base.cc \
+	lemon/color.cc \
+	lemon/lp_base.cc \
+	lemon/lp_skeleton.cc \
+	lemon/random.cc \
+	lemon/bits/windows.cc
+
+nodist_lemon_HEADERS = lemon/config.h	
+
+lemon_libemon_la_CXXFLAGS = \
+	$(AM_CXXFLAGS) \
+	$(GLPK_CFLAGS) \
+	$(CPLEX_CFLAGS) \
+	$(SOPLEX_CXXFLAGS) \
+	$(CLP_CXXFLAGS) \
+	$(CBC_CXXFLAGS)
+
+lemon_libemon_la_LDFLAGS = \
+	$(GLPK_LIBS) \
+	$(CPLEX_LIBS) \
+	$(SOPLEX_LIBS) \
+	$(CLP_LIBS) \
+	$(CBC_LIBS)
+
+if HAVE_GLPK
+lemon_libemon_la_SOURCES += lemon/glpk.cc
+endif
+
+if HAVE_CPLEX
+lemon_libemon_la_SOURCES += lemon/cplex.cc
+endif
+
+if HAVE_SOPLEX
+lemon_libemon_la_SOURCES += lemon/soplex.cc
+endif
+
+if HAVE_CLP
+lemon_libemon_la_SOURCES += lemon/clp.cc
+endif
+
+if HAVE_CBC
+lemon_libemon_la_SOURCES += lemon/cbc.cc
+endif
+
+lemon_HEADERS += \
+	lemon/adaptors.h \
+	lemon/arg_parser.h \
+	lemon/assert.h \
+	lemon/bellman_ford.h \
+	lemon/bfs.h \
+	lemon/bin_heap.h \
+	lemon/binom_heap.h \
+	lemon/bucket_heap.h \
+	lemon/capacity_scaling.h \
+	lemon/cbc.h \
+	lemon/circulation.h \
+	lemon/clp.h \
+	lemon/color.h \
+	lemon/concept_check.h \
+	lemon/connectivity.h \
+	lemon/core.h \
+	lemon/cost_scaling.h \
+	lemon/counter.h \
+	lemon/cplex.h \
+	lemon/cycle_canceling.h \
+	lemon/dfs.h \
+	lemon/dijkstra.h \
+	lemon/dim2.h \
+	lemon/dimacs.h \
+	lemon/edge_set.h \
+	lemon/elevator.h \
+	lemon/error.h \
+	lemon/euler.h \
+	lemon/fib_heap.h \
+	lemon/fourary_heap.h \
+	lemon/full_graph.h \
+	lemon/glpk.h \
+	lemon/gomory_hu.h \
+	lemon/graph_to_eps.h \
+	lemon/grid_graph.h \
+	lemon/hartmann_orlin.h \
+	lemon/howard.h \
+	lemon/hypercube_graph.h \
+	lemon/karp.h \
+	lemon/kary_heap.h \
+	lemon/kruskal.h \
+	lemon/hao_orlin.h \
+	lemon/lgf_reader.h \
+	lemon/lgf_writer.h \
+	lemon/list_graph.h \
+	lemon/lp.h \
+	lemon/lp_base.h \
+	lemon/lp_skeleton.h \
+	lemon/maps.h \
+	lemon/matching.h \
+	lemon/math.h \
+	lemon/min_cost_arborescence.h \
+	lemon/nauty_reader.h \
+	lemon/network_simplex.h \
+	lemon/pairing_heap.h \
+	lemon/path.h \
+	lemon/planarity.h \
+	lemon/preflow.h \
+	lemon/radix_heap.h \
+	lemon/radix_sort.h \
+	lemon/random.h \
+	lemon/smart_graph.h \
+	lemon/soplex.h \
+	lemon/static_graph.h \
+	lemon/suurballe.h \
+	lemon/time_measure.h \
+	lemon/tolerance.h \
+	lemon/unionfind.h \
+	lemon/bits/windows.h
+
+bits_HEADERS += \
+	lemon/bits/alteration_notifier.h \
+	lemon/bits/array_map.h \
+	lemon/bits/bezier.h \
+	lemon/bits/default_map.h \
+	lemon/bits/edge_set_extender.h \
+	lemon/bits/enable_if.h \
+	lemon/bits/graph_adaptor_extender.h \
+	lemon/bits/graph_extender.h \
+	lemon/bits/map_extender.h \
+	lemon/bits/path_dump.h \
+	lemon/bits/solver_bits.h \
+	lemon/bits/traits.h \
+	lemon/bits/variant.h \
+	lemon/bits/vector_map.h
+
+concept_HEADERS += \
+	lemon/concepts/digraph.h \
+	lemon/concepts/graph.h \
+	lemon/concepts/graph_components.h \
+	lemon/concepts/heap.h \
+	lemon/concepts/maps.h \
+	lemon/concepts/path.h
Index: lemon/adaptors.h
===================================================================
--- lemon/adaptors.h	(revision 1270)
+++ lemon/adaptors.h	(revision 834)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -422,5 +422,5 @@
       Parent::initialize(digraph);
       _node_filter = &node_filter;
-      _arc_filter = &arc_filter;
+      _arc_filter = &arc_filter;      
     }
 
@@ -509,9 +509,9 @@
 
     template <typename V>
-    class NodeMap
-      : public SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
-              LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> {
+    class NodeMap 
+      : public SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>, 
+	      LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> {
       typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
-        LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> Parent;
+	LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> Parent;
 
     public:
@@ -536,7 +536,7 @@
 
     template <typename V>
-    class ArcMap
+    class ArcMap 
       : public SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
-              LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> {
+	      LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> {
       typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
         LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> Parent;
@@ -583,5 +583,5 @@
       Parent::initialize(digraph);
       _node_filter = &node_filter;
-      _arc_filter = &arc_filter;
+      _arc_filter = &arc_filter;      
     }
 
@@ -652,8 +652,8 @@
 
     template <typename V>
-    class NodeMap
+    class NodeMap 
       : public SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,
           LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> {
-      typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,
+      typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, false>, 
         LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> Parent;
 
@@ -679,5 +679,5 @@
 
     template <typename V>
-    class ArcMap
+    class ArcMap 
       : public SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,
           LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> {
@@ -1022,8 +1022,8 @@
 
     template <typename V>
-    class NodeMap
+    class NodeMap 
       : public SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
           LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> {
-      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
+      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>, 
         LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> Parent;
 
@@ -1049,8 +1049,8 @@
 
     template <typename V>
-    class ArcMap
+    class ArcMap 
       : public SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
           LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> {
-      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
+      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>, 
         LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> Parent;
 
@@ -1076,8 +1076,8 @@
 
     template <typename V>
-    class EdgeMap
+    class EdgeMap 
       : public SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
         LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> {
-      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
+      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>, 
         LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> Parent;
 
@@ -1118,6 +1118,6 @@
     NF* _node_filter;
     EF* _edge_filter;
-    SubGraphBase()
-          : Parent(), _node_filter(0), _edge_filter(0) { }
+    SubGraphBase() 
+	  : Parent(), _node_filter(0), _edge_filter(0) { }
 
     void initialize(GR& graph, NF& node_filter, EF& edge_filter) {
@@ -1220,8 +1220,8 @@
 
     template <typename V>
-    class NodeMap
+    class NodeMap 
       : public SubMapExtender<SubGraphBase<GR, NF, EF, false>,
           LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> {
-      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>,
+      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>, 
         LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> Parent;
 
@@ -1247,8 +1247,8 @@
 
     template <typename V>
-    class ArcMap
+    class ArcMap 
       : public SubMapExtender<SubGraphBase<GR, NF, EF, false>,
           LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> {
-      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>,
+      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>, 
         LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> Parent;
 
@@ -1274,9 +1274,9 @@
 
     template <typename V>
-    class EdgeMap
+    class EdgeMap 
       : public SubMapExtender<SubGraphBase<GR, NF, EF, false>,
         LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> {
-      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>,
-        LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> Parent;
+      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>, 
+	LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> Parent;
 
     public:
@@ -1372,5 +1372,5 @@
     /// and edge filter maps.
     SubGraph(GR& graph, NF& node_filter, EF& edge_filter) {
-      this->initialize(graph, node_filter, edge_filter);
+      initialize(graph, node_filter, edge_filter);
     }
 
@@ -1505,5 +1505,5 @@
 #endif
     typedef DigraphAdaptorExtender<
-      SubDigraphBase<GR, NF, ConstMap<typename GR::Arc, Const<bool, true> >,
+      SubDigraphBase<GR, NF, ConstMap<typename GR::Arc, Const<bool, true> >, 
                      true> > Parent;
 
@@ -1526,5 +1526,5 @@
     /// Creates a subgraph for the given digraph or graph with the
     /// given node filter map.
-    FilterNodes(GR& graph, NF& node_filter)
+    FilterNodes(GR& graph, NF& node_filter) 
       : Parent(), const_true_map()
     {
@@ -1564,9 +1564,9 @@
                     typename enable_if<UndirectedTagIndicator<GR> >::type> :
     public GraphAdaptorExtender<
-      SubGraphBase<GR, NF, ConstMap<typename GR::Edge, Const<bool, true> >,
+      SubGraphBase<GR, NF, ConstMap<typename GR::Edge, Const<bool, true> >, 
                    true> > {
 
     typedef GraphAdaptorExtender<
-      SubGraphBase<GR, NF, ConstMap<typename GR::Edge, Const<bool, true> >,
+      SubGraphBase<GR, NF, ConstMap<typename GR::Edge, Const<bool, true> >, 
                    true> > Parent;
 
@@ -1654,5 +1654,5 @@
 #endif
     typedef DigraphAdaptorExtender<
-      SubDigraphBase<DGR, ConstMap<typename DGR::Node, Const<bool, true> >,
+      SubDigraphBase<DGR, ConstMap<typename DGR::Node, Const<bool, true> >, 
                      AF, false> > Parent;
 
@@ -1762,9 +1762,9 @@
   class FilterEdges :
     public GraphAdaptorExtender<
-      SubGraphBase<GR, ConstMap<typename GR::Node, Const<bool, true> >,
+      SubGraphBase<GR, ConstMap<typename GR::Node, Const<bool, true> >, 
                    EF, false> > {
 #endif
     typedef GraphAdaptorExtender<
-      SubGraphBase<GR, ConstMap<typename GR::Node, Const<bool, true > >,
+      SubGraphBase<GR, ConstMap<typename GR::Node, Const<bool, true > >, 
                    EF, false> > Parent;
 
@@ -1791,5 +1791,5 @@
     /// Creates a subgraph for the given graph with the given edge
     /// filter map.
-    FilterEdges(GR& graph, EF& edge_filter)
+    FilterEdges(GR& graph, EF& edge_filter) 
       : Parent(), const_true_map() {
       Parent::initialize(graph, const_true_map, edge_filter);
@@ -1859,5 +1859,5 @@
       bool _forward;
 
-      Arc(const Edge& edge, bool forward)
+      Arc(const Edge& edge, bool forward) 
         : _edge(edge), _forward(forward) {}
 
@@ -2099,5 +2099,5 @@
 
       ArcMapBase(const UndirectorBase<DGR>& adaptor, const V& value)
-        : _forward(*adaptor._digraph, value),
+        : _forward(*adaptor._digraph, value), 
           _backward(*adaptor._digraph, value) {}
 
@@ -2217,5 +2217,5 @@
     typedef typename ItemSetTraits<DGR, Edge>::ItemNotifier EdgeNotifier;
     EdgeNotifier& notifier(Edge) const { return _digraph->notifier(Edge()); }
-
+    
     typedef EdgeNotifier ArcNotifier;
     ArcNotifier& notifier(Arc) const { return _digraph->notifier(Edge()); }
@@ -2278,5 +2278,5 @@
     /// Creates an undirected graph from the given digraph.
     Undirector(DGR& digraph) {
-      this->initialize(digraph);
+      initialize(digraph);
     }
 
@@ -2729,5 +2729,5 @@
            typename FM = CM,
            typename TL = Tolerance<typename CM::Value> >
-  class ResidualDigraph
+  class ResidualDigraph 
     : public SubDigraph<
         Undirector<const DGR>,
@@ -2786,5 +2786,5 @@
     ResidualDigraph(const DGR& digraph, const CM& capacity,
                     FM& flow, const TL& tolerance = Tolerance())
-      : Parent(), _capacity(&capacity), _flow(&flow),
+      : Parent(), _capacity(&capacity), _flow(&flow), 
         _graph(digraph), _node_filter(),
         _forward_filter(capacity, flow, tolerance),
@@ -2868,5 +2868,5 @@
 
       /// Constructor
-      ResidualCapacity(const ResidualDigraph<DGR, CM, FM, TL>& adaptor)
+      ResidualCapacity(const ResidualDigraph<DGR, CM, FM, TL>& adaptor) 
         : _adaptor(&adaptor) {}
 
@@ -3448,5 +3448,5 @@
     /// to get a node map of the split digraph.
     /// Its value type is inherited from the first node map type (\c IN).
-    /// \tparam IN The type of the node map for the in-nodes.
+    /// \tparam IN The type of the node map for the in-nodes. 
     /// \tparam OUT The type of the node map for the out-nodes.
     template <typename IN, typename OUT>
Index: lemon/arg_parser.cc
===================================================================
--- lemon/arg_parser.cc	(revision 956)
+++ lemon/arg_parser.cc	(revision 463)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -21,21 +21,12 @@
 namespace lemon {
 
-  void ArgParser::_terminate(ArgParserException::Reason reason) const
-  {
-    if(_exit_on_problems)
-      exit(1);
-    else throw(ArgParserException(reason));
-  }
-
-
   void ArgParser::_showHelp(void *p)
   {
     (static_cast<ArgParser*>(p))->showHelp();
-    (static_cast<ArgParser*>(p))->_terminate(ArgParserException::HELP);
+    exit(1);
   }
 
   ArgParser::ArgParser(int argc, const char * const *argv)
-    :_argc(argc), _argv(argv), _command_name(argv[0]),
-    _exit_on_problems(true) {
+    :_argc(argc), _argv(argv), _command_name(argv[0]) {
     funcOption("-help","Print a short help message",_showHelp,this);
     synonym("help","-help");
@@ -352,5 +343,5 @@
         i!=_others_help.end();++i) showHelp(i);
     for(Opts::const_iterator i=_opts.begin();i!=_opts.end();++i) showHelp(i);
-    _terminate(ArgParserException::HELP);
+    exit(1);
   }
 
@@ -361,5 +352,5 @@
     std::cerr << "\nType '" << _command_name <<
       " --help' to obtain a short summary on the usage.\n\n";
-    _terminate(ArgParserException::UNKNOWN_OPT);
+    exit(1);
   }
 
@@ -424,5 +415,5 @@
       std::cerr << "\nType '" << _command_name <<
         " --help' to obtain a short summary on the usage.\n\n";
-      _terminate(ArgParserException::INVALID_OPT);
+      exit(1);
     }
   }
Index: lemon/arg_parser.h
===================================================================
--- lemon/arg_parser.h	(revision 1327)
+++ lemon/arg_parser.h	(revision 463)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -27,5 +27,4 @@
 #include <sstream>
 #include <algorithm>
-#include <lemon/core.h>
 #include <lemon/assert.h>
 
@@ -35,49 +34,4 @@
 
 namespace lemon {
-
-  ///Exception used by ArgParser
-
-  ///Exception used by ArgParser.
-  ///
-  class ArgParserException : public Exception {
-  public:
-    /// Reasons for failure
-
-    /// Reasons for failure.
-    ///
-    enum Reason {
-      HELP,         ///< <tt>--help</tt> option was given.
-      UNKNOWN_OPT,  ///< Unknown option was given.
-      INVALID_OPT   ///< Invalid combination of options.
-    };
-
-  private:
-    Reason _reason;
-
-  public:
-    ///Constructor
-    ArgParserException(Reason r) throw() : _reason(r) {}
-    ///Virtual destructor
-    virtual ~ArgParserException() throw() {}
-    ///A short description of the exception
-    virtual const char* what() const throw() {
-      switch(_reason)
-        {
-        case HELP:
-          return "lemon::ArgParseException: ask for help";
-          break;
-        case UNKNOWN_OPT:
-          return "lemon::ArgParseException: unknown option";
-          break;
-        case INVALID_OPT:
-          return "lemon::ArgParseException: invalid combination of options";
-          break;
-        }
-      return "";
-    }
-    ///Return the reason for the failure
-    Reason reason() const {return _reason; }
-  };
-
 
   ///Command line arguments parser
@@ -163,8 +117,4 @@
                     void (*func)(void *),void *data);
 
-    bool _exit_on_problems;
-
-    void _terminate(ArgParserException::Reason reason) const;
-
   public:
 
@@ -431,9 +381,4 @@
     const std::vector<std::string> &files() const { return _file_args; }
 
-    ///Throw instead of exit in case of problems
-    void throwOnProblems()
-    {
-      _exit_on_problems=false;
-    }
   };
 }
Index: lemon/assert.h
===================================================================
--- lemon/assert.h	(revision 1270)
+++ lemon/assert.h	(revision 463)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -200,5 +200,5 @@
                              ::lemon::_assert_bits::cstringify(msg),    \
                              #exp), 0)))
-#    if defined LEMON_ENABLE_DEBUG
+#    if LEMON_ENABLE_DEBUG
 #      define LEMON_DEBUG(exp, msg)                                     \
          (static_cast<void> (!!(exp) ? 0 : (                            \
Index: lemon/base.cc
===================================================================
--- lemon/base.cc	(revision 1270)
+++ lemon/base.cc	(revision 554)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -22,5 +22,4 @@
 #include<lemon/tolerance.h>
 #include<lemon/core.h>
-#include<lemon/time_measure.h>
 namespace lemon {
 
@@ -33,5 +32,3 @@
 #endif
 
-  TimeStamp::Format TimeStamp::_format = TimeStamp::NORMAL;
-
 } //namespace lemon
Index: lemon/bellman_ford.h
===================================================================
--- lemon/bellman_ford.h	(revision 1337)
+++ lemon/bellman_ford.h	(revision 870)
@@ -1,7 +1,7 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
+/* -*- C++ -*-
  *
- * This file is a part of LEMON, a generic C++ optimization library.
+ * This file is a part of LEMON, a generic C++ optimization library
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -30,5 +30,4 @@
 #include <lemon/maps.h>
 #include <lemon/path.h>
-#include <lemon/bits/stl_iterators.h>
 
 #include <limits>
@@ -37,5 +36,5 @@
 
   /// \brief Default OperationTraits for the BellmanFord algorithm class.
-  ///
+  ///  
   /// This operation traits class defines all computational operations
   /// and constants that are used in the Bellman-Ford algorithm.
@@ -44,5 +43,5 @@
   /// value is used as extremal infinity value.
   template <
-    typename V,
+    typename V, 
     bool has_inf = std::numeric_limits<V>::has_infinity>
   struct BellmanFordDefaultOperationTraits {
@@ -85,5 +84,5 @@
     }
   };
-
+  
   /// \brief Default traits class of BellmanFord class.
   ///
@@ -93,5 +92,5 @@
   template<typename GR, typename LEN>
   struct BellmanFordDefaultTraits {
-    /// The type of the digraph the algorithm runs on.
+    /// The type of the digraph the algorithm runs on. 
     typedef GR Digraph;
 
@@ -111,8 +110,8 @@
     /// \see BellmanFordDefaultOperationTraits
     typedef BellmanFordDefaultOperationTraits<Value> OperationTraits;
-
-    /// \brief The type of the map that stores the last arcs of the
+ 
+    /// \brief The type of the map that stores the last arcs of the 
     /// shortest paths.
-    ///
+    /// 
     /// The type of the map that stores the last
     /// arcs of the shortest paths.
@@ -121,6 +120,6 @@
 
     /// \brief Instantiates a \c PredMap.
-    ///
-    /// This function instantiates a \ref PredMap.
+    /// 
+    /// This function instantiates a \ref PredMap. 
     /// \param g is the digraph to which we would like to define the
     /// \ref PredMap.
@@ -137,6 +136,6 @@
     /// \brief Instantiates a \c DistMap.
     ///
-    /// This function instantiates a \ref DistMap.
-    /// \param g is the digraph to which we would like to define the
+    /// This function instantiates a \ref DistMap. 
+    /// \param g is the digraph to which we would like to define the 
     /// \ref DistMap.
     static DistMap *createDistMap(const GR& g) {
@@ -145,11 +144,11 @@
 
   };
-
+  
   /// \brief %BellmanFord algorithm class.
   ///
   /// \ingroup shortest_path
-  /// This class provides an efficient implementation of the Bellman-Ford
+  /// This class provides an efficient implementation of the Bellman-Ford 
   /// algorithm. The maximum time complexity of the algorithm is
-  /// <tt>O(nm)</tt>.
+  /// <tt>O(ne)</tt>.
   ///
   /// The Bellman-Ford algorithm solves the single-source shortest path
@@ -160,5 +159,5 @@
   ///
   /// The arc lengths are passed to the algorithm using a
-  /// \ref concepts::ReadMap "ReadMap", so it is easy to change it to any
+  /// \ref concepts::ReadMap "ReadMap", so it is easy to change it to any 
   /// kind of length. The type of the length values is determined by the
   /// \ref concepts::ReadMap::Value "Value" type of the length map.
@@ -173,9 +172,4 @@
   /// the lengths of the arcs. The default map type is
   /// \ref concepts::Digraph::ArcMap "GR::ArcMap<int>".
-  /// \tparam TR The traits class that defines various types used by the
-  /// algorithm. By default, it is \ref BellmanFordDefaultTraits
-  /// "BellmanFordDefaultTraits<GR, LEN>".
-  /// In most cases, this parameter should not be set directly,
-  /// consider to use the named template parameters instead.
 #ifdef DOXYGEN
   template <typename GR, typename LEN, typename TR>
@@ -190,5 +184,5 @@
     ///The type of the underlying digraph.
     typedef typename TR::Digraph Digraph;
-
+    
     /// \brief The type of the arc lengths.
     typedef typename TR::LengthMap::Value Value;
@@ -202,10 +196,9 @@
     /// The type of the paths.
     typedef PredMapPath<Digraph, PredMap> Path;
-    ///\brief The \ref lemon::BellmanFordDefaultOperationTraits
+    ///\brief The \ref BellmanFordDefaultOperationTraits
     /// "operation traits class" of the algorithm.
     typedef typename TR::OperationTraits OperationTraits;
 
-    ///\brief The \ref lemon::BellmanFordDefaultTraits "traits class"
-    ///of the algorithm.
+    ///The \ref BellmanFordDefaultTraits "traits class" of the algorithm.
     typedef TR Traits;
 
@@ -238,10 +231,10 @@
     void create_maps() {
       if(!_pred) {
-        _local_pred = true;
-        _pred = Traits::createPredMap(*_gr);
+	_local_pred = true;
+	_pred = Traits::createPredMap(*_gr);
       }
       if(!_dist) {
-        _local_dist = true;
-        _dist = Traits::createDistMap(*_gr);
+	_local_dist = true;
+	_dist = Traits::createDistMap(*_gr);
       }
       if(!_mask) {
@@ -249,7 +242,7 @@
       }
     }
-
+    
   public :
-
+ 
     typedef BellmanFord Create;
 
@@ -274,9 +267,9 @@
     /// It must conform to the \ref concepts::WriteMap "WriteMap" concept.
     template <class T>
-    struct SetPredMap
+    struct SetPredMap 
       : public BellmanFord< Digraph, LengthMap, SetPredMapTraits<T> > {
       typedef BellmanFord< Digraph, LengthMap, SetPredMapTraits<T> > Create;
     };
-
+    
     template <class T>
     struct SetDistMapTraits : public Traits {
@@ -295,5 +288,5 @@
     /// It must conform to the \ref concepts::WriteMap "WriteMap" concept.
     template <class T>
-    struct SetDistMap
+    struct SetDistMap 
       : public BellmanFord< Digraph, LengthMap, SetDistMapTraits<T> > {
       typedef BellmanFord< Digraph, LengthMap, SetDistMapTraits<T> > Create;
@@ -304,6 +297,6 @@
       typedef T OperationTraits;
     };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
+    
+    /// \brief \ref named-templ-param "Named parameter" for setting 
     /// \c OperationTraits type.
     ///
@@ -317,13 +310,13 @@
       Create;
     };
-
+    
     ///@}
 
   protected:
-
+    
     BellmanFord() {}
 
-  public:
-
+  public:      
+    
     /// \brief Constructor.
     ///
@@ -335,5 +328,5 @@
       _pred(0), _local_pred(false),
       _dist(0), _local_dist(false), _mask(0) {}
-
+    
     ///Destructor.
     ~BellmanFord() {
@@ -362,6 +355,6 @@
     BellmanFord &predMap(PredMap &map) {
       if(_local_pred) {
-        delete _pred;
-        _local_pred=false;
+	delete _pred;
+	_local_pred=false;
       }
       _pred = &map;
@@ -380,6 +373,6 @@
     BellmanFord &distMap(DistMap &map) {
       if(_local_dist) {
-        delete _dist;
-        _local_dist=false;
+	delete _dist;
+	_local_dist=false;
       }
       _dist = &map;
@@ -399,5 +392,5 @@
 
     /// \brief Initializes the internal data structures.
-    ///
+    /// 
     /// Initializes the internal data structures. The optional parameter
     /// is the initial distance of each node.
@@ -405,20 +398,20 @@
       create_maps();
       for (NodeIt it(*_gr); it != INVALID; ++it) {
-        _pred->set(it, INVALID);
-        _dist->set(it, value);
+	_pred->set(it, INVALID);
+	_dist->set(it, value);
       }
       _process.clear();
       if (OperationTraits::less(value, OperationTraits::infinity())) {
-        for (NodeIt it(*_gr); it != INVALID; ++it) {
-          _process.push_back(it);
-          _mask->set(it, true);
-        }
+	for (NodeIt it(*_gr); it != INVALID; ++it) {
+	  _process.push_back(it);
+	  _mask->set(it, true);
+	}
       } else {
-        for (NodeIt it(*_gr); it != INVALID; ++it) {
-          _mask->set(it, false);
-        }
-      }
-    }
-
+	for (NodeIt it(*_gr); it != INVALID; ++it) {
+	  _mask->set(it, false);
+	}
+      }
+    }
+    
     /// \brief Adds a new source node.
     ///
@@ -428,6 +421,6 @@
       _dist->set(source, dst);
       if (!(*_mask)[source]) {
-        _process.push_back(source);
-        _mask->set(source, true);
+	_process.push_back(source);
+	_mask->set(source, true);
       }
     }
@@ -454,24 +447,24 @@
     bool processNextRound() {
       for (int i = 0; i < int(_process.size()); ++i) {
-        _mask->set(_process[i], false);
+	_mask->set(_process[i], false);
       }
       std::vector<Node> nextProcess;
       std::vector<Value> values(_process.size());
       for (int i = 0; i < int(_process.size()); ++i) {
-        values[i] = (*_dist)[_process[i]];
+	values[i] = (*_dist)[_process[i]];
       }
       for (int i = 0; i < int(_process.size()); ++i) {
-        for (OutArcIt it(*_gr, _process[i]); it != INVALID; ++it) {
-          Node target = _gr->target(it);
-          Value relaxed = OperationTraits::plus(values[i], (*_length)[it]);
-          if (OperationTraits::less(relaxed, (*_dist)[target])) {
-            _pred->set(target, it);
-            _dist->set(target, relaxed);
-            if (!(*_mask)[target]) {
-              _mask->set(target, true);
-              nextProcess.push_back(target);
-            }
-          }
-        }
+	for (OutArcIt it(*_gr, _process[i]); it != INVALID; ++it) {
+	  Node target = _gr->target(it);
+	  Value relaxed = OperationTraits::plus(values[i], (*_length)[it]);
+	  if (OperationTraits::less(relaxed, (*_dist)[target])) {
+	    _pred->set(target, it);
+	    _dist->set(target, relaxed);
+	    if (!(*_mask)[target]) {
+	      _mask->set(target, true);
+	      nextProcess.push_back(target);
+	    }
+	  }	  
+	}
       }
       _process.swap(nextProcess);
@@ -495,21 +488,21 @@
     bool processNextWeakRound() {
       for (int i = 0; i < int(_process.size()); ++i) {
-        _mask->set(_process[i], false);
+	_mask->set(_process[i], false);
       }
       std::vector<Node> nextProcess;
       for (int i = 0; i < int(_process.size()); ++i) {
-        for (OutArcIt it(*_gr, _process[i]); it != INVALID; ++it) {
-          Node target = _gr->target(it);
-          Value relaxed =
-            OperationTraits::plus((*_dist)[_process[i]], (*_length)[it]);
-          if (OperationTraits::less(relaxed, (*_dist)[target])) {
-            _pred->set(target, it);
-            _dist->set(target, relaxed);
-            if (!(*_mask)[target]) {
-              _mask->set(target, true);
-              nextProcess.push_back(target);
-            }
-          }
-        }
+	for (OutArcIt it(*_gr, _process[i]); it != INVALID; ++it) {
+	  Node target = _gr->target(it);
+	  Value relaxed = 
+	    OperationTraits::plus((*_dist)[_process[i]], (*_length)[it]);
+	  if (OperationTraits::less(relaxed, (*_dist)[target])) {
+	    _pred->set(target, it);
+	    _dist->set(target, relaxed);
+	    if (!(*_mask)[target]) {
+	      _mask->set(target, true);
+	      nextProcess.push_back(target);
+	    }
+	  }	  
+	}
       }
       _process.swap(nextProcess);
@@ -533,5 +526,5 @@
       int num = countNodes(*_gr) - 1;
       for (int i = 0; i < num; ++i) {
-        if (processNextWeakRound()) break;
+	if (processNextWeakRound()) break;
       }
     }
@@ -545,16 +538,16 @@
     /// if the digraph contains cycles with negative total length.
     ///
-    /// The algorithm computes
+    /// The algorithm computes 
     /// - the shortest path tree (forest),
     /// - the distance of each node from the root(s).
-    ///
+    /// 
     /// \return \c false if there is a negative cycle in the digraph.
     ///
     /// \pre init() must be called and at least one root node should be
-    /// added with addSource() before using this function.
+    /// added with addSource() before using this function. 
     bool checkedStart() {
       int num = countNodes(*_gr);
       for (int i = 0; i < num; ++i) {
-        if (processNextWeakRound()) return true;
+	if (processNextWeakRound()) return true;
       }
       return _process.empty();
@@ -580,13 +573,13 @@
     ///
     /// \pre init() must be called and at least one root node should be
-    /// added with addSource() before using this function.
+    /// added with addSource() before using this function. 
     void limitedStart(int num) {
       for (int i = 0; i < num; ++i) {
-        if (processNextRound()) break;
-      }
-    }
-
+	if (processNextRound()) break;
+      }
+    }
+    
     /// \brief Runs the algorithm from the given root node.
-    ///
+    ///    
     /// This method runs the Bellman-Ford algorithm from the given root
     /// node \c s in order to compute the shortest path to each node.
@@ -607,8 +600,8 @@
       start();
     }
-
+    
     /// \brief Runs the algorithm from the given root node with arc
     /// number limit.
-    ///
+    ///    
     /// This method runs the Bellman-Ford algorithm from the given root
     /// node \c s in order to compute the shortest path distance for each
@@ -636,5 +629,5 @@
       limitedStart(num);
     }
-
+    
     ///@}
 
@@ -651,5 +644,5 @@
       ///
       /// Constructor for getting the active nodes of the given BellmanFord
-      /// instance.
+      /// instance. 
       ActiveIt(const BellmanFord& algorithm) : _algorithm(&algorithm)
       {
@@ -665,5 +658,5 @@
       ///
       /// Conversion to \c Node.
-      operator Node() const {
+      operator Node() const { 
         return _index >= 0 ? _algorithm->_process[_index] : INVALID;
       }
@@ -674,46 +667,31 @@
       ActiveIt& operator++() {
         --_index;
-        return *this;
-      }
-
-      bool operator==(const ActiveIt& it) const {
-        return static_cast<Node>(*this) == static_cast<Node>(it);
-      }
-      bool operator!=(const ActiveIt& it) const {
-        return static_cast<Node>(*this) != static_cast<Node>(it);
-      }
-      bool operator<(const ActiveIt& it) const {
-        return static_cast<Node>(*this) < static_cast<Node>(it);
-      }
-
+        return *this; 
+      }
+
+      bool operator==(const ActiveIt& it) const { 
+        return static_cast<Node>(*this) == static_cast<Node>(it); 
+      }
+      bool operator!=(const ActiveIt& it) const { 
+        return static_cast<Node>(*this) != static_cast<Node>(it); 
+      }
+      bool operator<(const ActiveIt& it) const { 
+        return static_cast<Node>(*this) < static_cast<Node>(it); 
+      }
+      
     private:
       const BellmanFord* _algorithm;
       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
     /// The result of the Bellman-Ford algorithm can be obtained using these
     /// functions.\n
     /// Either \ref run() or \ref init() should be called before using them.
-
+    
     ///@{
 
     /// \brief The shortest path to the given node.
-    ///
+    ///    
     /// Gives back the shortest path to the given node from the root(s).
     ///
@@ -726,5 +704,5 @@
       return Path(*_gr, *_pred, t);
     }
-
+	  
     /// \brief The distance of the given node from the root(s).
     ///
@@ -766,8 +744,8 @@
     /// \pre Either \ref run() or \ref init() must be called before
     /// using this function.
-    Node predNode(Node v) const {
-      return (*_pred)[v] == INVALID ? INVALID : _gr->source((*_pred)[v]);
-    }
-
+    Node predNode(Node v) const { 
+      return (*_pred)[v] == INVALID ? INVALID : _gr->source((*_pred)[v]); 
+    }
+    
     /// \brief Returns a const reference to the node map that stores the
     /// distances of the nodes.
@@ -779,5 +757,5 @@
     /// using this function.
     const DistMap &distMap() const { return *_dist;}
-
+ 
     /// \brief Returns a const reference to the node map that stores the
     /// predecessor arcs.
@@ -789,5 +767,5 @@
     /// using this function.
     const PredMap &predMap() const { return *_pred; }
-
+ 
     /// \brief Checks if a node is reached from the root(s).
     ///
@@ -801,5 +779,5 @@
 
     /// \brief Gives back a negative cycle.
-    ///
+    ///    
     /// This function gives back a directed cycle with negative total
     /// length if the algorithm has already found one.
@@ -828,8 +806,8 @@
       return cycle;
     }
-
+    
     ///@}
   };
-
+ 
   /// \brief Default traits class of bellmanFord() function.
   ///
@@ -839,5 +817,5 @@
   template <typename GR, typename LEN>
   struct BellmanFordWizardDefaultTraits {
-    /// The type of the digraph the algorithm runs on.
+    /// The type of the digraph the algorithm runs on. 
     typedef GR Digraph;
 
@@ -860,5 +838,5 @@
     /// \brief The type of the map that stores the last
     /// arcs of the shortest paths.
-    ///
+    /// 
     /// The type of the map that stores the last arcs of the shortest paths.
     /// It must conform to the \ref concepts::WriteMap "WriteMap" concept.
@@ -866,5 +844,5 @@
 
     /// \brief Instantiates a \c PredMap.
-    ///
+    /// 
     /// This function instantiates a \ref PredMap.
     /// \param g is the digraph to which we would like to define the
@@ -882,5 +860,5 @@
     /// \brief Instantiates a \c DistMap.
     ///
-    /// This function instantiates a \ref DistMap.
+    /// This function instantiates a \ref DistMap. 
     /// \param g is the digraph to which we would like to define the
     /// \ref DistMap.
@@ -895,5 +873,5 @@
     typedef lemon::Path<Digraph> Path;
   };
-
+  
   /// \brief Default traits class used by BellmanFordWizard.
   ///
@@ -902,5 +880,5 @@
   /// \tparam LEN The type of the length map.
   template <typename GR, typename LEN>
-  class BellmanFordWizardBase
+  class BellmanFordWizardBase 
     : public BellmanFordWizardDefaultTraits<GR, LEN> {
 
@@ -925,5 +903,5 @@
     public:
     /// Constructor.
-
+    
     /// This constructor does not require parameters, it initiates
     /// all of the attributes to default values \c 0.
@@ -932,17 +910,17 @@
 
     /// Constructor.
-
+    
     /// This constructor requires two parameters,
     /// others are initiated to \c 0.
     /// \param gr The digraph the algorithm runs on.
     /// \param len The length map.
-    BellmanFordWizardBase(const GR& gr,
-                          const LEN& len) :
-      _graph(reinterpret_cast<void*>(const_cast<GR*>(&gr))),
-      _length(reinterpret_cast<void*>(const_cast<LEN*>(&len))),
+    BellmanFordWizardBase(const GR& gr, 
+			  const LEN& len) :
+      _graph(reinterpret_cast<void*>(const_cast<GR*>(&gr))), 
+      _length(reinterpret_cast<void*>(const_cast<LEN*>(&len))), 
       _pred(0), _dist(0), _path(0), _di(0) {}
 
   };
-
+  
   /// \brief Auxiliary class for the function-type interface of the
   /// \ref BellmanFord "Bellman-Ford" algorithm.
@@ -956,7 +934,4 @@
   /// This class should only be used through the \ref bellmanFord()
   /// function, which makes it easier to use the algorithm.
-  ///
-  /// \tparam TR The traits class that defines various types used by the
-  /// algorithm.
   template<class TR>
   class BellmanFordWizard : public TR {
@@ -969,5 +944,5 @@
     typedef typename Digraph::Arc Arc;
     typedef typename Digraph::OutArcIt ArcIt;
-
+    
     typedef typename TR::LengthMap LengthMap;
     typedef typename LengthMap::Value Value;
@@ -986,5 +961,5 @@
     /// \param gr The digraph the algorithm runs on.
     /// \param len The length map.
-    BellmanFordWizard(const Digraph& gr, const LengthMap& len)
+    BellmanFordWizard(const Digraph& gr, const LengthMap& len) 
       : TR(gr, len) {}
 
@@ -995,10 +970,10 @@
 
     /// \brief Runs the Bellman-Ford algorithm from the given source node.
-    ///
+    ///    
     /// This method runs the Bellman-Ford algorithm from the given source
     /// node in order to compute the shortest path to each node.
     void run(Node s) {
-      BellmanFord<Digraph,LengthMap,TR>
-        bf(*reinterpret_cast<const Digraph*>(Base::_graph),
+      BellmanFord<Digraph,LengthMap,TR> 
+	bf(*reinterpret_cast<const Digraph*>(Base::_graph), 
            *reinterpret_cast<const LengthMap*>(Base::_length));
       if (Base::_pred) bf.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
@@ -1035,5 +1010,5 @@
       SetPredMapBase(const TR &b) : TR(b) {}
     };
-
+    
     /// \brief \ref named-templ-param "Named parameter" for setting
     /// the predecessor map.
@@ -1046,5 +1021,5 @@
       return BellmanFordWizard<SetPredMapBase<T> >(*this);
     }
-
+    
     template<class T>
     struct SetDistMapBase : public Base {
@@ -1053,5 +1028,5 @@
       SetDistMapBase(const TR &b) : TR(b) {}
     };
-
+    
     /// \brief \ref named-templ-param "Named parameter" for setting
     /// the distance map.
@@ -1094,7 +1069,7 @@
       return *this;
     }
-
+    
   };
-
+  
   /// \brief Function type interface for the \ref BellmanFord "Bellman-Ford"
   /// algorithm.
@@ -1104,6 +1079,6 @@
   /// algorithm.
   ///
-  /// This function also has several \ref named-templ-func-param
-  /// "named parameters", they are declared as the members of class
+  /// This function also has several \ref named-templ-func-param 
+  /// "named parameters", they are declared as the members of class 
   /// \ref BellmanFordWizard.
   /// The following examples show how to use these parameters.
@@ -1122,5 +1097,5 @@
   BellmanFordWizard<BellmanFordWizardBase<GR,LEN> >
   bellmanFord(const GR& digraph,
-              const LEN& length)
+	      const LEN& length)
   {
     return BellmanFordWizard<BellmanFordWizardBase<GR,LEN> >(digraph, length);
Index: lemon/bfs.h
===================================================================
--- lemon/bfs.h	(revision 1270)
+++ lemon/bfs.h	(revision 835)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -83,6 +83,5 @@
 
     ///The type of the map that indicates which nodes are reached.
-    ///It must conform to
-    ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
     ///Instantiates a \c ReachedMap.
@@ -123,9 +122,4 @@
   ///\tparam GR The type of the digraph the algorithm runs on.
   ///The default type is \ref ListDigraph.
-  ///\tparam TR The traits class that defines various types used by the
-  ///algorithm. By default, it is \ref BfsDefaultTraits
-  ///"BfsDefaultTraits<GR>".
-  ///In most cases, this parameter should not be set directly,
-  ///consider to use the named template parameters instead.
 #ifdef DOXYGEN
   template <typename GR,
@@ -153,5 +147,5 @@
     typedef PredMapPath<Digraph, PredMap> Path;
 
-    ///The \ref lemon::BfsDefaultTraits "traits class" of the algorithm.
+    ///The \ref BfsDefaultTraits "traits class" of the algorithm.
     typedef TR Traits;
 
@@ -273,6 +267,5 @@
     ///\ref named-templ-param "Named parameter" for setting
     ///\c ReachedMap type.
-    ///It must conform to
-    ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     template <class T>
     struct SetReachedMap : public Bfs< Digraph, SetReachedMapTraits<T> > {
@@ -875,6 +868,5 @@
 
     ///The type of the map that indicates which nodes are reached.
-    ///It must conform to
-    ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
     ///Instantiates a ReachedMap.
@@ -966,7 +958,4 @@
   /// This class should only be used through the \ref bfs() function,
   /// which makes it easier to use the algorithm.
-  ///
-  /// \tparam TR The traits class that defines various types used by the
-  /// algorithm.
   template<class TR>
   class BfsWizard : public TR
@@ -1252,5 +1241,4 @@
       }
       _Visitor& visitor;
-      Constraints() {}
     };
   };
@@ -1270,6 +1258,5 @@
     ///
     /// The type of the map that indicates which nodes are reached.
-    /// It must conform to
-    ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    /// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
 
@@ -1309,9 +1296,9 @@
   /// does not observe the BFS events. If you want to observe the BFS
   /// events, you should implement your own visitor class.
-  /// \tparam TR The traits class that defines various types used by the
-  /// algorithm. By default, it is \ref BfsVisitDefaultTraits
-  /// "BfsVisitDefaultTraits<GR>".
-  /// In most cases, this parameter should not be set directly,
-  /// consider to use the named template parameters instead.
+  /// \tparam TR Traits class to set various data types used by the
+  /// algorithm. The default traits class is
+  /// \ref BfsVisitDefaultTraits "BfsVisitDefaultTraits<GR>".
+  /// See \ref BfsVisitDefaultTraits for the documentation of
+  /// a BFS visit traits class.
 #ifdef DOXYGEN
   template <typename GR, typename VS, typename TR>
Index: lemon/bin_heap.h
===================================================================
--- lemon/bin_heap.h	(revision 1270)
+++ lemon/bin_heap.h	(revision 758)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/binom_heap.h
===================================================================
--- lemon/binom_heap.h	(revision 754)
+++ lemon/binom_heap.h	(revision 754)
@@ -0,0 +1,445 @@
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library.
+ *
+ * Copyright (C) 2003-2009
+ * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
+ * (Egervary Research Group on Combinatorial Optimization, EGRES).
+ *
+ * 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_BINOM_HEAP_H
+#define LEMON_BINOM_HEAP_H
+
+///\file
+///\ingroup heaps
+///\brief Binomial Heap implementation.
+
+#include <vector>
+#include <utility>
+#include <functional>
+#include <lemon/math.h>
+#include <lemon/counter.h>
+
+namespace lemon {
+
+  /// \ingroup heaps
+  ///
+  ///\brief Binomial heap data structure.
+  ///
+  /// This class implements the \e binomial \e heap data structure.
+  /// It fully conforms to the \ref concepts::Heap "heap concept".
+  ///
+  /// The methods \ref increase() and \ref erase() are not efficient
+  /// in a binomial heap. In case of many calls of these operations,
+  /// it is better to use other heap structure, e.g. \ref BinHeap
+  /// "binary heap".
+  ///
+  /// \tparam PR Type of the priorities of the items.
+  /// \tparam IM A read-writable item map with \c int values, used
+  /// internally to handle the cross references.
+  /// \tparam CMP A functor class for comparing the priorities.
+  /// The default is \c std::less<PR>.
+#ifdef DOXYGEN
+  template <typename PR, typename IM, typename CMP>
+#else
+  template <typename PR, typename IM, typename CMP = std::less<PR> >
+#endif
+  class BinomHeap {
+  public:
+    /// Type of the item-int map.
+    typedef IM ItemIntMap;
+    /// Type of the priorities.
+    typedef PR Prio;
+    /// Type of the items stored in the heap.
+    typedef typename ItemIntMap::Key Item;
+    /// Functor type for comparing the priorities.
+    typedef CMP Compare;
+
+    /// \brief Type to represent the states of the items.
+    ///
+    /// Each item has a state associated to it. It can be "in heap",
+    /// "pre-heap" or "post-heap". The latter two are indifferent from the
+    /// heap's point of view, but may be useful to the user.
+    ///
+    /// The item-int map must be initialized in such way that it assigns
+    /// \c PRE_HEAP (<tt>-1</tt>) to any element to be put in the heap.
+    enum State {
+      IN_HEAP = 0,    ///< = 0.
+      PRE_HEAP = -1,  ///< = -1.
+      POST_HEAP = -2  ///< = -2.
+    };
+
+  private:
+    class Store;
+
+    std::vector<Store> _data;
+    int _min, _head;
+    ItemIntMap &_iim;
+    Compare _comp;
+    int _num_items;
+
+  public:
+    /// \brief Constructor.
+    ///
+    /// Constructor.
+    /// \param map A map that assigns \c int values to the items.
+    /// It is used internally to handle the cross references.
+    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
+    explicit BinomHeap(ItemIntMap &map)
+      : _min(0), _head(-1), _iim(map), _num_items(0) {}
+
+    /// \brief Constructor.
+    ///
+    /// Constructor.
+    /// \param map A map that assigns \c int values to the items.
+    /// It is used internally to handle the cross references.
+    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
+    /// \param comp The function object used for comparing the priorities.
+    BinomHeap(ItemIntMap &map, const Compare &comp)
+      : _min(0), _head(-1), _iim(map), _comp(comp), _num_items(0) {}
+
+    /// \brief The number of items stored in the heap.
+    ///
+    /// This function returns the number of items stored in the heap.
+    int size() const { return _num_items; }
+
+    /// \brief Check if the heap is empty.
+    ///
+    /// This function returns \c true if the heap is empty.
+    bool empty() const { return _num_items==0; }
+
+    /// \brief Make the heap empty.
+    ///
+    /// This functon makes the heap empty.
+    /// It does not change the cross reference map. If you want to reuse
+    /// a heap that is not surely empty, you should first clear it and
+    /// then you should set the cross reference map to \c PRE_HEAP
+    /// for each item.
+    void clear() {
+      _data.clear(); _min=0; _num_items=0; _head=-1;
+    }
+
+    /// \brief Set the priority of an item or insert it, if it is
+    /// not stored in the heap.
+    ///
+    /// This method sets the priority of the given item if it is
+    /// already stored in the heap. Otherwise it inserts the given
+    /// item into the heap with the given priority.
+    /// \param item The item.
+    /// \param value The priority.
+    void set (const Item& item, const Prio& value) {
+      int i=_iim[item];
+      if ( i >= 0 && _data[i].in ) {
+        if ( _comp(value, _data[i].prio) ) decrease(item, value);
+        if ( _comp(_data[i].prio, value) ) increase(item, value);
+      } else push(item, value);
+    }
+
+    /// \brief Insert an item into the heap with the given priority.
+    ///
+    /// This function inserts the given item into the heap with the
+    /// given priority.
+    /// \param item The item to insert.
+    /// \param value The priority of the item.
+    /// \pre \e item must not be stored in the heap.
+    void push (const Item& item, const Prio& value) {
+      int i=_iim[item];
+      if ( i<0 ) {
+        int s=_data.size();
+        _iim.set( item,s );
+        Store st;
+        st.name=item;
+        st.prio=value;
+        _data.push_back(st);
+        i=s;
+      }
+      else {
+        _data[i].parent=_data[i].right_neighbor=_data[i].child=-1;
+        _data[i].degree=0;
+        _data[i].in=true;
+        _data[i].prio=value;
+      }
+
+      if( 0==_num_items ) {
+        _head=i;
+        _min=i;
+      } else {
+        merge(i);
+        if( _comp(_data[i].prio, _data[_min].prio) ) _min=i;
+      }
+      ++_num_items;
+    }
+
+    /// \brief Return the item having minimum priority.
+    ///
+    /// This function returns the item having minimum priority.
+    /// \pre The heap must be non-empty.
+    Item top() const { return _data[_min].name; }
+
+    /// \brief The minimum priority.
+    ///
+    /// This function returns the minimum priority.
+    /// \pre The heap must be non-empty.
+    Prio prio() const { return _data[_min].prio; }
+
+    /// \brief The priority of the given item.
+    ///
+    /// This function returns the priority of the given item.
+    /// \param item The item.
+    /// \pre \e item must be in the heap.
+    const Prio& operator[](const Item& item) const {
+      return _data[_iim[item]].prio;
+    }
+
+    /// \brief Remove the item having minimum priority.
+    ///
+    /// This function removes the item having minimum priority.
+    /// \pre The heap must be non-empty.
+    void pop() {
+      _data[_min].in=false;
+
+      int head_child=-1;
+      if ( _data[_min].child!=-1 ) {
+        int child=_data[_min].child;
+        int neighb;
+        while( child!=-1 ) {
+          neighb=_data[child].right_neighbor;
+          _data[child].parent=-1;
+          _data[child].right_neighbor=head_child;
+          head_child=child;
+          child=neighb;
+        }
+      }
+
+      if ( _data[_head].right_neighbor==-1 ) {
+        // there was only one root
+        _head=head_child;
+      }
+      else {
+        // there were more roots
+        if( _head!=_min )  { unlace(_min); }
+        else { _head=_data[_head].right_neighbor; }
+        merge(head_child);
+      }
+      _min=findMin();
+      --_num_items;
+    }
+
+    /// \brief Remove the given item from the heap.
+    ///
+    /// This function removes the given item from the heap if it is
+    /// already stored.
+    /// \param item The item to delete.
+    /// \pre \e item must be in the heap.
+    void erase (const Item& item) {
+      int i=_iim[item];
+      if ( i >= 0 && _data[i].in ) {
+        decrease( item, _data[_min].prio-1 );
+        pop();
+      }
+    }
+
+    /// \brief Decrease the priority of an item to the given value.
+    ///
+    /// This function decreases the priority of an item to the given value.
+    /// \param item The item.
+    /// \param value The priority.
+    /// \pre \e item must be stored in the heap with priority at least \e value.
+    void decrease (Item item, const Prio& value) {
+      int i=_iim[item];
+      int p=_data[i].parent;
+      _data[i].prio=value;
+      
+      while( p!=-1 && _comp(value, _data[p].prio) ) {
+        _data[i].name=_data[p].name;
+        _data[i].prio=_data[p].prio;
+        _data[p].name=item;
+        _data[p].prio=value;
+        _iim[_data[i].name]=i;
+        i=p;
+        p=_data[p].parent;
+      }
+      _iim[item]=i;
+      if ( _comp(value, _data[_min].prio) ) _min=i;
+    }
+
+    /// \brief Increase the priority of an item to the given value.
+    ///
+    /// This function increases the priority of an item to the given value.
+    /// \param item The item.
+    /// \param value The priority.
+    /// \pre \e item must be stored in the heap with priority at most \e value.
+    void increase (Item item, const Prio& value) {
+      erase(item);
+      push(item, value);
+    }
+
+    /// \brief Return the state of an item.
+    ///
+    /// This method returns \c PRE_HEAP if the given item has never
+    /// been in the heap, \c IN_HEAP if it is in the heap at the moment,
+    /// and \c POST_HEAP otherwise.
+    /// In the latter case it is possible that the item will get back
+    /// to the heap again.
+    /// \param item The item.
+    State state(const Item &item) const {
+      int i=_iim[item];
+      if( i>=0 ) {
+        if ( _data[i].in ) i=0;
+        else i=-2;
+      }
+      return State(i);
+    }
+
+    /// \brief Set the state of an item in the heap.
+    ///
+    /// This function sets the state of the given item in the heap.
+    /// It can be used to manually clear the heap when it is important
+    /// to achive better time complexity.
+    /// \param i The item.
+    /// \param st The state. It should not be \c IN_HEAP.
+    void state(const Item& i, State st) {
+      switch (st) {
+      case POST_HEAP:
+      case PRE_HEAP:
+        if (state(i) == IN_HEAP) {
+          erase(i);
+        }
+        _iim[i] = st;
+        break;
+      case IN_HEAP:
+        break;
+      }
+    }
+
+  private:
+    
+    // Find the minimum of the roots
+    int findMin() {
+      if( _head!=-1 ) {
+        int min_loc=_head, min_val=_data[_head].prio;
+        for( int x=_data[_head].right_neighbor; x!=-1;
+             x=_data[x].right_neighbor ) {
+          if( _comp( _data[x].prio,min_val ) ) {
+            min_val=_data[x].prio;
+            min_loc=x;
+          }
+        }
+        return min_loc;
+      }
+      else return -1;
+    }
+
+    // Merge the heap with another heap starting at the given position
+    void merge(int a) {
+      if( _head==-1 || a==-1 ) return;
+      if( _data[a].right_neighbor==-1 &&
+          _data[a].degree<=_data[_head].degree ) {
+        _data[a].right_neighbor=_head;
+        _head=a;
+      } else {
+        interleave(a);
+      }
+      if( _data[_head].right_neighbor==-1 ) return;
+      
+      int x=_head;
+      int x_prev=-1, x_next=_data[x].right_neighbor;
+      while( x_next!=-1 ) {
+        if( _data[x].degree!=_data[x_next].degree ||
+            ( _data[x_next].right_neighbor!=-1 &&
+              _data[_data[x_next].right_neighbor].degree==_data[x].degree ) ) {
+          x_prev=x;
+          x=x_next;
+        }
+        else {
+          if( _comp(_data[x_next].prio,_data[x].prio) ) {
+            if( x_prev==-1 ) {
+              _head=x_next;
+            } else {
+              _data[x_prev].right_neighbor=x_next;
+            }
+            fuse(x,x_next);
+            x=x_next;
+          }
+          else {
+            _data[x].right_neighbor=_data[x_next].right_neighbor;
+            fuse(x_next,x);
+          }
+        }
+        x_next=_data[x].right_neighbor;
+      }
+    }
+
+    // Interleave the elements of the given list into the list of the roots
+    void interleave(int a) {
+      int p=_head, q=a;
+      int curr=_data.size();
+      _data.push_back(Store());
+      
+      while( p!=-1 || q!=-1 ) {
+        if( q==-1 || ( p!=-1 && _data[p].degree<_data[q].degree ) ) {
+          _data[curr].right_neighbor=p;
+          curr=p;
+          p=_data[p].right_neighbor;
+        }
+        else {
+          _data[curr].right_neighbor=q;
+          curr=q;
+          q=_data[q].right_neighbor;
+        }
+      }
+      
+      _head=_data.back().right_neighbor;
+      _data.pop_back();
+    }
+
+    // Lace node a under node b
+    void fuse(int a, int b) {
+      _data[a].parent=b;
+      _data[a].right_neighbor=_data[b].child;
+      _data[b].child=a;
+
+      ++_data[b].degree;
+    }
+
+    // Unlace node a (if it has siblings)
+    void unlace(int a) {
+      int neighb=_data[a].right_neighbor;
+      int other=_head;
+
+      while( _data[other].right_neighbor!=a )
+        other=_data[other].right_neighbor;
+      _data[other].right_neighbor=neighb;
+    }
+
+  private:
+
+    class Store {
+      friend class BinomHeap;
+
+      Item name;
+      int parent;
+      int right_neighbor;
+      int child;
+      int degree;
+      bool in;
+      Prio prio;
+
+      Store() : parent(-1), right_neighbor(-1), child(-1), degree(0),
+        in(true) {}
+    };
+  };
+
+} //namespace lemon
+
+#endif //LEMON_BINOM_HEAP_H
+
Index: mon/binomial_heap.h
===================================================================
--- lemon/binomial_heap.h	(revision 956)
+++ 	(revision )
@@ -1,445 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2010
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * 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_BINOMIAL_HEAP_H
-#define LEMON_BINOMIAL_HEAP_H
-
-///\file
-///\ingroup heaps
-///\brief Binomial Heap implementation.
-
-#include <vector>
-#include <utility>
-#include <functional>
-#include <lemon/math.h>
-#include <lemon/counter.h>
-
-namespace lemon {
-
-  /// \ingroup heaps
-  ///
-  ///\brief Binomial heap data structure.
-  ///
-  /// This class implements the \e binomial \e heap data structure.
-  /// It fully conforms to the \ref concepts::Heap "heap concept".
-  ///
-  /// The methods \ref increase() and \ref erase() are not efficient
-  /// in a binomial heap. In case of many calls of these operations,
-  /// it is better to use other heap structure, e.g. \ref BinHeap
-  /// "binary heap".
-  ///
-  /// \tparam PR Type of the priorities of the items.
-  /// \tparam IM A read-writable item map with \c int values, used
-  /// internally to handle the cross references.
-  /// \tparam CMP A functor class for comparing the priorities.
-  /// The default is \c std::less<PR>.
-#ifdef DOXYGEN
-  template <typename PR, typename IM, typename CMP>
-#else
-  template <typename PR, typename IM, typename CMP = std::less<PR> >
-#endif
-  class BinomialHeap {
-  public:
-    /// Type of the item-int map.
-    typedef IM ItemIntMap;
-    /// Type of the priorities.
-    typedef PR Prio;
-    /// Type of the items stored in the heap.
-    typedef typename ItemIntMap::Key Item;
-    /// Functor type for comparing the priorities.
-    typedef CMP Compare;
-
-    /// \brief Type to represent the states of the items.
-    ///
-    /// Each item has a state associated to it. It can be "in heap",
-    /// "pre-heap" or "post-heap". The latter two are indifferent from the
-    /// heap's point of view, but may be useful to the user.
-    ///
-    /// The item-int map must be initialized in such way that it assigns
-    /// \c PRE_HEAP (<tt>-1</tt>) to any element to be put in the heap.
-    enum State {
-      IN_HEAP = 0,    ///< = 0.
-      PRE_HEAP = -1,  ///< = -1.
-      POST_HEAP = -2  ///< = -2.
-    };
-
-  private:
-    class Store;
-
-    std::vector<Store> _data;
-    int _min, _head;
-    ItemIntMap &_iim;
-    Compare _comp;
-    int _num_items;
-
-  public:
-    /// \brief Constructor.
-    ///
-    /// Constructor.
-    /// \param map A map that assigns \c int values to the items.
-    /// It is used internally to handle the cross references.
-    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
-    explicit BinomialHeap(ItemIntMap &map)
-      : _min(0), _head(-1), _iim(map), _num_items(0) {}
-
-    /// \brief Constructor.
-    ///
-    /// Constructor.
-    /// \param map A map that assigns \c int values to the items.
-    /// It is used internally to handle the cross references.
-    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
-    /// \param comp The function object used for comparing the priorities.
-    BinomialHeap(ItemIntMap &map, const Compare &comp)
-      : _min(0), _head(-1), _iim(map), _comp(comp), _num_items(0) {}
-
-    /// \brief The number of items stored in the heap.
-    ///
-    /// This function returns the number of items stored in the heap.
-    int size() const { return _num_items; }
-
-    /// \brief Check if the heap is empty.
-    ///
-    /// This function returns \c true if the heap is empty.
-    bool empty() const { return _num_items==0; }
-
-    /// \brief Make the heap empty.
-    ///
-    /// This functon makes the heap empty.
-    /// It does not change the cross reference map. If you want to reuse
-    /// a heap that is not surely empty, you should first clear it and
-    /// then you should set the cross reference map to \c PRE_HEAP
-    /// for each item.
-    void clear() {
-      _data.clear(); _min=0; _num_items=0; _head=-1;
-    }
-
-    /// \brief Set the priority of an item or insert it, if it is
-    /// not stored in the heap.
-    ///
-    /// This method sets the priority of the given item if it is
-    /// already stored in the heap. Otherwise it inserts the given
-    /// item into the heap with the given priority.
-    /// \param item The item.
-    /// \param value The priority.
-    void set (const Item& item, const Prio& value) {
-      int i=_iim[item];
-      if ( i >= 0 && _data[i].in ) {
-        if ( _comp(value, _data[i].prio) ) decrease(item, value);
-        if ( _comp(_data[i].prio, value) ) increase(item, value);
-      } else push(item, value);
-    }
-
-    /// \brief Insert an item into the heap with the given priority.
-    ///
-    /// This function inserts the given item into the heap with the
-    /// given priority.
-    /// \param item The item to insert.
-    /// \param value The priority of the item.
-    /// \pre \e item must not be stored in the heap.
-    void push (const Item& item, const Prio& value) {
-      int i=_iim[item];
-      if ( i<0 ) {
-        int s=_data.size();
-        _iim.set( item,s );
-        Store st;
-        st.name=item;
-        st.prio=value;
-        _data.push_back(st);
-        i=s;
-      }
-      else {
-        _data[i].parent=_data[i].right_neighbor=_data[i].child=-1;
-        _data[i].degree=0;
-        _data[i].in=true;
-        _data[i].prio=value;
-      }
-
-      if( 0==_num_items ) {
-        _head=i;
-        _min=i;
-      } else {
-        merge(i);
-        if( _comp(_data[i].prio, _data[_min].prio) ) _min=i;
-      }
-      ++_num_items;
-    }
-
-    /// \brief Return the item having minimum priority.
-    ///
-    /// This function returns the item having minimum priority.
-    /// \pre The heap must be non-empty.
-    Item top() const { return _data[_min].name; }
-
-    /// \brief The minimum priority.
-    ///
-    /// This function returns the minimum priority.
-    /// \pre The heap must be non-empty.
-    Prio prio() const { return _data[_min].prio; }
-
-    /// \brief The priority of the given item.
-    ///
-    /// This function returns the priority of the given item.
-    /// \param item The item.
-    /// \pre \e item must be in the heap.
-    const Prio& operator[](const Item& item) const {
-      return _data[_iim[item]].prio;
-    }
-
-    /// \brief Remove the item having minimum priority.
-    ///
-    /// This function removes the item having minimum priority.
-    /// \pre The heap must be non-empty.
-    void pop() {
-      _data[_min].in=false;
-
-      int head_child=-1;
-      if ( _data[_min].child!=-1 ) {
-        int child=_data[_min].child;
-        int neighb;
-        while( child!=-1 ) {
-          neighb=_data[child].right_neighbor;
-          _data[child].parent=-1;
-          _data[child].right_neighbor=head_child;
-          head_child=child;
-          child=neighb;
-        }
-      }
-
-      if ( _data[_head].right_neighbor==-1 ) {
-        // there was only one root
-        _head=head_child;
-      }
-      else {
-        // there were more roots
-        if( _head!=_min )  { unlace(_min); }
-        else { _head=_data[_head].right_neighbor; }
-        merge(head_child);
-      }
-      _min=findMin();
-      --_num_items;
-    }
-
-    /// \brief Remove the given item from the heap.
-    ///
-    /// This function removes the given item from the heap if it is
-    /// already stored.
-    /// \param item The item to delete.
-    /// \pre \e item must be in the heap.
-    void erase (const Item& item) {
-      int i=_iim[item];
-      if ( i >= 0 && _data[i].in ) {
-        decrease( item, _data[_min].prio-1 );
-        pop();
-      }
-    }
-
-    /// \brief Decrease the priority of an item to the given value.
-    ///
-    /// This function decreases the priority of an item to the given value.
-    /// \param item The item.
-    /// \param value The priority.
-    /// \pre \e item must be stored in the heap with priority at least \e value.
-    void decrease (Item item, const Prio& value) {
-      int i=_iim[item];
-      int p=_data[i].parent;
-      _data[i].prio=value;
-
-      while( p!=-1 && _comp(value, _data[p].prio) ) {
-        _data[i].name=_data[p].name;
-        _data[i].prio=_data[p].prio;
-        _data[p].name=item;
-        _data[p].prio=value;
-        _iim[_data[i].name]=i;
-        i=p;
-        p=_data[p].parent;
-      }
-      _iim[item]=i;
-      if ( _comp(value, _data[_min].prio) ) _min=i;
-    }
-
-    /// \brief Increase the priority of an item to the given value.
-    ///
-    /// This function increases the priority of an item to the given value.
-    /// \param item The item.
-    /// \param value The priority.
-    /// \pre \e item must be stored in the heap with priority at most \e value.
-    void increase (Item item, const Prio& value) {
-      erase(item);
-      push(item, value);
-    }
-
-    /// \brief Return the state of an item.
-    ///
-    /// This method returns \c PRE_HEAP if the given item has never
-    /// been in the heap, \c IN_HEAP if it is in the heap at the moment,
-    /// and \c POST_HEAP otherwise.
-    /// In the latter case it is possible that the item will get back
-    /// to the heap again.
-    /// \param item The item.
-    State state(const Item &item) const {
-      int i=_iim[item];
-      if( i>=0 ) {
-        if ( _data[i].in ) i=0;
-        else i=-2;
-      }
-      return State(i);
-    }
-
-    /// \brief Set the state of an item in the heap.
-    ///
-    /// This function sets the state of the given item in the heap.
-    /// It can be used to manually clear the heap when it is important
-    /// to achive better time complexity.
-    /// \param i The item.
-    /// \param st The state. It should not be \c IN_HEAP.
-    void state(const Item& i, State st) {
-      switch (st) {
-      case POST_HEAP:
-      case PRE_HEAP:
-        if (state(i) == IN_HEAP) {
-          erase(i);
-        }
-        _iim[i] = st;
-        break;
-      case IN_HEAP:
-        break;
-      }
-    }
-
-  private:
-
-    // Find the minimum of the roots
-    int findMin() {
-      if( _head!=-1 ) {
-        int min_loc=_head, min_val=_data[_head].prio;
-        for( int x=_data[_head].right_neighbor; x!=-1;
-             x=_data[x].right_neighbor ) {
-          if( _comp( _data[x].prio,min_val ) ) {
-            min_val=_data[x].prio;
-            min_loc=x;
-          }
-        }
-        return min_loc;
-      }
-      else return -1;
-    }
-
-    // Merge the heap with another heap starting at the given position
-    void merge(int a) {
-      if( _head==-1 || a==-1 ) return;
-      if( _data[a].right_neighbor==-1 &&
-          _data[a].degree<=_data[_head].degree ) {
-        _data[a].right_neighbor=_head;
-        _head=a;
-      } else {
-        interleave(a);
-      }
-      if( _data[_head].right_neighbor==-1 ) return;
-
-      int x=_head;
-      int x_prev=-1, x_next=_data[x].right_neighbor;
-      while( x_next!=-1 ) {
-        if( _data[x].degree!=_data[x_next].degree ||
-            ( _data[x_next].right_neighbor!=-1 &&
-              _data[_data[x_next].right_neighbor].degree==_data[x].degree ) ) {
-          x_prev=x;
-          x=x_next;
-        }
-        else {
-          if( _comp(_data[x_next].prio,_data[x].prio) ) {
-            if( x_prev==-1 ) {
-              _head=x_next;
-            } else {
-              _data[x_prev].right_neighbor=x_next;
-            }
-            fuse(x,x_next);
-            x=x_next;
-          }
-          else {
-            _data[x].right_neighbor=_data[x_next].right_neighbor;
-            fuse(x_next,x);
-          }
-        }
-        x_next=_data[x].right_neighbor;
-      }
-    }
-
-    // Interleave the elements of the given list into the list of the roots
-    void interleave(int a) {
-      int p=_head, q=a;
-      int curr=_data.size();
-      _data.push_back(Store());
-
-      while( p!=-1 || q!=-1 ) {
-        if( q==-1 || ( p!=-1 && _data[p].degree<_data[q].degree ) ) {
-          _data[curr].right_neighbor=p;
-          curr=p;
-          p=_data[p].right_neighbor;
-        }
-        else {
-          _data[curr].right_neighbor=q;
-          curr=q;
-          q=_data[q].right_neighbor;
-        }
-      }
-
-      _head=_data.back().right_neighbor;
-      _data.pop_back();
-    }
-
-    // Lace node a under node b
-    void fuse(int a, int b) {
-      _data[a].parent=b;
-      _data[a].right_neighbor=_data[b].child;
-      _data[b].child=a;
-
-      ++_data[b].degree;
-    }
-
-    // Unlace node a (if it has siblings)
-    void unlace(int a) {
-      int neighb=_data[a].right_neighbor;
-      int other=_head;
-
-      while( _data[other].right_neighbor!=a )
-        other=_data[other].right_neighbor;
-      _data[other].right_neighbor=neighb;
-    }
-
-  private:
-
-    class Store {
-      friend class BinomialHeap;
-
-      Item name;
-      int parent;
-      int right_neighbor;
-      int child;
-      int degree;
-      bool in;
-      Prio prio;
-
-      Store() : parent(-1), right_neighbor(-1), child(-1), degree(0),
-        in(true) {}
-    };
-  };
-
-} //namespace lemon
-
-#endif //LEMON_BINOMIAL_HEAP_H
-
Index: lemon/bits/alteration_notifier.h
===================================================================
--- lemon/bits/alteration_notifier.h	(revision 1270)
+++ lemon/bits/alteration_notifier.h	(revision 463)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -24,5 +24,4 @@
 
 #include <lemon/core.h>
-#include <lemon/bits/lock.h>
 
 //\ingroup graphbits
@@ -253,5 +252,5 @@
     typedef std::list<ObserverBase*> Observers;
     Observers _observers;
-    lemon::bits::Lock _lock;
+
 
   public:
@@ -334,16 +333,12 @@
 
     void attach(ObserverBase& observer) {
-      _lock.lock();
       observer._index = _observers.insert(_observers.begin(), &observer);
       observer._notifier = this;
-      _lock.unlock();
     }
 
     void detach(ObserverBase& observer) {
-      _lock.lock();
       _observers.erase(observer._index);
       observer._index = _observers.end();
       observer._notifier = 0;
-      _lock.unlock();
     }
 
Index: lemon/bits/array_map.h
===================================================================
--- lemon/bits/array_map.h	(revision 1270)
+++ lemon/bits/array_map.h	(revision 664)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -71,5 +71,5 @@
 
   private:
-
+  
     // The MapBase of the Map which imlements the core regisitry function.
     typedef typename Notifier::ObserverBase Parent;
Index: lemon/bits/bezier.h
===================================================================
--- lemon/bits/bezier.h	(revision 1270)
+++ lemon/bits/bezier.h	(revision 463)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -160,5 +160,5 @@
     const Point d=(a+b)/2;
     const Point e=(b+c)/2;
-    // const Point f=(d+e)/2;
+    const Point f=(d+e)/2;
     R f1=_f(Bezier3(p1,a,d,e),_d);
     R f2=_f(Bezier3(e,d,c,p4),_d);
Index: lemon/bits/default_map.h
===================================================================
--- lemon/bits/default_map.h	(revision 1270)
+++ lemon/bits/default_map.h	(revision 674)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -158,5 +158,5 @@
   public:
     typedef DefaultMap<_Graph, _Item, _Value> Map;
-
+    
     typedef typename Parent::GraphType GraphType;
     typedef typename Parent::Value Value;
Index: lemon/bits/edge_set_extender.h
===================================================================
--- lemon/bits/edge_set_extender.h	(revision 1337)
+++ lemon/bits/edge_set_extender.h	(revision 732)
@@ -1,7 +1,7 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
+/* -*- C++ -*-
  *
- * This file is a part of LEMON, a generic C++ optimization library.
+ * This file is a part of LEMON, a generic C++ optimization library
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -64,9 +64,9 @@
     Node oppositeNode(const Node &n, const Arc &e) const {
       if (n == Parent::source(e))
-        return Parent::target(e);
+	return Parent::target(e);
       else if(n==Parent::target(e))
-        return Parent::source(e);
+	return Parent::source(e);
       else
-        return INVALID;
+	return INVALID;
     }
 
@@ -92,5 +92,5 @@
     // Iterable extensions
 
-    class NodeIt : public Node {
+    class NodeIt : public Node { 
       const Digraph* digraph;
     public:
@@ -101,22 +101,19 @@
 
       explicit NodeIt(const Digraph& _graph) : digraph(&_graph) {
-        _graph.first(static_cast<Node&>(*this));
-      }
-
-      NodeIt(const Digraph& _graph, const Node& node)
-        : Node(node), digraph(&_graph) {}
-
-      NodeIt& operator++() {
-        digraph->next(*this);
-        return *this;
-      }
-
-    };
-
-    LemonRangeWrapper1<NodeIt, Digraph> nodes() const {
-      return LemonRangeWrapper1<NodeIt, Digraph>(*this);
-    }
-
-    class ArcIt : public Arc {
+	_graph.first(static_cast<Node&>(*this));
+      }
+
+      NodeIt(const Digraph& _graph, const Node& node) 
+	: Node(node), digraph(&_graph) {}
+
+      NodeIt& operator++() { 
+	digraph->next(*this);
+	return *this; 
+      }
+
+    };
+
+
+    class ArcIt : public Arc { 
       const Digraph* digraph;
     public:
@@ -127,22 +124,19 @@
 
       explicit ArcIt(const Digraph& _graph) : digraph(&_graph) {
-        _graph.first(static_cast<Arc&>(*this));
-      }
-
-      ArcIt(const Digraph& _graph, const Arc& e) :
-        Arc(e), digraph(&_graph) { }
-
-      ArcIt& operator++() {
-        digraph->next(*this);
-        return *this;
-      }
-
-    };
-
-    LemonRangeWrapper1<ArcIt, Digraph> arcs() const {
-      return LemonRangeWrapper1<ArcIt, Digraph>(*this);
-    }
-
-    class OutArcIt : public Arc {
+	_graph.first(static_cast<Arc&>(*this));
+      }
+
+      ArcIt(const Digraph& _graph, const Arc& e) : 
+	Arc(e), digraph(&_graph) { }
+
+      ArcIt& operator++() { 
+	digraph->next(*this);
+	return *this; 
+      }
+
+    };
+
+
+    class OutArcIt : public Arc { 
       const Digraph* digraph;
     public:
@@ -152,24 +146,21 @@
       OutArcIt(Invalid i) : Arc(i) { }
 
-      OutArcIt(const Digraph& _graph, const Node& node)
-        : digraph(&_graph) {
-        _graph.firstOut(*this, node);
-      }
-
-      OutArcIt(const Digraph& _graph, const Arc& arc)
-        : Arc(arc), digraph(&_graph) {}
-
-      OutArcIt& operator++() {
-        digraph->nextOut(*this);
-        return *this;
-      }
-
-    };
-
-    LemonRangeWrapper2<OutArcIt, Digraph, Node> outArcs(const Node& u) const {
-      return LemonRangeWrapper2<OutArcIt, Digraph, Node>(*this, u);
-    }
-
-    class InArcIt : public Arc {
+      OutArcIt(const Digraph& _graph, const Node& node) 
+	: digraph(&_graph) {
+	_graph.firstOut(*this, node);
+      }
+
+      OutArcIt(const Digraph& _graph, const Arc& arc) 
+	: Arc(arc), digraph(&_graph) {}
+
+      OutArcIt& operator++() { 
+	digraph->nextOut(*this);
+	return *this; 
+      }
+
+    };
+
+
+    class InArcIt : public Arc { 
       const Digraph* digraph;
     public:
@@ -179,22 +170,18 @@
       InArcIt(Invalid i) : Arc(i) { }
 
-      InArcIt(const Digraph& _graph, const Node& node)
-        : digraph(&_graph) {
-        _graph.firstIn(*this, node);
-      }
-
-      InArcIt(const Digraph& _graph, const Arc& arc) :
-        Arc(arc), digraph(&_graph) {}
-
-      InArcIt& operator++() {
-        digraph->nextIn(*this);
-        return *this;
-      }
-
-    };
-
-    LemonRangeWrapper2<InArcIt, Digraph, Node> inArcs(const Node& u) const {
-      return LemonRangeWrapper2<InArcIt, Digraph, Node>(*this, u);
-    }
+      InArcIt(const Digraph& _graph, const Node& node) 
+	: digraph(&_graph) {
+	_graph.firstIn(*this, node);
+      }
+
+      InArcIt(const Digraph& _graph, const Arc& arc) : 
+	Arc(arc), digraph(&_graph) {}
+
+      InArcIt& operator++() { 
+	digraph->nextIn(*this);
+	return *this; 
+      }
+
+    };
 
     // \brief Base node of the iterator
@@ -229,18 +216,18 @@
 
     // Mappable extension
-
+    
     template <typename _Value>
-    class ArcMap
+    class ArcMap 
       : public MapExtender<DefaultMap<Digraph, Arc, _Value> > {
       typedef MapExtender<DefaultMap<Digraph, Arc, _Value> > Parent;
 
     public:
-      explicit ArcMap(const Digraph& _g)
-        : Parent(_g) {}
-      ArcMap(const Digraph& _g, const _Value& _v)
-        : Parent(_g, _v) {}
+      explicit ArcMap(const Digraph& _g) 
+	: Parent(_g) {}
+      ArcMap(const Digraph& _g, const _Value& _v) 
+	: Parent(_g, _v) {}
 
       ArcMap& operator=(const ArcMap& cmap) {
-        return operator=<ArcMap>(cmap);
+	return operator=<ArcMap>(cmap);
       }
 
@@ -248,5 +235,5 @@
       ArcMap& operator=(const CMap& cmap) {
         Parent::operator=(cmap);
-        return *this;
+	return *this;
       }
 
@@ -261,5 +248,5 @@
       return arc;
     }
-
+    
     void clear() {
       notifier(Arc()).clear();
@@ -294,6 +281,4 @@
     typedef EdgeSetExtender Graph;
 
-    typedef True UndirectedTag;
-
     typedef typename Parent::Node Node;
     typedef typename Parent::Arc Arc;
@@ -326,9 +311,9 @@
     Node oppositeNode(const Node &n, const Edge &e) const {
       if( n == Parent::u(e))
-        return Parent::v(e);
+	return Parent::v(e);
       else if( n == Parent::v(e))
-        return Parent::u(e);
+	return Parent::u(e);
       else
-        return INVALID;
+	return INVALID;
     }
 
@@ -354,5 +339,5 @@
 
     using Parent::notifier;
-
+    
     ArcNotifier& notifier(Arc) const {
       return arc_notifier;
@@ -364,5 +349,5 @@
 
 
-    class NodeIt : public Node {
+    class NodeIt : public Node { 
       const Graph* graph;
     public:
@@ -373,22 +358,19 @@
 
       explicit NodeIt(const Graph& _graph) : graph(&_graph) {
-        _graph.first(static_cast<Node&>(*this));
-      }
-
-      NodeIt(const Graph& _graph, const Node& node)
-        : Node(node), graph(&_graph) {}
-
-      NodeIt& operator++() {
-        graph->next(*this);
-        return *this;
-      }
-
-    };
-
-    LemonRangeWrapper1<NodeIt, Graph> nodes() const {
-      return LemonRangeWrapper1<NodeIt, Graph>(*this);
-    }
-
-    class ArcIt : public Arc {
+	_graph.first(static_cast<Node&>(*this));
+      }
+
+      NodeIt(const Graph& _graph, const Node& node) 
+	: Node(node), graph(&_graph) {}
+
+      NodeIt& operator++() { 
+	graph->next(*this);
+	return *this; 
+      }
+
+    };
+
+
+    class ArcIt : public Arc { 
       const Graph* graph;
     public:
@@ -399,22 +381,19 @@
 
       explicit ArcIt(const Graph& _graph) : graph(&_graph) {
-        _graph.first(static_cast<Arc&>(*this));
-      }
-
-      ArcIt(const Graph& _graph, const Arc& e) :
-        Arc(e), graph(&_graph) { }
-
-      ArcIt& operator++() {
-        graph->next(*this);
-        return *this;
-      }
-
-    };
-
-    LemonRangeWrapper1<ArcIt, Graph> arcs() const {
-      return LemonRangeWrapper1<ArcIt, Graph>(*this);
-    }
-
-    class OutArcIt : public Arc {
+	_graph.first(static_cast<Arc&>(*this));
+      }
+
+      ArcIt(const Graph& _graph, const Arc& e) : 
+	Arc(e), graph(&_graph) { }
+
+      ArcIt& operator++() { 
+	graph->next(*this);
+	return *this; 
+      }
+
+    };
+
+
+    class OutArcIt : public Arc { 
       const Graph* graph;
     public:
@@ -424,24 +403,21 @@
       OutArcIt(Invalid i) : Arc(i) { }
 
-      OutArcIt(const Graph& _graph, const Node& node)
-        : graph(&_graph) {
-        _graph.firstOut(*this, node);
-      }
-
-      OutArcIt(const Graph& _graph, const Arc& arc)
-        : Arc(arc), graph(&_graph) {}
-
-      OutArcIt& operator++() {
-        graph->nextOut(*this);
-        return *this;
-      }
-
-    };
-
-    LemonRangeWrapper2<OutArcIt, Graph, Node> outArcs(const Node& u) const {
-      return LemonRangeWrapper2<OutArcIt, Graph, Node>(*this, u);
-    }
-
-    class InArcIt : public Arc {
+      OutArcIt(const Graph& _graph, const Node& node) 
+	: graph(&_graph) {
+	_graph.firstOut(*this, node);
+      }
+
+      OutArcIt(const Graph& _graph, const Arc& arc) 
+	: Arc(arc), graph(&_graph) {}
+
+      OutArcIt& operator++() { 
+	graph->nextOut(*this);
+	return *this; 
+      }
+
+    };
+
+
+    class InArcIt : public Arc { 
       const Graph* graph;
     public:
@@ -451,24 +427,21 @@
       InArcIt(Invalid i) : Arc(i) { }
 
-      InArcIt(const Graph& _graph, const Node& node)
-        : graph(&_graph) {
-        _graph.firstIn(*this, node);
-      }
-
-      InArcIt(const Graph& _graph, const Arc& arc) :
-        Arc(arc), graph(&_graph) {}
-
-      InArcIt& operator++() {
-        graph->nextIn(*this);
-        return *this;
-      }
-
-    };
-
-    LemonRangeWrapper2<InArcIt, Graph, Node> inArcs(const Node& u) const {
-      return LemonRangeWrapper2<InArcIt, Graph, Node>(*this, u);
-    }
-
-    class EdgeIt : public Parent::Edge {
+      InArcIt(const Graph& _graph, const Node& node) 
+	: graph(&_graph) {
+	_graph.firstIn(*this, node);
+      }
+
+      InArcIt(const Graph& _graph, const Arc& arc) : 
+	Arc(arc), graph(&_graph) {}
+
+      InArcIt& operator++() { 
+	graph->nextIn(*this);
+	return *this; 
+      }
+
+    };
+
+
+    class EdgeIt : public Parent::Edge { 
       const Graph* graph;
     public:
@@ -479,20 +452,16 @@
 
       explicit EdgeIt(const Graph& _graph) : graph(&_graph) {
-        _graph.first(static_cast<Edge&>(*this));
-      }
-
-      EdgeIt(const Graph& _graph, const Edge& e) :
-        Edge(e), graph(&_graph) { }
-
-      EdgeIt& operator++() {
-        graph->next(*this);
-        return *this;
-      }
-
-    };
-
-    LemonRangeWrapper1<EdgeIt, Graph> edges() const {
-      return LemonRangeWrapper1<EdgeIt, Graph>(*this);
-    }
+	_graph.first(static_cast<Edge&>(*this));
+      }
+
+      EdgeIt(const Graph& _graph, const Edge& e) : 
+	Edge(e), graph(&_graph) { }
+
+      EdgeIt& operator++() { 
+	graph->next(*this);
+	return *this; 
+      }
+
+    };
 
     class IncEdgeIt : public Parent::Edge {
@@ -507,21 +476,17 @@
 
       IncEdgeIt(const Graph& _graph, const Node &n) : graph(&_graph) {
-        _graph.firstInc(*this, direction, n);
+	_graph.firstInc(*this, direction, n);
       }
 
       IncEdgeIt(const Graph& _graph, const Edge &ue, const Node &n)
-        : graph(&_graph), Edge(ue) {
-        direction = (_graph.source(ue) == n);
+	: graph(&_graph), Edge(ue) {
+	direction = (_graph.source(ue) == n);
       }
 
       IncEdgeIt& operator++() {
-        graph->nextInc(*this, direction);
-        return *this;
-      }
-    };
-
-    LemonRangeWrapper2<IncEdgeIt, Graph, Node> incEdges(const Node& u) const {
-      return LemonRangeWrapper2<IncEdgeIt, Graph, Node>(*this, u);
-    }
+	graph->nextInc(*this, direction);
+	return *this; 
+      }
+    };
 
     // \brief Base node of the iterator
@@ -557,5 +522,5 @@
     // Returns the base node of the iterator
     Node baseNode(const IncEdgeIt &e) const {
-      return e.direction ? this->u(e) : this->v(e);
+      return e.direction ? u(e) : v(e);
     }
     // Running node of the iterator
@@ -563,21 +528,21 @@
     // Returns the running node of the iterator
     Node runningNode(const IncEdgeIt &e) const {
-      return e.direction ? this->v(e) : this->u(e);
+      return e.direction ? v(e) : u(e);
     }
 
 
     template <typename _Value>
-    class ArcMap
+    class ArcMap 
       : public MapExtender<DefaultMap<Graph, Arc, _Value> > {
       typedef MapExtender<DefaultMap<Graph, Arc, _Value> > Parent;
 
     public:
-      explicit ArcMap(const Graph& _g)
-        : Parent(_g) {}
-      ArcMap(const Graph& _g, const _Value& _v)
-        : Parent(_g, _v) {}
+      explicit ArcMap(const Graph& _g) 
+	: Parent(_g) {}
+      ArcMap(const Graph& _g, const _Value& _v) 
+	: Parent(_g, _v) {}
 
       ArcMap& operator=(const ArcMap& cmap) {
-        return operator=<ArcMap>(cmap);
+	return operator=<ArcMap>(cmap);
       }
 
@@ -585,5 +550,5 @@
       ArcMap& operator=(const CMap& cmap) {
         Parent::operator=(cmap);
-        return *this;
+	return *this;
       }
 
@@ -592,17 +557,17 @@
 
     template <typename _Value>
-    class EdgeMap
+    class EdgeMap 
       : public MapExtender<DefaultMap<Graph, Edge, _Value> > {
       typedef MapExtender<DefaultMap<Graph, Edge, _Value> > Parent;
 
     public:
-      explicit EdgeMap(const Graph& _g)
-        : Parent(_g) {}
-
-      EdgeMap(const Graph& _g, const _Value& _v)
-        : Parent(_g, _v) {}
+      explicit EdgeMap(const Graph& _g) 
+	: Parent(_g) {}
+
+      EdgeMap(const Graph& _g, const _Value& _v) 
+	: Parent(_g, _v) {}
 
       EdgeMap& operator=(const EdgeMap& cmap) {
-        return operator=<EdgeMap>(cmap);
+	return operator=<EdgeMap>(cmap);
       }
 
@@ -610,5 +575,5 @@
       EdgeMap& operator=(const CMap& cmap) {
         Parent::operator=(cmap);
-        return *this;
+	return *this;
       }
 
@@ -627,5 +592,5 @@
       return edge;
     }
-
+    
     void clear() {
       notifier(Arc()).clear();
@@ -653,5 +618,5 @@
       arc_notifier.clear();
     }
-
+    
   };
 
Index: lemon/bits/graph_adaptor_extender.h
===================================================================
--- lemon/bits/graph_adaptor_extender.h	(revision 1337)
+++ lemon/bits/graph_adaptor_extender.h	(revision 664)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -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 {
@@ -168,8 +157,4 @@
     };
 
-    LemonRangeWrapper2<InArcIt, Adaptor, Node> inArcs(const Node& u) const {
-      return LemonRangeWrapper2<InArcIt, Adaptor, Node>(*this, u);
-    }
-
     Node baseNode(const OutArcIt &e) const {
       return Parent::source(e);
@@ -196,6 +181,4 @@
     typedef _Graph Graph;
     typedef GraphAdaptorExtender Adaptor;
-
-    typedef True UndirectedTag;
 
     typedef typename Parent::Node Node;
@@ -270,8 +253,4 @@
     };
 
-    LemonRangeWrapper1<NodeIt, Adaptor> nodes() const {
-      return LemonRangeWrapper1<NodeIt, Adaptor>(*this);
-    }
-
 
     class ArcIt : public Arc {
@@ -296,8 +275,4 @@
 
     };
-
-    LemonRangeWrapper1<ArcIt, Adaptor> arcs() const {
-      return LemonRangeWrapper1<ArcIt, Adaptor>(*this);
-    }
 
 
@@ -325,8 +300,4 @@
     };
 
-    LemonRangeWrapper2<OutArcIt, Adaptor, Node> outArcs(const Node& u) const {
-      return LemonRangeWrapper2<OutArcIt, Adaptor, Node>(*this, u);
-    }
-
 
     class InArcIt : public Arc {
@@ -353,8 +324,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 +345,4 @@
 
     };
-
-    LemonRangeWrapper1<EdgeIt, Adaptor> edges() const {
-      return LemonRangeWrapper1<EdgeIt, Adaptor>(*this);
-    }
-
 
     class IncEdgeIt : public Edge {
@@ -409,9 +371,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 825)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -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 {
@@ -595,9 +556,4 @@
     };
 
-    LemonRangeWrapper2<IncEdgeIt, Graph, Node> incEdges(const Node& u) const {
-      return LemonRangeWrapper2<IncEdgeIt, Graph, Node>(*this, u);
-    }
-
-
     // \brief Base node of the iterator
     //
@@ -632,5 +588,5 @@
     // Returns the base node of the iterator
     Node baseNode(const IncEdgeIt &edge) const {
-      return edge._direction ? this->u(edge) : this->v(edge);
+      return edge._direction ? u(edge) : v(edge);
     }
     // Running node of the iterator
@@ -638,5 +594,5 @@
     // Returns the running node of the iterator
     Node runningNode(const IncEdgeIt &edge) const {
-      return edge._direction ? this->v(edge) : this->u(edge);
+      return edge._direction ? v(edge) : u(edge);
     }
 
@@ -791,622 +747,4 @@
   };
 
-  // \ingroup _graphbits
-  //
-  // \brief Extender for the BpGraphs
-  template <typename Base>
-  class BpGraphExtender : public Base {
-    typedef Base Parent;
-
-  public:
-
-    typedef BpGraphExtender BpGraph;
-
-    typedef True UndirectedTag;
-
-    typedef typename Parent::Node Node;
-    typedef typename Parent::RedNode RedNode;
-    typedef typename Parent::BlueNode BlueNode;
-    typedef typename Parent::Arc Arc;
-    typedef typename Parent::Edge Edge;
-
-    // BpGraph extension
-
-    using Parent::first;
-    using Parent::next;
-    using Parent::id;
-
-    int maxId(Node) const {
-      return Parent::maxNodeId();
-    }
-
-    int maxId(RedNode) const {
-      return Parent::maxRedId();
-    }
-
-    int maxId(BlueNode) const {
-      return Parent::maxBlueId();
-    }
-
-    int maxId(Arc) const {
-      return Parent::maxArcId();
-    }
-
-    int maxId(Edge) const {
-      return Parent::maxEdgeId();
-    }
-
-    static Node fromId(int id, Node) {
-      return Parent::nodeFromId(id);
-    }
-
-    static Arc fromId(int id, Arc) {
-      return Parent::arcFromId(id);
-    }
-
-    static Edge fromId(int id, Edge) {
-      return Parent::edgeFromId(id);
-    }
-
-    Node u(Edge e) const { return this->redNode(e); }
-    Node v(Edge e) const { return this->blueNode(e); }
-
-    Node oppositeNode(const Node &n, const Edge &e) const {
-      if( n == u(e))
-        return v(e);
-      else if( n == v(e))
-        return u(e);
-      else
-        return INVALID;
-    }
-
-    Arc oppositeArc(const Arc &arc) const {
-      return Parent::direct(arc, !Parent::direction(arc));
-    }
-
-    using Parent::direct;
-    Arc direct(const Edge &edge, const Node &node) const {
-      return Parent::direct(edge, Parent::redNode(edge) == node);
-    }
-
-    RedNode asRedNode(const Node& node) const {
-      if (node == INVALID || Parent::blue(node)) {
-        return INVALID;
-      } else {
-        return Parent::asRedNodeUnsafe(node);
-      }
-    }
-
-    BlueNode asBlueNode(const Node& node) const {
-      if (node == INVALID || Parent::red(node)) {
-        return INVALID;
-      } else {
-        return Parent::asBlueNodeUnsafe(node);
-      }
-    }
-
-    // Alterable extension
-
-    typedef AlterationNotifier<BpGraphExtender, Node> NodeNotifier;
-    typedef AlterationNotifier<BpGraphExtender, RedNode> RedNodeNotifier;
-    typedef AlterationNotifier<BpGraphExtender, BlueNode> BlueNodeNotifier;
-    typedef AlterationNotifier<BpGraphExtender, Arc> ArcNotifier;
-    typedef AlterationNotifier<BpGraphExtender, Edge> EdgeNotifier;
-
-
-  protected:
-
-    mutable NodeNotifier node_notifier;
-    mutable RedNodeNotifier red_node_notifier;
-    mutable BlueNodeNotifier blue_node_notifier;
-    mutable ArcNotifier arc_notifier;
-    mutable EdgeNotifier edge_notifier;
-
-  public:
-
-    NodeNotifier& notifier(Node) const {
-      return node_notifier;
-    }
-
-    RedNodeNotifier& notifier(RedNode) const {
-      return red_node_notifier;
-    }
-
-    BlueNodeNotifier& notifier(BlueNode) const {
-      return blue_node_notifier;
-    }
-
-    ArcNotifier& notifier(Arc) const {
-      return arc_notifier;
-    }
-
-    EdgeNotifier& notifier(Edge) const {
-      return edge_notifier;
-    }
-
-
-
-    class NodeIt : public Node {
-      const BpGraph* _graph;
-    public:
-
-      NodeIt() {}
-
-      NodeIt(Invalid i) : Node(i) { }
-
-      explicit NodeIt(const BpGraph& graph) : _graph(&graph) {
-        _graph->first(static_cast<Node&>(*this));
-      }
-
-      NodeIt(const BpGraph& graph, const Node& node)
-        : Node(node), _graph(&graph) {}
-
-      NodeIt& operator++() {
-        _graph->next(*this);
-        return *this;
-      }
-
-    };
-
-    LemonRangeWrapper1<NodeIt, BpGraph> nodes() const {
-      return LemonRangeWrapper1<NodeIt, BpGraph>(*this);
-    }
-
-
-    class RedNodeIt : public RedNode {
-      const BpGraph* _graph;
-    public:
-
-      RedNodeIt() {}
-
-      RedNodeIt(Invalid i) : RedNode(i) { }
-
-      explicit RedNodeIt(const BpGraph& graph) : _graph(&graph) {
-        _graph->first(static_cast<RedNode&>(*this));
-      }
-
-      RedNodeIt(const BpGraph& graph, const RedNode& node)
-        : RedNode(node), _graph(&graph) {}
-
-      RedNodeIt& operator++() {
-        _graph->next(static_cast<RedNode&>(*this));
-        return *this;
-      }
-
-    };
-
-    LemonRangeWrapper1<RedNodeIt, BpGraph> redNodes() const {
-      return LemonRangeWrapper1<RedNodeIt, BpGraph>(*this);
-    }
-
-
-    class BlueNodeIt : public BlueNode {
-      const BpGraph* _graph;
-    public:
-
-      BlueNodeIt() {}
-
-      BlueNodeIt(Invalid i) : BlueNode(i) { }
-
-      explicit BlueNodeIt(const BpGraph& graph) : _graph(&graph) {
-        _graph->first(static_cast<BlueNode&>(*this));
-      }
-
-      BlueNodeIt(const BpGraph& graph, const BlueNode& node)
-        : BlueNode(node), _graph(&graph) {}
-
-      BlueNodeIt& operator++() {
-        _graph->next(static_cast<BlueNode&>(*this));
-        return *this;
-      }
-
-    };
-
-    LemonRangeWrapper1<BlueNodeIt, BpGraph> blueNodes() const {
-      return LemonRangeWrapper1<BlueNodeIt, BpGraph>(*this);
-    }
-
-
-
-    class ArcIt : public Arc {
-      const BpGraph* _graph;
-    public:
-
-      ArcIt() { }
-
-      ArcIt(Invalid i) : Arc(i) { }
-
-      explicit ArcIt(const BpGraph& graph) : _graph(&graph) {
-        _graph->first(static_cast<Arc&>(*this));
-      }
-
-      ArcIt(const BpGraph& graph, const Arc& arc) :
-        Arc(arc), _graph(&graph) { }
-
-      ArcIt& operator++() {
-        _graph->next(*this);
-        return *this;
-      }
-
-    };
-
-    LemonRangeWrapper1<ArcIt, BpGraph> arcs() const {
-      return LemonRangeWrapper1<ArcIt, BpGraph>(*this);
-    }
-
-
-    class OutArcIt : public Arc {
-      const BpGraph* _graph;
-    public:
-
-      OutArcIt() { }
-
-      OutArcIt(Invalid i) : Arc(i) { }
-
-      OutArcIt(const BpGraph& graph, const Node& node)
-        : _graph(&graph) {
-        _graph->firstOut(*this, node);
-      }
-
-      OutArcIt(const BpGraph& graph, const Arc& arc)
-        : Arc(arc), _graph(&graph) {}
-
-      OutArcIt& operator++() {
-        _graph->nextOut(*this);
-        return *this;
-      }
-
-    };
-
-    LemonRangeWrapper2<OutArcIt, BpGraph, Node> outArcs(const Node& u) const {
-      return LemonRangeWrapper2<OutArcIt, BpGraph, Node>(*this, u);
-    }
-
-
-    class InArcIt : public Arc {
-      const BpGraph* _graph;
-    public:
-
-      InArcIt() { }
-
-      InArcIt(Invalid i) : Arc(i) { }
-
-      InArcIt(const BpGraph& graph, const Node& node)
-        : _graph(&graph) {
-        _graph->firstIn(*this, node);
-      }
-
-      InArcIt(const BpGraph& graph, const Arc& arc) :
-        Arc(arc), _graph(&graph) {}
-
-      InArcIt& operator++() {
-        _graph->nextIn(*this);
-        return *this;
-      }
-
-    };
-
-    LemonRangeWrapper2<InArcIt, BpGraph, Node> inArcs(const Node& u) const {
-      return LemonRangeWrapper2<InArcIt, BpGraph, Node>(*this, u);
-    }
-
-
-    class EdgeIt : public Parent::Edge {
-      const BpGraph* _graph;
-    public:
-
-      EdgeIt() { }
-
-      EdgeIt(Invalid i) : Edge(i) { }
-
-      explicit EdgeIt(const BpGraph& graph) : _graph(&graph) {
-        _graph->first(static_cast<Edge&>(*this));
-      }
-
-      EdgeIt(const BpGraph& graph, const Edge& edge) :
-        Edge(edge), _graph(&graph) { }
-
-      EdgeIt& operator++() {
-        _graph->next(*this);
-        return *this;
-      }
-
-    };
-
-    LemonRangeWrapper1<EdgeIt, BpGraph> edges() const {
-      return LemonRangeWrapper1<EdgeIt, BpGraph>(*this);
-    }
-
-
-    class IncEdgeIt : public Parent::Edge {
-      friend class BpGraphExtender;
-      const BpGraph* _graph;
-      bool _direction;
-    public:
-
-      IncEdgeIt() { }
-
-      IncEdgeIt(Invalid i) : Edge(i), _direction(false) { }
-
-      IncEdgeIt(const BpGraph& graph, const Node &node) : _graph(&graph) {
-        _graph->firstInc(*this, _direction, node);
-      }
-
-      IncEdgeIt(const BpGraph& graph, const Edge &edge, const Node &node)
-        : _graph(&graph), Edge(edge) {
-        _direction = (_graph->source(edge) == node);
-      }
-
-      IncEdgeIt& operator++() {
-        _graph->nextInc(*this, _direction);
-        return *this;
-      }
-    };
-
-    LemonRangeWrapper2<IncEdgeIt, BpGraph, Node> incEdges(const Node& u) const {
-      return LemonRangeWrapper2<IncEdgeIt, BpGraph, Node>(*this, u);
-    }
-
-
-    // \brief Base node of the iterator
-    //
-    // Returns the base node (ie. the source in this case) of the iterator
-    Node baseNode(const OutArcIt &arc) const {
-      return Parent::source(static_cast<const Arc&>(arc));
-    }
-    // \brief Running node of the iterator
-    //
-    // Returns the running node (ie. the target in this case) of the
-    // iterator
-    Node runningNode(const OutArcIt &arc) const {
-      return Parent::target(static_cast<const Arc&>(arc));
-    }
-
-    // \brief Base node of the iterator
-    //
-    // Returns the base node (ie. the target in this case) of the iterator
-    Node baseNode(const InArcIt &arc) const {
-      return Parent::target(static_cast<const Arc&>(arc));
-    }
-    // \brief Running node of the iterator
-    //
-    // Returns the running node (ie. the source in this case) of the
-    // iterator
-    Node runningNode(const InArcIt &arc) const {
-      return Parent::source(static_cast<const Arc&>(arc));
-    }
-
-    // Base node of the iterator
-    //
-    // Returns the base node of the iterator
-    Node baseNode(const IncEdgeIt &edge) const {
-      return edge._direction ? this->u(edge) : this->v(edge);
-    }
-    // Running node of the iterator
-    //
-    // Returns the running node of the iterator
-    Node runningNode(const IncEdgeIt &edge) const {
-      return edge._direction ? this->v(edge) : this->u(edge);
-    }
-
-    // Mappable extension
-
-    template <typename _Value>
-    class NodeMap
-      : public MapExtender<DefaultMap<BpGraph, Node, _Value> > {
-      typedef MapExtender<DefaultMap<BpGraph, Node, _Value> > Parent;
-
-    public:
-      explicit NodeMap(const BpGraph& bpgraph)
-        : Parent(bpgraph) {}
-      NodeMap(const BpGraph& bpgraph, const _Value& value)
-        : Parent(bpgraph, value) {}
-
-    private:
-      NodeMap& operator=(const NodeMap& cmap) {
-        return operator=<NodeMap>(cmap);
-      }
-
-      template <typename CMap>
-      NodeMap& operator=(const CMap& cmap) {
-        Parent::operator=(cmap);
-        return *this;
-      }
-
-    };
-
-    template <typename _Value>
-    class RedNodeMap
-      : public MapExtender<DefaultMap<BpGraph, RedNode, _Value> > {
-      typedef MapExtender<DefaultMap<BpGraph, RedNode, _Value> > Parent;
-
-    public:
-      explicit RedNodeMap(const BpGraph& bpgraph)
-        : Parent(bpgraph) {}
-      RedNodeMap(const BpGraph& bpgraph, const _Value& value)
-        : Parent(bpgraph, value) {}
-
-    private:
-      RedNodeMap& operator=(const RedNodeMap& cmap) {
-        return operator=<RedNodeMap>(cmap);
-      }
-
-      template <typename CMap>
-      RedNodeMap& operator=(const CMap& cmap) {
-        Parent::operator=(cmap);
-        return *this;
-      }
-
-    };
-
-    template <typename _Value>
-    class BlueNodeMap
-      : public MapExtender<DefaultMap<BpGraph, BlueNode, _Value> > {
-      typedef MapExtender<DefaultMap<BpGraph, BlueNode, _Value> > Parent;
-
-    public:
-      explicit BlueNodeMap(const BpGraph& bpgraph)
-        : Parent(bpgraph) {}
-      BlueNodeMap(const BpGraph& bpgraph, const _Value& value)
-        : Parent(bpgraph, value) {}
-
-    private:
-      BlueNodeMap& operator=(const BlueNodeMap& cmap) {
-        return operator=<BlueNodeMap>(cmap);
-      }
-
-      template <typename CMap>
-      BlueNodeMap& operator=(const CMap& cmap) {
-        Parent::operator=(cmap);
-        return *this;
-      }
-
-    };
-
-    template <typename _Value>
-    class ArcMap
-      : public MapExtender<DefaultMap<BpGraph, Arc, _Value> > {
-      typedef MapExtender<DefaultMap<BpGraph, Arc, _Value> > Parent;
-
-    public:
-      explicit ArcMap(const BpGraph& graph)
-        : Parent(graph) {}
-      ArcMap(const BpGraph& graph, const _Value& value)
-        : Parent(graph, value) {}
-
-    private:
-      ArcMap& operator=(const ArcMap& cmap) {
-        return operator=<ArcMap>(cmap);
-      }
-
-      template <typename CMap>
-      ArcMap& operator=(const CMap& cmap) {
-        Parent::operator=(cmap);
-        return *this;
-      }
-    };
-
-
-    template <typename _Value>
-    class EdgeMap
-      : public MapExtender<DefaultMap<BpGraph, Edge, _Value> > {
-      typedef MapExtender<DefaultMap<BpGraph, Edge, _Value> > Parent;
-
-    public:
-      explicit EdgeMap(const BpGraph& graph)
-        : Parent(graph) {}
-
-      EdgeMap(const BpGraph& graph, const _Value& value)
-        : Parent(graph, value) {}
-
-    private:
-      EdgeMap& operator=(const EdgeMap& cmap) {
-        return operator=<EdgeMap>(cmap);
-      }
-
-      template <typename CMap>
-      EdgeMap& operator=(const CMap& cmap) {
-        Parent::operator=(cmap);
-        return *this;
-      }
-
-    };
-
-    // Alteration extension
-
-    RedNode addRedNode() {
-      RedNode node = Parent::addRedNode();
-      notifier(RedNode()).add(node);
-      notifier(Node()).add(node);
-      return node;
-    }
-
-    BlueNode addBlueNode() {
-      BlueNode node = Parent::addBlueNode();
-      notifier(BlueNode()).add(node);
-      notifier(Node()).add(node);
-      return node;
-    }
-
-    Edge addEdge(const RedNode& from, const BlueNode& to) {
-      Edge edge = Parent::addEdge(from, to);
-      notifier(Edge()).add(edge);
-      std::vector<Arc> av;
-      av.push_back(Parent::direct(edge, true));
-      av.push_back(Parent::direct(edge, false));
-      notifier(Arc()).add(av);
-      return edge;
-    }
-
-    void clear() {
-      notifier(Arc()).clear();
-      notifier(Edge()).clear();
-      notifier(Node()).clear();
-      notifier(BlueNode()).clear();
-      notifier(RedNode()).clear();
-      Parent::clear();
-    }
-
-    template <typename BpGraph, typename NodeRefMap, typename EdgeRefMap>
-    void build(const BpGraph& graph, NodeRefMap& nodeRef,
-               EdgeRefMap& edgeRef) {
-      Parent::build(graph, nodeRef, edgeRef);
-      notifier(RedNode()).build();
-      notifier(BlueNode()).build();
-      notifier(Node()).build();
-      notifier(Edge()).build();
-      notifier(Arc()).build();
-    }
-
-    void erase(const Node& node) {
-      Arc arc;
-      Parent::firstOut(arc, node);
-      while (arc != INVALID ) {
-        erase(arc);
-        Parent::firstOut(arc, node);
-      }
-
-      Parent::firstIn(arc, node);
-      while (arc != INVALID ) {
-        erase(arc);
-        Parent::firstIn(arc, node);
-      }
-
-      if (Parent::red(node)) {
-        notifier(RedNode()).erase(this->asRedNodeUnsafe(node));
-      } else {
-        notifier(BlueNode()).erase(this->asBlueNodeUnsafe(node));
-      }
-
-      notifier(Node()).erase(node);
-      Parent::erase(node);
-    }
-
-    void erase(const Edge& edge) {
-      std::vector<Arc> av;
-      av.push_back(Parent::direct(edge, true));
-      av.push_back(Parent::direct(edge, false));
-      notifier(Arc()).erase(av);
-      notifier(Edge()).erase(edge);
-      Parent::erase(edge);
-    }
-
-    BpGraphExtender() {
-      red_node_notifier.setContainer(*this);
-      blue_node_notifier.setContainer(*this);
-      node_notifier.setContainer(*this);
-      arc_notifier.setContainer(*this);
-      edge_notifier.setContainer(*this);
-    }
-
-    ~BpGraphExtender() {
-      edge_notifier.clear();
-      arc_notifier.clear();
-      node_notifier.clear();
-      blue_node_notifier.clear();
-      red_node_notifier.clear();
-    }
-
-  };
-
 }
 
Index: mon/bits/lock.h
===================================================================
--- lemon/bits/lock.h	(revision 1270)
+++ 	(revision )
@@ -1,65 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2013
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * 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_BITS_LOCK_H
-#define LEMON_BITS_LOCK_H
-
-#include <lemon/config.h>
-#if defined(LEMON_USE_PTHREAD)
-#include <pthread.h>
-#elif defined(LEMON_USE_WIN32_THREADS)
-#include <lemon/bits/windows.h>
-#endif
-
-namespace lemon {
-  namespace bits {
-
-#if defined(LEMON_USE_PTHREAD)
-    class Lock {
-    public:
-      Lock() {
-        pthread_mutex_init(&_lock, 0);
-      }
-      ~Lock() {
-        pthread_mutex_destroy(&_lock);
-      }
-      void lock() {
-        pthread_mutex_lock(&_lock);
-      }
-      void unlock() {
-        pthread_mutex_unlock(&_lock);
-      }
-
-    private:
-      pthread_mutex_t _lock;
-    };
-#elif defined(LEMON_USE_WIN32_THREADS)
-    class Lock : public WinLock {};
-#else
-    class Lock {
-    public:
-      Lock() {}
-      ~Lock() {}
-      void lock() {}
-      void unlock() {}
-    };
-#endif
-  }
-}
-
-#endif
Index: lemon/bits/map_extender.h
===================================================================
--- lemon/bits/map_extender.h	(revision 1270)
+++ lemon/bits/map_extender.h	(revision 867)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/bits/path_dump.h
===================================================================
--- lemon/bits/path_dump.h	(revision 1338)
+++ lemon/bits/path_dump.h	(revision 576)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -50,5 +50,5 @@
 
     bool empty() const {
-      return predMap[target] == INVALID;
+      return predMap[target] != INVALID;
     }
 
@@ -62,5 +62,5 @@
       }
 
-      operator typename Digraph::Arc() const {
+      operator const typename Digraph::Arc() const {
         return path->predMap[current];
       }
@@ -124,5 +124,5 @@
 
     bool empty() const {
-      return predMatrixMap(source, target) == INVALID;
+      return source != target;
     }
 
Index: lemon/bits/solver_bits.h
===================================================================
--- lemon/bits/solver_bits.h	(revision 1270)
+++ lemon/bits/solver_bits.h	(revision 566)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -45,5 +45,4 @@
       void clear() {
         first_item = -1;
-        last_item = -1;
         first_free_item = -1;
         items.clear();
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/traits.h
===================================================================
--- lemon/bits/traits.h	(revision 1270)
+++ lemon/bits/traits.h	(revision 663)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -149,86 +149,4 @@
         : Parent(_digraph, _value) {}
     };
-
-  };
-
-  template <typename GR, typename Enable = void>
-  struct RedNodeNotifierIndicator {
-    typedef InvalidType Type;
-  };
-  template <typename GR>
-  struct RedNodeNotifierIndicator<
-    GR,
-    typename enable_if<typename GR::RedNodeNotifier::Notifier, void>::type
-  > {
-    typedef typename GR::RedNodeNotifier Type;
-  };
-
-  template <typename GR>
-  class ItemSetTraits<GR, typename GR::RedNode> {
-  public:
-
-    typedef GR BpGraph;
-    typedef GR Graph;
-    typedef GR Digraph;
-
-    typedef typename GR::RedNode Item;
-    typedef typename GR::RedNodeIt ItemIt;
-
-    typedef typename RedNodeNotifierIndicator<GR>::Type ItemNotifier;
-
-    template <typename V>
-    class Map : public GR::template RedNodeMap<V> {
-      typedef typename GR::template RedNodeMap<V> Parent;
-
-    public:
-      typedef typename GR::template RedNodeMap<V> Type;
-      typedef typename Parent::Value Value;
-
-      Map(const GR& _bpgraph) : Parent(_bpgraph) {}
-      Map(const GR& _bpgraph, const Value& _value)
-        : Parent(_bpgraph, _value) {}
-
-     };
-
-  };
-
-  template <typename GR, typename Enable = void>
-  struct BlueNodeNotifierIndicator {
-    typedef InvalidType Type;
-  };
-  template <typename GR>
-  struct BlueNodeNotifierIndicator<
-    GR,
-    typename enable_if<typename GR::BlueNodeNotifier::Notifier, void>::type
-  > {
-    typedef typename GR::BlueNodeNotifier Type;
-  };
-
-  template <typename GR>
-  class ItemSetTraits<GR, typename GR::BlueNode> {
-  public:
-
-    typedef GR BpGraph;
-    typedef GR Graph;
-    typedef GR Digraph;
-
-    typedef typename GR::BlueNode Item;
-    typedef typename GR::BlueNodeIt ItemIt;
-
-    typedef typename BlueNodeNotifierIndicator<GR>::Type ItemNotifier;
-
-    template <typename V>
-    class Map : public GR::template BlueNodeMap<V> {
-      typedef typename GR::template BlueNodeMap<V> Parent;
-
-    public:
-      typedef typename GR::template BlueNodeMap<V> Type;
-      typedef typename Parent::Value Value;
-
-      Map(const GR& _bpgraph) : Parent(_bpgraph) {}
-      Map(const GR& _bpgraph, const Value& _value)
-        : Parent(_bpgraph, _value) {}
-
-     };
 
   };
Index: lemon/bits/windows.cc
===================================================================
--- lemon/bits/windows.cc	(revision 1341)
+++ lemon/bits/windows.cc	(revision 513)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -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,7 +41,5 @@
 #include <unistd.h>
 #include <ctime>
-#ifndef LEMON_WIN32
 #include <sys/times.h>
-#endif
 #include <sys/time.h>
 #endif
@@ -60,5 +54,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 +93,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 +119,5 @@
     int getWinRndSeed()
     {
-#ifdef LEMON_WIN32
+#ifdef WIN32
       FILETIME time;
       GetSystemTimeAsFileTime(&time);
@@ -135,36 +129,4 @@
 #endif
     }
-
-    WinLock::WinLock() {
-#ifdef LEMON_WIN32
-      CRITICAL_SECTION *lock = new CRITICAL_SECTION;
-      InitializeCriticalSection(lock);
-      _repr = lock;
-#else
-      _repr = 0; //Just to avoid 'unused variable' warning with clang
-#endif
-    }
-
-    WinLock::~WinLock() {
-#ifdef LEMON_WIN32
-      CRITICAL_SECTION *lock = static_cast<CRITICAL_SECTION*>(_repr);
-      DeleteCriticalSection(lock);
-      delete lock;
-#endif
-    }
-
-    void WinLock::lock() {
-#ifdef LEMON_WIN32
-      CRITICAL_SECTION *lock = static_cast<CRITICAL_SECTION*>(_repr);
-      EnterCriticalSection(lock);
-#endif
-    }
-
-    void WinLock::unlock() {
-#ifdef LEMON_WIN32
-      CRITICAL_SECTION *lock = static_cast<CRITICAL_SECTION*>(_repr);
-      LeaveCriticalSection(lock);
-#endif
-    }
   }
 }
Index: lemon/bits/windows.h
===================================================================
--- lemon/bits/windows.h	(revision 1340)
+++ lemon/bits/windows.h	(revision 576)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -20,5 +20,4 @@
 #define LEMON_BITS_WINDOWS_H
 
-#include <lemon/config.h>
 #include <string>
 
@@ -30,14 +29,4 @@
     std::string getWinFormattedDate();
     int getWinRndSeed();
-
-    class WinLock {
-    public:
-      WinLock();
-      ~WinLock();
-      void lock();
-      void unlock();\
-    private:
-      void *_repr;
-    };
   }
 }
Index: lemon/bucket_heap.h
===================================================================
--- lemon/bucket_heap.h	(revision 956)
+++ lemon/bucket_heap.h	(revision 758)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -385,5 +385,5 @@
   ///
   /// Note that this implementation does not conform to the
-  /// \ref concepts::Heap "heap concept" due to the lack of some
+  /// \ref concepts::Heap "heap concept" due to the lack of some 
   /// functionality.
   ///
Index: lemon/capacity_scaling.h
===================================================================
--- lemon/capacity_scaling.h	(revision 1298)
+++ lemon/capacity_scaling.h	(revision 1362)
@@ -1,7 +1,7 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
+/* -*- C++ -*-
  *
- * This file is a part of LEMON, a generic C++ optimization library.
+ * This file is a part of LEMON, a generic C++ optimization library
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -28,4 +28,5 @@
 #include <limits>
 #include <lemon/core.h>
+#include <lemon/maps.h>
 #include <lemon/bin_heap.h>
 
@@ -67,14 +68,7 @@
   /// \ref CapacityScaling implements the capacity scaling version
   /// of the successive shortest path algorithm for finding a
-  /// \ref min_cost_flow "minimum cost flow" \cite amo93networkflows,
-  /// \cite edmondskarp72theoretical. It is an efficient dual
-  /// solution method, which runs in polynomial time
-  /// \f$O(m\log U (n+m)\log n)\f$, where <i>U</i> denotes the maximum
-  /// of node supply and arc capacity values.
-  ///
-  /// This algorithm is typically slower than \ref CostScaling and
-  /// \ref NetworkSimplex, but in special cases, it can be more
-  /// efficient than them.
-  /// (For more information, see \ref min_cost_flow_algs "the module page".)
+  /// \ref min_cost_flow "minimum cost flow" \ref amo93networkflows,
+  /// \ref edmondskarp72theoretical. It is an efficient dual
+  /// solution method.
   ///
   /// Most of the parameters of the problem (except for the digraph)
@@ -85,18 +79,12 @@
   /// \tparam GR The digraph type the algorithm runs on.
   /// \tparam V The number type used for flow amounts, capacity bounds
-  /// and supply values in the algorithm. By default, it is \c int.
+  /// and supply values in the algorithm. By default it is \c int.
   /// \tparam C The number type used for costs and potentials in the
-  /// algorithm. By default, it is the same as \c V.
-  /// \tparam TR The traits class that defines various types used by the
-  /// algorithm. By default, it is \ref CapacityScalingDefaultTraits
-  /// "CapacityScalingDefaultTraits<GR, V, C>".
-  /// In most cases, this parameter should not be set directly,
-  /// consider to use the named template parameters instead.
+  /// algorithm. By default it is the same as \c V.
   ///
-  /// \warning Both \c V and \c C must be signed number types.
-  /// \warning Capacity bounds and supply values must be integer, but
-  /// arc costs can be arbitrary real numbers.
-  /// \warning This algorithm does not support negative costs for
-  /// arcs having infinite upper bound.
+  /// \warning Both number types must be signed and all input data must
+  /// be integer.
+  /// \warning This algorithm does not support negative costs for such
+  /// arcs that have infinite upper bound.
 #ifdef DOXYGEN
   template <typename GR, typename V, typename C, typename TR>
@@ -119,6 +107,5 @@
     typedef typename TR::Heap Heap;
 
-    /// \brief The \ref lemon::CapacityScalingDefaultTraits "traits class"
-    /// of the algorithm
+    /// The \ref CapacityScalingDefaultTraits "traits class" of the algorithm
     typedef TR Traits;
 
@@ -143,5 +130,5 @@
       UNBOUNDED
     };
-
+  
   private:
 
@@ -149,8 +136,7 @@
 
     typedef std::vector<int> IntVector;
+    typedef std::vector<char> BoolVector;
     typedef std::vector<Value> ValueVector;
     typedef std::vector<Cost> CostVector;
-    typedef std::vector<char> BoolVector;
-    // Note: vector<char> is used instead of vector<bool> for efficiency reasons
 
   private:
@@ -164,5 +150,5 @@
 
     // Parameters of the problem
-    bool _has_lower;
+    bool _have_lower;
     Value _sum_supply;
 
@@ -194,5 +180,5 @@
 
   public:
-
+  
     /// \brief Constant for infinite upper bounds (capacities).
     ///
@@ -221,8 +207,8 @@
       CostVector &_pi;
       IntVector &_pred;
-
+      
       IntVector _proc_nodes;
       CostVector _dist;
-
+      
     public:
 
@@ -311,8 +297,4 @@
     /// @}
 
-  protected:
-
-    CapacityScaling() {}
-
   public:
 
@@ -334,5 +316,67 @@
         "The cost type of CapacityScaling must be signed");
 
-      // Reset data structures
+      // Resize vectors
+      _node_num = countNodes(_graph);
+      _arc_num = countArcs(_graph);
+      _res_arc_num = 2 * (_arc_num + _node_num);
+      _root = _node_num;
+      ++_node_num;
+
+      _first_out.resize(_node_num + 1);
+      _forward.resize(_res_arc_num);
+      _source.resize(_res_arc_num);
+      _target.resize(_res_arc_num);
+      _reverse.resize(_res_arc_num);
+
+      _lower.resize(_res_arc_num);
+      _upper.resize(_res_arc_num);
+      _cost.resize(_res_arc_num);
+      _supply.resize(_node_num);
+      
+      _res_cap.resize(_res_arc_num);
+      _pi.resize(_node_num);
+      _excess.resize(_node_num);
+      _pred.resize(_node_num);
+
+      // Copy the graph
+      int i = 0, j = 0, k = 2 * _arc_num + _node_num - 1;
+      for (NodeIt n(_graph); n != INVALID; ++n, ++i) {
+        _node_id[n] = i;
+      }
+      i = 0;
+      for (NodeIt n(_graph); n != INVALID; ++n, ++i) {
+        _first_out[i] = j;
+        for (OutArcIt a(_graph, n); a != INVALID; ++a, ++j) {
+          _arc_idf[a] = j;
+          _forward[j] = true;
+          _source[j] = i;
+          _target[j] = _node_id[_graph.runningNode(a)];
+        }
+        for (InArcIt a(_graph, n); a != INVALID; ++a, ++j) {
+          _arc_idb[a] = j;
+          _forward[j] = false;
+          _source[j] = i;
+          _target[j] = _node_id[_graph.runningNode(a)];
+        }
+        _forward[j] = false;
+        _source[j] = i;
+        _target[j] = _root;
+        _reverse[j] = k;
+        _forward[k] = true;
+        _source[k] = _root;
+        _target[k] = i;
+        _reverse[k] = j;
+        ++j; ++k;
+      }
+      _first_out[i] = j;
+      _first_out[_node_num] = k;
+      for (ArcIt a(_graph); a != INVALID; ++a) {
+        int fi = _arc_idf[a];
+        int bi = _arc_idb[a];
+        _reverse[fi] = bi;
+        _reverse[bi] = fi;
+      }
+      
+      // Reset parameters
       reset();
     }
@@ -357,7 +401,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;
@@ -431,5 +476,5 @@
     ///
     /// Using this function has the same effect as using \ref supplyMap()
-    /// with a map in which \c k is assigned to \c s, \c -k is
+    /// with such a map in which \c k is assigned to \c s, \c -k is
     /// assigned to \c t and all other nodes have zero supply value.
     ///
@@ -448,5 +493,5 @@
       return *this;
     }
-
+    
     /// @}
 
@@ -468,10 +513,10 @@
     /// \endcode
     ///
-    /// This function can be called more than once. All the given parameters
-    /// are kept for the next call, unless \ref resetParams() or \ref reset()
-    /// is used, thus only the modified parameters have to be set again.
-    /// If the underlying digraph was also modified after the construction
-    /// of the class (or the last \ref reset() call), then the \ref reset()
-    /// function must be called.
+    /// This function can be called more than once. All the parameters
+    /// that have been given are kept for the next call, unless
+    /// \ref reset() is called, thus only the modified parameters
+    /// have to be set again. See \ref reset() for examples.
+    /// However, the underlying digraph must not be modified after this
+    /// class have been constructed, since it copies and extends the graph.
     ///
     /// \param factor The capacity scaling factor. It must be larger than
@@ -490,5 +535,4 @@
     ///
     /// \see ProblemType
-    /// \see resetParams(), reset()
     ProblemType run(int factor = 4) {
       _factor = factor;
@@ -504,10 +548,9 @@
     /// \ref costMap(), \ref supplyMap(), \ref stSupply().
     ///
-    /// It is useful for multiple \ref run() calls. Basically, all the given
-    /// parameters are kept for the next \ref run() call, unless
-    /// \ref resetParams() or \ref reset() is used.
-    /// If the underlying digraph was also modified after the construction
-    /// of the class or the last \ref reset() call, then the \ref reset()
-    /// function must be used, otherwise \ref resetParams() is sufficient.
+    /// It is useful for multiple run() calls. If this function is not
+    /// used, all the parameters given before are kept for the next
+    /// \ref run() call.
+    /// However, the underlying digraph must not be modified after this
+    /// class have been constructed, since it copies and extends the graph.
     ///
     /// For example,
@@ -519,12 +562,12 @@
     ///     .supplyMap(sup).run();
     ///
-    ///   // Run again with modified cost map (resetParams() is not called,
+    ///   // Run again with modified cost map (reset() is not called,
     ///   // so only the cost map have to be set again)
     ///   cost[e] += 100;
     ///   cs.costMap(cost).run();
     ///
-    ///   // Run again from scratch using resetParams()
+    ///   // Run again from scratch using reset()
     ///   // (the lower bounds will be set to zero on all arcs)
-    ///   cs.resetParams();
+    ///   cs.reset();
     ///   cs.upperMap(capacity).costMap(cost)
     ///     .supplyMap(sup).run();
@@ -532,7 +575,5 @@
     ///
     /// \return <tt>(*this)</tt>
-    ///
-    /// \see reset(), run()
-    CapacityScaling& resetParams() {
+    CapacityScaling& reset() {
       for (int i = 0; i != _node_num; ++i) {
         _supply[i] = 0;
@@ -543,92 +584,5 @@
         _cost[j] = _forward[j] ? 1 : -1;
       }
-      _has_lower = false;
-      return *this;
-    }
-
-    /// \brief Reset the internal data structures and all the parameters
-    /// that have been given before.
-    ///
-    /// This function resets the internal data structures and all the
-    /// paramaters that have been given before using functions \ref lowerMap(),
-    /// \ref upperMap(), \ref costMap(), \ref supplyMap(), \ref stSupply().
-    ///
-    /// It is useful for multiple \ref run() calls. Basically, all the given
-    /// parameters are kept for the next \ref run() call, unless
-    /// \ref resetParams() or \ref reset() is used.
-    /// If the underlying digraph was also modified after the construction
-    /// of the class or the last \ref reset() call, then the \ref reset()
-    /// function must be used, otherwise \ref resetParams() is sufficient.
-    ///
-    /// See \ref resetParams() for examples.
-    ///
-    /// \return <tt>(*this)</tt>
-    ///
-    /// \see resetParams(), run()
-    CapacityScaling& reset() {
-      // Resize vectors
-      _node_num = countNodes(_graph);
-      _arc_num = countArcs(_graph);
-      _res_arc_num = 2 * (_arc_num + _node_num);
-      _root = _node_num;
-      ++_node_num;
-
-      _first_out.resize(_node_num + 1);
-      _forward.resize(_res_arc_num);
-      _source.resize(_res_arc_num);
-      _target.resize(_res_arc_num);
-      _reverse.resize(_res_arc_num);
-
-      _lower.resize(_res_arc_num);
-      _upper.resize(_res_arc_num);
-      _cost.resize(_res_arc_num);
-      _supply.resize(_node_num);
-
-      _res_cap.resize(_res_arc_num);
-      _pi.resize(_node_num);
-      _excess.resize(_node_num);
-      _pred.resize(_node_num);
-
-      // Copy the graph
-      int i = 0, j = 0, k = 2 * _arc_num + _node_num - 1;
-      for (NodeIt n(_graph); n != INVALID; ++n, ++i) {
-        _node_id[n] = i;
-      }
-      i = 0;
-      for (NodeIt n(_graph); n != INVALID; ++n, ++i) {
-        _first_out[i] = j;
-        for (OutArcIt a(_graph, n); a != INVALID; ++a, ++j) {
-          _arc_idf[a] = j;
-          _forward[j] = true;
-          _source[j] = i;
-          _target[j] = _node_id[_graph.runningNode(a)];
-        }
-        for (InArcIt a(_graph, n); a != INVALID; ++a, ++j) {
-          _arc_idb[a] = j;
-          _forward[j] = false;
-          _source[j] = i;
-          _target[j] = _node_id[_graph.runningNode(a)];
-        }
-        _forward[j] = false;
-        _source[j] = i;
-        _target[j] = _root;
-        _reverse[j] = k;
-        _forward[k] = true;
-        _source[k] = _root;
-        _target[k] = i;
-        _reverse[k] = j;
-        ++j; ++k;
-      }
-      _first_out[i] = j;
-      _first_out[_node_num] = k;
-      for (ArcIt a(_graph); a != INVALID; ++a) {
-        int fi = _arc_idf[a];
-        int bi = _arc_idb[a];
-        _reverse[fi] = bi;
-        _reverse[bi] = fi;
-      }
-
-      // Reset parameters
-      resetParams();
+      _have_lower = false;
       return *this;
     }
@@ -646,5 +600,5 @@
     ///
     /// This function returns the total cost of the found flow.
-    /// Its complexity is O(m).
+    /// Its complexity is O(e).
     ///
     /// \note The return type of the function can be specified as a
@@ -684,6 +638,5 @@
     }
 
-    /// \brief Copy the flow values (the primal solution) into the
-    /// given map.
+    /// \brief Return the flow map (the primal solution).
     ///
     /// This function copies the flow value on each arc into the given
@@ -709,6 +662,5 @@
     }
 
-    /// \brief Copy the potential values (the dual solution) into the
-    /// given map.
+    /// \brief Return the potential map (the dual solution).
     ///
     /// This function copies the potential (dual value) of each node
@@ -739,10 +691,5 @@
       }
       if (_sum_supply > 0) return INFEASIBLE;
-
-      // Check lower and upper bounds
-      LEMON_DEBUG(checkBoundMaps(),
-          "Upper bounds must be greater or equal to the lower bounds");
-
-
+      
       // Initialize vectors
       for (int i = 0; i != _root; ++i) {
@@ -754,5 +701,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];
@@ -792,5 +739,5 @@
         }
       }
-
+      
       // Handle GEQ supply type
       if (_sum_supply < 0) {
@@ -819,13 +766,13 @@
       if (_factor > 1) {
         // With scaling
-        Value max_sup = 0, max_dem = 0, max_cap = 0;
-        for (int i = 0; i != _root; ++i) {
+        Value max_sup = 0, max_dem = 0;
+        for (int i = 0; i != _node_num; ++i) {
           Value ex = _excess[i];
           if ( ex > max_sup) max_sup =  ex;
           if (-ex > max_dem) max_dem = -ex;
-          int last_out = _first_out[i+1] - 1;
-          for (int j = _first_out[i]; j != last_out; ++j) {
-            if (_res_cap[j] > max_cap) max_cap = _res_cap[j];
-          }
+        }
+        Value max_cap = 0;
+        for (int j = 0; j != _res_arc_num; ++j) {
+          if (_res_cap[j] > max_cap) max_cap = _res_cap[j];
         }
         max_sup = std::min(std::min(max_sup, max_dem), max_cap);
@@ -837,13 +784,4 @@
 
       return OPTIMAL;
-    }
-
-    // Check if the upper bound is greater than or equal to the lower bound
-    // on each forward arc.
-    bool checkBoundMaps() {
-      for (int j = 0; j != _res_arc_num; ++j) {
-        if (_forward[j] && _upper[j] < _lower[j]) return false;
-      }
-      return true;
     }
 
@@ -857,8 +795,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];
         }
       }
@@ -869,7 +807,7 @@
         for (int i = 0; i != _node_num; ++i) {
           _pi[i] -= pr;
-        }
-      }
-
+        }        
+      }
+      
       return pt;
     }
Index: lemon/cbc.cc
===================================================================
--- lemon/cbc.cc	(revision 1336)
+++ lemon/cbc.cc	(revision 793)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -26,5 +26,10 @@
 #include <coin/OsiSolverInterface.hpp>
 
+#ifdef COIN_HAS_CLP
 #include "coin/OsiClpSolverInterface.hpp"
+#endif
+#ifdef COIN_HAS_OSL
+#include "coin/OsiOslSolverInterface.hpp"
+#endif
 
 #include "coin/CbcCutGenerator.hpp"
@@ -112,9 +117,9 @@
 
   void CbcMip::_eraseColId(int i) {
-    _cols.eraseIndex(i);
+    cols.eraseIndex(i);
   }
 
   void CbcMip::_eraseRowId(int i) {
-    _rows.eraseIndex(i);
+    rows.eraseIndex(i);
   }
 
@@ -266,5 +271,11 @@
       delete _osi_solver;
     }
+#ifdef COIN_HAS_CLP
     _osi_solver = new OsiClpSolverInterface();
+#elif COIN_HAS_OSL
+    _osi_solver = new OsiOslSolverInterface();
+#else
+#error Cannot instantiate Osi solver
+#endif
 
     _osi_solver->loadFromCoinModel(*_prob);
@@ -318,4 +329,5 @@
       _cbc_model->addCutGenerator(&flowGen, -1, "FlowCover");
 
+#ifdef COIN_HAS_CLP
       OsiClpSolverInterface* osiclp =
         dynamic_cast<OsiClpSolverInterface*>(_cbc_model->solver());
@@ -323,4 +335,5 @@
         osiclp->setupForRepeatedUse(2, 0);
       }
+#endif
 
       CbcRounding heuristic1(*_cbc_model);
@@ -436,4 +449,6 @@
 
     _prob = new CoinModel();
+    rows.clear();
+    cols.clear();
   }
 
Index: lemon/cbc.h
===================================================================
--- lemon/cbc.h	(revision 1270)
+++ lemon/cbc.h	(revision 793)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -17,4 +17,5 @@
  */
 
+// -*- C++ -*-
 #ifndef LEMON_CBC_H
 #define LEMON_CBC_H
@@ -121,5 +122,5 @@
     int _message_level;
 
-
+    
 
   };
Index: mon/christofides_tsp.h
===================================================================
--- lemon/christofides_tsp.h	(revision 1270)
+++ 	(revision )
@@ -1,254 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2013
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * 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_CHRISTOFIDES_TSP_H
-#define LEMON_CHRISTOFIDES_TSP_H
-
-/// \ingroup tsp
-/// \file
-/// \brief Christofides algorithm for symmetric TSP
-
-#include <lemon/full_graph.h>
-#include <lemon/smart_graph.h>
-#include <lemon/kruskal.h>
-#include <lemon/matching.h>
-#include <lemon/euler.h>
-
-namespace lemon {
-
-  /// \ingroup tsp
-  ///
-  /// \brief Christofides algorithm for symmetric TSP.
-  ///
-  /// ChristofidesTsp implements Christofides' heuristic for solving
-  /// symmetric \ref tsp "TSP".
-  ///
-  /// This a well-known approximation method for the TSP problem with
-  /// metric cost function.
-  /// It has a guaranteed approximation factor of 3/2 (i.e. it finds a tour
-  /// whose total cost is at most 3/2 of the optimum), but it usually
-  /// provides better solutions in practice.
-  /// This implementation runs in O(n<sup>3</sup>log(n)) time.
-  ///
-  /// The algorithm starts with a \ref spantree "minimum cost spanning tree" and
-  /// finds a \ref MaxWeightedPerfectMatching "minimum cost perfect matching"
-  /// in the subgraph induced by the nodes that have odd degree in the
-  /// spanning tree.
-  /// Finally, it constructs the tour from the \ref EulerIt "Euler traversal"
-  /// of the union of the spanning tree and the matching.
-  /// During this last step, the algorithm simply skips the visited nodes
-  /// (i.e. creates shortcuts) assuming that the triangle inequality holds
-  /// for the cost function.
-  ///
-  /// \tparam CM Type of the cost map.
-  ///
-  /// \warning CM::Value must be a signed number type.
-  template <typename CM>
-  class ChristofidesTsp
-  {
-    public:
-
-      /// Type of the cost map
-      typedef CM CostMap;
-      /// Type of the edge costs
-      typedef typename CM::Value Cost;
-
-    private:
-
-      GRAPH_TYPEDEFS(FullGraph);
-
-      const FullGraph &_gr;
-      const CostMap &_cost;
-      std::vector<Node> _path;
-      Cost _sum;
-
-    public:
-
-      /// \brief Constructor
-      ///
-      /// Constructor.
-      /// \param gr The \ref FullGraph "full graph" the algorithm runs on.
-      /// \param cost The cost map.
-      ChristofidesTsp(const FullGraph &gr, const CostMap &cost)
-        : _gr(gr), _cost(cost) {}
-
-      /// \name Execution Control
-      /// @{
-
-      /// \brief Runs the algorithm.
-      ///
-      /// This function runs the algorithm.
-      ///
-      /// \return The total cost of the found tour.
-      Cost run() {
-        _path.clear();
-
-        if (_gr.nodeNum() == 0) return _sum = 0;
-        else if (_gr.nodeNum() == 1) {
-          _path.push_back(_gr(0));
-          return _sum = 0;
-        }
-        else if (_gr.nodeNum() == 2) {
-          _path.push_back(_gr(0));
-          _path.push_back(_gr(1));
-          return _sum = 2 * _cost[_gr.edge(_gr(0), _gr(1))];
-        }
-
-        // Compute min. cost spanning tree
-        std::vector<Edge> tree;
-        kruskal(_gr, _cost, std::back_inserter(tree));
-
-        FullGraph::NodeMap<int> deg(_gr, 0);
-        for (int i = 0; i != int(tree.size()); ++i) {
-          Edge e = tree[i];
-          ++deg[_gr.u(e)];
-          ++deg[_gr.v(e)];
-        }
-
-        // Copy the induced subgraph of odd nodes
-        std::vector<Node> odd_nodes;
-        for (NodeIt u(_gr); u != INVALID; ++u) {
-          if (deg[u] % 2 == 1) odd_nodes.push_back(u);
-        }
-
-        SmartGraph sgr;
-        SmartGraph::EdgeMap<Cost> scost(sgr);
-        for (int i = 0; i != int(odd_nodes.size()); ++i) {
-          sgr.addNode();
-        }
-        for (int i = 0; i != int(odd_nodes.size()); ++i) {
-          for (int j = 0; j != int(odd_nodes.size()); ++j) {
-            if (j == i) continue;
-            SmartGraph::Edge e =
-              sgr.addEdge(sgr.nodeFromId(i), sgr.nodeFromId(j));
-            scost[e] = -_cost[_gr.edge(odd_nodes[i], odd_nodes[j])];
-          }
-        }
-
-        // Compute min. cost perfect matching
-        MaxWeightedPerfectMatching<SmartGraph, SmartGraph::EdgeMap<Cost> >
-          mwpm(sgr, scost);
-        mwpm.run();
-
-        for (SmartGraph::EdgeIt e(sgr); e != INVALID; ++e) {
-          if (mwpm.matching(e)) {
-            tree.push_back( _gr.edge(odd_nodes[sgr.id(sgr.u(e))],
-                                     odd_nodes[sgr.id(sgr.v(e))]) );
-          }
-        }
-
-        // Join the spanning tree and the matching
-        sgr.clear();
-        for (int i = 0; i != _gr.nodeNum(); ++i) {
-          sgr.addNode();
-        }
-        for (int i = 0; i != int(tree.size()); ++i) {
-          int ui = _gr.id(_gr.u(tree[i])),
-              vi = _gr.id(_gr.v(tree[i]));
-          sgr.addEdge(sgr.nodeFromId(ui), sgr.nodeFromId(vi));
-        }
-
-        // Compute the tour from the Euler traversal
-        SmartGraph::NodeMap<bool> visited(sgr, false);
-        for (EulerIt<SmartGraph> e(sgr); e != INVALID; ++e) {
-          SmartGraph::Node n = sgr.target(e);
-          if (!visited[n]) {
-            _path.push_back(_gr(sgr.id(n)));
-            visited[n] = true;
-          }
-        }
-
-        _sum = _cost[_gr.edge(_path.back(), _path.front())];
-        for (int i = 0; i < int(_path.size())-1; ++i) {
-          _sum += _cost[_gr.edge(_path[i], _path[i+1])];
-        }
-
-        return _sum;
-      }
-
-      /// @}
-
-      /// \name Query Functions
-      /// @{
-
-      /// \brief The total cost of the found tour.
-      ///
-      /// This function returns the total cost of the found tour.
-      ///
-      /// \pre run() must be called before using this function.
-      Cost tourCost() const {
-        return _sum;
-      }
-
-      /// \brief Returns a const reference to the node sequence of the
-      /// found tour.
-      ///
-      /// This function returns a const reference to a vector
-      /// that stores the node sequence of the found tour.
-      ///
-      /// \pre run() must be called before using this function.
-      const std::vector<Node>& tourNodes() const {
-        return _path;
-      }
-
-      /// \brief Gives back the node sequence of the found tour.
-      ///
-      /// This function copies the node sequence of the found tour into
-      /// an STL container through the given output iterator. The
-      /// <tt>value_type</tt> of the container must be <tt>FullGraph::Node</tt>.
-      /// For example,
-      /// \code
-      /// std::vector<FullGraph::Node> nodes(countNodes(graph));
-      /// tsp.tourNodes(nodes.begin());
-      /// \endcode
-      /// or
-      /// \code
-      /// std::list<FullGraph::Node> nodes;
-      /// tsp.tourNodes(std::back_inserter(nodes));
-      /// \endcode
-      ///
-      /// \pre run() must be called before using this function.
-      template <typename Iterator>
-      void tourNodes(Iterator out) const {
-        std::copy(_path.begin(), _path.end(), out);
-      }
-
-      /// \brief Gives back the found tour as a path.
-      ///
-      /// This function copies the found tour as a list of arcs/edges into
-      /// the given \ref lemon::concepts::Path "path structure".
-      ///
-      /// \pre run() must be called before using this function.
-      template <typename Path>
-      void tour(Path &path) const {
-        path.clear();
-        for (int i = 0; i < int(_path.size()) - 1; ++i) {
-          path.addBack(_gr.arc(_path[i], _path[i+1]));
-        }
-        if (int(_path.size()) >= 2) {
-          path.addBack(_gr.arc(_path.back(), _path.front()));
-        }
-      }
-
-      /// @}
-
-  };
-
-}; // namespace lemon
-
-#endif
Index: lemon/circulation.h
===================================================================
--- lemon/circulation.h	(revision 1270)
+++ lemon/circulation.h	(revision 833)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -60,6 +60,6 @@
     /// \brief The type of supply map.
     ///
-    /// The type of the map that stores the signed supply values of the
-    /// nodes.
+    /// The type of the map that stores the signed supply values of the 
+    /// nodes. 
     /// It must conform to the \ref concepts::ReadMap "ReadMap" concept.
     typedef SM SupplyMap;
@@ -142,5 +142,5 @@
      \geq sup(u) \quad \forall u\in V, \f]
      \f[ lower(uv) \leq f(uv) \leq upper(uv) \quad \forall uv\in A. \f]
-
+     
      The sum of the supply values, i.e. \f$\sum_{u\in V} sup(u)\f$ must be
      zero or negative in order to have a feasible solution (since the sum
@@ -152,5 +152,5 @@
      constraints have to be satisfied with equality, i.e. all demands
      have to be satisfied and all supplies have to be used.
-
+     
      If you need the opposite inequalities in the supply/demand constraints
      (i.e. the total demand is less than the total supply and all the demands
@@ -174,9 +174,4 @@
      \tparam SM The type of the supply map. The default map type is
      \ref concepts::Digraph::NodeMap "GR::NodeMap<UM::Value>".
-     \tparam TR The traits class that defines various types used by the
-     algorithm. By default, it is \ref CirculationDefaultTraits
-     "CirculationDefaultTraits<GR, LM, UM, SM>".
-     In most cases, this parameter should not be set directly,
-     consider to use the named template parameters instead.
   */
 #ifdef DOXYGEN
@@ -196,6 +191,5 @@
   public:
 
-    /// \brief The \ref lemon::CirculationDefaultTraits "traits class"
-    /// of the algorithm.
+    ///The \ref CirculationDefaultTraits "traits class" of the algorithm.
     typedef TR Traits;
     ///The type of the digraph the algorithm runs on.
@@ -339,5 +333,5 @@
     /// \param graph The digraph the algorithm runs on.
     /// \param lower The lower bounds for the flow values on the arcs.
-    /// \param upper The upper bounds (capacities) for the flow values
+    /// \param upper The upper bounds (capacities) for the flow values 
     /// on the arcs.
     /// \param supply The signed supply values of the nodes.
@@ -574,4 +568,6 @@
 
       Node act;
+      Node bact=INVALID;
+      Node last_activated=INVALID;
       while((act=_level->highestActive())!=INVALID) {
         int actlevel=(*_level)[act];
Index: lemon/clp.cc
===================================================================
--- lemon/clp.cc	(revision 1336)
+++ lemon/clp.cc	(revision 793)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -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);
   }
 
@@ -438,4 +438,6 @@
     delete _prob;
     _prob = new ClpSimplex();
+    rows.clear();
+    cols.clear();
     _col_names_ref.clear();
     _clear_temporals();
Index: lemon/clp.h
===================================================================
--- lemon/clp.h	(revision 1336)
+++ lemon/clp.h	(revision 793)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -139,5 +139,5 @@
 
     virtual void _messageLevel(MessageLevel);
-
+    
   public:
 
@@ -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/concept_check.h
===================================================================
--- lemon/concept_check.h	(revision 1270)
+++ lemon/concept_check.h	(revision 463)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -36,20 +36,4 @@
 
   template <class T> inline void ignore_unused_variable_warning(const T&) { }
-  template <class T1, class T2>
-  inline void ignore_unused_variable_warning(const T1&, const T2&) { }
-  template <class T1, class T2, class T3>
-  inline void ignore_unused_variable_warning(const T1&, const T2&,
-                                             const T3&) { }
-  template <class T1, class T2, class T3, class T4>
-  inline void ignore_unused_variable_warning(const T1&, const T2&,
-                                             const T3&, const T4&) { }
-  template <class T1, class T2, class T3, class T4, class T5>
-  inline void ignore_unused_variable_warning(const T1&, const T2&,
-                                             const T3&, const T4&,
-                                             const T5&) { }
-  template <class T1, class T2, class T3, class T4, class T5, class T6>
-  inline void ignore_unused_variable_warning(const T1&, const T2&,
-                                             const T3&, const T4&,
-                                             const T5&, const T6&) { }
 
   ///\e
@@ -59,5 +43,5 @@
 #if !defined(NDEBUG)
     void (Concept::*x)() = & Concept::constraints;
-    ::lemon::ignore_unused_variable_warning(x);
+    ignore_unused_variable_warning(x);
 #endif
   }
@@ -69,5 +53,5 @@
     typedef typename Concept::template Constraints<Type> ConceptCheck;
     void (ConceptCheck::*x)() = & ConceptCheck::constraints;
-    ::lemon::ignore_unused_variable_warning(x);
+    ignore_unused_variable_warning(x);
 #endif
   }
Index: mon/concepts/bpgraph.h
===================================================================
--- lemon/concepts/bpgraph.h	(revision 1336)
+++ 	(revision )
@@ -1,1167 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2013
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * 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.
- *
- */
-
-///\ingroup graph_concepts
-///\file
-///\brief The concept of undirected graphs.
-
-#ifndef LEMON_CONCEPTS_BPGRAPH_H
-#define LEMON_CONCEPTS_BPGRAPH_H
-
-#include <lemon/concepts/graph_components.h>
-#include <lemon/concepts/maps.h>
-#include <lemon/concept_check.h>
-#include <lemon/core.h>
-#include <lemon/bits/stl_iterators.h>
-
-namespace lemon {
-  namespace concepts {
-
-    /// \ingroup graph_concepts
-    ///
-    /// \brief Class describing the concept of undirected bipartite graphs.
-    ///
-    /// This class describes the common interface of all undirected
-    /// bipartite graphs.
-    ///
-    /// Like all concept classes, it only provides an interface
-    /// without any sensible implementation. So any general algorithm for
-    /// undirected bipartite graphs should compile with this class,
-    /// but it will not run properly, of course.
-    /// An actual graph implementation like \ref ListBpGraph or
-    /// \ref SmartBpGraph may have additional functionality.
-    ///
-    /// The bipartite graphs also fulfill the concept of \ref Graph
-    /// "undirected graphs". Bipartite graphs provide a bipartition of
-    /// the node set, namely a red and blue set of the nodes. The
-    /// nodes can be iterated with the RedNodeIt and BlueNodeIt in the
-    /// two node sets. With RedNodeMap and BlueNodeMap values can be
-    /// assigned to the nodes in the two sets.
-    ///
-    /// The edges of the graph cannot connect two nodes of the same
-    /// set. The edges inherent orientation is from the red nodes to
-    /// the blue nodes.
-    ///
-    /// \sa Graph
-    class BpGraph {
-    private:
-      /// BpGraphs are \e not copy constructible. Use bpGraphCopy instead.
-      BpGraph(const BpGraph&) {}
-      /// \brief Assignment of a graph to another one is \e not allowed.
-      /// Use bpGraphCopy instead.
-      void operator=(const BpGraph&) {}
-
-    public:
-      /// Default constructor.
-      BpGraph() {}
-
-      /// \brief Undirected graphs should be tagged with \c UndirectedTag.
-      ///
-      /// Undirected graphs should be tagged with \c UndirectedTag.
-      ///
-      /// This tag helps the \c enable_if technics to make compile time
-      /// specializations for undirected graphs.
-      typedef True UndirectedTag;
-
-      /// The node type of the graph
-
-      /// This class identifies a node of the graph. It also serves
-      /// as a base class of the node iterators,
-      /// thus they convert to this type.
-      class Node {
-      public:
-        /// Default constructor
-
-        /// Default constructor.
-        /// \warning It sets the object to an undefined value.
-        Node() { }
-        /// Copy constructor.
-
-        /// Copy constructor.
-        ///
-        Node(const Node&) { }
-
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the object to be invalid.
-        /// \sa Invalid for more details.
-        Node(Invalid) { }
-        /// Equality operator
-
-        /// Equality operator.
-        ///
-        /// Two iterators are equal if and only if they point to the
-        /// same object or both are \c INVALID.
-        bool operator==(Node) const { return true; }
-
-        /// Inequality operator
-
-        /// Inequality operator.
-        bool operator!=(Node) const { return true; }
-
-        /// Artificial ordering operator.
-
-        /// Artificial ordering operator.
-        ///
-        /// \note This operator only has to define some strict ordering of
-        /// the items; this order has nothing to do with the iteration
-        /// ordering of the items.
-        bool operator<(Node) const { return false; }
-
-      };
-
-      /// Class to represent red nodes.
-
-      /// This class represents the red nodes of the graph. It does
-      /// not supposed to be used directly, because the nodes can be
-      /// represented as Node instances. This class can be used as
-      /// template parameter for special map classes.
-      class RedNode : public Node {
-      public:
-        /// Default constructor
-
-        /// Default constructor.
-        /// \warning It sets the object to an undefined value.
-        RedNode() { }
-        /// Copy constructor.
-
-        /// Copy constructor.
-        ///
-        RedNode(const RedNode&) : Node() { }
-
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the object to be invalid.
-        /// \sa Invalid for more details.
-        RedNode(Invalid) { }
-
-      };
-
-      /// Class to represent blue nodes.
-
-      /// This class represents the blue nodes of the graph. It does
-      /// not supposed to be used directly, because the nodes can be
-      /// represented as Node instances. This class can be used as
-      /// template parameter for special map classes.
-      class BlueNode : public Node {
-      public:
-        /// Default constructor
-
-        /// Default constructor.
-        /// \warning It sets the object to an undefined value.
-        BlueNode() { }
-        /// Copy constructor.
-
-        /// Copy constructor.
-        ///
-        BlueNode(const BlueNode&) : Node() { }
-
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the object to be invalid.
-        /// \sa Invalid for more details.
-        BlueNode(Invalid) { }
-
-      };
-
-      /// Iterator class for the red nodes.
-
-      /// This iterator goes through each red node of the graph.
-      /// Its usage is quite simple, for example, you can count the number
-      /// of red nodes in a graph \c g of type \c %BpGraph like this:
-      ///\code
-      /// int count=0;
-      /// for (BpGraph::RedNodeIt n(g); n!=INVALID; ++n) ++count;
-      ///\endcode
-      class RedNodeIt : public RedNode {
-      public:
-        /// Default constructor
-
-        /// Default constructor.
-        /// \warning It sets the iterator to an undefined value.
-        RedNodeIt() { }
-        /// Copy constructor.
-
-        /// Copy constructor.
-        ///
-        RedNodeIt(const RedNodeIt& n) : RedNode(n) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the iterator to be invalid.
-        /// \sa Invalid for more details.
-        RedNodeIt(Invalid) { }
-        /// Sets the iterator to the first red node.
-
-        /// Sets the iterator to the first red node of the given
-        /// digraph.
-        explicit RedNodeIt(const BpGraph&) { }
-        /// Sets the iterator to the given red node.
-
-        /// Sets the iterator to the given red node of the given
-        /// digraph.
-        RedNodeIt(const BpGraph&, const RedNode&) { }
-        /// Next node.
-
-        /// Assign the iterator to the next red node.
-        ///
-        RedNodeIt& operator++() { return *this; }
-      };
-
-      /// \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.
-
-      /// This iterator goes through each blue node of the graph.
-      /// Its usage is quite simple, for example, you can count the number
-      /// of blue nodes in a graph \c g of type \c %BpGraph like this:
-      ///\code
-      /// int count=0;
-      /// for (BpGraph::BlueNodeIt n(g); n!=INVALID; ++n) ++count;
-      ///\endcode
-      class BlueNodeIt : public BlueNode {
-      public:
-        /// Default constructor
-
-        /// Default constructor.
-        /// \warning It sets the iterator to an undefined value.
-        BlueNodeIt() { }
-        /// Copy constructor.
-
-        /// Copy constructor.
-        ///
-        BlueNodeIt(const BlueNodeIt& n) : BlueNode(n) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the iterator to be invalid.
-        /// \sa Invalid for more details.
-        BlueNodeIt(Invalid) { }
-        /// Sets the iterator to the first blue node.
-
-        /// Sets the iterator to the first blue node of the given
-        /// digraph.
-        explicit BlueNodeIt(const BpGraph&) { }
-        /// Sets the iterator to the given blue node.
-
-        /// Sets the iterator to the given blue node of the given
-        /// digraph.
-        BlueNodeIt(const BpGraph&, const BlueNode&) { }
-        /// Next node.
-
-        /// Assign the iterator to the next blue node.
-        ///
-        BlueNodeIt& operator++() { return *this; }
-      };
-
-      /// \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.
-
-      /// This iterator goes through each node of the graph.
-      /// Its usage is quite simple, for example, you can count the number
-      /// of nodes in a graph \c g of type \c %BpGraph like this:
-      ///\code
-      /// int count=0;
-      /// for (BpGraph::NodeIt n(g); n!=INVALID; ++n) ++count;
-      ///\endcode
-      class NodeIt : public Node {
-      public:
-        /// Default constructor
-
-        /// Default constructor.
-        /// \warning It sets the iterator to an undefined value.
-        NodeIt() { }
-        /// Copy constructor.
-
-        /// Copy constructor.
-        ///
-        NodeIt(const NodeIt& n) : Node(n) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the iterator to be invalid.
-        /// \sa Invalid for more details.
-        NodeIt(Invalid) { }
-        /// Sets the iterator to the first node.
-
-        /// Sets the iterator to the first node of the given digraph.
-        ///
-        explicit NodeIt(const BpGraph&) { }
-        /// Sets the iterator to the given node.
-
-        /// Sets the iterator to the given node of the given digraph.
-        ///
-        NodeIt(const BpGraph&, const Node&) { }
-        /// Next node.
-
-        /// Assign the iterator to the next node.
-        ///
-        NodeIt& operator++() { return *this; }
-      };
-
-      /// \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
-
-      /// This class identifies an edge of the graph. It also serves
-      /// as a base class of the edge iterators,
-      /// thus they will convert to this type.
-      class Edge {
-      public:
-        /// Default constructor
-
-        /// Default constructor.
-        /// \warning It sets the object to an undefined value.
-        Edge() { }
-        /// Copy constructor.
-
-        /// Copy constructor.
-        ///
-        Edge(const Edge&) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the object to be invalid.
-        /// \sa Invalid for more details.
-        Edge(Invalid) { }
-        /// Equality operator
-
-        /// Equality operator.
-        ///
-        /// Two iterators are equal if and only if they point to the
-        /// same object or both are \c INVALID.
-        bool operator==(Edge) const { return true; }
-        /// Inequality operator
-
-        /// Inequality operator.
-        bool operator!=(Edge) const { return true; }
-
-        /// Artificial ordering operator.
-
-        /// Artificial ordering operator.
-        ///
-        /// \note This operator only has to define some strict ordering of
-        /// the edges; this order has nothing to do with the iteration
-        /// ordering of the edges.
-        bool operator<(Edge) const { return false; }
-      };
-
-      /// Iterator class for the edges.
-
-      /// This iterator goes through each edge of the graph.
-      /// Its usage is quite simple, for example, you can count the number
-      /// of edges in a graph \c g of type \c %BpGraph as follows:
-      ///\code
-      /// int count=0;
-      /// for(BpGraph::EdgeIt e(g); e!=INVALID; ++e) ++count;
-      ///\endcode
-      class EdgeIt : public Edge {
-      public:
-        /// Default constructor
-
-        /// Default constructor.
-        /// \warning It sets the iterator to an undefined value.
-        EdgeIt() { }
-        /// Copy constructor.
-
-        /// Copy constructor.
-        ///
-        EdgeIt(const EdgeIt& e) : Edge(e) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the iterator to be invalid.
-        /// \sa Invalid for more details.
-        EdgeIt(Invalid) { }
-        /// Sets the iterator to the first edge.
-
-        /// Sets the iterator to the first edge of the given graph.
-        ///
-        explicit EdgeIt(const BpGraph&) { }
-        /// Sets the iterator to the given edge.
-
-        /// Sets the iterator to the given edge of the given graph.
-        ///
-        EdgeIt(const BpGraph&, const Edge&) { }
-        /// Next edge
-
-        /// Assign the iterator to the next edge.
-        ///
-        EdgeIt& operator++() { return *this; }
-      };
-
-      /// \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.
-
-      /// This iterator goes trough the incident undirected edges
-      /// of a certain node of a graph.
-      /// Its usage is quite simple, for example, you can compute the
-      /// degree (i.e. the number of incident edges) of a node \c n
-      /// in a graph \c g of type \c %BpGraph as follows.
-      ///
-      ///\code
-      /// int count=0;
-      /// for(BpGraph::IncEdgeIt e(g, n); e!=INVALID; ++e) ++count;
-      ///\endcode
-      ///
-      /// \warning Loop edges will be iterated twice.
-      class IncEdgeIt : public Edge {
-      public:
-        /// Default constructor
-
-        /// Default constructor.
-        /// \warning It sets the iterator to an undefined value.
-        IncEdgeIt() { }
-        /// Copy constructor.
-
-        /// Copy constructor.
-        ///
-        IncEdgeIt(const IncEdgeIt& e) : Edge(e) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the iterator to be invalid.
-        /// \sa Invalid for more details.
-        IncEdgeIt(Invalid) { }
-        /// Sets the iterator to the first incident edge.
-
-        /// Sets the iterator to the first incident edge of the given node.
-        ///
-        IncEdgeIt(const BpGraph&, const Node&) { }
-        /// Sets the iterator to the given edge.
-
-        /// Sets the iterator to the given edge of the given graph.
-        ///
-        IncEdgeIt(const BpGraph&, const Edge&) { }
-        /// Next incident edge
-
-        /// Assign the iterator to the next incident edge
-        /// of the corresponding node.
-        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
-
-      /// This class identifies a directed arc of the graph. It also serves
-      /// as a base class of the arc iterators,
-      /// thus they will convert to this type.
-      class Arc {
-      public:
-        /// Default constructor
-
-        /// Default constructor.
-        /// \warning It sets the object to an undefined value.
-        Arc() { }
-        /// Copy constructor.
-
-        /// Copy constructor.
-        ///
-        Arc(const Arc&) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the object to be invalid.
-        /// \sa Invalid for more details.
-        Arc(Invalid) { }
-        /// Equality operator
-
-        /// Equality operator.
-        ///
-        /// Two iterators are equal if and only if they point to the
-        /// same object or both are \c INVALID.
-        bool operator==(Arc) const { return true; }
-        /// Inequality operator
-
-        /// Inequality operator.
-        bool operator!=(Arc) const { return true; }
-
-        /// Artificial ordering operator.
-
-        /// Artificial ordering operator.
-        ///
-        /// \note This operator only has to define some strict ordering of
-        /// the arcs; this order has nothing to do with the iteration
-        /// ordering of the arcs.
-        bool operator<(Arc) const { return false; }
-
-        /// Converison to \c Edge
-
-        /// Converison to \c Edge.
-        ///
-        operator Edge() const { return Edge(); }
-      };
-
-      /// Iterator class for the arcs.
-
-      /// This iterator goes through each directed arc of the graph.
-      /// Its usage is quite simple, for example, you can count the number
-      /// of arcs in a graph \c g of type \c %BpGraph as follows:
-      ///\code
-      /// int count=0;
-      /// for(BpGraph::ArcIt a(g); a!=INVALID; ++a) ++count;
-      ///\endcode
-      class ArcIt : public Arc {
-      public:
-        /// Default constructor
-
-        /// Default constructor.
-        /// \warning It sets the iterator to an undefined value.
-        ArcIt() { }
-        /// Copy constructor.
-
-        /// Copy constructor.
-        ///
-        ArcIt(const ArcIt& e) : Arc(e) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the iterator to be invalid.
-        /// \sa Invalid for more details.
-        ArcIt(Invalid) { }
-        /// Sets the iterator to the first arc.
-
-        /// Sets the iterator to the first arc of the given graph.
-        ///
-        explicit ArcIt(const BpGraph &g)
-        {
-          ::lemon::ignore_unused_variable_warning(g);
-        }
-        /// Sets the iterator to the given arc.
-
-        /// Sets the iterator to the given arc of the given graph.
-        ///
-        ArcIt(const BpGraph&, const Arc&) { }
-        /// Next arc
-
-        /// Assign the iterator to the next arc.
-        ///
-        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.
-
-      /// This iterator goes trough the \e outgoing directed arcs of a
-      /// certain node of a graph.
-      /// Its usage is quite simple, for example, you can count the number
-      /// of outgoing arcs of a node \c n
-      /// in a graph \c g of type \c %BpGraph as follows.
-      ///\code
-      /// int count=0;
-      /// for (Digraph::OutArcIt a(g, n); a!=INVALID; ++a) ++count;
-      ///\endcode
-      class OutArcIt : public Arc {
-      public:
-        /// Default constructor
-
-        /// Default constructor.
-        /// \warning It sets the iterator to an undefined value.
-        OutArcIt() { }
-        /// Copy constructor.
-
-        /// Copy constructor.
-        ///
-        OutArcIt(const OutArcIt& e) : Arc(e) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the iterator to be invalid.
-        /// \sa Invalid for more details.
-        OutArcIt(Invalid) { }
-        /// Sets the iterator to the first outgoing arc.
-
-        /// Sets the iterator to the first outgoing arc of the given node.
-        ///
-        OutArcIt(const BpGraph& n, const Node& g) {
-          ::lemon::ignore_unused_variable_warning(n);
-          ::lemon::ignore_unused_variable_warning(g);
-        }
-        /// Sets the iterator to the given arc.
-
-        /// Sets the iterator to the given arc of the given graph.
-        ///
-        OutArcIt(const BpGraph&, const Arc&) { }
-        /// Next outgoing arc
-
-        /// Assign the iterator to the next
-        /// outgoing arc of the corresponding node.
-        OutArcIt& operator++() { return *this; }
-      };
-
-      /// \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.
-
-      /// This iterator goes trough the \e incoming directed arcs of a
-      /// certain node of a graph.
-      /// Its usage is quite simple, for example, you can count the number
-      /// of incoming arcs of a node \c n
-      /// in a graph \c g of type \c %BpGraph as follows.
-      ///\code
-      /// int count=0;
-      /// for (Digraph::InArcIt a(g, n); a!=INVALID; ++a) ++count;
-      ///\endcode
-      class InArcIt : public Arc {
-      public:
-        /// Default constructor
-
-        /// Default constructor.
-        /// \warning It sets the iterator to an undefined value.
-        InArcIt() { }
-        /// Copy constructor.
-
-        /// Copy constructor.
-        ///
-        InArcIt(const InArcIt& e) : Arc(e) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the iterator to be invalid.
-        /// \sa Invalid for more details.
-        InArcIt(Invalid) { }
-        /// Sets the iterator to the first incoming arc.
-
-        /// Sets the iterator to the first incoming arc of the given node.
-        ///
-        InArcIt(const BpGraph& g, const Node& n) {
-          ::lemon::ignore_unused_variable_warning(n);
-          ::lemon::ignore_unused_variable_warning(g);
-        }
-        /// Sets the iterator to the given arc.
-
-        /// Sets the iterator to the given arc of the given graph.
-        ///
-        InArcIt(const BpGraph&, const Arc&) { }
-        /// Next incoming arc
-
-        /// Assign the iterator to the next
-        /// incoming arc of the corresponding node.
-        InArcIt& operator++() { return *this; }
-      };
-
-      /// \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.
-      ///
-      /// Standard graph map type for the nodes.
-      /// It conforms to the ReferenceMap concept.
-      template<class T>
-      class NodeMap : public ReferenceMap<Node, T, T&, const T&>
-      {
-      public:
-
-        /// Constructor
-        explicit NodeMap(const BpGraph&) { }
-        /// Constructor with given initial value
-        NodeMap(const BpGraph&, T) { }
-
-      private:
-        ///Copy constructor
-        NodeMap(const NodeMap& nm) :
-          ReferenceMap<Node, T, T&, const T&>(nm) { }
-        ///Assignment operator
-        template <typename CMap>
-        NodeMap& operator=(const CMap&) {
-          checkConcept<ReadMap<Node, T>, CMap>();
-          return *this;
-        }
-      };
-
-      /// \brief Standard graph map type for the red nodes.
-      ///
-      /// Standard graph map type for the red nodes.
-      /// It conforms to the ReferenceMap concept.
-      template<class T>
-      class RedNodeMap : public ReferenceMap<Node, T, T&, const T&>
-      {
-      public:
-
-        /// Constructor
-        explicit RedNodeMap(const BpGraph&) { }
-        /// Constructor with given initial value
-        RedNodeMap(const BpGraph&, T) { }
-
-      private:
-        ///Copy constructor
-        RedNodeMap(const RedNodeMap& nm) :
-          ReferenceMap<Node, T, T&, const T&>(nm) { }
-        ///Assignment operator
-        template <typename CMap>
-        RedNodeMap& operator=(const CMap&) {
-          checkConcept<ReadMap<Node, T>, CMap>();
-          return *this;
-        }
-      };
-
-      /// \brief Standard graph map type for the blue nodes.
-      ///
-      /// Standard graph map type for the blue nodes.
-      /// It conforms to the ReferenceMap concept.
-      template<class T>
-      class BlueNodeMap : public ReferenceMap<Node, T, T&, const T&>
-      {
-      public:
-
-        /// Constructor
-        explicit BlueNodeMap(const BpGraph&) { }
-        /// Constructor with given initial value
-        BlueNodeMap(const BpGraph&, T) { }
-
-      private:
-        ///Copy constructor
-        BlueNodeMap(const BlueNodeMap& nm) :
-          ReferenceMap<Node, T, T&, const T&>(nm) { }
-        ///Assignment operator
-        template <typename CMap>
-        BlueNodeMap& operator=(const CMap&) {
-          checkConcept<ReadMap<Node, T>, CMap>();
-          return *this;
-        }
-      };
-
-      /// \brief Standard graph map type for the arcs.
-      ///
-      /// Standard graph map type for the arcs.
-      /// It conforms to the ReferenceMap concept.
-      template<class T>
-      class ArcMap : public ReferenceMap<Arc, T, T&, const T&>
-      {
-      public:
-
-        /// Constructor
-        explicit ArcMap(const BpGraph&) { }
-        /// Constructor with given initial value
-        ArcMap(const BpGraph&, T) { }
-
-      private:
-        ///Copy constructor
-        ArcMap(const ArcMap& em) :
-          ReferenceMap<Arc, T, T&, const T&>(em) { }
-        ///Assignment operator
-        template <typename CMap>
-        ArcMap& operator=(const CMap&) {
-          checkConcept<ReadMap<Arc, T>, CMap>();
-          return *this;
-        }
-      };
-
-      /// \brief Standard graph map type for the edges.
-      ///
-      /// Standard graph map type for the edges.
-      /// It conforms to the ReferenceMap concept.
-      template<class T>
-      class EdgeMap : public ReferenceMap<Edge, T, T&, const T&>
-      {
-      public:
-
-        /// Constructor
-        explicit EdgeMap(const BpGraph&) { }
-        /// Constructor with given initial value
-        EdgeMap(const BpGraph&, T) { }
-
-      private:
-        ///Copy constructor
-        EdgeMap(const EdgeMap& em) :
-          ReferenceMap<Edge, T, T&, const T&>(em) {}
-        ///Assignment operator
-        template <typename CMap>
-        EdgeMap& operator=(const CMap&) {
-          checkConcept<ReadMap<Edge, T>, CMap>();
-          return *this;
-        }
-      };
-
-      /// \brief Gives back %true for red nodes.
-      ///
-      /// Gives back %true for red nodes.
-      bool red(const Node&) const { return true; }
-
-      /// \brief Gives back %true for blue nodes.
-      ///
-      /// Gives back %true for blue nodes.
-      bool blue(const Node&) const { return true; }
-
-      /// \brief Converts the node to red node object.
-      ///
-      /// This function converts unsafely the node to red node
-      /// object. It should be called only if the node is from the red
-      /// partition or INVALID.
-      RedNode asRedNodeUnsafe(const Node&) const { return RedNode(); }
-
-      /// \brief Converts the node to blue node object.
-      ///
-      /// This function converts unsafely the node to blue node
-      /// object. It should be called only if the node is from the red
-      /// partition or INVALID.
-      BlueNode asBlueNodeUnsafe(const Node&) const { return BlueNode(); }
-
-      /// \brief Converts the node to red node object.
-      ///
-      /// This function converts safely the node to red node
-      /// object. If the node is not from the red partition, then it
-      /// returns INVALID.
-      RedNode asRedNode(const Node&) const { return RedNode(); }
-
-      /// \brief Converts the node to blue node object.
-      ///
-      /// This function converts unsafely the node to blue node
-      /// object. If the node is not from the blue partition, then it
-      /// returns INVALID.
-      BlueNode asBlueNode(const Node&) const { return BlueNode(); }
-
-      /// \brief Gives back the red end node of the edge.
-      ///
-      /// Gives back the red end node of the edge.
-      RedNode redNode(const Edge&) const { return RedNode(); }
-
-      /// \brief Gives back the blue end node of the edge.
-      ///
-      /// Gives back the blue end node of the edge.
-      BlueNode blueNode(const Edge&) const { return BlueNode(); }
-
-      /// \brief The first node of the edge.
-      ///
-      /// It is a synonim for the \c redNode().
-      Node u(Edge) const { return INVALID; }
-
-      /// \brief The second node of the edge.
-      ///
-      /// It is a synonim for the \c blueNode().
-      Node v(Edge) const { return INVALID; }
-
-      /// \brief The source node of the arc.
-      ///
-      /// Returns the source node of the given arc.
-      Node source(Arc) const { return INVALID; }
-
-      /// \brief The target node of the arc.
-      ///
-      /// Returns the target node of the given arc.
-      Node target(Arc) const { return INVALID; }
-
-      /// \brief The ID of the node.
-      ///
-      /// Returns the ID of the given node.
-      int id(Node) const { return -1; }
-
-      /// \brief The red ID of the node.
-      ///
-      /// Returns the red ID of the given node.
-      int id(RedNode) const { return -1; }
-
-      /// \brief The blue ID of the node.
-      ///
-      /// Returns the blue ID of the given node.
-      int id(BlueNode) const { return -1; }
-
-      /// \brief The ID of the edge.
-      ///
-      /// Returns the ID of the given edge.
-      int id(Edge) const { return -1; }
-
-      /// \brief The ID of the arc.
-      ///
-      /// Returns the ID of the given arc.
-      int id(Arc) const { return -1; }
-
-      /// \brief The node with the given ID.
-      ///
-      /// Returns the node with the given ID.
-      /// \pre The argument should be a valid node ID in the graph.
-      Node nodeFromId(int) const { return INVALID; }
-
-      /// \brief The edge with the given ID.
-      ///
-      /// Returns the edge with the given ID.
-      /// \pre The argument should be a valid edge ID in the graph.
-      Edge edgeFromId(int) const { return INVALID; }
-
-      /// \brief The arc with the given ID.
-      ///
-      /// Returns the arc with the given ID.
-      /// \pre The argument should be a valid arc ID in the graph.
-      Arc arcFromId(int) const { return INVALID; }
-
-      /// \brief An upper bound on the node IDs.
-      ///
-      /// Returns an upper bound on the node IDs.
-      int maxNodeId() const { return -1; }
-
-      /// \brief An upper bound on the red IDs.
-      ///
-      /// Returns an upper bound on the red IDs.
-      int maxRedId() const { return -1; }
-
-      /// \brief An upper bound on the blue IDs.
-      ///
-      /// Returns an upper bound on the blue IDs.
-      int maxBlueId() const { return -1; }
-
-      /// \brief An upper bound on the edge IDs.
-      ///
-      /// Returns an upper bound on the edge IDs.
-      int maxEdgeId() const { return -1; }
-
-      /// \brief An upper bound on the arc IDs.
-      ///
-      /// Returns an upper bound on the arc IDs.
-      int maxArcId() const { return -1; }
-
-      /// \brief The direction of the arc.
-      ///
-      /// Returns \c true if the given arc goes from a red node to a blue node.
-      bool direction(Arc) const { return true; }
-
-      /// \brief Direct the edge.
-      ///
-      /// Direct the given edge. The returned arc
-      /// represents the given edge and its direction comes
-      /// from the bool parameter. If it is \c true, then the source of the node
-      /// will be a red node.
-      Arc direct(Edge, bool) const {
-        return INVALID;
-      }
-
-      /// \brief Direct the edge.
-      ///
-      /// Direct the given edge. The returned arc represents the given
-      /// edge and its source node is the given node.
-      Arc direct(Edge, Node) const {
-        return INVALID;
-      }
-
-      /// \brief The oppositely directed arc.
-      ///
-      /// Returns the oppositely directed arc representing the same edge.
-      Arc oppositeArc(Arc) const { return INVALID; }
-
-      /// \brief The opposite node on the edge.
-      ///
-      /// Returns the opposite node on the given edge.
-      Node oppositeNode(Node, Edge) const { return INVALID; }
-
-      void first(Node&) const {}
-      void next(Node&) const {}
-
-      void firstRed(RedNode&) const {}
-      void nextRed(RedNode&) const {}
-
-      void firstBlue(BlueNode&) const {}
-      void nextBlue(BlueNode&) const {}
-
-      void first(Edge&) const {}
-      void next(Edge&) const {}
-
-      void first(Arc&) const {}
-      void next(Arc&) const {}
-
-      void firstOut(Arc&, Node) const {}
-      void nextOut(Arc&) const {}
-
-      void firstIn(Arc&, Node) const {}
-      void nextIn(Arc&) const {}
-
-      void firstInc(Edge &, bool &, const Node &) const {}
-      void nextInc(Edge &, bool &) const {}
-
-      // The second parameter is dummy.
-      Node fromId(int, Node) const { return INVALID; }
-      // The second parameter is dummy.
-      Edge fromId(int, Edge) const { return INVALID; }
-      // The second parameter is dummy.
-      Arc fromId(int, Arc) const { return INVALID; }
-
-      // Dummy parameter.
-      int maxId(Node) const { return -1; }
-      // Dummy parameter.
-      int maxId(RedNode) const { return -1; }
-      // Dummy parameter.
-      int maxId(BlueNode) const { return -1; }
-      // Dummy parameter.
-      int maxId(Edge) const { return -1; }
-      // Dummy parameter.
-      int maxId(Arc) const { return -1; }
-
-      /// \brief The base node of the iterator.
-      ///
-      /// Returns the base node of the given incident edge iterator.
-      Node baseNode(IncEdgeIt) const { return INVALID; }
-
-      /// \brief The running node of the iterator.
-      ///
-      /// Returns the running node of the given incident edge iterator.
-      Node runningNode(IncEdgeIt) const { return INVALID; }
-
-      /// \brief The base node of the iterator.
-      ///
-      /// Returns the base node of the given outgoing arc iterator
-      /// (i.e. the source node of the corresponding arc).
-      Node baseNode(OutArcIt) const { return INVALID; }
-
-      /// \brief The running node of the iterator.
-      ///
-      /// Returns the running node of the given outgoing arc iterator
-      /// (i.e. the target node of the corresponding arc).
-      Node runningNode(OutArcIt) const { return INVALID; }
-
-      /// \brief The base node of the iterator.
-      ///
-      /// Returns the base node of the given incoming arc iterator
-      /// (i.e. the target node of the corresponding arc).
-      Node baseNode(InArcIt) const { return INVALID; }
-
-      /// \brief The running node of the iterator.
-      ///
-      /// Returns the running node of the given incoming arc iterator
-      /// (i.e. the source node of the corresponding arc).
-      Node runningNode(InArcIt) const { return INVALID; }
-
-      template <typename _BpGraph>
-      struct Constraints {
-        void constraints() {
-          checkConcept<BaseBpGraphComponent, _BpGraph>();
-          checkConcept<IterableBpGraphComponent<>, _BpGraph>();
-          checkConcept<IDableBpGraphComponent<>, _BpGraph>();
-          checkConcept<MappableBpGraphComponent<>, _BpGraph>();
-        }
-      };
-
-    };
-
-  }
-
-}
-
-#endif
Index: lemon/concepts/digraph.h
===================================================================
--- lemon/concepts/digraph.h	(revision 1336)
+++ lemon/concepts/digraph.h	(revision 833)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -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) { 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.
@@ -495,5 +410,5 @@
       /// \brief The base node of the iterator.
       ///
-      /// Returns the base node of the given incoming arc iterator
+      /// Returns the base node of the given incomming arc iterator
       /// (i.e. the target node of the corresponding arc).
       Node baseNode(InArcIt) const { return INVALID; }
@@ -501,5 +416,5 @@
       /// \brief The running node of the iterator.
       ///
-      /// Returns the running node of the given incoming arc iterator
+      /// Returns the running node of the given incomming arc iterator
       /// (i.e. the source node of the corresponding arc).
       Node runningNode(InArcIt) const { return INVALID; }
@@ -520,5 +435,5 @@
       private:
         ///Copy constructor
-        NodeMap(const NodeMap& nm) :
+        NodeMap(const NodeMap& nm) : 
           ReferenceMap<Node, T, T&, const T&>(nm) { }
         ///Assignment operator
Index: lemon/concepts/graph.h
===================================================================
--- lemon/concepts/graph.h	(revision 1336)
+++ lemon/concepts/graph.h	(revision 833)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -28,5 +28,4 @@
 #include <lemon/concept_check.h>
 #include <lemon/core.h>
-#include <lemon/bits/stl_iterators.h>
 
 namespace lemon {
@@ -45,5 +44,5 @@
     /// run properly, of course.
     /// An actual graph implementation like \ref ListGraph or
-    /// \ref SmartGraph may have additional functionality.
+    /// \ref SmartGraph may have additional functionality.    
     ///
     /// The undirected graphs also fulfill the concept of \ref Digraph
@@ -74,8 +73,8 @@
     class Graph {
     private:
-      /// Graphs are \e not copy constructible. Use GraphCopy instead.
+      /// Graphs are \e not copy constructible. Use DigraphCopy instead.
       Graph(const Graph&) {}
       /// \brief Assignment of a graph to another one is \e not allowed.
-      /// Use GraphCopy instead.
+      /// Use DigraphCopy instead.
       void operator=(const Graph&) {}
 
@@ -87,5 +86,5 @@
       ///
       /// Undirected graphs should be tagged with \c UndirectedTag.
-      ///
+      /// 
       /// This tag helps the \c enable_if technics to make compile time
       /// specializations for undirected graphs.
@@ -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.
 
@@ -358,26 +317,4 @@
       };
 
-      /// \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
 
@@ -424,5 +361,5 @@
 
         /// Converison to \c Edge
-
+        
         /// Converison to \c Edge.
         ///
@@ -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) { 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.
@@ -529,6 +443,6 @@
         ///
         OutArcIt(const Graph& n, const Node& g) {
-          ::lemon::ignore_unused_variable_warning(n);
-          ::lemon::ignore_unused_variable_warning(g);
+          ignore_unused_variable_warning(n);
+          ignore_unused_variable_warning(g);
         }
         /// Sets the iterator to the given arc.
@@ -543,25 +457,4 @@
         OutArcIt& operator++() { return *this; }
       };
-
-      /// \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.
@@ -598,6 +491,6 @@
         ///
         InArcIt(const Graph& g, const Node& n) {
-          ::lemon::ignore_unused_variable_warning(n);
-          ::lemon::ignore_unused_variable_warning(g);
+          ignore_unused_variable_warning(n);
+          ignore_unused_variable_warning(g);
         }
         /// Sets the iterator to the given arc.
@@ -612,24 +505,4 @@
         InArcIt& operator++() { return *this; }
       };
-
-      /// \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.
@@ -885,5 +758,5 @@
       /// \brief The base node of the iterator.
       ///
-      /// Returns the base node of the given incoming arc iterator
+      /// Returns the base node of the given incomming arc iterator
       /// (i.e. the target node of the corresponding arc).
       Node baseNode(InArcIt) const { return INVALID; }
@@ -891,5 +764,5 @@
       /// \brief The running node of the iterator.
       ///
-      /// Returns the running node of the given incoming arc iterator
+      /// Returns the running node of the given incomming arc iterator
       /// (i.e. the source node of the corresponding arc).
       Node runningNode(InArcIt) const { return INVALID; }
Index: lemon/concepts/graph_components.h
===================================================================
--- lemon/concepts/graph_components.h	(revision 1270)
+++ lemon/concepts/graph_components.h	(revision 833)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -39,5 +39,5 @@
     /// \note This class is a template class so that we can use it to
     /// create graph skeleton classes. The reason for this is that \c Node
-    /// and \c Arc (or \c Edge) types should \e not derive from the same
+    /// and \c Arc (or \c Edge) types should \e not derive from the same 
     /// base class. For \c Node you should instantiate it with character
     /// \c 'n', for \c Arc with \c 'a' and for \c Edge with \c 'e'.
@@ -90,5 +90,5 @@
       ///
       /// This operator defines an ordering of the items.
-      /// It makes possible to use graph item types as key types in
+      /// It makes possible to use graph item types as key types in 
       /// associative containers (e.g. \c std::map).
       ///
@@ -109,6 +109,4 @@
 
           bool b;
-          ::lemon::ignore_unused_variable_warning(b);
-
           b = (ia == ib) && (ia != ib);
           b = (ia == INVALID) && (ib != INVALID);
@@ -118,5 +116,4 @@
         const _GraphItem &ia;
         const _GraphItem &ib;
-        Constraints() {}
       };
     };
@@ -126,5 +123,5 @@
     /// This class describes the base interface of directed graph types.
     /// All digraph %concepts have to conform to this class.
-    /// It just provides types for nodes and arcs and functions
+    /// It just provides types for nodes and arcs and functions 
     /// to get the source and the target nodes of arcs.
     class BaseDigraphComponent {
@@ -178,5 +175,4 @@
 
         const _Digraph& digraph;
-        Constraints() {}
       };
     };
@@ -290,176 +286,9 @@
             ue = e;
             bool d = graph.direction(e);
-            ::lemon::ignore_unused_variable_warning(d);
+            ignore_unused_variable_warning(d);
           }
         }
 
         const _Graph& graph;
-      Constraints() {}
-      };
-
-    };
-
-    /// \brief Base skeleton class for undirected bipartite graphs.
-    ///
-    /// This class describes the base interface of undirected
-    /// bipartite graph types.  All bipartite graph %concepts have to
-    /// conform to this class.  It extends the interface of \ref
-    /// BaseGraphComponent with an \c Edge type and functions to get
-    /// the end nodes of edges, to convert from arcs to edges and to
-    /// get both direction of edges.
-    class BaseBpGraphComponent : public BaseGraphComponent {
-    public:
-
-      typedef BaseBpGraphComponent BpGraph;
-
-      typedef BaseDigraphComponent::Node Node;
-      typedef BaseDigraphComponent::Arc Arc;
-
-      /// \brief Class to represent red nodes.
-      ///
-      /// This class represents the red nodes of the graph. The red
-      /// nodes can also be used as normal nodes.
-      class RedNode : public Node {
-        typedef Node Parent;
-
-      public:
-        /// \brief Default constructor.
-        ///
-        /// Default constructor.
-        /// \warning The default constructor is not required to set
-        /// the item to some well-defined value. So you should consider it
-        /// as uninitialized.
-        RedNode() {}
-
-        /// \brief Copy constructor.
-        ///
-        /// Copy constructor.
-        RedNode(const RedNode &) : Parent() {}
-
-        /// \brief Constructor for conversion from \c INVALID.
-        ///
-        /// Constructor for conversion from \c INVALID.
-        /// It initializes the item to be invalid.
-        /// \sa Invalid for more details.
-        RedNode(Invalid) {}
-      };
-
-      /// \brief Class to represent blue nodes.
-      ///
-      /// This class represents the blue nodes of the graph. The blue
-      /// nodes can also be used as normal nodes.
-      class BlueNode : public Node {
-        typedef Node Parent;
-
-      public:
-        /// \brief Default constructor.
-        ///
-        /// Default constructor.
-        /// \warning The default constructor is not required to set
-        /// the item to some well-defined value. So you should consider it
-        /// as uninitialized.
-        BlueNode() {}
-
-        /// \brief Copy constructor.
-        ///
-        /// Copy constructor.
-        BlueNode(const BlueNode &) : Parent() {}
-
-        /// \brief Constructor for conversion from \c INVALID.
-        ///
-        /// Constructor for conversion from \c INVALID.
-        /// It initializes the item to be invalid.
-        /// \sa Invalid for more details.
-        BlueNode(Invalid) {}
-
-        /// \brief Constructor for conversion from a node.
-        ///
-        /// Constructor for conversion from a node. The conversion can
-        /// be invalid, since the Node can be member of the red
-        /// set.
-        BlueNode(const Node&) {}
-      };
-
-      /// \brief Gives back %true for red nodes.
-      ///
-      /// Gives back %true for red nodes.
-      bool red(const Node&) const { return true; }
-
-      /// \brief Gives back %true for blue nodes.
-      ///
-      /// Gives back %true for blue nodes.
-      bool blue(const Node&) const { return true; }
-
-      /// \brief Gives back the red end node of the edge.
-      ///
-      /// Gives back the red end node of the edge.
-      RedNode redNode(const Edge&) const { return RedNode(); }
-
-      /// \brief Gives back the blue end node of the edge.
-      ///
-      /// Gives back the blue end node of the edge.
-      BlueNode blueNode(const Edge&) const { return BlueNode(); }
-
-      /// \brief Converts the node to red node object.
-      ///
-      /// This function converts unsafely the node to red node
-      /// object. It should be called only if the node is from the red
-      /// partition or INVALID.
-      RedNode asRedNodeUnsafe(const Node&) const { return RedNode(); }
-
-      /// \brief Converts the node to blue node object.
-      ///
-      /// This function converts unsafely the node to blue node
-      /// object. It should be called only if the node is from the red
-      /// partition or INVALID.
-      BlueNode asBlueNodeUnsafe(const Node&) const { return BlueNode(); }
-
-      /// \brief Converts the node to red node object.
-      ///
-      /// This function converts safely the node to red node
-      /// object. If the node is not from the red partition, then it
-      /// returns INVALID.
-      RedNode asRedNode(const Node&) const { return RedNode(); }
-
-      /// \brief Converts the node to blue node object.
-      ///
-      /// This function converts unsafely the node to blue node
-      /// object. If the node is not from the blue partition, then it
-      /// returns INVALID.
-      BlueNode asBlueNode(const Node&) const { return BlueNode(); }
-
-      template <typename _BpGraph>
-      struct Constraints {
-        typedef typename _BpGraph::Node Node;
-        typedef typename _BpGraph::RedNode RedNode;
-        typedef typename _BpGraph::BlueNode BlueNode;
-        typedef typename _BpGraph::Arc Arc;
-        typedef typename _BpGraph::Edge Edge;
-
-        void constraints() {
-          checkConcept<BaseGraphComponent, _BpGraph>();
-          checkConcept<GraphItem<'n'>, RedNode>();
-          checkConcept<GraphItem<'n'>, BlueNode>();
-          {
-            Node n;
-            RedNode rn;
-            BlueNode bn;
-            Node rnan = rn;
-            Node bnan = bn;
-            Edge e;
-            bool b;
-            b = bpgraph.red(rnan);
-            b = bpgraph.blue(bnan);
-            rn = bpgraph.redNode(e);
-            bn = bpgraph.blueNode(e);
-            rn = bpgraph.asRedNodeUnsafe(rnan);
-            bn = bpgraph.asBlueNodeUnsafe(bnan);
-            rn = bpgraph.asRedNode(rnan);
-            bn = bpgraph.asBlueNode(bnan);
-            ::lemon::ignore_unused_variable_warning(b);
-          }
-        }
-
-        const _BpGraph& bpgraph;
       };
 
@@ -535,11 +364,10 @@
 
           nid = digraph.maxNodeId();
-          ::lemon::ignore_unused_variable_warning(nid);
+          ignore_unused_variable_warning(nid);
           eid = digraph.maxArcId();
-          ::lemon::ignore_unused_variable_warning(eid);
+          ignore_unused_variable_warning(eid);
         }
 
         const _Digraph& digraph;
-        Constraints() {}
       };
     };
@@ -590,73 +418,8 @@
           edge = graph.edgeFromId(ueid);
           ueid = graph.maxEdgeId();
-          ::lemon::ignore_unused_variable_warning(ueid);
+          ignore_unused_variable_warning(ueid);
         }
 
         const _Graph& graph;
-        Constraints() {}
-      };
-    };
-
-    /// \brief Skeleton class for \e idable undirected bipartite graphs.
-    ///
-    /// This class describes the interface of \e idable undirected
-    /// bipartite graphs. It extends \ref IDableGraphComponent with
-    /// the core ID functions of undirected bipartite graphs. Beside
-    /// the regular node ids, this class also provides ids within the
-    /// the red and blue sets of the nodes. This concept is part of
-    /// the BpGraph concept.
-    template <typename BAS = BaseBpGraphComponent>
-    class IDableBpGraphComponent : public IDableGraphComponent<BAS> {
-    public:
-
-      typedef BAS Base;
-      typedef IDableGraphComponent<BAS> Parent;
-      typedef typename Base::Node Node;
-      typedef typename Base::RedNode RedNode;
-      typedef typename Base::BlueNode BlueNode;
-
-      using Parent::id;
-
-      /// \brief Return a unique integer id for the given node in the red set.
-      ///
-      /// Return a unique integer id for the given node in the red set.
-      int id(const RedNode&) const { return -1; }
-
-      /// \brief Return a unique integer id for the given node in the blue set.
-      ///
-      /// Return a unique integer id for the given node in the blue set.
-      int id(const BlueNode&) const { return -1; }
-
-      /// \brief Return an integer greater or equal to the maximum
-      /// node id in the red set.
-      ///
-      /// Return an integer greater or equal to the maximum
-      /// node id in the red set.
-      int maxRedId() const { return -1; }
-
-      /// \brief Return an integer greater or equal to the maximum
-      /// node id in the blue set.
-      ///
-      /// Return an integer greater or equal to the maximum
-      /// node id in the blue set.
-      int maxBlueId() const { return -1; }
-
-      template <typename _BpGraph>
-      struct Constraints {
-
-        void constraints() {
-          checkConcept<IDableGraphComponent<Base>, _BpGraph>();
-          typename _BpGraph::Node node;
-          typename _BpGraph::RedNode red;
-          typename _BpGraph::BlueNode blue;
-          int rid = bpgraph.id(red);
-          int bid = bpgraph.id(blue);
-          rid = bpgraph.maxRedId();
-          bid = bpgraph.maxBlueId();
-          ::lemon::ignore_unused_variable_warning(rid);
-          ::lemon::ignore_unused_variable_warning(bid);
-        }
-
-        const _BpGraph& bpgraph;
       };
     };
@@ -664,5 +427,5 @@
     /// \brief Concept class for \c NodeIt, \c ArcIt and \c EdgeIt types.
     ///
-    /// This class describes the concept of \c NodeIt, \c ArcIt and
+    /// This class describes the concept of \c NodeIt, \c ArcIt and 
     /// \c EdgeIt subtypes of digraph and graph types.
     template <typename GR, typename Item>
@@ -704,5 +467,5 @@
       /// next item.
       GraphItemIt& operator++() { return *this; }
-
+ 
       /// \brief Equality operator
       ///
@@ -727,6 +490,4 @@
           _GraphItemIt it3 = it1;
           _GraphItemIt it4 = INVALID;
-          ::lemon::ignore_unused_variable_warning(it3);
-          ::lemon::ignore_unused_variable_warning(it4);
 
           it2 = ++it1;
@@ -738,17 +499,16 @@
         }
         const GR& g;
-        Constraints() {}
-      };
-    };
-
-    /// \brief Concept class for \c InArcIt, \c OutArcIt and
+      };
+    };
+
+    /// \brief Concept class for \c InArcIt, \c OutArcIt and 
     /// \c IncEdgeIt types.
     ///
-    /// This class describes the concept of \c InArcIt, \c OutArcIt
+    /// This class describes the concept of \c InArcIt, \c OutArcIt 
     /// and \c IncEdgeIt subtypes of digraph and graph types.
     ///
     /// \note Since these iterator classes do not inherit from the same
     /// base class, there is an additional template parameter (selector)
-    /// \c sel. For \c InArcIt you should instantiate it with character
+    /// \c sel. For \c InArcIt you should instantiate it with character 
     /// \c 'i', for \c OutArcIt with \c 'o' and for \c IncEdgeIt with \c 'e'.
     template <typename GR,
@@ -771,8 +531,8 @@
       GraphIncIt(const GraphIncIt& it) : Item(it) {}
 
-      /// \brief Constructor that sets the iterator to the first
+      /// \brief Constructor that sets the iterator to the first 
       /// incoming or outgoing arc.
       ///
-      /// Constructor that sets the iterator to the first arc
+      /// Constructor that sets the iterator to the first arc 
       /// incoming to or outgoing from the given node.
       explicit GraphIncIt(const GR&, const Base&) {}
@@ -818,6 +578,4 @@
           _GraphIncIt it3 = it1;
           _GraphIncIt it4 = INVALID;
-          ::lemon::ignore_unused_variable_warning(it3);
-          ::lemon::ignore_unused_variable_warning(it4);
 
           it2 = ++it1;
@@ -829,5 +587,4 @@
         const Base& node;
         const GR& graph;
-        Constraints() {}
       };
     };
@@ -876,13 +633,13 @@
       void next(Arc&) const {}
 
-      /// \brief Return the first arc incoming to the given node.
-      ///
-      /// This function gives back the first arc incoming to the
+      /// \brief Return the first arc incomming to the given node.
+      ///
+      /// This function gives back the first arc incomming to the
       /// given node.
       void firstIn(Arc&, const Node&) const {}
 
-      /// \brief Return the next arc incoming to the given node.
-      ///
-      /// This function gives back the next arc incoming to the
+      /// \brief Return the next arc incomming to the given node.
+      ///
+      /// This function gives back the next arc incomming to the
       /// given node.
       void nextIn(Arc&) const {}
@@ -1001,10 +758,9 @@
             n = digraph.baseNode(oait);
             n = digraph.runningNode(oait);
-            ::lemon::ignore_unused_variable_warning(n);
+            ignore_unused_variable_warning(n);
           }
         }
 
         const _Digraph& digraph;
-        Constraints() {}
       };
     };
@@ -1049,7 +805,7 @@
       /// \brief Return the first edge incident to the given node.
       ///
-      /// This function gives back the first edge incident to the given
+      /// This function gives back the first edge incident to the given 
       /// node. The bool parameter gives back the direction for which the
-      /// source node of the directed arc representing the edge is the
+      /// source node of the directed arc representing the edge is the 
       /// given node.
       void firstInc(Edge&, bool&, const Node&) const {}
@@ -1058,5 +814,5 @@
       /// given node.
       ///
-      /// This function gives back the next edge incident to the given
+      /// This function gives back the next edge incident to the given 
       /// node. The bool parameter should be used as \c firstInc() use it.
       void nextInc(Edge&, bool&) const {}
@@ -1131,96 +887,4 @@
 
         const _Graph& graph;
-        Constraints() {}
-      };
-    };
-
-    /// \brief Skeleton class for iterable undirected bipartite graphs.
-    ///
-    /// This class describes the interface of iterable undirected
-    /// bipartite graphs. It extends \ref IterableGraphComponent with
-    /// the core iterable interface of undirected bipartite graphs.
-    /// This concept is part of the BpGraph concept.
-    template <typename BAS = BaseBpGraphComponent>
-    class IterableBpGraphComponent : public IterableGraphComponent<BAS> {
-    public:
-
-      typedef BAS Base;
-      typedef typename Base::Node Node;
-      typedef typename Base::RedNode RedNode;
-      typedef typename Base::BlueNode BlueNode;
-      typedef typename Base::Arc Arc;
-      typedef typename Base::Edge Edge;
-
-      typedef IterableBpGraphComponent BpGraph;
-
-      using IterableGraphComponent<BAS>::first;
-      using IterableGraphComponent<BAS>::next;
-
-      /// \name Base Iteration
-      ///
-      /// This interface provides functions for iteration on red and blue nodes.
-      ///
-      /// @{
-
-      /// \brief Return the first red node.
-      ///
-      /// This function gives back the first red node in the iteration order.
-      void first(RedNode&) const {}
-
-      /// \brief Return the next red node.
-      ///
-      /// This function gives back the next red node in the iteration order.
-      void next(RedNode&) const {}
-
-      /// \brief Return the first blue node.
-      ///
-      /// This function gives back the first blue node in the iteration order.
-      void first(BlueNode&) const {}
-
-      /// \brief Return the next blue node.
-      ///
-      /// This function gives back the next blue node in the iteration order.
-      void next(BlueNode&) const {}
-
-
-      /// @}
-
-      /// \name Class Based Iteration
-      ///
-      /// This interface provides iterator classes for red and blue nodes.
-      ///
-      /// @{
-
-      /// \brief This iterator goes through each red node.
-      ///
-      /// This iterator goes through each red node.
-      typedef GraphItemIt<BpGraph, RedNode> RedNodeIt;
-
-      /// \brief This iterator goes through each blue node.
-      ///
-      /// This iterator goes through each blue node.
-      typedef GraphItemIt<BpGraph, BlueNode> BlueNodeIt;
-
-      /// @}
-
-      template <typename _BpGraph>
-      struct Constraints {
-        void constraints() {
-          checkConcept<IterableGraphComponent<Base>, _BpGraph>();
-
-          typename _BpGraph::RedNode rn(INVALID);
-          bpgraph.first(rn);
-          bpgraph.next(rn);
-          typename _BpGraph::BlueNode bn(INVALID);
-          bpgraph.first(bn);
-          bpgraph.next(bn);
-
-          checkConcept<GraphItemIt<_BpGraph, typename _BpGraph::RedNode>,
-            typename _BpGraph::RedNodeIt>();
-          checkConcept<GraphItemIt<_BpGraph, typename _BpGraph::BlueNode>,
-            typename _BpGraph::BlueNodeIt>();
-        }
-
-        const _BpGraph& bpgraph;
       };
     };
@@ -1251,12 +915,9 @@
       ArcNotifier;
 
-      mutable NodeNotifier node_notifier;
-      mutable ArcNotifier arc_notifier;
-
       /// \brief Return the node alteration notifier.
       ///
       /// This function gives back the node alteration notifier.
       NodeNotifier& notifier(Node) const {
-        return node_notifier;
+         return NodeNotifier();
       }
 
@@ -1265,5 +926,5 @@
       /// This function gives back the arc alteration notifier.
       ArcNotifier& notifier(Arc) const {
-        return arc_notifier;
+        return ArcNotifier();
       }
 
@@ -1278,10 +939,9 @@
             = digraph.notifier(typename _Digraph::Arc());
 
-          ::lemon::ignore_unused_variable_warning(nn);
-          ::lemon::ignore_unused_variable_warning(en);
+          ignore_unused_variable_warning(nn);
+          ignore_unused_variable_warning(en);
         }
 
         const _Digraph& digraph;
-        Constraints() {}
       };
     };
@@ -1301,5 +961,4 @@
 
       typedef BAS Base;
-      typedef AlterableDigraphComponent<Base> Parent;
       typedef typename Base::Edge Edge;
 
@@ -1309,13 +968,9 @@
       EdgeNotifier;
 
-      mutable EdgeNotifier edge_notifier;
-
-      using Parent::notifier;
-
       /// \brief Return the edge alteration notifier.
       ///
       /// This function gives back the edge alteration notifier.
       EdgeNotifier& notifier(Edge) const {
-        return edge_notifier;
+        return EdgeNotifier();
       }
 
@@ -1326,71 +981,8 @@
           typename _Graph::EdgeNotifier& uen
             = graph.notifier(typename _Graph::Edge());
-          ::lemon::ignore_unused_variable_warning(uen);
+          ignore_unused_variable_warning(uen);
         }
 
         const _Graph& graph;
-        Constraints() {}
-      };
-    };
-
-    /// \brief Skeleton class for alterable undirected bipartite graphs.
-    ///
-    /// This class describes the interface of alterable undirected
-    /// bipartite graphs. It extends \ref AlterableGraphComponent with
-    /// the alteration notifier interface of bipartite graphs. It
-    /// implements an observer-notifier pattern for the red and blue
-    /// nodes. More obsevers can be registered into the notifier and
-    /// whenever an alteration occured in the graph all the observers
-    /// will be notified about it.
-    template <typename BAS = BaseBpGraphComponent>
-    class AlterableBpGraphComponent : public AlterableGraphComponent<BAS> {
-    public:
-
-      typedef BAS Base;
-      typedef AlterableGraphComponent<Base> Parent;
-      typedef typename Base::RedNode RedNode;
-      typedef typename Base::BlueNode BlueNode;
-
-
-      /// Red node alteration notifier class.
-      typedef AlterationNotifier<AlterableBpGraphComponent, RedNode>
-      RedNodeNotifier;
-
-      /// Blue node alteration notifier class.
-      typedef AlterationNotifier<AlterableBpGraphComponent, BlueNode>
-      BlueNodeNotifier;
-
-      mutable RedNodeNotifier red_node_notifier;
-      mutable BlueNodeNotifier blue_node_notifier;
-
-      using Parent::notifier;
-
-      /// \brief Return the red node alteration notifier.
-      ///
-      /// This function gives back the red node alteration notifier.
-      RedNodeNotifier& notifier(RedNode) const {
-        return red_node_notifier;
-      }
-
-      /// \brief Return the blue node alteration notifier.
-      ///
-      /// This function gives back the blue node alteration notifier.
-      BlueNodeNotifier& notifier(BlueNode) const {
-        return blue_node_notifier;
-      }
-
-      template <typename _BpGraph>
-      struct Constraints {
-        void constraints() {
-          checkConcept<AlterableGraphComponent<Base>, _BpGraph>();
-          typename _BpGraph::RedNodeNotifier& rnn
-            = bpgraph.notifier(typename _BpGraph::RedNode());
-          typename _BpGraph::BlueNodeNotifier& bnn
-            = bpgraph.notifier(typename _BpGraph::BlueNode());
-          ::lemon::ignore_unused_variable_warning(rnn);
-          ::lemon::ignore_unused_variable_warning(bnn);
-        }
-
-        const _BpGraph& bpgraph;
       };
     };
@@ -1399,5 +991,5 @@
     ///
     /// This class describes the concept of standard graph maps, i.e.
-    /// the \c NodeMap, \c ArcMap and \c EdgeMap subtypes of digraph and
+    /// the \c NodeMap, \c ArcMap and \c EdgeMap subtypes of digraph and 
     /// graph types, which can be used for associating data to graph items.
     /// The standard graph maps must conform to the ReferenceMap concept.
@@ -1454,5 +1046,5 @@
           _Map m1(g);
           _Map m2(g,t);
-
+          
           // Copy constructor
           // _Map m3(m);
@@ -1462,7 +1054,7 @@
           // m3 = cmap;
 
-          ::lemon::ignore_unused_variable_warning(m1);
-          ::lemon::ignore_unused_variable_warning(m2);
-          // ::lemon::ignore_unused_variable_warning(m3);
+          ignore_unused_variable_warning(m1);
+          ignore_unused_variable_warning(m2);
+          // ignore_unused_variable_warning(m3);
         }
 
@@ -1470,5 +1062,4 @@
         const GR &g;
         const typename GraphMap::Value &t;
-        Constraints() {}
       };
 
@@ -1478,5 +1069,5 @@
     ///
     /// This class describes the interface of mappable directed graphs.
-    /// It extends \ref BaseDigraphComponent with the standard digraph
+    /// It extends \ref BaseDigraphComponent with the standard digraph 
     /// map classes, namely \c NodeMap and \c ArcMap.
     /// This concept is part of the Digraph concept.
@@ -1609,5 +1200,4 @@
 
         const _Digraph& digraph;
-        Constraints() {}
       };
     };
@@ -1616,5 +1206,5 @@
     ///
     /// This class describes the interface of mappable undirected graphs.
-    /// It extends \ref MappableDigraphComponent with the standard graph
+    /// It extends \ref MappableDigraphComponent with the standard graph 
     /// map class for edges (\c EdgeMap).
     /// This concept is part of the Graph concept.
@@ -1695,149 +1285,4 @@
 
         const _Graph& graph;
-        Constraints() {}
-      };
-    };
-
-    /// \brief Skeleton class for mappable undirected bipartite graphs.
-    ///
-    /// This class describes the interface of mappable undirected
-    /// bipartite graphs.  It extends \ref MappableGraphComponent with
-    /// the standard graph map class for red and blue nodes (\c
-    /// RedNodeMap and BlueNodeMap). This concept is part of the
-    /// BpGraph concept.
-    template <typename BAS = BaseBpGraphComponent>
-    class MappableBpGraphComponent : public MappableGraphComponent<BAS>  {
-    public:
-
-      typedef BAS Base;
-      typedef typename Base::Node Node;
-
-      typedef MappableBpGraphComponent BpGraph;
-
-      /// \brief Standard graph map for the red nodes.
-      ///
-      /// Standard graph map for the red nodes.
-      /// It conforms to the ReferenceMap concept.
-      template <typename V>
-      class RedNodeMap : public GraphMap<MappableBpGraphComponent, Node, V> {
-        typedef GraphMap<MappableBpGraphComponent, Node, V> Parent;
-
-      public:
-        /// \brief Construct a new map.
-        ///
-        /// Construct a new map for the graph.
-        explicit RedNodeMap(const MappableBpGraphComponent& graph)
-          : Parent(graph) {}
-
-        /// \brief Construct a new map with default value.
-        ///
-        /// Construct a new map for the graph and initalize the values.
-        RedNodeMap(const MappableBpGraphComponent& graph, const V& value)
-          : Parent(graph, value) {}
-
-      private:
-        /// \brief Copy constructor.
-        ///
-        /// Copy Constructor.
-        RedNodeMap(const RedNodeMap& nm) : Parent(nm) {}
-
-        /// \brief Assignment operator.
-        ///
-        /// Assignment operator.
-        template <typename CMap>
-        RedNodeMap& operator=(const CMap&) {
-          checkConcept<ReadMap<Node, V>, CMap>();
-          return *this;
-        }
-
-      };
-
-      /// \brief Standard graph map for the blue nodes.
-      ///
-      /// Standard graph map for the blue nodes.
-      /// It conforms to the ReferenceMap concept.
-      template <typename V>
-      class BlueNodeMap : public GraphMap<MappableBpGraphComponent, Node, V> {
-        typedef GraphMap<MappableBpGraphComponent, Node, V> Parent;
-
-      public:
-        /// \brief Construct a new map.
-        ///
-        /// Construct a new map for the graph.
-        explicit BlueNodeMap(const MappableBpGraphComponent& graph)
-          : Parent(graph) {}
-
-        /// \brief Construct a new map with default value.
-        ///
-        /// Construct a new map for the graph and initalize the values.
-        BlueNodeMap(const MappableBpGraphComponent& graph, const V& value)
-          : Parent(graph, value) {}
-
-      private:
-        /// \brief Copy constructor.
-        ///
-        /// Copy Constructor.
-        BlueNodeMap(const BlueNodeMap& nm) : Parent(nm) {}
-
-        /// \brief Assignment operator.
-        ///
-        /// Assignment operator.
-        template <typename CMap>
-        BlueNodeMap& operator=(const CMap&) {
-          checkConcept<ReadMap<Node, V>, CMap>();
-          return *this;
-        }
-
-      };
-
-
-      template <typename _BpGraph>
-      struct Constraints {
-
-        struct Dummy {
-          int value;
-          Dummy() : value(0) {}
-          Dummy(int _v) : value(_v) {}
-        };
-
-        void constraints() {
-          checkConcept<MappableGraphComponent<Base>, _BpGraph>();
-
-          { // int map test
-            typedef typename _BpGraph::template RedNodeMap<int>
-              IntRedNodeMap;
-            checkConcept<GraphMap<_BpGraph, typename _BpGraph::RedNode, int>,
-              IntRedNodeMap >();
-          } { // bool map test
-            typedef typename _BpGraph::template RedNodeMap<bool>
-              BoolRedNodeMap;
-            checkConcept<GraphMap<_BpGraph, typename _BpGraph::RedNode, bool>,
-              BoolRedNodeMap >();
-          } { // Dummy map test
-            typedef typename _BpGraph::template RedNodeMap<Dummy>
-              DummyRedNodeMap;
-            checkConcept<GraphMap<_BpGraph, typename _BpGraph::RedNode, Dummy>,
-              DummyRedNodeMap >();
-          }
-
-          { // int map test
-            typedef typename _BpGraph::template BlueNodeMap<int>
-              IntBlueNodeMap;
-            checkConcept<GraphMap<_BpGraph, typename _BpGraph::BlueNode, int>,
-              IntBlueNodeMap >();
-          } { // bool map test
-            typedef typename _BpGraph::template BlueNodeMap<bool>
-              BoolBlueNodeMap;
-            checkConcept<GraphMap<_BpGraph, typename _BpGraph::BlueNode, bool>,
-              BoolBlueNodeMap >();
-          } { // Dummy map test
-            typedef typename _BpGraph::template BlueNodeMap<Dummy>
-              DummyBlueNodeMap;
-            checkConcept<GraphMap<_BpGraph, typename _BpGraph::BlueNode, Dummy>,
-              DummyBlueNodeMap >();
-          }
-        }
-
-        const _BpGraph& bpgraph;
       };
     };
@@ -1846,5 +1291,5 @@
     ///
     /// This class describes the interface of extendable directed graphs.
-    /// It extends \ref BaseDigraphComponent with functions for adding
+    /// It extends \ref BaseDigraphComponent with functions for adding 
     /// nodes and arcs to the digraph.
     /// This concept requires \ref AlterableDigraphComponent.
@@ -1884,5 +1329,4 @@
 
         _Digraph& digraph;
-        Constraints() {}
       };
     };
@@ -1891,5 +1335,5 @@
     ///
     /// This class describes the interface of extendable undirected graphs.
-    /// It extends \ref BaseGraphComponent with functions for adding
+    /// It extends \ref BaseGraphComponent with functions for adding 
     /// nodes and edges to the graph.
     /// This concept requires \ref AlterableGraphComponent.
@@ -1929,64 +1373,4 @@
 
         _Graph& graph;
-        Constraints() {}
-      };
-    };
-
-    /// \brief Skeleton class for extendable undirected bipartite graphs.
-    ///
-    /// This class describes the interface of extendable undirected
-    /// bipartite graphs. It extends \ref BaseGraphComponent with
-    /// functions for adding nodes and edges to the graph. This
-    /// concept requires \ref AlterableBpGraphComponent.
-    template <typename BAS = BaseBpGraphComponent>
-    class ExtendableBpGraphComponent : public BAS {
-    public:
-
-      typedef BAS Base;
-      typedef typename Base::Node Node;
-      typedef typename Base::RedNode RedNode;
-      typedef typename Base::BlueNode BlueNode;
-      typedef typename Base::Edge Edge;
-
-      /// \brief Add a new red node to the digraph.
-      ///
-      /// This function adds a red new node to the digraph.
-      RedNode addRedNode() {
-        return INVALID;
-      }
-
-      /// \brief Add a new blue node to the digraph.
-      ///
-      /// This function adds a blue new node to the digraph.
-      BlueNode addBlueNode() {
-        return INVALID;
-      }
-
-      /// \brief Add a new edge connecting the given two nodes.
-      ///
-      /// This function adds a new edge connecting the given two nodes
-      /// of the graph. The first node has to be a red node, and the
-      /// second one a blue node.
-      Edge addEdge(const RedNode&, const BlueNode&) {
-        return INVALID;
-      }
-      Edge addEdge(const BlueNode&, const RedNode&) {
-        return INVALID;
-      }
-
-      template <typename _BpGraph>
-      struct Constraints {
-        void constraints() {
-          checkConcept<Base, _BpGraph>();
-          typename _BpGraph::RedNode red_node;
-          typename _BpGraph::BlueNode blue_node;
-          red_node = bpgraph.addRedNode();
-          blue_node = bpgraph.addBlueNode();
-          typename _BpGraph::Edge edge;
-          edge = bpgraph.addEdge(red_node, blue_node);
-          edge = bpgraph.addEdge(blue_node, red_node);
-        }
-
-        _BpGraph& bpgraph;
       };
     };
@@ -1995,5 +1379,5 @@
     ///
     /// This class describes the interface of erasable directed graphs.
-    /// It extends \ref BaseDigraphComponent with functions for removing
+    /// It extends \ref BaseDigraphComponent with functions for removing 
     /// nodes and arcs from the digraph.
     /// This concept requires \ref AlterableDigraphComponent.
@@ -2008,5 +1392,5 @@
       /// \brief Erase a node from the digraph.
       ///
-      /// This function erases the given node from the digraph and all arcs
+      /// This function erases the given node from the digraph and all arcs 
       /// connected to the node.
       void erase(const Node&) {}
@@ -2028,5 +1412,4 @@
 
         _Digraph& digraph;
-        Constraints() {}
       };
     };
@@ -2035,5 +1418,5 @@
     ///
     /// This class describes the interface of erasable undirected graphs.
-    /// It extends \ref BaseGraphComponent with functions for removing
+    /// It extends \ref BaseGraphComponent with functions for removing 
     /// nodes and edges from the graph.
     /// This concept requires \ref AlterableGraphComponent.
@@ -2068,16 +1451,6 @@
 
         _Graph& graph;
-        Constraints() {}
-      };
-    };
-
-    /// \brief Skeleton class for erasable undirected graphs.
-    ///
-    /// This class describes the interface of erasable undirected
-    /// bipartite graphs. It extends \ref BaseBpGraphComponent with
-    /// functions for removing nodes and edges from the graph. This
-    /// concept requires \ref AlterableBpGraphComponent.
-    template <typename BAS = BaseBpGraphComponent>
-    class ErasableBpGraphComponent : public ErasableGraphComponent<BAS> {};
+      };
+    };
 
     /// \brief Skeleton class for clearable directed graphs.
@@ -2106,5 +1479,4 @@
 
         _Digraph& digraph;
-        Constraints() {}
       };
     };
@@ -2117,14 +1489,24 @@
     /// This concept requires \ref AlterableGraphComponent.
     template <typename BAS = BaseGraphComponent>
-    class ClearableGraphComponent : public ClearableDigraphComponent<BAS> {};
-
-    /// \brief Skeleton class for clearable undirected biparite graphs.
-    ///
-    /// This class describes the interface of clearable undirected
-    /// bipartite graphs. It extends \ref BaseBpGraphComponent with a
-    /// function for clearing the graph.  This concept requires \ref
-    /// AlterableBpGraphComponent.
-    template <typename BAS = BaseBpGraphComponent>
-    class ClearableBpGraphComponent : public ClearableGraphComponent<BAS> {};
+    class ClearableGraphComponent : public ClearableDigraphComponent<BAS> {
+    public:
+
+      typedef BAS Base;
+
+      /// \brief Erase all nodes and edges from the graph.
+      ///
+      /// This function erases all nodes and edges from the graph.
+      void clear() {}
+
+      template <typename _Graph>
+      struct Constraints {
+        void constraints() {
+          checkConcept<Base, _Graph>();
+          graph.clear();
+        }
+
+        _Graph& graph;
+      };
+    };
 
   }
Index: lemon/concepts/heap.h
===================================================================
--- lemon/concepts/heap.h	(revision 1270)
+++ lemon/concepts/heap.h	(revision 883)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -93,5 +93,5 @@
 #else
       explicit Heap(ItemIntMap&) {}
-#endif
+#endif      
 
       /// \brief Constructor.
@@ -107,5 +107,5 @@
 #else
       explicit Heap(ItemIntMap&, const CMP&) {}
-#endif
+#endif      
 
       /// \brief The number of items stored in the heap.
@@ -139,5 +139,5 @@
 #else
       void push(const Item&, const Prio&) {}
-#endif
+#endif      
 
       /// \brief Return the item having minimum priority.
@@ -169,5 +169,5 @@
 #else
       void erase(const Item&) {}
-#endif
+#endif      
 
       /// \brief The priority of the given item.
@@ -180,5 +180,5 @@
 #else
       Prio operator[](const Item&) const { return Prio(); }
-#endif
+#endif      
 
       /// \brief Set the priority of an item or insert it, if it is
@@ -195,5 +195,5 @@
 #else
       void set(const Item&, const Prio&) {}
-#endif
+#endif      
 
       /// \brief Decrease the priority of an item to the given value.
@@ -207,5 +207,5 @@
 #else
       void decrease(const Item&, const Prio&) {}
-#endif
+#endif      
 
       /// \brief Increase the priority of an item to the given value.
@@ -219,5 +219,5 @@
 #else
       void increase(const Item&, const Prio&) {}
-#endif
+#endif      
 
       /// \brief Return the state of an item.
@@ -233,5 +233,5 @@
 #else
       State state(const Item&) const { return PRE_HEAP; }
-#endif
+#endif      
 
       /// \brief Set the state of an item in the heap.
@@ -246,5 +246,5 @@
 #else
       void state(const Item&, State) {}
-#endif
+#endif      
 
 
@@ -261,6 +261,6 @@
           item=Item();
           prio=Prio();
-          ::lemon::ignore_unused_variable_warning(item);
-          ::lemon::ignore_unused_variable_warning(prio);
+          ignore_unused_variable_warning(item);
+          ignore_unused_variable_warning(prio);
 
           OwnItem own_item;
@@ -269,17 +269,17 @@
           own_item=Item();
           own_prio=Prio();
-          ::lemon::ignore_unused_variable_warning(own_item);
-          ::lemon::ignore_unused_variable_warning(own_prio);
-          ::lemon::ignore_unused_variable_warning(own_state);
+          ignore_unused_variable_warning(own_item);
+          ignore_unused_variable_warning(own_prio);
+          ignore_unused_variable_warning(own_state);
 
           _Heap heap1(map);
           _Heap heap2 = heap1;
-          ::lemon::ignore_unused_variable_warning(heap1);
-          ::lemon::ignore_unused_variable_warning(heap2);
+          ignore_unused_variable_warning(heap1);
+          ignore_unused_variable_warning(heap2);
 
           int s = heap.size();
-          ::lemon::ignore_unused_variable_warning(s);
+          ignore_unused_variable_warning(s);
           bool e = heap.empty();
-          ::lemon::ignore_unused_variable_warning(e);
+          ignore_unused_variable_warning(e);
 
           prio = heap.prio();
@@ -315,5 +315,4 @@
         _Heap& heap;
         ItemIntMap& map;
-        Constraints() {}
       };
     };
Index: lemon/concepts/maps.h
===================================================================
--- lemon/concepts/maps.h	(revision 1270)
+++ lemon/concepts/maps.h	(revision 765)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -50,5 +50,5 @@
       /// Returns the value associated with the given key.
       Value operator[](const Key &) const {
-        return *(static_cast<Value *>(0)+1);
+        return *static_cast<Value *>(0);
       }
 
@@ -61,13 +61,12 @@
           own_val = m[own_key];
 
-          ::lemon::ignore_unused_variable_warning(key);
-          ::lemon::ignore_unused_variable_warning(val);
-          ::lemon::ignore_unused_variable_warning(own_key);
-          ::lemon::ignore_unused_variable_warning(own_val);
+          ignore_unused_variable_warning(key);
+          ignore_unused_variable_warning(val);
+          ignore_unused_variable_warning(own_key);
+          ignore_unused_variable_warning(own_val);
         }
         const Key& key;
         const typename _ReadMap::Key& own_key;
         const _ReadMap& m;
-        Constraints() {}
       };
 
@@ -101,8 +100,8 @@
           m.set(own_key, own_val);
 
-          ::lemon::ignore_unused_variable_warning(key);
-          ::lemon::ignore_unused_variable_warning(val);
-          ::lemon::ignore_unused_variable_warning(own_key);
-          ::lemon::ignore_unused_variable_warning(own_val);
+          ignore_unused_variable_warning(key);
+          ignore_unused_variable_warning(val);
+          ignore_unused_variable_warning(own_key);
+          ignore_unused_variable_warning(own_val);
         }
         const Key& key;
@@ -111,5 +110,4 @@
         const typename _WriteMap::Value& own_val;
         _WriteMap& m;
-        Constraints() {}
       };
     };
@@ -132,6 +130,5 @@
       /// Returns the value associated with the given key.
       Value operator[](const Key &) const {
-        Value *r = 0;
-        return *r;
+        return *static_cast<Value *>(0);
       }
 
@@ -173,12 +170,10 @@
       /// Returns a reference to the value associated with the given key.
       Reference operator[](const Key &) {
-        Value *r = 0;
-        return *r;
+        return *static_cast<Value *>(0);
       }
 
       /// Returns a const reference to the value associated with the given key.
       ConstReference operator[](const Key &) const {
-        Value *r = 0;
-        return *r;
+        return *static_cast<Value *>(0);
       }
 
@@ -211,5 +206,4 @@
         typename _ReferenceMap::ConstReference own_cref;
         _ReferenceMap& m;
-        Constraints() {}
       };
     };
Index: lemon/concepts/path.h
===================================================================
--- lemon/concepts/path.h	(revision 1336)
+++ lemon/concepts/path.h	(revision 832)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -27,5 +27,4 @@
 #include <lemon/core.h>
 #include <lemon/concept_check.h>
-#include <lemon/bits/stl_iterators.h>
 
 namespace lemon {
@@ -77,5 +76,5 @@
       template <typename CPath>
       Path& operator=(const CPath& cpath) {
-        ::lemon::ignore_unused_variable_warning(cpath);
+        ignore_unused_variable_warning(cpath);
         return *this;
       }
@@ -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 {
@@ -154,10 +136,10 @@
           e = (i < ii);
 
-          ::lemon::ignore_unused_variable_warning(l);
-          ::lemon::ignore_unused_variable_warning(pp);
-          ::lemon::ignore_unused_variable_warning(e);
-          ::lemon::ignore_unused_variable_warning(id);
-          ::lemon::ignore_unused_variable_warning(ii);
-          ::lemon::ignore_unused_variable_warning(ed);
+          ignore_unused_variable_warning(l);
+          ignore_unused_variable_warning(pp);
+          ignore_unused_variable_warning(e);
+          ignore_unused_variable_warning(id);
+          ignore_unused_variable_warning(ii);
+          ignore_unused_variable_warning(ed);
         }
       };
@@ -181,11 +163,10 @@
           e = (i != INVALID);
 
-          ::lemon::ignore_unused_variable_warning(l);
-          ::lemon::ignore_unused_variable_warning(e);
-          ::lemon::ignore_unused_variable_warning(id);
-          ::lemon::ignore_unused_variable_warning(ed);
+          ignore_unused_variable_warning(l);
+          ignore_unused_variable_warning(e);
+          ignore_unused_variable_warning(id);
+          ignore_unused_variable_warning(ed);
         }
         _Path& p;
-        PathDumperConstraints() {}
       };
 
@@ -207,11 +188,10 @@
           e = (i != INVALID);
 
-          ::lemon::ignore_unused_variable_warning(l);
-          ::lemon::ignore_unused_variable_warning(e);
-          ::lemon::ignore_unused_variable_warning(id);
-          ::lemon::ignore_unused_variable_warning(ed);
+          ignore_unused_variable_warning(l);
+          ignore_unused_variable_warning(e);
+          ignore_unused_variable_warning(id);
+          ignore_unused_variable_warning(ed);
         }
         _Path& p;
-        PathDumperConstraints() {}
       };
 
@@ -282,21 +262,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 +292,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.cmake
===================================================================
--- lemon/config.h.cmake	(revision 725)
+++ lemon/config.h.cmake	(revision 725)
@@ -0,0 +1,8 @@
+#define LEMON_VERSION "@PROJECT_VERSION@"
+#cmakedefine LEMON_HAVE_LONG_LONG 1
+#cmakedefine LEMON_HAVE_LP 1
+#cmakedefine LEMON_HAVE_MIP 1
+#cmakedefine LEMON_HAVE_GLPK 1
+#cmakedefine LEMON_HAVE_CPLEX 1
+#cmakedefine LEMON_HAVE_CLP 1
+#cmakedefine LEMON_HAVE_CBC 1
Index: lemon/config.h.in
===================================================================
--- lemon/config.h.in	(revision 1343)
+++ lemon/config.h.in	(revision 725)
@@ -1,31 +1,26 @@
-#ifndef LEMON_CONFIG_H
-#define LEMON_CONFIG_H
+/* The version string */
+#undef LEMON_VERSION
 
-#define LEMON_VERSION "@PROJECT_VERSION@"
-#cmakedefine LEMON_HAVE_LONG_LONG 1
+/* Define to 1 if you have long long */
+#undef LEMON_HAVE_LONG_LONG
 
-#cmakedefine LEMON_CXX11 1
+/* Define to 1 if you have any LP solver. */
+#undef LEMON_HAVE_LP
 
-#cmakedefine LEMON_WIN32 1
+/* Define to 1 if you have any MIP solver. */
+#undef LEMON_HAVE_MIP
 
-#cmakedefine LEMON_HAVE_LP 1
-#cmakedefine LEMON_HAVE_MIP 1
-#cmakedefine LEMON_HAVE_GLPK 1
-#cmakedefine LEMON_HAVE_CPLEX 1
-#cmakedefine LEMON_HAVE_SOPLEX 1
-#cmakedefine LEMON_HAVE_CLP 1
-#cmakedefine LEMON_HAVE_CBC 1
+/* Define to 1 if you have CPLEX. */
+#undef LEMON_HAVE_CPLEX
 
-#define LEMON_CPLEX_ 1
-#define LEMON_CLP_ 2
-#define LEMON_GLPK_ 3
-#define LEMON_SOPLEX_ 4
-#define LEMON_CBC_ 5
+/* Define to 1 if you have GLPK. */
+#undef LEMON_HAVE_GLPK
 
-#cmakedefine LEMON_DEFAULT_LP LEMON_@LEMON_DEFAULT_LP@_
-#cmakedefine LEMON_DEFAULT_MIP LEMON_@LEMON_DEFAULT_MIP@_
+/* Define to 1 if you have SOPLEX */
+#undef LEMON_HAVE_SOPLEX
 
-#cmakedefine LEMON_USE_PTHREAD 1
-#cmakedefine LEMON_USE_WIN32_THREADS 1
+/* Define to 1 if you have CLP */
+#undef LEMON_HAVE_CLP
 
-#endif
+/* Define to 1 if you have CBC */
+#undef LEMON_HAVE_CBC
Index: lemon/connectivity.h
===================================================================
--- lemon/connectivity.h	(revision 1270)
+++ lemon/connectivity.h	(revision 695)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -259,5 +259,5 @@
   /// \return \c true if the digraph is strongly connected.
   /// \note By definition, the empty digraph is strongly connected.
-  ///
+  /// 
   /// \see countStronglyConnectedComponents(), stronglyConnectedComponents()
   /// \see connected()
@@ -311,5 +311,5 @@
   /// \ingroup graph_properties
   ///
-  /// \brief Count the number of strongly connected components of a
+  /// \brief Count the number of strongly connected components of a 
   /// directed graph
   ///
@@ -745,36 +745,13 @@
   /// \brief Check whether an undirected graph is bi-node-connected.
   ///
-  /// This function checks whether the given undirected graph is
-  /// bi-node-connected, i.e. a connected graph without articulation
-  /// node.
+  /// This function checks whether the given undirected graph is 
+  /// bi-node-connected, i.e. any two edges are on same circle.
   ///
   /// \return \c true if the graph bi-node-connected.
-  ///
-  /// \note By definition,
-  /// \li a graph consisting of zero or one node is bi-node-connected,
-  /// \li a graph consisting of two isolated nodes
-  /// is \e not bi-node-connected and
-  /// \li a graph consisting of two nodes connected by an edge
-  /// is bi-node-connected.
+  /// \note By definition, the empty graph is bi-node-connected.
   ///
   /// \see countBiNodeConnectedComponents(), biNodeConnectedComponents()
   template <typename Graph>
   bool biNodeConnected(const Graph& graph) {
-    bool hasNonIsolated = false, hasIsolated = false;
-    for (typename Graph::NodeIt n(graph); n != INVALID; ++n) {
-      if (typename Graph::OutArcIt(graph, n) == INVALID) {
-        if (hasIsolated || hasNonIsolated) {
-          return false;
-        } else {
-          hasIsolated = true;
-        }
-      } else {
-        if (hasIsolated) {
-          return false;
-        } else {
-          hasNonIsolated = true;
-        }
-      }
-    }
     return countBiNodeConnectedComponents(graph) <= 1;
   }
@@ -782,5 +759,5 @@
   /// \ingroup graph_properties
   ///
-  /// \brief Count the number of bi-node-connected components of an
+  /// \brief Count the number of bi-node-connected components of an 
   /// undirected graph.
   ///
@@ -836,5 +813,5 @@
   /// \retval compMap A writable edge map. The values will be set from 0
   /// to the number of the bi-node-connected components minus one. Each
-  /// value of the map will be set exactly once, and the values of a
+  /// value of the map will be set exactly once, and the values of a 
   /// certain component will be set continuously.
   /// \return The number of bi-node-connected components.
@@ -882,5 +859,5 @@
   ///
   /// \param graph The undirected graph.
-  /// \retval cutMap A writable node map. The values will be set to
+  /// \retval cutMap A writable node map. The values will be set to 
   /// \c true for the nodes that separate two or more components
   /// (exactly once for each cut node), and will not be changed for
@@ -1109,5 +1086,5 @@
   /// \brief Check whether an undirected graph is bi-edge-connected.
   ///
-  /// This function checks whether the given undirected graph is
+  /// This function checks whether the given undirected graph is 
   /// bi-edge-connected, i.e. any two nodes are connected with at least
   /// two edge-disjoint paths.
@@ -1216,5 +1193,5 @@
   ///
   /// This function finds the bi-edge-connected cut edges in the given
-  /// undirected graph.
+  /// undirected graph. 
   ///
   /// The bi-edge-connected components are the classes of an equivalence
@@ -1373,5 +1350,5 @@
   /// \param digraph The digraph.
   /// \retval order A readable and writable node map. The values will be
-  /// set from 0 to the number of the nodes in the digraph minus one.
+  /// set from 0 to the number of the nodes in the digraph minus one. 
   /// Each value of the map will be set exactly once, and the values will
   /// be set descending order.
Index: lemon/core.h
===================================================================
--- lemon/core.h	(revision 1341)
+++ lemon/core.h	(revision 718)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -20,4 +20,22 @@
 #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
+
 ///\file
 ///\brief LEMON core utilities.
@@ -26,30 +44,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 {
@@ -157,47 +149,4 @@
   typedef typename Graph::template EdgeMap<double> DoubleEdgeMap
 
-  ///Create convenience typedefs for the bipartite graph types and iterators
-
-  ///This \c \#define creates the same convenient type definitions as
-  ///defined by \ref GRAPH_TYPEDEFS(BpGraph) and ten more, namely it
-  ///creates \c RedNode, \c RedNodeIt, \c BoolRedNodeMap,
-  ///\c IntRedNodeMap, \c DoubleRedNodeMap, \c BlueNode, \c BlueNodeIt,
-  ///\c BoolBlueNodeMap, \c IntBlueNodeMap, \c DoubleBlueNodeMap.
-  ///
-  ///\note If the graph type is a dependent type, ie. the graph type depend
-  ///on a template parameter, then use \c TEMPLATE_BPGRAPH_TYPEDEFS()
-  ///macro.
-#define BPGRAPH_TYPEDEFS(BpGraph)                                       \
-  GRAPH_TYPEDEFS(BpGraph);                                              \
-  typedef BpGraph::RedNode RedNode;                                     \
-  typedef BpGraph::RedNodeIt RedNodeIt;                                 \
-  typedef BpGraph::RedNodeMap<bool> BoolRedNodeMap;                     \
-  typedef BpGraph::RedNodeMap<int> IntRedNodeMap;                       \
-  typedef BpGraph::RedNodeMap<double> DoubleRedNodeMap;                 \
-  typedef BpGraph::BlueNode BlueNode;                                   \
-  typedef BpGraph::BlueNodeIt BlueNodeIt;                               \
-  typedef BpGraph::BlueNodeMap<bool> BoolBlueNodeMap;                   \
-  typedef BpGraph::BlueNodeMap<int> IntBlueNodeMap;                     \
-  typedef BpGraph::BlueNodeMap<double> DoubleBlueNodeMap
-
-  ///Create convenience typedefs for the bipartite graph types and iterators
-
-  ///\see BPGRAPH_TYPEDEFS
-  ///
-  ///\note Use this macro, if the graph type is a dependent type,
-  ///ie. the graph type depend on a template parameter.
-#define TEMPLATE_BPGRAPH_TYPEDEFS(BpGraph)                                  \
-  TEMPLATE_GRAPH_TYPEDEFS(BpGraph);                                         \
-  typedef typename BpGraph::RedNode RedNode;                                \
-  typedef typename BpGraph::RedNodeIt RedNodeIt;                            \
-  typedef typename BpGraph::template RedNodeMap<bool> BoolRedNodeMap;       \
-  typedef typename BpGraph::template RedNodeMap<int> IntRedNodeMap;         \
-  typedef typename BpGraph::template RedNodeMap<double> DoubleRedNodeMap;   \
-  typedef typename BpGraph::BlueNode BlueNode;                              \
-  typedef typename BpGraph::BlueNodeIt BlueNodeIt;                          \
-  typedef typename BpGraph::template BlueNodeMap<bool> BoolBlueNodeMap;     \
-  typedef typename BpGraph::template BlueNodeMap<int> IntBlueNodeMap;       \
-  typedef typename BpGraph::template BlueNodeMap<double> DoubleBlueNodeMap
-
   /// \brief Function to count the items in a graph.
   ///
@@ -251,72 +200,4 @@
   }
 
-  namespace _graph_utils_bits {
-
-    template <typename Graph, typename Enable = void>
-    struct CountRedNodesSelector {
-      static int count(const Graph &g) {
-        return countItems<Graph, typename Graph::RedNode>(g);
-      }
-    };
-
-    template <typename Graph>
-    struct CountRedNodesSelector<
-      Graph, typename
-      enable_if<typename Graph::NodeNumTag, void>::type>
-    {
-      static int count(const Graph &g) {
-        return g.redNum();
-      }
-    };
-  }
-
-  /// \brief Function to count the red nodes in the graph.
-  ///
-  /// This function counts the red nodes in the graph.
-  /// The complexity of the function is O(n) but for some
-  /// graph structures it is specialized to run in O(1).
-  ///
-  /// If the graph contains a \e redNum() member function and a
-  /// \e NodeNumTag tag then this function calls directly the member
-  /// function to query the cardinality of the node set.
-  template <typename Graph>
-  inline int countRedNodes(const Graph& g) {
-    return _graph_utils_bits::CountRedNodesSelector<Graph>::count(g);
-  }
-
-  namespace _graph_utils_bits {
-
-    template <typename Graph, typename Enable = void>
-    struct CountBlueNodesSelector {
-      static int count(const Graph &g) {
-        return countItems<Graph, typename Graph::BlueNode>(g);
-      }
-    };
-
-    template <typename Graph>
-    struct CountBlueNodesSelector<
-      Graph, typename
-      enable_if<typename Graph::NodeNumTag, void>::type>
-    {
-      static int count(const Graph &g) {
-        return g.blueNum();
-      }
-    };
-  }
-
-  /// \brief Function to count the blue nodes in the graph.
-  ///
-  /// This function counts the blue nodes in the graph.
-  /// The complexity of the function is O(n) but for some
-  /// graph structures it is specialized to run in O(1).
-  ///
-  /// If the graph contains a \e blueNum() member function and a
-  /// \e NodeNumTag tag then this function calls directly the member
-  /// function to query the cardinality of the node set.
-  template <typename Graph>
-  inline int countBlueNodes(const Graph& g) {
-    return _graph_utils_bits::CountBlueNodesSelector<Graph>::count(g);
-  }
-
   // Arc counting:
 
@@ -514,5 +395,4 @@
       static void copy(const From& from, Digraph &to,
                        NodeRefMap& nodeRefMap, ArcRefMap& arcRefMap) {
-        to.clear();
         for (typename From::NodeIt it(from); it != INVALID; ++it) {
           nodeRefMap[it] = to.addNode();
@@ -542,5 +422,4 @@
       static void copy(const From& from, Graph &to,
                        NodeRefMap& nodeRefMap, EdgeRefMap& edgeRefMap) {
-        to.clear();
         for (typename From::NodeIt it(from); it != INVALID; ++it) {
           nodeRefMap[it] = to.addNode();
@@ -560,67 +439,10 @@
       template <typename From, typename NodeRefMap, typename EdgeRefMap>
       static void copy(const From& from, Graph &to,
-                       NodeRefMap& nodeRefMap,
-                       EdgeRefMap& edgeRefMap) {
+                       NodeRefMap& nodeRefMap, EdgeRefMap& edgeRefMap) {
         to.build(from, nodeRefMap, edgeRefMap);
       }
     };
 
-    template <typename BpGraph, typename Enable = void>
-    struct BpGraphCopySelector {
-      template <typename From, typename RedNodeRefMap,
-                typename BlueNodeRefMap, typename EdgeRefMap>
-      static void copy(const From& from, BpGraph &to,
-                       RedNodeRefMap& redNodeRefMap,
-                       BlueNodeRefMap& blueNodeRefMap,
-                       EdgeRefMap& edgeRefMap) {
-        to.clear();
-        for (typename From::RedNodeIt it(from); it != INVALID; ++it) {
-          redNodeRefMap[it] = to.addRedNode();
-        }
-        for (typename From::BlueNodeIt it(from); it != INVALID; ++it) {
-          blueNodeRefMap[it] = to.addBlueNode();
-        }
-        for (typename From::EdgeIt it(from); it != INVALID; ++it) {
-          edgeRefMap[it] = to.addEdge(redNodeRefMap[from.redNode(it)],
-                                      blueNodeRefMap[from.blueNode(it)]);
-        }
-      }
-    };
-
-    template <typename BpGraph>
-    struct BpGraphCopySelector<
-      BpGraph,
-      typename enable_if<typename BpGraph::BuildTag, void>::type>
-    {
-      template <typename From, typename RedNodeRefMap,
-                typename BlueNodeRefMap, typename EdgeRefMap>
-      static void copy(const From& from, BpGraph &to,
-                       RedNodeRefMap& redNodeRefMap,
-                       BlueNodeRefMap& blueNodeRefMap,
-                       EdgeRefMap& edgeRefMap) {
-        to.build(from, redNodeRefMap, blueNodeRefMap, edgeRefMap);
-      }
-    };
-
   }
-
-  /// \brief Check whether a graph is undirected.
-  ///
-  /// This function returns \c true if the given graph is undirected.
-#ifdef DOXYGEN
-  template <typename GR>
-  bool undirected(const GR& g) { return false; }
-#else
-  template <typename GR>
-  typename enable_if<UndirectedTagIndicator<GR>, bool>::type
-  undirected(const GR&) {
-    return true;
-  }
-  template <typename GR>
-  typename disable_if<UndirectedTagIndicator<GR>, bool>::type
-  undirected(const GR&) {
-    return false;
-  }
-#endif
 
   /// \brief Class to copy a digraph.
@@ -1147,452 +969,4 @@
   graphCopy(const From& from, To& to) {
     return GraphCopy<From, To>(from, to);
-  }
-
-  /// \brief Class to copy a bipartite graph.
-  ///
-  /// Class to copy a bipartite graph to another graph (duplicate a
-  /// graph). The simplest way of using it is through the
-  /// \c bpGraphCopy() function.
-  ///
-  /// This class not only make a copy of a bipartite graph, but it can
-  /// create references and cross references between the nodes, edges
-  /// and arcs of the two graphs, and it can copy maps for using with
-  /// the newly created graph.
-  ///
-  /// To make a copy from a graph, first an instance of BpGraphCopy
-  /// should be created, then the data belongs to the graph should
-  /// assigned to copy. In the end, the \c run() member should be
-  /// called.
-  ///
-  /// The next code copies a graph with several data:
-  ///\code
-  ///  BpGraphCopy<OrigBpGraph, NewBpGraph> cg(orig_graph, new_graph);
-  ///  // Create references for the nodes
-  ///  OrigBpGraph::NodeMap<NewBpGraph::Node> nr(orig_graph);
-  ///  cg.nodeRef(nr);
-  ///  // Create cross references (inverse) for the edges
-  ///  NewBpGraph::EdgeMap<OrigBpGraph::Edge> ecr(new_graph);
-  ///  cg.edgeCrossRef(ecr);
-  ///  // Copy a red node map
-  ///  OrigBpGraph::RedNodeMap<double> ormap(orig_graph);
-  ///  NewBpGraph::RedNodeMap<double> nrmap(new_graph);
-  ///  cg.redNodeMap(ormap, nrmap);
-  ///  // Copy a node
-  ///  OrigBpGraph::Node on;
-  ///  NewBpGraph::Node nn;
-  ///  cg.node(on, nn);
-  ///  // Execute copying
-  ///  cg.run();
-  ///\endcode
-  template <typename From, typename To>
-  class BpGraphCopy {
-  private:
-
-    typedef typename From::Node Node;
-    typedef typename From::RedNode RedNode;
-    typedef typename From::BlueNode BlueNode;
-    typedef typename From::NodeIt NodeIt;
-    typedef typename From::Arc Arc;
-    typedef typename From::ArcIt ArcIt;
-    typedef typename From::Edge Edge;
-    typedef typename From::EdgeIt EdgeIt;
-
-    typedef typename To::Node TNode;
-    typedef typename To::RedNode TRedNode;
-    typedef typename To::BlueNode TBlueNode;
-    typedef typename To::Arc TArc;
-    typedef typename To::Edge TEdge;
-
-    typedef typename From::template RedNodeMap<TRedNode> RedNodeRefMap;
-    typedef typename From::template BlueNodeMap<TBlueNode> BlueNodeRefMap;
-    typedef typename From::template EdgeMap<TEdge> EdgeRefMap;
-
-    struct NodeRefMap {
-      NodeRefMap(const From& from, const RedNodeRefMap& red_node_ref,
-                 const BlueNodeRefMap& blue_node_ref)
-        : _from(from), _red_node_ref(red_node_ref),
-          _blue_node_ref(blue_node_ref) {}
-
-      typedef typename From::Node Key;
-      typedef typename To::Node Value;
-
-      Value operator[](const Key& key) const {
-        if (_from.red(key)) {
-          return _red_node_ref[_from.asRedNodeUnsafe(key)];
-        } else {
-          return _blue_node_ref[_from.asBlueNodeUnsafe(key)];
-        }
-      }
-
-      const From& _from;
-      const RedNodeRefMap& _red_node_ref;
-      const BlueNodeRefMap& _blue_node_ref;
-    };
-
-    struct ArcRefMap {
-      ArcRefMap(const From& from, const To& to, const EdgeRefMap& edge_ref)
-        : _from(from), _to(to), _edge_ref(edge_ref) {}
-
-      typedef typename From::Arc Key;
-      typedef typename To::Arc Value;
-
-      Value operator[](const Key& key) const {
-        return _to.direct(_edge_ref[key], _from.direction(key));
-      }
-
-      const From& _from;
-      const To& _to;
-      const EdgeRefMap& _edge_ref;
-    };
-
-  public:
-
-    /// \brief Constructor of BpGraphCopy.
-    ///
-    /// Constructor of BpGraphCopy for copying the content of the
-    /// \c from graph into the \c to graph.
-    BpGraphCopy(const From& from, To& to)
-      : _from(from), _to(to) {}
-
-    /// \brief Destructor of BpGraphCopy
-    ///
-    /// Destructor of BpGraphCopy.
-    ~BpGraphCopy() {
-      for (int i = 0; i < int(_node_maps.size()); ++i) {
-        delete _node_maps[i];
-      }
-      for (int i = 0; i < int(_red_maps.size()); ++i) {
-        delete _red_maps[i];
-      }
-      for (int i = 0; i < int(_blue_maps.size()); ++i) {
-        delete _blue_maps[i];
-      }
-      for (int i = 0; i < int(_arc_maps.size()); ++i) {
-        delete _arc_maps[i];
-      }
-      for (int i = 0; i < int(_edge_maps.size()); ++i) {
-        delete _edge_maps[i];
-      }
-    }
-
-    /// \brief Copy the node references into the given map.
-    ///
-    /// This function copies the node references into the given map.
-    /// The parameter should be a map, whose key type is the Node type of
-    /// the source graph, while the value type is the Node type of the
-    /// destination graph.
-    template <typename NodeRef>
-    BpGraphCopy& nodeRef(NodeRef& map) {
-      _node_maps.push_back(new _core_bits::RefCopy<From, Node,
-                           NodeRefMap, NodeRef>(map));
-      return *this;
-    }
-
-    /// \brief Copy the node cross references into the given map.
-    ///
-    /// This function copies the node cross references (reverse references)
-    /// into the given map. The parameter should be a map, whose key type
-    /// is the Node type of the destination graph, while the value type is
-    /// the Node type of the source graph.
-    template <typename NodeCrossRef>
-    BpGraphCopy& nodeCrossRef(NodeCrossRef& map) {
-      _node_maps.push_back(new _core_bits::CrossRefCopy<From, Node,
-                           NodeRefMap, NodeCrossRef>(map));
-      return *this;
-    }
-
-    /// \brief Make a copy of the given node map.
-    ///
-    /// This function makes a copy of the given node map for the newly
-    /// created graph.
-    /// The key type of the new map \c tmap should be the Node type of the
-    /// destination graph, and the key type of the original map \c map
-    /// should be the Node type of the source graph.
-    template <typename FromMap, typename ToMap>
-    BpGraphCopy& nodeMap(const FromMap& map, ToMap& tmap) {
-      _node_maps.push_back(new _core_bits::MapCopy<From, Node,
-                           NodeRefMap, FromMap, ToMap>(map, tmap));
-      return *this;
-    }
-
-    /// \brief Make a copy of the given node.
-    ///
-    /// This function makes a copy of the given node.
-    BpGraphCopy& node(const Node& node, TNode& tnode) {
-      _node_maps.push_back(new _core_bits::ItemCopy<From, Node,
-                           NodeRefMap, TNode>(node, tnode));
-      return *this;
-    }
-
-    /// \brief Copy the red node references into the given map.
-    ///
-    /// This function copies the red node references into the given
-    /// map.  The parameter should be a map, whose key type is the
-    /// Node type of the source graph with the red item set, while the
-    /// value type is the Node type of the destination graph.
-    template <typename RedRef>
-    BpGraphCopy& redRef(RedRef& map) {
-      _red_maps.push_back(new _core_bits::RefCopy<From, RedNode,
-                          RedNodeRefMap, RedRef>(map));
-      return *this;
-    }
-
-    /// \brief Copy the red node cross references into the given map.
-    ///
-    /// This function copies the red node cross references (reverse
-    /// references) into the given map. The parameter should be a map,
-    /// whose key type is the Node type of the destination graph with
-    /// the red item set, while the value type is the Node type of the
-    /// source graph.
-    template <typename RedCrossRef>
-    BpGraphCopy& redCrossRef(RedCrossRef& map) {
-      _red_maps.push_back(new _core_bits::CrossRefCopy<From, RedNode,
-                          RedNodeRefMap, RedCrossRef>(map));
-      return *this;
-    }
-
-    /// \brief Make a copy of the given red node map.
-    ///
-    /// This function makes a copy of the given red node map for the newly
-    /// created graph.
-    /// The key type of the new map \c tmap should be the Node type of
-    /// the destination graph with the red items, and the key type of
-    /// the original map \c map should be the Node type of the source
-    /// graph.
-    template <typename FromMap, typename ToMap>
-    BpGraphCopy& redNodeMap(const FromMap& map, ToMap& tmap) {
-      _red_maps.push_back(new _core_bits::MapCopy<From, RedNode,
-                          RedNodeRefMap, FromMap, ToMap>(map, tmap));
-      return *this;
-    }
-
-    /// \brief Make a copy of the given red node.
-    ///
-    /// This function makes a copy of the given red node.
-    BpGraphCopy& redNode(const RedNode& node, TRedNode& tnode) {
-      _red_maps.push_back(new _core_bits::ItemCopy<From, RedNode,
-                          RedNodeRefMap, TRedNode>(node, tnode));
-      return *this;
-    }
-
-    /// \brief Copy the blue node references into the given map.
-    ///
-    /// This function copies the blue node references into the given
-    /// map.  The parameter should be a map, whose key type is the
-    /// Node type of the source graph with the blue item set, while the
-    /// value type is the Node type of the destination graph.
-    template <typename BlueRef>
-    BpGraphCopy& blueRef(BlueRef& map) {
-      _blue_maps.push_back(new _core_bits::RefCopy<From, BlueNode,
-                           BlueNodeRefMap, BlueRef>(map));
-      return *this;
-    }
-
-    /// \brief Copy the blue node cross references into the given map.
-    ///
-    /// This function copies the blue node cross references (reverse
-    /// references) into the given map. The parameter should be a map,
-    /// whose key type is the Node type of the destination graph with
-    /// the blue item set, while the value type is the Node type of the
-    /// source graph.
-    template <typename BlueCrossRef>
-    BpGraphCopy& blueCrossRef(BlueCrossRef& map) {
-      _blue_maps.push_back(new _core_bits::CrossRefCopy<From, BlueNode,
-                           BlueNodeRefMap, BlueCrossRef>(map));
-      return *this;
-    }
-
-    /// \brief Make a copy of the given blue node map.
-    ///
-    /// This function makes a copy of the given blue node map for the newly
-    /// created graph.
-    /// The key type of the new map \c tmap should be the Node type of
-    /// the destination graph with the blue items, and the key type of
-    /// the original map \c map should be the Node type of the source
-    /// graph.
-    template <typename FromMap, typename ToMap>
-    BpGraphCopy& blueNodeMap(const FromMap& map, ToMap& tmap) {
-      _blue_maps.push_back(new _core_bits::MapCopy<From, BlueNode,
-                           BlueNodeRefMap, FromMap, ToMap>(map, tmap));
-      return *this;
-    }
-
-    /// \brief Make a copy of the given blue node.
-    ///
-    /// This function makes a copy of the given blue node.
-    BpGraphCopy& blueNode(const BlueNode& node, TBlueNode& tnode) {
-      _blue_maps.push_back(new _core_bits::ItemCopy<From, BlueNode,
-                           BlueNodeRefMap, TBlueNode>(node, tnode));
-      return *this;
-    }
-
-    /// \brief Copy the arc references into the given map.
-    ///
-    /// This function copies the arc references into the given map.
-    /// The parameter should be a map, whose key type is the Arc type of
-    /// the source graph, while the value type is the Arc type of the
-    /// destination graph.
-    template <typename ArcRef>
-    BpGraphCopy& arcRef(ArcRef& map) {
-      _arc_maps.push_back(new _core_bits::RefCopy<From, Arc,
-                          ArcRefMap, ArcRef>(map));
-      return *this;
-    }
-
-    /// \brief Copy the arc cross references into the given map.
-    ///
-    /// This function copies the arc cross references (reverse references)
-    /// into the given map. The parameter should be a map, whose key type
-    /// is the Arc type of the destination graph, while the value type is
-    /// the Arc type of the source graph.
-    template <typename ArcCrossRef>
-    BpGraphCopy& arcCrossRef(ArcCrossRef& map) {
-      _arc_maps.push_back(new _core_bits::CrossRefCopy<From, Arc,
-                          ArcRefMap, ArcCrossRef>(map));
-      return *this;
-    }
-
-    /// \brief Make a copy of the given arc map.
-    ///
-    /// This function makes a copy of the given arc map for the newly
-    /// created graph.
-    /// The key type of the new map \c tmap should be the Arc type of the
-    /// destination graph, and the key type of the original map \c map
-    /// should be the Arc type of the source graph.
-    template <typename FromMap, typename ToMap>
-    BpGraphCopy& arcMap(const FromMap& map, ToMap& tmap) {
-      _arc_maps.push_back(new _core_bits::MapCopy<From, Arc,
-                          ArcRefMap, FromMap, ToMap>(map, tmap));
-      return *this;
-    }
-
-    /// \brief Make a copy of the given arc.
-    ///
-    /// This function makes a copy of the given arc.
-    BpGraphCopy& arc(const Arc& arc, TArc& tarc) {
-      _arc_maps.push_back(new _core_bits::ItemCopy<From, Arc,
-                          ArcRefMap, TArc>(arc, tarc));
-      return *this;
-    }
-
-    /// \brief Copy the edge references into the given map.
-    ///
-    /// This function copies the edge references into the given map.
-    /// The parameter should be a map, whose key type is the Edge type of
-    /// the source graph, while the value type is the Edge type of the
-    /// destination graph.
-    template <typename EdgeRef>
-    BpGraphCopy& edgeRef(EdgeRef& map) {
-      _edge_maps.push_back(new _core_bits::RefCopy<From, Edge,
-                           EdgeRefMap, EdgeRef>(map));
-      return *this;
-    }
-
-    /// \brief Copy the edge cross references into the given map.
-    ///
-    /// This function copies the edge cross references (reverse references)
-    /// into the given map. The parameter should be a map, whose key type
-    /// is the Edge type of the destination graph, while the value type is
-    /// the Edge type of the source graph.
-    template <typename EdgeCrossRef>
-    BpGraphCopy& edgeCrossRef(EdgeCrossRef& map) {
-      _edge_maps.push_back(new _core_bits::CrossRefCopy<From,
-                           Edge, EdgeRefMap, EdgeCrossRef>(map));
-      return *this;
-    }
-
-    /// \brief Make a copy of the given edge map.
-    ///
-    /// This function makes a copy of the given edge map for the newly
-    /// created graph.
-    /// The key type of the new map \c tmap should be the Edge type of the
-    /// destination graph, and the key type of the original map \c map
-    /// should be the Edge type of the source graph.
-    template <typename FromMap, typename ToMap>
-    BpGraphCopy& edgeMap(const FromMap& map, ToMap& tmap) {
-      _edge_maps.push_back(new _core_bits::MapCopy<From, Edge,
-                           EdgeRefMap, FromMap, ToMap>(map, tmap));
-      return *this;
-    }
-
-    /// \brief Make a copy of the given edge.
-    ///
-    /// This function makes a copy of the given edge.
-    BpGraphCopy& edge(const Edge& edge, TEdge& tedge) {
-      _edge_maps.push_back(new _core_bits::ItemCopy<From, Edge,
-                           EdgeRefMap, TEdge>(edge, tedge));
-      return *this;
-    }
-
-    /// \brief Execute copying.
-    ///
-    /// This function executes the copying of the graph along with the
-    /// copying of the assigned data.
-    void run() {
-      RedNodeRefMap redNodeRefMap(_from);
-      BlueNodeRefMap blueNodeRefMap(_from);
-      NodeRefMap nodeRefMap(_from, redNodeRefMap, blueNodeRefMap);
-      EdgeRefMap edgeRefMap(_from);
-      ArcRefMap arcRefMap(_from, _to, edgeRefMap);
-      _core_bits::BpGraphCopySelector<To>::
-        copy(_from, _to, redNodeRefMap, blueNodeRefMap, edgeRefMap);
-      for (int i = 0; i < int(_node_maps.size()); ++i) {
-        _node_maps[i]->copy(_from, nodeRefMap);
-      }
-      for (int i = 0; i < int(_red_maps.size()); ++i) {
-        _red_maps[i]->copy(_from, redNodeRefMap);
-      }
-      for (int i = 0; i < int(_blue_maps.size()); ++i) {
-        _blue_maps[i]->copy(_from, blueNodeRefMap);
-      }
-      for (int i = 0; i < int(_edge_maps.size()); ++i) {
-        _edge_maps[i]->copy(_from, edgeRefMap);
-      }
-      for (int i = 0; i < int(_arc_maps.size()); ++i) {
-        _arc_maps[i]->copy(_from, arcRefMap);
-      }
-    }
-
-  private:
-
-    const From& _from;
-    To& _to;
-
-    std::vector<_core_bits::MapCopyBase<From, Node, NodeRefMap>* >
-      _node_maps;
-
-    std::vector<_core_bits::MapCopyBase<From, RedNode, RedNodeRefMap>* >
-      _red_maps;
-
-    std::vector<_core_bits::MapCopyBase<From, BlueNode, BlueNodeRefMap>* >
-      _blue_maps;
-
-    std::vector<_core_bits::MapCopyBase<From, Arc, ArcRefMap>* >
-      _arc_maps;
-
-    std::vector<_core_bits::MapCopyBase<From, Edge, EdgeRefMap>* >
-      _edge_maps;
-
-  };
-
-  /// \brief Copy a graph to another graph.
-  ///
-  /// This function copies a graph to another graph.
-  /// The complete usage of it is detailed in the BpGraphCopy class,
-  /// but a short example shows a basic work:
-  ///\code
-  /// graphCopy(src, trg).nodeRef(nr).edgeCrossRef(ecr).run();
-  ///\endcode
-  ///
-  /// After the copy the \c nr map will contain the mapping from the
-  /// nodes of the \c from graph to the nodes of the \c to graph and
-  /// \c ecr will contain the mapping from the edges of the \c to graph
-  /// to the edges of the \c from graph.
-  ///
-  /// \see BpGraphCopy
-  template <typename From, typename To>
-  BpGraphCopy<From, To>
-  bpGraphCopy(const From& from, To& to) {
-    return BpGraphCopy<From, To>(from, to);
   }
 
@@ -1866,6 +1240,5 @@
   protected:
 
-    class AutoNodeMap : public ItemSetTraits<GR, Node>::template Map<Arc>::Type
-    {
+    class AutoNodeMap : public ItemSetTraits<GR, Node>::template Map<Arc>::Type {
       typedef typename ItemSetTraits<GR, Node>::template Map<Arc>::Type Parent;
 
@@ -1906,5 +1279,5 @@
     };
 
-  protected:
+  protected: 
 
     const Digraph &_g;
@@ -2474,24 +1847,13 @@
     ///a single node \c n, then \ref refresh(Node) "refresh(n)" is enough.
     ///
-    Arc operator()(Node s, Node t, Arc prev=INVALID) const
+#ifdef DOXYGEN
+    Arc operator()(Node s, Node t, Arc prev=INVALID) const {}
+#else
+    using ArcLookUp<GR>::operator() ;
+    Arc operator()(Node s, Node t, Arc prev) const
     {
-      if(prev==INVALID)
-        {
-          Arc f=INVALID;
-          Arc e;
-          for(e=_head[s];
-              e!=INVALID&&_g.target(e)!=t;
-              e = t < _g.target(e)?_left[e]:_right[e]) ;
-          while(e!=INVALID)
-            if(_g.target(e)==t)
-              {
-                f = e;
-                e = _left[e];
-              }
-            else e = _right[e];
-          return f;
-        }
-      else return _next[prev];
-    }
+      return prev==INVALID?(*this)(s,t):_next[prev];
+    }
+#endif
 
   };
Index: lemon/cost_scaling.h
===================================================================
--- lemon/cost_scaling.h	(revision 1298)
+++ lemon/cost_scaling.h	(revision 887)
@@ -1,7 +1,7 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
+/* -*- C++ -*-
  *
- * This file is a part of LEMON, a generic C++ optimization library.
+ * This file is a part of LEMON, a generic C++ optimization library
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -92,16 +92,9 @@
   /// \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,
-  /// \cite goldberg97efficient, \cite bunnagel98efficient.
+  /// "minimum cost flow" \ref amo93networkflows, \ref goldberg90approximation,
+  /// \ref goldberg97efficient, \ref bunnagel98efficient. 
   /// It is a highly efficient primal-dual solution method, which
   /// can be viewed as the generalization of the \ref Preflow
   /// "preflow push-relabel" algorithm for the maximum flow problem.
-  /// It is a polynomial algorithm, its running time complexity is
-  /// \f$O(n^2m\log(nK))\f$, where <i>K</i> denotes the maximum arc cost.
-  ///
-  /// In general, \ref NetworkSimplex and \ref CostScaling are the fastest
-  /// implementations available in LEMON for solving this problem.
-  /// (For more information, see \ref min_cost_flow_algs "the module page".)
   ///
   /// Most of the parameters of the problem (except for the digraph)
@@ -112,18 +105,12 @@
   /// \tparam GR The digraph type the algorithm runs on.
   /// \tparam V The number type used for flow amounts, capacity bounds
-  /// and supply values in the algorithm. By default, it is \c int.
+  /// and supply values in the algorithm. By default it is \c int.
   /// \tparam C The number type used for costs and potentials in the
-  /// algorithm. By default, it is the same as \c V.
-  /// \tparam TR The traits class that defines various types used by the
-  /// algorithm. By default, it is \ref CostScalingDefaultTraits
-  /// "CostScalingDefaultTraits<GR, V, C>".
-  /// In most cases, this parameter should not be set directly,
-  /// consider to use the named template parameters instead.
+  /// algorithm. By default it is the same as \c V.
   ///
-  /// \warning Both \c V and \c C must be signed number types.
-  /// \warning All input data (capacities, supply values, and costs) must
+  /// \warning Both number types must be signed and all input data must
   /// be integer.
-  /// \warning This algorithm does not support negative costs for
-  /// arcs having infinite upper bound.
+  /// \warning This algorithm does not support negative costs for such
+  /// arcs that have infinite upper bound.
   ///
   /// \note %CostScaling provides three different internal methods,
@@ -150,10 +137,10 @@
     ///
     /// The large cost type used for internal computations.
-    /// By default, it is \c long \c long if the \c Cost type is integer,
+    /// Using the \ref CostScalingDefaultTraits "default traits class",
+    /// it is \c long \c long if the \c Cost type is integer,
     /// otherwise it is \c double.
     typedef typename TR::LargeCost LargeCost;
 
-    /// \brief The \ref lemon::CostScalingDefaultTraits "traits class"
-    /// of the algorithm
+    /// The \ref CostScalingDefaultTraits "traits class" of the algorithm
     typedef TR Traits;
 
@@ -188,5 +175,5 @@
     /// relabel operation.
     /// By default, the so called \ref PARTIAL_AUGMENT
-    /// "Partial Augment-Relabel" method is used, which turned out to be
+    /// "Partial Augment-Relabel" method is used, which proved to be
     /// the most efficient and the most robust on various test inputs.
     /// However, the other methods can be selected using the \ref run()
@@ -199,5 +186,5 @@
       /// paths from a node with excess to a node with deficit.
       AUGMENT,
-      /// Partial augment operations are used, i.e. flow is moved on
+      /// Partial augment operations are used, i.e. flow is moved on 
       /// admissible paths started from a node with excess, but the
       /// lengths of these paths are limited. This method can be viewed
@@ -211,13 +198,11 @@
 
     typedef std::vector<int> IntVector;
+    typedef std::vector<char> BoolVector;
     typedef std::vector<Value> ValueVector;
     typedef std::vector<Cost> CostVector;
     typedef std::vector<LargeCost> LargeCostVector;
-    typedef std::vector<char> BoolVector;
-    // Note: vector<char> is used instead of vector<bool>
-    // for efficiency reasons
 
   private:
-
+  
     template <typename KT, typename VT>
     class StaticVectorMap {
@@ -225,7 +210,7 @@
       typedef KT Key;
       typedef VT Value;
-
+      
       StaticVectorMap(std::vector<Value>& v) : _v(v) {}
-
+      
       const Value& operator[](const Key& key) const {
         return _v[StaticDigraph::id(key)];
@@ -235,5 +220,5 @@
         return _v[StaticDigraph::id(key)];
       }
-
+      
       void set(const Key& key, const Value& val) {
         _v[StaticDigraph::id(key)] = val;
@@ -244,4 +229,5 @@
     };
 
+    typedef StaticVectorMap<StaticDigraph::Node, LargeCost> LargeCostNodeMap;
     typedef StaticVectorMap<StaticDigraph::Arc, LargeCost> LargeCostArcMap;
 
@@ -257,7 +243,6 @@
 
     // Parameters of the problem
-    bool _has_lower;
+    bool _have_lower;
     Value _sum_supply;
-    int _sup_node_num;
 
     // Data structures for storing the digraph
@@ -288,12 +273,14 @@
     int _alpha;
 
-    IntVector _buckets;
-    IntVector _bucket_next;
-    IntVector _bucket_prev;
-    IntVector _rank;
-    int _max_rank;
-
+    // Data for a StaticDigraph structure
+    typedef std::pair<int, int> IntPair;
+    StaticDigraph _sgr;
+    std::vector<IntPair> _arc_vec;
+    std::vector<LargeCost> _cost_vec;
+    LargeCostArcMap _cost_map;
+    LargeCostNodeMap _pi_map;
+  
   public:
-
+  
     /// \brief Constant for infinite upper bounds (capacities).
     ///
@@ -327,8 +314,4 @@
     /// @}
 
-  protected:
-
-    CostScaling() {}
-
   public:
 
@@ -340,4 +323,5 @@
     CostScaling(const GR& graph) :
       _graph(graph), _node_id(graph), _arc_idf(graph), _arc_idb(graph),
+      _cost_map(_cost_vec), _pi_map(_pi),
       INF(std::numeric_limits<Value>::has_infinity ?
           std::numeric_limits<Value>::infinity() :
@@ -350,5 +334,71 @@
         "The cost type of CostScaling must be signed");
 
-      // Reset data structures
+      // Resize vectors
+      _node_num = countNodes(_graph);
+      _arc_num = countArcs(_graph);
+      _res_node_num = _node_num + 1;
+      _res_arc_num = 2 * (_arc_num + _node_num);
+      _root = _node_num;
+
+      _first_out.resize(_res_node_num + 1);
+      _forward.resize(_res_arc_num);
+      _source.resize(_res_arc_num);
+      _target.resize(_res_arc_num);
+      _reverse.resize(_res_arc_num);
+
+      _lower.resize(_res_arc_num);
+      _upper.resize(_res_arc_num);
+      _scost.resize(_res_arc_num);
+      _supply.resize(_res_node_num);
+      
+      _res_cap.resize(_res_arc_num);
+      _cost.resize(_res_arc_num);
+      _pi.resize(_res_node_num);
+      _excess.resize(_res_node_num);
+      _next_out.resize(_res_node_num);
+
+      _arc_vec.reserve(_res_arc_num);
+      _cost_vec.reserve(_res_arc_num);
+
+      // Copy the graph
+      int i = 0, j = 0, k = 2 * _arc_num + _node_num;
+      for (NodeIt n(_graph); n != INVALID; ++n, ++i) {
+        _node_id[n] = i;
+      }
+      i = 0;
+      for (NodeIt n(_graph); n != INVALID; ++n, ++i) {
+        _first_out[i] = j;
+        for (OutArcIt a(_graph, n); a != INVALID; ++a, ++j) {
+          _arc_idf[a] = j;
+          _forward[j] = true;
+          _source[j] = i;
+          _target[j] = _node_id[_graph.runningNode(a)];
+        }
+        for (InArcIt a(_graph, n); a != INVALID; ++a, ++j) {
+          _arc_idb[a] = j;
+          _forward[j] = false;
+          _source[j] = i;
+          _target[j] = _node_id[_graph.runningNode(a)];
+        }
+        _forward[j] = false;
+        _source[j] = i;
+        _target[j] = _root;
+        _reverse[j] = k;
+        _forward[k] = true;
+        _source[k] = _root;
+        _target[k] = i;
+        _reverse[k] = j;
+        ++j; ++k;
+      }
+      _first_out[i] = j;
+      _first_out[_res_node_num] = k;
+      for (ArcIt a(_graph); a != INVALID; ++a) {
+        int fi = _arc_idf[a];
+        int bi = _arc_idb[a];
+        _reverse[fi] = bi;
+        _reverse[bi] = fi;
+      }
+      
+      // Reset parameters
       reset();
     }
@@ -373,7 +423,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;
@@ -447,5 +498,5 @@
     ///
     /// Using this function has the same effect as using \ref supplyMap()
-    /// with a map in which \c k is assigned to \c s, \c -k is
+    /// with such a map in which \c k is assigned to \c s, \c -k is
     /// assigned to \c t and all other nodes have zero supply value.
     ///
@@ -464,5 +515,5 @@
       return *this;
     }
-
+    
     /// @}
 
@@ -484,14 +535,14 @@
     /// \endcode
     ///
-    /// This function can be called more than once. All the given parameters
-    /// are kept for the next call, unless \ref resetParams() or \ref reset()
-    /// is used, thus only the modified parameters have to be set again.
-    /// If the underlying digraph was also modified after the construction
-    /// of the class (or the last \ref reset() call), then the \ref reset()
-    /// function must be called.
+    /// This function can be called more than once. All the parameters
+    /// that have been given are kept for the next call, unless
+    /// \ref reset() is called, thus only the modified parameters
+    /// have to be set again. See \ref reset() for examples.
+    /// However, the underlying digraph must not be modified after this
+    /// class have been constructed, since it copies and extends the graph.
     ///
     /// \param method The internal method that will be used in the
     /// algorithm. For more information, see \ref Method.
-    /// \param factor The cost scaling factor. It must be at least two.
+    /// \param factor The cost scaling factor. It must be larger than one.
     ///
     /// \return \c INFEASIBLE if no feasible flow exists,
@@ -506,7 +557,5 @@
     ///
     /// \see ProblemType, Method
-    /// \see resetParams(), reset()
-    ProblemType run(Method method = PARTIAL_AUGMENT, int factor = 16) {
-      LEMON_ASSERT(factor >= 2, "The scaling factor must be at least 2");
+    ProblemType run(Method method = PARTIAL_AUGMENT, int factor = 8) {
       _alpha = factor;
       ProblemType pt = init();
@@ -522,10 +571,9 @@
     /// \ref costMap(), \ref supplyMap(), \ref stSupply().
     ///
-    /// It is useful for multiple \ref run() calls. Basically, all the given
-    /// parameters are kept for the next \ref run() call, unless
-    /// \ref resetParams() or \ref reset() is used.
-    /// If the underlying digraph was also modified after the construction
-    /// of the class or the last \ref reset() call, then the \ref reset()
-    /// function must be used, otherwise \ref resetParams() is sufficient.
+    /// It is useful for multiple run() calls. If this function is not
+    /// used, all the parameters given before are kept for the next
+    /// \ref run() call.
+    /// However, the underlying digraph must not be modified after this
+    /// class have been constructed, since it copies and extends the graph.
     ///
     /// For example,
@@ -537,12 +585,12 @@
     ///     .supplyMap(sup).run();
     ///
-    ///   // Run again with modified cost map (resetParams() is not called,
+    ///   // Run again with modified cost map (reset() is not called,
     ///   // so only the cost map have to be set again)
     ///   cost[e] += 100;
     ///   cs.costMap(cost).run();
     ///
-    ///   // Run again from scratch using resetParams()
+    ///   // Run again from scratch using reset()
     ///   // (the lower bounds will be set to zero on all arcs)
-    ///   cs.resetParams();
+    ///   cs.reset();
     ///   cs.upperMap(capacity).costMap(cost)
     ///     .supplyMap(sup).run();
@@ -550,7 +598,5 @@
     ///
     /// \return <tt>(*this)</tt>
-    ///
-    /// \see reset(), run()
-    CostScaling& resetParams() {
+    CostScaling& reset() {
       for (int i = 0; i != _res_node_num; ++i) {
         _supply[i] = 0;
@@ -567,94 +613,6 @@
         _scost[j] = 0;
         _scost[_reverse[j]] = 0;
-      }
-      _has_lower = false;
-      return *this;
-    }
-
-    /// \brief Reset the internal data structures and all the parameters
-    /// that have been given before.
-    ///
-    /// This function resets the internal data structures and all the
-    /// paramaters that have been given before using functions \ref lowerMap(),
-    /// \ref upperMap(), \ref costMap(), \ref supplyMap(), \ref stSupply().
-    ///
-    /// It is useful for multiple \ref run() calls. By default, all the given
-    /// parameters are kept for the next \ref run() call, unless
-    /// \ref resetParams() or \ref reset() is used.
-    /// If the underlying digraph was also modified after the construction
-    /// of the class or the last \ref reset() call, then the \ref reset()
-    /// function must be used, otherwise \ref resetParams() is sufficient.
-    ///
-    /// See \ref resetParams() for examples.
-    ///
-    /// \return <tt>(*this)</tt>
-    ///
-    /// \see resetParams(), run()
-    CostScaling& reset() {
-      // Resize vectors
-      _node_num = countNodes(_graph);
-      _arc_num = countArcs(_graph);
-      _res_node_num = _node_num + 1;
-      _res_arc_num = 2 * (_arc_num + _node_num);
-      _root = _node_num;
-
-      _first_out.resize(_res_node_num + 1);
-      _forward.resize(_res_arc_num);
-      _source.resize(_res_arc_num);
-      _target.resize(_res_arc_num);
-      _reverse.resize(_res_arc_num);
-
-      _lower.resize(_res_arc_num);
-      _upper.resize(_res_arc_num);
-      _scost.resize(_res_arc_num);
-      _supply.resize(_res_node_num);
-
-      _res_cap.resize(_res_arc_num);
-      _cost.resize(_res_arc_num);
-      _pi.resize(_res_node_num);
-      _excess.resize(_res_node_num);
-      _next_out.resize(_res_node_num);
-
-      // Copy the graph
-      int i = 0, j = 0, k = 2 * _arc_num + _node_num;
-      for (NodeIt n(_graph); n != INVALID; ++n, ++i) {
-        _node_id[n] = i;
-      }
-      i = 0;
-      for (NodeIt n(_graph); n != INVALID; ++n, ++i) {
-        _first_out[i] = j;
-        for (OutArcIt a(_graph, n); a != INVALID; ++a, ++j) {
-          _arc_idf[a] = j;
-          _forward[j] = true;
-          _source[j] = i;
-          _target[j] = _node_id[_graph.runningNode(a)];
-        }
-        for (InArcIt a(_graph, n); a != INVALID; ++a, ++j) {
-          _arc_idb[a] = j;
-          _forward[j] = false;
-          _source[j] = i;
-          _target[j] = _node_id[_graph.runningNode(a)];
-        }
-        _forward[j] = false;
-        _source[j] = i;
-        _target[j] = _root;
-        _reverse[j] = k;
-        _forward[k] = true;
-        _source[k] = _root;
-        _target[k] = i;
-        _reverse[k] = j;
-        ++j; ++k;
-      }
-      _first_out[i] = j;
-      _first_out[_res_node_num] = k;
-      for (ArcIt a(_graph); a != INVALID; ++a) {
-        int fi = _arc_idf[a];
-        int bi = _arc_idb[a];
-        _reverse[fi] = bi;
-        _reverse[bi] = fi;
-      }
-
-      // Reset parameters
-      resetParams();
+      }      
+      _have_lower = false;
       return *this;
     }
@@ -672,5 +630,5 @@
     ///
     /// This function returns the total cost of the found flow.
-    /// Its complexity is O(m).
+    /// Its complexity is O(e).
     ///
     /// \note The return type of the function can be specified as a
@@ -710,6 +668,5 @@
     }
 
-    /// \brief Copy the flow values (the primal solution) into the
-    /// given map.
+    /// \brief Return the flow map (the primal solution).
     ///
     /// This function copies the flow value on each arc into the given
@@ -735,6 +692,5 @@
     }
 
-    /// \brief Copy the potential values (the dual solution) into the
-    /// given map.
+    /// \brief Return the potential map (the dual solution).
     ///
     /// This function copies the potential (dual value) of each node
@@ -765,9 +721,5 @@
       }
       if (_sum_supply > 0) return INFEASIBLE;
-
-      // Check lower and upper bounds
-      LEMON_DEBUG(checkBoundMaps(),
-          "Upper bounds must be greater or equal to the lower bounds");
-
+      
 
       // Initialize vectors
@@ -776,9 +728,9 @@
         _excess[i] = _supply[i];
       }
-
+      
       // Remove infinite upper bounds and check negative arcs
       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 +789,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];
@@ -849,9 +801,4 @@
           cap[a] = _upper[_arc_idf[a]];
         }
-      }
-
-      _sup_node_num = 0;
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        if (sup[n] > 0) ++_sup_node_num;
       }
 
@@ -890,5 +837,5 @@
         for (int a = _first_out[_root]; a != _res_arc_num; ++a) {
           int ra = _reverse[a];
-          _res_cap[a] = 0;
+          _res_cap[a] = 1;
           _res_cap[ra] = 0;
           _cost[a] = 0;
@@ -896,28 +843,14 @@
         }
       }
-
-      // Initialize data structures for buckets
-      _max_rank = _alpha * _res_node_num;
-      _buckets.resize(_max_rank);
-      _bucket_next.resize(_res_node_num + 1);
-      _bucket_prev.resize(_res_node_num + 1);
-      _rank.resize(_res_node_num + 1);
-
+      
       return OPTIMAL;
-    }
-
-    // Check if the upper bound is greater than or equal to the lower bound
-    // on each forward arc.
-    bool checkBoundMaps() {
-      for (int j = 0; j != _res_arc_num; ++j) {
-        if (_forward[j] && _upper[j] < _lower[j]) return false;
-      }
-      return true;
     }
 
     // Execute the algorithm and transform the results
     void start(Method method) {
-      const int MAX_PARTIAL_PATH_LENGTH = 4;
-
+      // Maximum path length for partial augment
+      const int MAX_PATH_LENGTH = 4;
+      
+      // Execute the algorithm
       switch (method) {
         case PUSH:
@@ -925,423 +858,33 @@
           break;
         case AUGMENT:
-          startAugment(_res_node_num - 1);
+          startAugment();
           break;
         case PARTIAL_AUGMENT:
-          startAugment(MAX_PARTIAL_PATH_LENGTH);
+          startAugment(MAX_PATH_LENGTH);
           break;
       }
 
-      // Compute node potentials (dual solution)
-      for (int i = 0; i != _res_node_num; ++i) {
-        _pi[i] = static_cast<Cost>(_pi[i] / (_res_node_num * _alpha));
-      }
-      bool optimal = true;
-      for (int i = 0; optimal && i != _res_node_num; ++i) {
-        LargeCost pi_i = _pi[i];
-        int last_out = _first_out[i+1];
-        for (int j = _first_out[i]; j != last_out; ++j) {
-          if (_res_cap[j] > 0 && _scost[j] + pi_i - _pi[_target[j]] < 0) {
-            optimal = false;
-            break;
-          }
-        }
-      }
-
-      if (!optimal) {
-        // Compute node potentials for the original costs with BellmanFord
-        // (if it is necessary)
-        typedef std::pair<int, int> IntPair;
-        StaticDigraph sgr;
-        std::vector<IntPair> arc_vec;
-        std::vector<LargeCost> cost_vec;
-        LargeCostArcMap cost_map(cost_vec);
-
-        arc_vec.clear();
-        cost_vec.clear();
-        for (int j = 0; j != _res_arc_num; ++j) {
-          if (_res_cap[j] > 0) {
-            int u = _source[j], v = _target[j];
-            arc_vec.push_back(IntPair(u, v));
-            cost_vec.push_back(_scost[j] + _pi[u] - _pi[v]);
-          }
-        }
-        sgr.build(_res_node_num, arc_vec.begin(), arc_vec.end());
-
-        typename BellmanFord<StaticDigraph, LargeCostArcMap>::Create
-          bf(sgr, cost_map);
-        bf.init(0);
-        bf.start();
-
-        for (int i = 0; i != _res_node_num; ++i) {
-          _pi[i] += bf.dist(sgr.node(i));
-        }
-      }
-
-      // Shift potentials to meet the requirements of the GEQ type
-      // optimality conditions
-      LargeCost max_pot = _pi[_root];
-      for (int i = 0; i != _res_node_num; ++i) {
-        if (_pi[i] > max_pot) max_pot = _pi[i];
-      }
-      if (max_pot != 0) {
-        for (int i = 0; i != _res_node_num; ++i) {
-          _pi[i] -= max_pot;
-        }
-      }
+      // Compute node potentials for the original costs
+      _arc_vec.clear();
+      _cost_vec.clear();
+      for (int j = 0; j != _res_arc_num; ++j) {
+        if (_res_cap[j] > 0) {
+          _arc_vec.push_back(IntPair(_source[j], _target[j]));
+          _cost_vec.push_back(_scost[j]);
+        }
+      }
+      _sgr.build(_res_node_num, _arc_vec.begin(), _arc_vec.end());
+
+      typename BellmanFord<StaticDigraph, LargeCostArcMap>
+        ::template SetDistMap<LargeCostNodeMap>::Create bf(_sgr, _cost_map);
+      bf.distMap(_pi_map);
+      bf.init(0);
+      bf.start();
 
       // 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];
-        }
-      }
-    }
-
-    // Initialize a cost scaling phase
-    void initPhase() {
-      // Saturate arcs not satisfying the optimality condition
-      for (int u = 0; u != _res_node_num; ++u) {
-        int last_out = _first_out[u+1];
-        LargeCost pi_u = _pi[u];
-        for (int a = _first_out[u]; a != last_out; ++a) {
-          Value delta = _res_cap[a];
-          if (delta > 0) {
-            int v = _target[a];
-            if (_cost[a] + pi_u - _pi[v] < 0) {
-              _excess[u] -= delta;
-              _excess[v] += delta;
-              _res_cap[a] = 0;
-              _res_cap[_reverse[a]] += delta;
-            }
-          }
-        }
-      }
-
-      // Find active nodes (i.e. nodes with positive excess)
-      for (int u = 0; u != _res_node_num; ++u) {
-        if (_excess[u] > 0) _active_nodes.push_back(u);
-      }
-
-      // Initialize the next arcs
-      for (int u = 0; u != _res_node_num; ++u) {
-        _next_out[u] = _first_out[u];
-      }
-    }
-
-    // Price (potential) refinement heuristic
-    bool priceRefinement() {
-
-      // Stack for stroing the topological order
-      IntVector stack(_res_node_num);
-      int stack_top;
-
-      // Perform phases
-      while (topologicalSort(stack, stack_top)) {
-
-        // Compute node ranks in the acyclic admissible network and
-        // store the nodes in buckets
-        for (int i = 0; i != _res_node_num; ++i) {
-          _rank[i] = 0;
-        }
-        const int bucket_end = _root + 1;
-        for (int r = 0; r != _max_rank; ++r) {
-          _buckets[r] = bucket_end;
-        }
-        int top_rank = 0;
-        for ( ; stack_top >= 0; --stack_top) {
-          int u = stack[stack_top], v;
-          int rank_u = _rank[u];
-
-          LargeCost rc, pi_u = _pi[u];
-          int last_out = _first_out[u+1];
-          for (int a = _first_out[u]; a != last_out; ++a) {
-            if (_res_cap[a] > 0) {
-              v = _target[a];
-              rc = _cost[a] + pi_u - _pi[v];
-              if (rc < 0) {
-                LargeCost nrc = static_cast<LargeCost>((-rc - 0.5) / _epsilon);
-                if (nrc < LargeCost(_max_rank)) {
-                  int new_rank_v = rank_u + static_cast<int>(nrc);
-                  if (new_rank_v > _rank[v]) {
-                    _rank[v] = new_rank_v;
-                  }
-                }
-              }
-            }
-          }
-
-          if (rank_u > 0) {
-            top_rank = std::max(top_rank, rank_u);
-            int bfirst = _buckets[rank_u];
-            _bucket_next[u] = bfirst;
-            _bucket_prev[bfirst] = u;
-            _buckets[rank_u] = u;
-          }
-        }
-
-        // Check if the current flow is epsilon-optimal
-        if (top_rank == 0) {
-          return true;
-        }
-
-        // Process buckets in top-down order
-        for (int rank = top_rank; rank > 0; --rank) {
-          while (_buckets[rank] != bucket_end) {
-            // Remove the first node from the current bucket
-            int u = _buckets[rank];
-            _buckets[rank] = _bucket_next[u];
-
-            // Search the outgoing arcs of u
-            LargeCost rc, pi_u = _pi[u];
-            int last_out = _first_out[u+1];
-            int v, old_rank_v, new_rank_v;
-            for (int a = _first_out[u]; a != last_out; ++a) {
-              if (_res_cap[a] > 0) {
-                v = _target[a];
-                old_rank_v = _rank[v];
-
-                if (old_rank_v < rank) {
-
-                  // Compute the new rank of node v
-                  rc = _cost[a] + pi_u - _pi[v];
-                  if (rc < 0) {
-                    new_rank_v = rank;
-                  } else {
-                    LargeCost nrc = rc / _epsilon;
-                    new_rank_v = 0;
-                    if (nrc < LargeCost(_max_rank)) {
-                      new_rank_v = rank - 1 - static_cast<int>(nrc);
-                    }
-                  }
-
-                  // Change the rank of node v
-                  if (new_rank_v > old_rank_v) {
-                    _rank[v] = new_rank_v;
-
-                    // Remove v from its old bucket
-                    if (old_rank_v > 0) {
-                      if (_buckets[old_rank_v] == v) {
-                        _buckets[old_rank_v] = _bucket_next[v];
-                      } else {
-                        int pv = _bucket_prev[v], nv = _bucket_next[v];
-                        _bucket_next[pv] = nv;
-                        _bucket_prev[nv] = pv;
-                      }
-                    }
-
-                    // Insert v into its new bucket
-                    int nv = _buckets[new_rank_v];
-                    _bucket_next[v] = nv;
-                    _bucket_prev[nv] = v;
-                    _buckets[new_rank_v] = v;
-                  }
-                }
-              }
-            }
-
-            // Refine potential of node u
-            _pi[u] -= rank * _epsilon;
-          }
-        }
-
-      }
-
-      return false;
-    }
-
-    // Find and cancel cycles in the admissible network and
-    // determine topological order using DFS
-    bool topologicalSort(IntVector &stack, int &stack_top) {
-      const int MAX_CYCLE_CANCEL = 1;
-
-      BoolVector reached(_res_node_num, false);
-      BoolVector processed(_res_node_num, false);
-      IntVector pred(_res_node_num);
-      for (int i = 0; i != _res_node_num; ++i) {
-        _next_out[i] = _first_out[i];
-      }
-      stack_top = -1;
-
-      int cycle_cnt = 0;
-      for (int start = 0; start != _res_node_num; ++start) {
-        if (reached[start]) continue;
-
-        // Start DFS search from this start node
-        pred[start] = -1;
-        int tip = start, v;
-        while (true) {
-          // Check the outgoing arcs of the current tip node
-          reached[tip] = true;
-          LargeCost pi_tip = _pi[tip];
-          int a, last_out = _first_out[tip+1];
-          for (a = _next_out[tip]; a != last_out; ++a) {
-            if (_res_cap[a] > 0) {
-              v = _target[a];
-              if (_cost[a] + pi_tip - _pi[v] < 0) {
-                if (!reached[v]) {
-                  // A new node is reached
-                  reached[v] = true;
-                  pred[v] = tip;
-                  _next_out[tip] = a;
-                  tip = v;
-                  a = _next_out[tip];
-                  last_out = _first_out[tip+1];
-                  break;
-                }
-                else if (!processed[v]) {
-                  // A cycle is found
-                  ++cycle_cnt;
-                  _next_out[tip] = a;
-
-                  // Find the minimum residual capacity along the cycle
-                  Value d, delta = _res_cap[a];
-                  int u, delta_node = tip;
-                  for (u = tip; u != v; ) {
-                    u = pred[u];
-                    d = _res_cap[_next_out[u]];
-                    if (d <= delta) {
-                      delta = d;
-                      delta_node = u;
-                    }
-                  }
-
-                  // Augment along the cycle
-                  _res_cap[a] -= delta;
-                  _res_cap[_reverse[a]] += delta;
-                  for (u = tip; u != v; ) {
-                    u = pred[u];
-                    int ca = _next_out[u];
-                    _res_cap[ca] -= delta;
-                    _res_cap[_reverse[ca]] += delta;
-                  }
-
-                  // Check the maximum number of cycle canceling
-                  if (cycle_cnt >= MAX_CYCLE_CANCEL) {
-                    return false;
-                  }
-
-                  // Roll back search to delta_node
-                  if (delta_node != tip) {
-                    for (u = tip; u != delta_node; u = pred[u]) {
-                      reached[u] = false;
-                    }
-                    tip = delta_node;
-                    a = _next_out[tip] + 1;
-                    last_out = _first_out[tip+1];
-                    break;
-                  }
-                }
-              }
-            }
-          }
-
-          // Step back to the previous node
-          if (a == last_out) {
-            processed[tip] = true;
-            stack[++stack_top] = tip;
-            tip = pred[tip];
-            if (tip < 0) {
-              // Finish DFS from the current start node
-              break;
-            }
-            ++_next_out[tip];
-          }
-        }
-
-      }
-
-      return (cycle_cnt == 0);
-    }
-
-    // Global potential update heuristic
-    void globalUpdate() {
-      const int bucket_end = _root + 1;
-
-      // Initialize buckets
-      for (int r = 0; r != _max_rank; ++r) {
-        _buckets[r] = bucket_end;
-      }
-      Value total_excess = 0;
-      int b0 = bucket_end;
-      for (int i = 0; i != _res_node_num; ++i) {
-        if (_excess[i] < 0) {
-          _rank[i] = 0;
-          _bucket_next[i] = b0;
-          _bucket_prev[b0] = i;
-          b0 = i;
-        } else {
-          total_excess += _excess[i];
-          _rank[i] = _max_rank;
-        }
-      }
-      if (total_excess == 0) return;
-      _buckets[0] = b0;
-
-      // Search the buckets
-      int r = 0;
-      for ( ; r != _max_rank; ++r) {
-        while (_buckets[r] != bucket_end) {
-          // Remove the first node from the current bucket
-          int u = _buckets[r];
-          _buckets[r] = _bucket_next[u];
-
-          // Search the incoming arcs of u
-          LargeCost pi_u = _pi[u];
-          int last_out = _first_out[u+1];
-          for (int a = _first_out[u]; a != last_out; ++a) {
-            int ra = _reverse[a];
-            if (_res_cap[ra] > 0) {
-              int v = _source[ra];
-              int old_rank_v = _rank[v];
-              if (r < old_rank_v) {
-                // Compute the new rank of v
-                LargeCost nrc = (_cost[ra] + _pi[v] - pi_u) / _epsilon;
-                int new_rank_v = old_rank_v;
-                if (nrc < LargeCost(_max_rank)) {
-                  new_rank_v = r + 1 + static_cast<int>(nrc);
-                }
-
-                // Change the rank of v
-                if (new_rank_v < old_rank_v) {
-                  _rank[v] = new_rank_v;
-                  _next_out[v] = _first_out[v];
-
-                  // Remove v from its old bucket
-                  if (old_rank_v < _max_rank) {
-                    if (_buckets[old_rank_v] == v) {
-                      _buckets[old_rank_v] = _bucket_next[v];
-                    } else {
-                      int pv = _bucket_prev[v], nv = _bucket_next[v];
-                      _bucket_next[pv] = nv;
-                      _bucket_prev[nv] = pv;
-                    }
-                  }
-
-                  // Insert v into its new bucket
-                  int nv = _buckets[new_rank_v];
-                  _bucket_next[v] = nv;
-                  _bucket_prev[nv] = v;
-                  _buckets[new_rank_v] = v;
-                }
-              }
-            }
-          }
-
-          // Finish search if there are no more active nodes
-          if (_excess[u] > 0) {
-            total_excess -= _excess[u];
-            if (total_excess <= 0) break;
-          }
-        }
-        if (total_excess <= 0) break;
-      }
-
-      // Relabel nodes
-      for (int u = 0; u != _res_node_num; ++u) {
-        int k = std::min(_rank[u], r);
-        if (k > 0) {
-          _pi[u] -= _epsilon * k;
-          _next_out[u] = _first_out[u];
+          if (!_forward[j]) _res_cap[j] += _lower[j];
         }
       }
@@ -1349,29 +892,58 @@
 
     /// Execute the algorithm performing augment and relabel operations
-    void startAugment(int max_length) {
+    void startAugment(int max_length = std::numeric_limits<int>::max()) {
       // Paramters for heuristics
-      const int PRICE_REFINEMENT_LIMIT = 2;
-      const double GLOBAL_UPDATE_FACTOR = 1.0;
-      const int global_update_skip = static_cast<int>(GLOBAL_UPDATE_FACTOR *
-        (_res_node_num + _sup_node_num * _sup_node_num));
-      int next_global_update_limit = global_update_skip;
+      const int BF_HEURISTIC_EPSILON_BOUND = 1000;
+      const int BF_HEURISTIC_BOUND_FACTOR  = 3;
 
       // Perform cost scaling phases
-      IntVector path;
-      BoolVector path_arc(_res_arc_num, false);
-      int relabel_cnt = 0;
-      int eps_phase_cnt = 0;
+      IntVector pred_arc(_res_node_num);
+      std::vector<int> path_nodes;
       for ( ; _epsilon >= 1; _epsilon = _epsilon < _alpha && _epsilon > 1 ?
                                         1 : _epsilon / _alpha )
       {
-        ++eps_phase_cnt;
-
-        // Price refinement heuristic
-        if (eps_phase_cnt >= PRICE_REFINEMENT_LIMIT) {
-          if (priceRefinement()) continue;
-        }
-
-        // Initialize current phase
-        initPhase();
+        // "Early Termination" heuristic: use Bellman-Ford algorithm
+        // to check if the current flow is optimal
+        if (_epsilon <= BF_HEURISTIC_EPSILON_BOUND) {
+          _arc_vec.clear();
+          _cost_vec.clear();
+          for (int j = 0; j != _res_arc_num; ++j) {
+            if (_res_cap[j] > 0) {
+              _arc_vec.push_back(IntPair(_source[j], _target[j]));
+              _cost_vec.push_back(_cost[j] + 1);
+            }
+          }
+          _sgr.build(_res_node_num, _arc_vec.begin(), _arc_vec.end());
+
+          BellmanFord<StaticDigraph, LargeCostArcMap> bf(_sgr, _cost_map);
+          bf.init(0);
+          bool done = false;
+          int K = int(BF_HEURISTIC_BOUND_FACTOR * sqrt(_res_node_num));
+          for (int i = 0; i < K && !done; ++i)
+            done = bf.processNextWeakRound();
+          if (done) break;
+        }
+
+        // Saturate arcs not satisfying the optimality condition
+        for (int a = 0; a != _res_arc_num; ++a) {
+          if (_res_cap[a] > 0 &&
+              _cost[a] + _pi[_source[a]] - _pi[_target[a]] < 0) {
+            Value delta = _res_cap[a];
+            _excess[_source[a]] -= delta;
+            _excess[_target[a]] += delta;
+            _res_cap[a] = 0;
+            _res_cap[_reverse[a]] += delta;
+          }
+        }
+        
+        // Find active nodes (i.e. nodes with positive excess)
+        for (int u = 0; u != _res_node_num; ++u) {
+          if (_excess[u] > 0) _active_nodes.push_back(u);
+        }
+
+        // Initialize the next arcs
+        for (int u = 0; u != _res_node_num; ++u) {
+          _next_out[u] = _first_out[u];
+        }
 
         // Perform partial augment and relabel operations
@@ -1384,57 +956,44 @@
           if (_active_nodes.size() == 0) break;
           int start = _active_nodes.front();
+          path_nodes.clear();
+          path_nodes.push_back(start);
 
           // Find an augmenting path from the start node
           int tip = start;
-          while (int(path.size()) < max_length && _excess[tip] >= 0) {
+          while (_excess[tip] >= 0 &&
+                 int(path_nodes.size()) <= max_length) {
             int u;
-            LargeCost rc, min_red_cost = std::numeric_limits<LargeCost>::max();
-            LargeCost pi_tip = _pi[tip];
-            int last_out = _first_out[tip+1];
+            LargeCost min_red_cost, rc;
+            int last_out = _sum_supply < 0 ?
+              _first_out[tip+1] : _first_out[tip+1] - 1;
             for (int a = _next_out[tip]; a != last_out; ++a) {
-              if (_res_cap[a] > 0) {
+              if (_res_cap[a] > 0 &&
+                  _cost[a] + _pi[_source[a]] - _pi[_target[a]] < 0) {
                 u = _target[a];
-                rc = _cost[a] + pi_tip - _pi[u];
-                if (rc < 0) {
-                  path.push_back(a);
-                  _next_out[tip] = a;
-                  if (path_arc[a]) {
-                    goto augment;   // a cycle is found, stop path search
-                  }
-                  tip = u;
-                  path_arc[a] = true;
-                  goto next_step;
-                }
-                else if (rc < min_red_cost) {
-                  min_red_cost = rc;
-                }
+                pred_arc[u] = a;
+                _next_out[tip] = a;
+                tip = u;
+                path_nodes.push_back(tip);
+                goto next_step;
               }
             }
 
             // Relabel tip node
-            if (tip != start) {
-              int ra = _reverse[path.back()];
-              min_red_cost =
-                std::min(min_red_cost, _cost[ra] + pi_tip - _pi[_target[ra]]);
-            }
-            last_out = _next_out[tip];
+            min_red_cost = std::numeric_limits<LargeCost>::max() / 2;
             for (int a = _first_out[tip]; a != last_out; ++a) {
-              if (_res_cap[a] > 0) {
-                rc = _cost[a] + pi_tip - _pi[_target[a]];
-                if (rc < min_red_cost) {
-                  min_red_cost = rc;
-                }
+              rc = _cost[a] + _pi[_source[a]] - _pi[_target[a]];
+              if (_res_cap[a] > 0 && rc < min_red_cost) {
+                min_red_cost = rc;
               }
             }
             _pi[tip] -= min_red_cost + _epsilon;
+
+            // Reset the next arc of tip
             _next_out[tip] = _first_out[tip];
-            ++relabel_cnt;
 
             // Step back
             if (tip != start) {
-              int pa = path.back();
-              path_arc[pa] = false;
-              tip = _source[pa];
-              path.pop_back();
+              path_nodes.pop_back();
+              tip = path_nodes.back();
             }
 
@@ -1443,12 +1002,10 @@
 
           // Augment along the found path (as much flow as possible)
-        augment:
           Value delta;
-          int pa, u, v = start;
-          for (int i = 0; i != int(path.size()); ++i) {
-            pa = path[i];
+          int u, v = path_nodes.front(), pa;
+          for (int i = 1; i < int(path_nodes.size()); ++i) {
             u = v;
-            v = _target[pa];
-            path_arc[pa] = false;
+            v = path_nodes[i];
+            pa = pred_arc[v];
             delta = std::min(_res_cap[pa], _excess[u]);
             _res_cap[pa] -= delta;
@@ -1456,19 +1013,9 @@
             _excess[u] -= delta;
             _excess[v] += delta;
-            if (_excess[v] > 0 && _excess[v] <= delta) {
+            if (_excess[v] > 0 && _excess[v] <= delta)
               _active_nodes.push_back(v);
-            }
           }
-          path.clear();
-
-          // Global update heuristic
-          if (relabel_cnt >= next_global_update_limit) {
-            globalUpdate();
-            next_global_update_limit += global_update_skip;
-          }
-        }
-
-      }
-
+        }
+      }
     }
 
@@ -1476,40 +1023,67 @@
     void startPush() {
       // Paramters for heuristics
-      const int PRICE_REFINEMENT_LIMIT = 2;
-      const double GLOBAL_UPDATE_FACTOR = 2.0;
-
-      const int global_update_skip = static_cast<int>(GLOBAL_UPDATE_FACTOR *
-        (_res_node_num + _sup_node_num * _sup_node_num));
-      int next_global_update_limit = global_update_skip;
+      const int BF_HEURISTIC_EPSILON_BOUND = 1000;
+      const int BF_HEURISTIC_BOUND_FACTOR  = 3;
 
       // Perform cost scaling phases
       BoolVector hyper(_res_node_num, false);
-      LargeCostVector hyper_cost(_res_node_num);
-      int relabel_cnt = 0;
-      int eps_phase_cnt = 0;
       for ( ; _epsilon >= 1; _epsilon = _epsilon < _alpha && _epsilon > 1 ?
                                         1 : _epsilon / _alpha )
       {
-        ++eps_phase_cnt;
-
-        // Price refinement heuristic
-        if (eps_phase_cnt >= PRICE_REFINEMENT_LIMIT) {
-          if (priceRefinement()) continue;
-        }
-
-        // Initialize current phase
-        initPhase();
+        // "Early Termination" heuristic: use Bellman-Ford algorithm
+        // to check if the current flow is optimal
+        if (_epsilon <= BF_HEURISTIC_EPSILON_BOUND) {
+          _arc_vec.clear();
+          _cost_vec.clear();
+          for (int j = 0; j != _res_arc_num; ++j) {
+            if (_res_cap[j] > 0) {
+              _arc_vec.push_back(IntPair(_source[j], _target[j]));
+              _cost_vec.push_back(_cost[j] + 1);
+            }
+          }
+          _sgr.build(_res_node_num, _arc_vec.begin(), _arc_vec.end());
+
+          BellmanFord<StaticDigraph, LargeCostArcMap> bf(_sgr, _cost_map);
+          bf.init(0);
+          bool done = false;
+          int K = int(BF_HEURISTIC_BOUND_FACTOR * sqrt(_res_node_num));
+          for (int i = 0; i < K && !done; ++i)
+            done = bf.processNextWeakRound();
+          if (done) break;
+        }
+
+        // Saturate arcs not satisfying the optimality condition
+        for (int a = 0; a != _res_arc_num; ++a) {
+          if (_res_cap[a] > 0 &&
+              _cost[a] + _pi[_source[a]] - _pi[_target[a]] < 0) {
+            Value delta = _res_cap[a];
+            _excess[_source[a]] -= delta;
+            _excess[_target[a]] += delta;
+            _res_cap[a] = 0;
+            _res_cap[_reverse[a]] += delta;
+          }
+        }
+
+        // Find active nodes (i.e. nodes with positive excess)
+        for (int u = 0; u != _res_node_num; ++u) {
+          if (_excess[u] > 0) _active_nodes.push_back(u);
+        }
+
+        // Initialize the next arcs
+        for (int u = 0; u != _res_node_num; ++u) {
+          _next_out[u] = _first_out[u];
+        }
 
         // Perform push and relabel operations
         while (_active_nodes.size() > 0) {
-          LargeCost min_red_cost, rc, pi_n;
+          LargeCost min_red_cost, rc;
           Value delta;
           int n, t, a, last_out = _res_arc_num;
 
+          // Select an active node (FIFO selection)
         next_node:
-          // Select an active node (FIFO selection)
           n = _active_nodes.front();
-          last_out = _first_out[n+1];
-          pi_n = _pi[n];
+          last_out = _sum_supply < 0 ?
+            _first_out[n+1] : _first_out[n+1] - 1;
 
           // Perform push operations if there are admissible arcs
@@ -1517,5 +1091,5 @@
             for (a = _next_out[n]; a != last_out; ++a) {
               if (_res_cap[a] > 0 &&
-                  _cost[a] + pi_n - _pi[_target[a]] < 0) {
+                  _cost[a] + _pi[_source[a]] - _pi[_target[a]] < 0) {
                 delta = std::min(_res_cap[a], _excess[n]);
                 t = _target[a];
@@ -1523,9 +1097,9 @@
                 // Push-look-ahead heuristic
                 Value ahead = -_excess[t];
-                int last_out_t = _first_out[t+1];
-                LargeCost pi_t = _pi[t];
+                int last_out_t = _sum_supply < 0 ?
+                  _first_out[t+1] : _first_out[t+1] - 1;
                 for (int ta = _next_out[t]; ta != last_out_t; ++ta) {
-                  if (_res_cap[ta] > 0 &&
-                      _cost[ta] + pi_t - _pi[_target[ta]] < 0)
+                  if (_res_cap[ta] > 0 && 
+                      _cost[ta] + _pi[_source[ta]] - _pi[_target[ta]] < 0)
                     ahead += _res_cap[ta];
                   if (ahead >= delta) break;
@@ -1534,5 +1108,5 @@
 
                 // Push flow along the arc
-                if (ahead < delta && !hyper[t]) {
+                if (ahead < delta) {
                   _res_cap[a] -= ahead;
                   _res_cap[_reverse[a]] += ahead;
@@ -1541,5 +1115,4 @@
                   _active_nodes.push_front(t);
                   hyper[t] = true;
-                  hyper_cost[t] = _cost[a] + pi_n - pi_t;
                   _next_out[n] = a;
                   goto next_node;
@@ -1564,20 +1137,18 @@
           // Relabel the node if it is still active (or hyper)
           if (_excess[n] > 0 || hyper[n]) {
-             min_red_cost = hyper[n] ? -hyper_cost[n] :
-               std::numeric_limits<LargeCost>::max();
+            min_red_cost = std::numeric_limits<LargeCost>::max() / 2;
             for (int a = _first_out[n]; a != last_out; ++a) {
-              if (_res_cap[a] > 0) {
-                rc = _cost[a] + pi_n - _pi[_target[a]];
-                if (rc < min_red_cost) {
-                  min_red_cost = rc;
-                }
+              rc = _cost[a] + _pi[_source[a]] - _pi[_target[a]];
+              if (_res_cap[a] > 0 && rc < min_red_cost) {
+                min_red_cost = rc;
               }
             }
             _pi[n] -= min_red_cost + _epsilon;
+            hyper[n] = false;
+
+            // Reset the next arc
             _next_out[n] = _first_out[n];
-            hyper[n] = false;
-            ++relabel_cnt;
           }
-
+        
           // Remove nodes that are not active nor hyper
         remove_nodes:
@@ -1587,12 +1158,4 @@
             _active_nodes.pop_front();
           }
-
-          // Global update heuristic
-          if (relabel_cnt >= next_global_update_limit) {
-            globalUpdate();
-            for (int u = 0; u != _res_node_num; ++u)
-              hyper[u] = false;
-            next_global_update_limit += global_update_skip;
-          }
         }
       }
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 793)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -38,52 +38,34 @@
   }
 
-  void CplexEnv::incCnt()
-  {
-    _cnt_lock->lock();
+  CplexEnv::CplexEnv() {
+    int status;
+    _cnt = new int;
+    _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 +87,6 @@
     int status;
     _prob = CPXcloneprob(cplexEnv(), cplex._prob, &status);
-    _rows = cplex._rows;
-    _cols = cplex._cols;
+    rows = cplex.rows;
+    cols = cplex.cols;
     messageLevel(MESSAGE_NOTHING);
   }
@@ -130,11 +112,24 @@
   }
 
-  int CplexBase::_addRow(Value lb, ExprIterator b,
+  int CplexBase::_addRow(Value lb, ExprIterator b, 
                          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 +137,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 +155,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);
   }
 
@@ -492,4 +471,6 @@
     int status;
     _prob = CPXcreateprob(cplexEnv(), &status, "Cplex problem");
+    rows.clear();
+    cols.clear();
   }
 
@@ -509,18 +490,7 @@
 
   void CplexBase::_applyMessageLevel() {
-    CPXsetintparam(cplexEnv(), CPX_PARAM_SCRIND,
+    CPXsetintparam(cplexEnv(), CPX_PARAM_SCRIND, 
                    _message_enabled ? CPX_ON : CPX_OFF);
   }
-
-  void CplexBase::_write(std::string file, std::string format) const
-  {
-    if(format == "MPS" || format == "LP")
-      CPXwriteprob(cplexEnv(), cplexLp(), file.c_str(), format.c_str());
-    else if(format == "SOL")
-      CPXsolwrite(cplexEnv(), cplexLp(), file.c_str());
-    else throw UnsupportedFormatError(format);
-  }
-
-
 
   // CplexLp members
Index: lemon/cplex.h
===================================================================
--- lemon/cplex.h	(revision 1347)
+++ lemon/cplex.h	(revision 793)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -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:
 
@@ -156,6 +151,4 @@
     bool _message_enabled;
 
-    void _write(std::string file, std::string format) const;
-
   public:
 
@@ -178,17 +171,4 @@
     const cpxlp* cplexLp() const { return _prob; }
 
-#ifdef DOXYGEN
-    /// Write the problem or the solution to a file in the given format
-
-    /// This function writes the problem or the solution
-    /// to a file in the given format.
-    /// Trying to write in an unsupported format will trigger
-    /// \ref lemon::LpBase::UnsupportedFormatError "UnsupportedFormatError".
-    /// \param file The file path
-    /// \param format The output file format.
-    /// Supportted formats are "MPS", "LP" and "SOL".
-    void write(std::string file, std::string format = "MPS") const {}
-#endif
-
   };
 
Index: lemon/cycle_canceling.h
===================================================================
--- lemon/cycle_canceling.h	(revision 1298)
+++ lemon/cycle_canceling.h	(revision 886)
@@ -1,7 +1,7 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
+/* -*- C++ -*-
  *
- * This file is a part of LEMON, a generic C++ optimization library.
+ * This file is a part of LEMON, a generic C++ optimization library
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -35,6 +35,5 @@
 #include <lemon/circulation.h>
 #include <lemon/bellman_ford.h>
-#include <lemon/howard_mmc.h>
-#include <lemon/hartmann_orlin_mmc.h>
+#include <lemon/howard.h>
 
 namespace lemon {
@@ -48,12 +47,11 @@
   /// \ref CycleCanceling implements three different cycle-canceling
   /// algorithms for finding a \ref min_cost_flow "minimum cost flow"
-  /// \cite amo93networkflows, \cite klein67primal,
-  /// \cite goldberg89cyclecanceling.
-  /// The most efficent one is the \ref CANCEL_AND_TIGHTEN
-  /// "Cancel-and-Tighten" algorithm, thus it is the default method.
-  /// It runs in strongly polynomial time \f$O(n^2 m^2 \log n)\f$,
-  /// but in practice, it is typically orders of magnitude slower than
-  /// the scaling algorithms and \ref NetworkSimplex.
-  /// (For more information, see \ref min_cost_flow_algs "the module page".)
+  /// \ref amo93networkflows, \ref klein67primal,
+  /// \ref goldberg89cyclecanceling.
+  /// The most efficent one (both theoretically and practically)
+  /// is the \ref CANCEL_AND_TIGHTEN "Cancel and Tighten" algorithm,
+  /// thus it is the default method.
+  /// It is strongly polynomial, but in practice, it is typically much
+  /// slower than the scaling algorithms and NetworkSimplex.
   ///
   /// Most of the parameters of the problem (except for the digraph)
@@ -68,9 +66,8 @@
   /// algorithm. By default, it is the same as \c V.
   ///
-  /// \warning Both \c V and \c C must be signed number types.
-  /// \warning All input data (capacities, supply values, and costs) must
+  /// \warning Both number types must be signed and all input data must
   /// be integer.
-  /// \warning This algorithm does not support negative costs for
-  /// arcs having infinite upper bound.
+  /// \warning This algorithm does not support negative costs for such
+  /// arcs that have infinite upper bound.
   ///
   /// \note For more information about the three available methods,
@@ -119,26 +116,25 @@
     ///
     /// \ref CycleCanceling provides three different cycle-canceling
-    /// methods. By default, \ref CANCEL_AND_TIGHTEN "Cancel-and-Tighten"
-    /// is used, which is by far the most efficient and the most robust.
+    /// methods. By default, \ref CANCEL_AND_TIGHTEN "Cancel and Tighten"
+    /// is used, which proved to be the most efficient and the most robust
+    /// on various test inputs.
     /// However, the other methods can be selected using the \ref run()
     /// function with the proper parameter.
     enum Method {
       /// A simple cycle-canceling method, which uses the
-      /// \ref BellmanFord "Bellman-Ford" algorithm for detecting negative
-      /// cycles in the residual network.
-      /// The number of Bellman-Ford iterations is bounded by a successively
-      /// increased limit.
+      /// \ref BellmanFord "Bellman-Ford" algorithm with limited iteration
+      /// number for detecting negative cycles in the residual network.
       SIMPLE_CYCLE_CANCELING,
       /// The "Minimum Mean Cycle-Canceling" algorithm, which is a
       /// well-known strongly polynomial method
-      /// \cite goldberg89cyclecanceling. It improves along a
+      /// \ref goldberg89cyclecanceling. It improves along a
       /// \ref min_mean_cycle "minimum mean cycle" in each iteration.
-      /// Its running time complexity is \f$O(n^2 m^3 \log n)\f$.
+      /// Its running time complexity is O(n<sup>2</sup>m<sup>3</sup>log(n)).
       MINIMUM_MEAN_CYCLE_CANCELING,
-      /// The "Cancel-and-Tighten" algorithm, which can be viewed as an
+      /// The "Cancel And Tighten" algorithm, which can be viewed as an
       /// improved version of the previous method
-      /// \cite goldberg89cyclecanceling.
+      /// \ref goldberg89cyclecanceling.
       /// It is faster both in theory and in practice, its running time
-      /// complexity is \f$O(n^2 m^2 \log n)\f$.
+      /// complexity is O(n<sup>2</sup>m<sup>2</sup>log(n)).
       CANCEL_AND_TIGHTEN
     };
@@ -147,14 +143,13 @@
 
     TEMPLATE_DIGRAPH_TYPEDEFS(GR);
-
+    
     typedef std::vector<int> IntVector;
+    typedef std::vector<char> CharVector;
     typedef std::vector<double> DoubleVector;
     typedef std::vector<Value> ValueVector;
     typedef std::vector<Cost> CostVector;
-    typedef std::vector<char> BoolVector;
-    // Note: vector<char> is used instead of vector<bool> for efficiency reasons
 
   private:
-
+  
     template <typename KT, typename VT>
     class StaticVectorMap {
@@ -162,7 +157,7 @@
       typedef KT Key;
       typedef VT Value;
-
+      
       StaticVectorMap(std::vector<Value>& v) : _v(v) {}
-
+      
       const Value& operator[](const Key& key) const {
         return _v[StaticDigraph::id(key)];
@@ -172,5 +167,5 @@
         return _v[StaticDigraph::id(key)];
       }
-
+      
       void set(const Key& key, const Value& val) {
         _v[StaticDigraph::id(key)] = val;
@@ -196,5 +191,5 @@
 
     // Parameters of the problem
-    bool _has_lower;
+    bool _have_lower;
     Value _sum_supply;
 
@@ -204,5 +199,5 @@
     IntArcMap _arc_idb;
     IntVector _first_out;
-    BoolVector _forward;
+    CharVector _forward;
     IntVector _source;
     IntVector _target;
@@ -226,7 +221,7 @@
     CostArcMap _cost_map;
     CostNodeMap _pi_map;
-
+  
   public:
-
+  
     /// \brief Constant for infinite upper bounds (capacities).
     ///
@@ -256,5 +251,69 @@
         "The cost type of CycleCanceling must be signed");
 
-      // Reset data structures
+      // Resize vectors
+      _node_num = countNodes(_graph);
+      _arc_num = countArcs(_graph);
+      _res_node_num = _node_num + 1;
+      _res_arc_num = 2 * (_arc_num + _node_num);
+      _root = _node_num;
+
+      _first_out.resize(_res_node_num + 1);
+      _forward.resize(_res_arc_num);
+      _source.resize(_res_arc_num);
+      _target.resize(_res_arc_num);
+      _reverse.resize(_res_arc_num);
+
+      _lower.resize(_res_arc_num);
+      _upper.resize(_res_arc_num);
+      _cost.resize(_res_arc_num);
+      _supply.resize(_res_node_num);
+      
+      _res_cap.resize(_res_arc_num);
+      _pi.resize(_res_node_num);
+
+      _arc_vec.reserve(_res_arc_num);
+      _cost_vec.reserve(_res_arc_num);
+      _id_vec.reserve(_res_arc_num);
+
+      // Copy the graph
+      int i = 0, j = 0, k = 2 * _arc_num + _node_num;
+      for (NodeIt n(_graph); n != INVALID; ++n, ++i) {
+        _node_id[n] = i;
+      }
+      i = 0;
+      for (NodeIt n(_graph); n != INVALID; ++n, ++i) {
+        _first_out[i] = j;
+        for (OutArcIt a(_graph, n); a != INVALID; ++a, ++j) {
+          _arc_idf[a] = j;
+          _forward[j] = true;
+          _source[j] = i;
+          _target[j] = _node_id[_graph.runningNode(a)];
+        }
+        for (InArcIt a(_graph, n); a != INVALID; ++a, ++j) {
+          _arc_idb[a] = j;
+          _forward[j] = false;
+          _source[j] = i;
+          _target[j] = _node_id[_graph.runningNode(a)];
+        }
+        _forward[j] = false;
+        _source[j] = i;
+        _target[j] = _root;
+        _reverse[j] = k;
+        _forward[k] = true;
+        _source[k] = _root;
+        _target[k] = i;
+        _reverse[k] = j;
+        ++j; ++k;
+      }
+      _first_out[i] = j;
+      _first_out[_res_node_num] = k;
+      for (ArcIt a(_graph); a != INVALID; ++a) {
+        int fi = _arc_idf[a];
+        int bi = _arc_idb[a];
+        _reverse[fi] = bi;
+        _reverse[bi] = fi;
+      }
+      
+      // Reset parameters
       reset();
     }
@@ -279,7 +338,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;
@@ -353,5 +413,5 @@
     ///
     /// Using this function has the same effect as using \ref supplyMap()
-    /// with a map in which \c k is assigned to \c s, \c -k is
+    /// with such a map in which \c k is assigned to \c s, \c -k is
     /// assigned to \c t and all other nodes have zero supply value.
     ///
@@ -370,5 +430,5 @@
       return *this;
     }
-
+    
     /// @}
 
@@ -390,10 +450,10 @@
     /// \endcode
     ///
-    /// This function can be called more than once. All the given parameters
-    /// are kept for the next call, unless \ref resetParams() or \ref reset()
-    /// is used, thus only the modified parameters have to be set again.
-    /// If the underlying digraph was also modified after the construction
-    /// of the class (or the last \ref reset() call), then the \ref reset()
-    /// function must be called.
+    /// This function can be called more than once. All the parameters
+    /// that have been given are kept for the next call, unless
+    /// \ref reset() is called, thus only the modified parameters
+    /// have to be set again. See \ref reset() for examples.
+    /// However, the underlying digraph must not be modified after this
+    /// class have been constructed, since it copies and extends the graph.
     ///
     /// \param method The cycle-canceling method that will be used.
@@ -411,5 +471,4 @@
     ///
     /// \see ProblemType, Method
-    /// \see resetParams(), reset()
     ProblemType run(Method method = CANCEL_AND_TIGHTEN) {
       ProblemType pt = init();
@@ -425,10 +484,9 @@
     /// \ref costMap(), \ref supplyMap(), \ref stSupply().
     ///
-    /// It is useful for multiple \ref run() calls. Basically, all the given
-    /// parameters are kept for the next \ref run() call, unless
-    /// \ref resetParams() or \ref reset() is used.
-    /// If the underlying digraph was also modified after the construction
-    /// of the class or the last \ref reset() call, then the \ref reset()
-    /// function must be used, otherwise \ref resetParams() is sufficient.
+    /// It is useful for multiple run() calls. If this function is not
+    /// used, all the parameters given before are kept for the next
+    /// \ref run() call.
+    /// However, the underlying digraph must not be modified after this
+    /// class have been constructed, since it copies and extends the graph.
     ///
     /// For example,
@@ -440,12 +498,12 @@
     ///     .supplyMap(sup).run();
     ///
-    ///   // Run again with modified cost map (resetParams() is not called,
+    ///   // Run again with modified cost map (reset() is not called,
     ///   // so only the cost map have to be set again)
     ///   cost[e] += 100;
     ///   cc.costMap(cost).run();
     ///
-    ///   // Run again from scratch using resetParams()
+    ///   // Run again from scratch using reset()
     ///   // (the lower bounds will be set to zero on all arcs)
-    ///   cc.resetParams();
+    ///   cc.reset();
     ///   cc.upperMap(capacity).costMap(cost)
     ///     .supplyMap(sup).run();
@@ -453,7 +511,5 @@
     ///
     /// \return <tt>(*this)</tt>
-    ///
-    /// \see reset(), run()
-    CycleCanceling& resetParams() {
+    CycleCanceling& reset() {
       for (int i = 0; i != _res_node_num; ++i) {
         _supply[i] = 0;
@@ -470,95 +526,6 @@
         _cost[j] = 0;
         _cost[_reverse[j]] = 0;
-      }
-      _has_lower = false;
-      return *this;
-    }
-
-    /// \brief Reset the internal data structures and all the parameters
-    /// that have been given before.
-    ///
-    /// This function resets the internal data structures and all the
-    /// paramaters that have been given before using functions \ref lowerMap(),
-    /// \ref upperMap(), \ref costMap(), \ref supplyMap(), \ref stSupply().
-    ///
-    /// It is useful for multiple \ref run() calls. Basically, all the given
-    /// parameters are kept for the next \ref run() call, unless
-    /// \ref resetParams() or \ref reset() is used.
-    /// If the underlying digraph was also modified after the construction
-    /// of the class or the last \ref reset() call, then the \ref reset()
-    /// function must be used, otherwise \ref resetParams() is sufficient.
-    ///
-    /// See \ref resetParams() for examples.
-    ///
-    /// \return <tt>(*this)</tt>
-    ///
-    /// \see resetParams(), run()
-    CycleCanceling& reset() {
-      // Resize vectors
-      _node_num = countNodes(_graph);
-      _arc_num = countArcs(_graph);
-      _res_node_num = _node_num + 1;
-      _res_arc_num = 2 * (_arc_num + _node_num);
-      _root = _node_num;
-
-      _first_out.resize(_res_node_num + 1);
-      _forward.resize(_res_arc_num);
-      _source.resize(_res_arc_num);
-      _target.resize(_res_arc_num);
-      _reverse.resize(_res_arc_num);
-
-      _lower.resize(_res_arc_num);
-      _upper.resize(_res_arc_num);
-      _cost.resize(_res_arc_num);
-      _supply.resize(_res_node_num);
-
-      _res_cap.resize(_res_arc_num);
-      _pi.resize(_res_node_num);
-
-      _arc_vec.reserve(_res_arc_num);
-      _cost_vec.reserve(_res_arc_num);
-      _id_vec.reserve(_res_arc_num);
-
-      // Copy the graph
-      int i = 0, j = 0, k = 2 * _arc_num + _node_num;
-      for (NodeIt n(_graph); n != INVALID; ++n, ++i) {
-        _node_id[n] = i;
-      }
-      i = 0;
-      for (NodeIt n(_graph); n != INVALID; ++n, ++i) {
-        _first_out[i] = j;
-        for (OutArcIt a(_graph, n); a != INVALID; ++a, ++j) {
-          _arc_idf[a] = j;
-          _forward[j] = true;
-          _source[j] = i;
-          _target[j] = _node_id[_graph.runningNode(a)];
-        }
-        for (InArcIt a(_graph, n); a != INVALID; ++a, ++j) {
-          _arc_idb[a] = j;
-          _forward[j] = false;
-          _source[j] = i;
-          _target[j] = _node_id[_graph.runningNode(a)];
-        }
-        _forward[j] = false;
-        _source[j] = i;
-        _target[j] = _root;
-        _reverse[j] = k;
-        _forward[k] = true;
-        _source[k] = _root;
-        _target[k] = i;
-        _reverse[k] = j;
-        ++j; ++k;
-      }
-      _first_out[i] = j;
-      _first_out[_res_node_num] = k;
-      for (ArcIt a(_graph); a != INVALID; ++a) {
-        int fi = _arc_idf[a];
-        int bi = _arc_idb[a];
-        _reverse[fi] = bi;
-        _reverse[bi] = fi;
-      }
-
-      // Reset parameters
-      resetParams();
+      }      
+      _have_lower = false;
       return *this;
     }
@@ -576,5 +543,5 @@
     ///
     /// This function returns the total cost of the found flow.
-    /// Its complexity is O(m).
+    /// Its complexity is O(e).
     ///
     /// \note The return type of the function can be specified as a
@@ -614,6 +581,5 @@
     }
 
-    /// \brief Copy the flow values (the primal solution) into the
-    /// given map.
+    /// \brief Return the flow map (the primal solution).
     ///
     /// This function copies the flow value on each arc into the given
@@ -639,6 +605,5 @@
     }
 
-    /// \brief Copy the potential values (the dual solution) into the
-    /// given map.
+    /// \brief Return the potential map (the dual solution).
     ///
     /// This function copies the potential (dual value) of each node
@@ -669,9 +634,5 @@
       }
       if (_sum_supply > 0) return INFEASIBLE;
-
-      // Check lower and upper bounds
-      LEMON_DEBUG(checkBoundMaps(),
-          "Upper bounds must be greater or equal to the lower bounds");
-
+      
 
       // Initialize vectors
@@ -680,9 +641,9 @@
       }
       ValueVector excess(_supply);
-
+      
       // Remove infinite upper bounds and check negative arcs
       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 +688,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];
@@ -780,17 +741,8 @@
         }
       }
-
+      
       return OPTIMAL;
     }
-
-    // Check if the upper bound is greater than or equal to the lower bound
-    // on each forward arc.
-    bool checkBoundMaps() {
-      for (int j = 0; j != _res_arc_num; ++j) {
-        if (_forward[j] && _upper[j] < _lower[j]) return false;
-      }
-      return true;
-    }
-
+    
     // Build a StaticDigraph structure containing the current
     // residual network
@@ -835,8 +787,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];
         }
       }
@@ -848,5 +800,5 @@
       const int BF_FIRST_LIMIT  = 2;
       const double BF_LIMIT_FACTOR = 1.5;
-
+      
       typedef StaticVectorMap<StaticDigraph::Arc, Value> FilterMap;
       typedef FilterArcs<StaticDigraph, FilterMap> ResDigraph;
@@ -855,5 +807,5 @@
         ::template SetDistMap<CostNodeMap>
         ::template SetPredMap<PredMap>::Create BF;
-
+      
       // Build the residual network
       _arc_vec.clear();
@@ -941,39 +893,16 @@
     // Execute the "Minimum Mean Cycle Canceling" method
     void startMinMeanCycleCanceling() {
-      typedef Path<StaticDigraph> SPath;
+      typedef SimplePath<StaticDigraph> SPath;
       typedef typename SPath::ArcIt SPathArcIt;
-      typedef typename HowardMmc<StaticDigraph, CostArcMap>
-        ::template SetPath<SPath>::Create HwMmc;
-      typedef typename HartmannOrlinMmc<StaticDigraph, CostArcMap>
-        ::template SetPath<SPath>::Create HoMmc;
-
-      const double HW_ITER_LIMIT_FACTOR = 1.0;
-      const int HW_ITER_LIMIT_MIN_VALUE = 5;
-
-      const int hw_iter_limit =
-          std::max(static_cast<int>(HW_ITER_LIMIT_FACTOR * _node_num),
-                   HW_ITER_LIMIT_MIN_VALUE);
-
+      typedef typename Howard<StaticDigraph, CostArcMap>
+        ::template SetPath<SPath>::Create MMC;
+      
       SPath cycle;
-      HwMmc hw_mmc(_sgr, _cost_map);
-      hw_mmc.cycle(cycle);
+      MMC mmc(_sgr, _cost_map);
+      mmc.cycle(cycle);
       buildResidualNetwork();
-      while (true) {
-
-        typename HwMmc::TerminationCause hw_tc =
-            hw_mmc.findCycleMean(hw_iter_limit);
-        if (hw_tc == HwMmc::ITERATION_LIMIT) {
-          // Howard's algorithm reached the iteration limit, start a
-          // strongly polynomial algorithm instead
-          HoMmc ho_mmc(_sgr, _cost_map);
-          ho_mmc.cycle(cycle);
-          // Find a minimum mean cycle (Hartmann-Orlin algorithm)
-          if (!(ho_mmc.findCycleMean() && ho_mmc.cycleCost() < 0)) break;
-          ho_mmc.findCycle();
-        } else {
-          // Find a minimum mean cycle (Howard algorithm)
-          if (!(hw_tc == HwMmc::OPTIMAL && hw_mmc.cycleCost() < 0)) break;
-          hw_mmc.findCycle();
-        }
+      while (mmc.findMinMean() && mmc.cycleLength() < 0) {
+        // Find the cycle
+        mmc.findCycle();
 
         // Compute delta value
@@ -991,26 +920,20 @@
         }
 
-        // Rebuild the residual network
+        // Rebuild the residual network        
         buildResidualNetwork();
       }
     }
 
-    // Execute the "Cancel-and-Tighten" method
+    // Execute the "Cancel And Tighten" method
     void startCancelAndTighten() {
       // Constants for the min mean cycle computations
       const double LIMIT_FACTOR = 1.0;
       const int MIN_LIMIT = 5;
-      const double HW_ITER_LIMIT_FACTOR = 1.0;
-      const int HW_ITER_LIMIT_MIN_VALUE = 5;
-
-      const int hw_iter_limit =
-          std::max(static_cast<int>(HW_ITER_LIMIT_FACTOR * _node_num),
-                   HW_ITER_LIMIT_MIN_VALUE);
 
       // Contruct auxiliary data vectors
       DoubleVector pi(_res_node_num, 0.0);
       IntVector level(_res_node_num);
-      BoolVector reached(_res_node_num);
-      BoolVector processed(_res_node_num);
+      CharVector reached(_res_node_num);
+      CharVector processed(_res_node_num);
       IntVector pred_node(_res_node_num);
       IntVector pred_arc(_res_node_num);
@@ -1180,29 +1103,16 @@
           }
         } else {
-          typedef HowardMmc<StaticDigraph, CostArcMap> HwMmc;
-          typedef HartmannOrlinMmc<StaticDigraph, CostArcMap> HoMmc;
+          typedef Howard<StaticDigraph, CostArcMap> MMC;
           typedef typename BellmanFord<StaticDigraph, CostArcMap>
             ::template SetDistMap<CostNodeMap>::Create BF;
 
           // Set epsilon to the minimum cycle mean
-          Cost cycle_cost = 0;
-          int cycle_size = 1;
           buildResidualNetwork();
-          HwMmc hw_mmc(_sgr, _cost_map);
-          if (hw_mmc.findCycleMean(hw_iter_limit) == HwMmc::ITERATION_LIMIT) {
-            // Howard's algorithm reached the iteration limit, start a
-            // strongly polynomial algorithm instead
-            HoMmc ho_mmc(_sgr, _cost_map);
-            ho_mmc.findCycleMean();
-            epsilon = -ho_mmc.cycleMean();
-            cycle_cost = ho_mmc.cycleCost();
-            cycle_size = ho_mmc.cycleSize();
-          } else {
-            // Set epsilon
-            epsilon = -hw_mmc.cycleMean();
-            cycle_cost = hw_mmc.cycleCost();
-            cycle_size = hw_mmc.cycleSize();
-          }
-
+          MMC mmc(_sgr, _cost_map);
+          mmc.findMinMean();
+          epsilon = -mmc.cycleMean();
+          Cost cycle_cost = mmc.cycleLength();
+          int cycle_size = mmc.cycleArcNum();
+          
           // Compute feasible potentials for the current epsilon
           for (int i = 0; i != int(_cost_vec.size()); ++i) {
@@ -1216,5 +1126,5 @@
             pi[u] = static_cast<double>(_pi[u]) / cycle_size;
           }
-
+        
           iter = limit;
         }
Index: lemon/dfs.h
===================================================================
--- lemon/dfs.h	(revision 1270)
+++ lemon/dfs.h	(revision 835)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -83,6 +83,5 @@
 
     ///The type of the map that indicates which nodes are reached.
-    ///It must conform to
-    ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
     ///Instantiates a \c ReachedMap.
@@ -123,9 +122,4 @@
   ///\tparam GR The type of the digraph the algorithm runs on.
   ///The default type is \ref ListDigraph.
-  ///\tparam TR The traits class that defines various types used by the
-  ///algorithm. By default, it is \ref DfsDefaultTraits
-  ///"DfsDefaultTraits<GR>".
-  ///In most cases, this parameter should not be set directly,
-  ///consider to use the named template parameters instead.
 #ifdef DOXYGEN
   template <typename GR,
@@ -153,5 +147,5 @@
     typedef PredMapPath<Digraph, PredMap> Path;
 
-    ///The \ref lemon::DfsDefaultTraits "traits class" of the algorithm.
+    ///The \ref DfsDefaultTraits "traits class" of the algorithm.
     typedef TR Traits;
 
@@ -272,6 +266,5 @@
     ///\ref named-templ-param "Named parameter" for setting
     ///\c ReachedMap type.
-    ///It must conform to
-    ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     template <class T>
     struct SetReachedMap : public Dfs< Digraph, SetReachedMapTraits<T> > {
@@ -566,5 +559,5 @@
     void start(Node t)
     {
-      while ( !emptyQueue() && !(*_reached)[t] )
+      while ( !emptyQueue() && G->target(_stack[_stack_head])!=t )
         processNextArc();
     }
@@ -805,6 +798,5 @@
 
     ///The type of the map that indicates which nodes are reached.
-    ///It must conform to
-    ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
     ///Instantiates a ReachedMap.
@@ -896,7 +888,4 @@
   /// This class should only be used through the \ref dfs() function,
   /// which makes it easier to use the algorithm.
-  ///
-  /// \tparam TR The traits class that defines various types used by the
-  /// algorithm.
   template<class TR>
   class DfsWizard : public TR
@@ -1194,5 +1183,4 @@
       }
       _Visitor& visitor;
-      Constraints() {}
     };
   };
@@ -1212,6 +1200,5 @@
     ///
     /// The type of the map that indicates which nodes are reached.
-    /// It must conform to the
-    /// \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    /// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
 
@@ -1251,9 +1238,9 @@
   /// does not observe the DFS events. If you want to observe the DFS
   /// events, you should implement your own visitor class.
-  /// \tparam TR The traits class that defines various types used by the
-  /// algorithm. By default, it is \ref DfsVisitDefaultTraits
-  /// "DfsVisitDefaultTraits<GR>".
-  /// In most cases, this parameter should not be set directly,
-  /// consider to use the named template parameters instead.
+  /// \tparam TR Traits class to set various data types used by the
+  /// algorithm. The default traits class is
+  /// \ref DfsVisitDefaultTraits "DfsVisitDefaultTraits<GR>".
+  /// See \ref DfsVisitDefaultTraits for the documentation of
+  /// a DFS visit traits class.
 #ifdef DOXYGEN
   template <typename GR, typename VS, typename TR>
@@ -1514,5 +1501,5 @@
     /// with addSource() before using this function.
     void start(Node t) {
-      while ( !emptyQueue() && !(*_reached)[t] )
+      while ( !emptyQueue() && _digraph->target(_stack[_stack_head]) != t )
         processNextArc();
     }
Index: mon/dheap.h
===================================================================
--- lemon/dheap.h	(revision 929)
+++ 	(revision )
@@ -1,352 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2009
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * 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_DHEAP_H
-#define LEMON_DHEAP_H
-
-///\ingroup heaps
-///\file
-///\brief D-ary heap implementation.
-
-#include <vector>
-#include <utility>
-#include <functional>
-
-namespace lemon {
-
-  /// \ingroup heaps
-  ///
-  ///\brief D-ary heap data structure.
-  ///
-  /// This class implements the \e D-ary \e heap data structure.
-  /// It fully conforms to the \ref concepts::Heap "heap concept".
-  ///
-  /// The \ref DHeap "D-ary heap" is a generalization of the
-  /// \ref BinHeap "binary heap" structure, its nodes have at most
-  /// \c D children, instead of two.
-  /// \ref BinHeap and \ref QuadHeap are specialized implementations
-  /// of this structure for <tt>D=2</tt> and <tt>D=4</tt>, respectively.
-  ///
-  /// \tparam PR Type of the priorities of the items.
-  /// \tparam IM A read-writable item map with \c int values, used
-  /// internally to handle the cross references.
-  /// \tparam D The degree of the heap, each node have at most \e D
-  /// children. The default is 16. Powers of two are suggested to use
-  /// so that the multiplications and divisions needed to traverse the
-  /// nodes of the heap could be performed faster.
-  /// \tparam CMP A functor class for comparing the priorities.
-  /// The default is \c std::less<PR>.
-  ///
-  ///\sa BinHeap
-  ///\sa FouraryHeap
-#ifdef DOXYGEN
-  template <typename PR, typename IM, int D, typename CMP>
-#else
-  template <typename PR, typename IM, int D = 16,
-            typename CMP = std::less<PR> >
-#endif
-  class DHeap {
-  public:
-    /// Type of the item-int map.
-    typedef IM ItemIntMap;
-    /// Type of the priorities.
-    typedef PR Prio;
-    /// Type of the items stored in the heap.
-    typedef typename ItemIntMap::Key Item;
-    /// Type of the item-priority pairs.
-    typedef std::pair<Item,Prio> Pair;
-    /// Functor type for comparing the priorities.
-    typedef CMP Compare;
-
-    /// \brief Type to represent the states of the items.
-    ///
-    /// Each item has a state associated to it. It can be "in heap",
-    /// "pre-heap" or "post-heap". The latter two are indifferent from the
-    /// heap's point of view, but may be useful to the user.
-    ///
-    /// The item-int map must be initialized in such way that it assigns
-    /// \c PRE_HEAP (<tt>-1</tt>) to any element to be put in the heap.
-    enum State {
-      IN_HEAP = 0,    ///< = 0.
-      PRE_HEAP = -1,  ///< = -1.
-      POST_HEAP = -2  ///< = -2.
-    };
-
-  private:
-    std::vector<Pair> _data;
-    Compare _comp;
-    ItemIntMap &_iim;
-
-  public:
-    /// \brief Constructor.
-    ///
-    /// Constructor.
-    /// \param map A map that assigns \c int values to the items.
-    /// It is used internally to handle the cross references.
-    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
-    explicit DHeap(ItemIntMap &map) : _iim(map) {}
-
-    /// \brief Constructor.
-    ///
-    /// Constructor.
-    /// \param map A map that assigns \c int values to the items.
-    /// It is used internally to handle the cross references.
-    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
-    /// \param comp The function object used for comparing the priorities.
-    DHeap(ItemIntMap &map, const Compare &comp)
-      : _iim(map), _comp(comp) {}
-
-    /// \brief The number of items stored in the heap.
-    ///
-    /// This function returns the number of items stored in the heap.
-    int size() const { return _data.size(); }
-
-    /// \brief Check if the heap is empty.
-    ///
-    /// This function returns \c true if the heap is empty.
-    bool empty() const { return _data.empty(); }
-
-    /// \brief Make the heap empty.
-    ///
-    /// This functon makes the heap empty.
-    /// It does not change the cross reference map. If you want to reuse
-    /// a heap that is not surely empty, you should first clear it and
-    /// then you should set the cross reference map to \c PRE_HEAP
-    /// for each item.
-    void clear() { _data.clear(); }
-
-  private:
-    int parent(int i) { return (i-1)/D; }
-    int firstChild(int i) { return D*i+1; }
-
-    bool less(const Pair &p1, const Pair &p2) const {
-      return _comp(p1.second, p2.second);
-    }
-
-    void bubbleUp(int hole, Pair p) {
-      int par = parent(hole);
-      while( hole>0 && less(p,_data[par]) ) {
-        move(_data[par],hole);
-        hole = par;
-        par = parent(hole);
-      }
-      move(p, hole);
-    }
-
-    void bubbleDown(int hole, Pair p, int length) {
-      if( length>1 ) {
-        int child = firstChild(hole);
-        while( child+D<=length ) {
-          int min=child;
-          for (int i=1; i<D; ++i) {
-            if( less(_data[child+i], _data[min]) )
-              min=child+i;
-          }
-          if( !less(_data[min], p) )
-            goto ok;
-          move(_data[min], hole);
-          hole = min;
-          child = firstChild(hole);
-        }
-        if ( child<length ) {
-          int min = child;
-          while (++child < length) {
-            if( less(_data[child], _data[min]) )
-              min=child;
-          }
-          if( less(_data[min], p) ) {
-            move(_data[min], hole);
-            hole = min;
-          }
-        }
-      }
-    ok:
-      move(p, hole);
-    }
-
-    void move(const Pair &p, int i) {
-      _data[i] = p;
-      _iim.set(p.first, i);
-    }
-
-  public:
-    /// \brief Insert a pair of item and priority into the heap.
-    ///
-    /// This function inserts \c p.first to the heap with priority
-    /// \c p.second.
-    /// \param p The pair to insert.
-    /// \pre \c p.first must not be stored in the heap.
-    void push(const Pair &p) {
-      int n = _data.size();
-      _data.resize(n+1);
-      bubbleUp(n, p);
-    }
-
-    /// \brief Insert an item into the heap with the given priority.
-    ///
-    /// This function inserts the given item into the heap with the
-    /// given priority.
-    /// \param i The item to insert.
-    /// \param p The priority of the item.
-    /// \pre \e i must not be stored in the heap.
-    void push(const Item &i, const Prio &p) { push(Pair(i,p)); }
-
-    /// \brief Return the item having minimum priority.
-    ///
-    /// This function returns the item having minimum priority.
-    /// \pre The heap must be non-empty.
-    Item top() const { return _data[0].first; }
-
-    /// \brief The minimum priority.
-    ///
-    /// This function returns the minimum priority.
-    /// \pre The heap must be non-empty.
-    Prio prio() const { return _data[0].second; }
-
-    /// \brief Remove the item having minimum priority.
-    ///
-    /// This function removes the item having minimum priority.
-    /// \pre The heap must be non-empty.
-    void pop() {
-      int n = _data.size()-1;
-      _iim.set(_data[0].first, POST_HEAP);
-      if (n>0) bubbleDown(0, _data[n], n);
-      _data.pop_back();
-    }
-
-    /// \brief Remove the given item from the heap.
-    ///
-    /// This function removes the given item from the heap if it is
-    /// already stored.
-    /// \param i The item to delete.
-    /// \pre \e i must be in the heap.
-    void erase(const Item &i) {
-      int h = _iim[i];
-      int n = _data.size()-1;
-      _iim.set(_data[h].first, POST_HEAP);
-      if( h<n ) {
-        if( less(_data[parent(h)], _data[n]) )
-          bubbleDown(h, _data[n], n);
-        else
-          bubbleUp(h, _data[n]);
-      }
-      _data.pop_back();
-    }
-
-    /// \brief The priority of the given item.
-    ///
-    /// This function returns the priority of the given item.
-    /// \param i The item.
-    /// \pre \e i must be in the heap.
-    Prio operator[](const Item &i) const {
-      int idx = _iim[i];
-      return _data[idx].second;
-    }
-
-    /// \brief Set the priority of an item or insert it, if it is
-    /// not stored in the heap.
-    ///
-    /// This method sets the priority of the given item if it is
-    /// already stored in the heap. Otherwise it inserts the given
-    /// item into the heap with the given priority.
-    /// \param i The item.
-    /// \param p The priority.
-    void set(const Item &i, const Prio &p) {
-      int idx = _iim[i];
-      if( idx<0 )
-        push(i,p);
-      else if( _comp(p, _data[idx].second) )
-        bubbleUp(idx, Pair(i,p));
-      else
-        bubbleDown(idx, Pair(i,p), _data.size());
-    }
-
-    /// \brief Decrease the priority of an item to the given value.
-    ///
-    /// This function decreases the priority of an item to the given value.
-    /// \param i The item.
-    /// \param p The priority.
-    /// \pre \e i must be stored in the heap with priority at least \e p.
-    void decrease(const Item &i, const Prio &p) {
-      int idx = _iim[i];
-      bubbleUp(idx, Pair(i,p));
-    }
-
-    /// \brief Increase the priority of an item to the given value.
-    ///
-    /// This function increases the priority of an item to the given value.
-    /// \param i The item.
-    /// \param p The priority.
-    /// \pre \e i must be stored in the heap with priority at most \e p.
-    void increase(const Item &i, const Prio &p) {
-      int idx = _iim[i];
-      bubbleDown(idx, Pair(i,p), _data.size());
-    }
-
-    /// \brief Return the state of an item.
-    ///
-    /// This method returns \c PRE_HEAP if the given item has never
-    /// been in the heap, \c IN_HEAP if it is in the heap at the moment,
-    /// and \c POST_HEAP otherwise.
-    /// In the latter case it is possible that the item will get back
-    /// to the heap again.
-    /// \param i The item.
-    State state(const Item &i) const {
-      int s = _iim[i];
-      if (s>=0) s=0;
-      return State(s);
-    }
-
-    /// \brief Set the state of an item in the heap.
-    ///
-    /// This function sets the state of the given item in the heap.
-    /// It can be used to manually clear the heap when it is important
-    /// to achive better time complexity.
-    /// \param i The item.
-    /// \param st The state. It should not be \c IN_HEAP.
-    void state(const Item& i, State st) {
-      switch (st) {
-        case POST_HEAP:
-        case PRE_HEAP:
-          if (state(i) == IN_HEAP) erase(i);
-          _iim[i] = st;
-          break;
-        case IN_HEAP:
-          break;
-      }
-    }
-
-    /// \brief Replace an item in the heap.
-    ///
-    /// This function replaces item \c i with item \c j.
-    /// Item \c i must be in the heap, while \c j must be out of the heap.
-    /// After calling this method, item \c i will be out of the
-    /// heap and \c j will be in the heap with the same prioriority
-    /// as item \c i had before.
-    void replace(const Item& i, const Item& j) {
-      int idx=_iim[i];
-      _iim.set(i, _iim[j]);
-      _iim.set(j, idx);
-      _data[idx].first=j;
-    }
-
-  }; // class DHeap
-
-} // namespace lemon
-
-#endif // LEMON_DHEAP_H
Index: lemon/dijkstra.h
===================================================================
--- lemon/dijkstra.h	(revision 1270)
+++ lemon/dijkstra.h	(revision 835)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -193,9 +193,4 @@
   ///it is necessary. The default map type is \ref
   ///concepts::Digraph::ArcMap "GR::ArcMap<int>".
-  ///\tparam TR The traits class that defines various types used by the
-  ///algorithm. By default, it is \ref DijkstraDefaultTraits
-  ///"DijkstraDefaultTraits<GR, LEN>".
-  ///In most cases, this parameter should not be set directly,
-  ///consider to use the named template parameters instead.
 #ifdef DOXYGEN
   template <typename GR, typename LEN, typename TR>
@@ -228,9 +223,9 @@
     ///The heap type used by the algorithm.
     typedef typename TR::Heap Heap;
-    /// \brief The \ref lemon::DijkstraDefaultOperationTraits
-    /// "operation traits class" of the algorithm.
+    ///\brief The \ref DijkstraDefaultOperationTraits "operation traits class"
+    ///of the algorithm.
     typedef typename TR::OperationTraits OperationTraits;
 
-    ///The \ref lemon::DijkstraDefaultTraits "traits class" of the algorithm.
+    ///The \ref DijkstraDefaultTraits "traits class" of the algorithm.
     typedef TR Traits;
 
@@ -1098,7 +1093,4 @@
   /// This class should only be used through the \ref dijkstra() function,
   /// which makes it easier to use the algorithm.
-  ///
-  /// \tparam TR The traits class that defines various types used by the
-  /// algorithm.
   template<class TR>
   class DijkstraWizard : public TR
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/dimacs.h
===================================================================
--- lemon/dimacs.h	(revision 1270)
+++ lemon/dimacs.h	(revision 631)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -62,5 +62,5 @@
 
   ///This function starts seeking the beginning of the given file for the
-  ///problem type and size info.
+  ///problem type and size info. 
   ///The found data is returned in a special struct that can be evaluated
   ///and passed to the appropriate reader function.
@@ -213,5 +213,5 @@
         std::numeric_limits<Capacity>::infinity() :
         std::numeric_limits<Capacity>::max();
-
+ 
     while (is >> c) {
       switch (c) {
@@ -238,5 +238,5 @@
           e = g.addArc(nodes[i], nodes[j]);
           capacity.set(e, _cap);
-        }
+        } 
         else if (desc.type==DimacsDescriptor::MAX) {
           is >> i >> j >> _cap;
@@ -363,9 +363,9 @@
     g.addArc(s,t);
   }
-
+  
   /// \brief DIMACS plain (di)graph reader function.
   ///
   /// This function reads a plain (di)graph without any designated nodes
-  /// and maps (e.g. a matching instance) from DIMACS format, i.e. from
+  /// and maps (e.g. a matching instance) from DIMACS format, i.e. from 
   /// DIMACS files having a line starting with
   /// \code
@@ -393,5 +393,5 @@
       nodes[k] = g.addNode();
     }
-
+    
     while (is >> c) {
       switch (c) {
Index: lemon/edge_set.h
===================================================================
--- lemon/edge_set.h	(revision 1270)
+++ lemon/edge_set.h	(revision 834)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: mon/edmonds_karp.h
===================================================================
--- lemon/edmonds_karp.h	(revision 1270)
+++ 	(revision )
@@ -1,556 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2013
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * 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_EDMONDS_KARP_H
-#define LEMON_EDMONDS_KARP_H
-
-/// \file
-/// \ingroup max_flow
-/// \brief Implementation of the Edmonds-Karp algorithm.
-
-#include <lemon/tolerance.h>
-#include <vector>
-
-namespace lemon {
-
-  /// \brief Default traits class of EdmondsKarp class.
-  ///
-  /// Default traits class of EdmondsKarp class.
-  /// \param GR Digraph type.
-  /// \param CAP Type of capacity map.
-  template <typename GR, typename CAP>
-  struct EdmondsKarpDefaultTraits {
-
-    /// \brief The digraph type the algorithm runs on.
-    typedef GR Digraph;
-
-    /// \brief The type of the map that stores the arc capacities.
-    ///
-    /// The type of the map that stores the arc capacities.
-    /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
-    typedef CAP CapacityMap;
-
-    /// \brief The type of the flow values.
-    typedef typename CapacityMap::Value Value;
-
-    /// \brief The type of the map that stores the flow values.
-    ///
-    /// The type of the map that stores the flow values.
-    /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
-#ifdef DOXYGEN
-    typedef GR::ArcMap<Value> FlowMap;
-#else
-    typedef typename Digraph::template ArcMap<Value> FlowMap;
-#endif
-
-    /// \brief Instantiates a FlowMap.
-    ///
-    /// This function instantiates a \ref FlowMap.
-    /// \param digraph The digraph for which we would like to define
-    /// the flow map.
-    static FlowMap* createFlowMap(const Digraph& digraph) {
-      return new FlowMap(digraph);
-    }
-
-    /// \brief The tolerance used by the algorithm
-    ///
-    /// The tolerance used by the algorithm to handle inexact computation.
-    typedef lemon::Tolerance<Value> Tolerance;
-
-  };
-
-  /// \ingroup max_flow
-  ///
-  /// \brief Edmonds-Karp algorithms class.
-  ///
-  /// This class provides an implementation of the \e Edmonds-Karp \e
-  /// algorithm producing a \ref max_flow "flow of maximum value" in a
-  /// digraph \cite clrs01algorithms, \cite amo93networkflows,
-  /// \cite edmondskarp72theoretical.
-  /// The Edmonds-Karp algorithm is slower than the Preflow
-  /// algorithm, but it has an advantage of the step-by-step execution
-  /// control with feasible flow solutions. The \e source node, the \e
-  /// target node, the \e capacity of the arcs and the \e starting \e
-  /// flow value of the arcs should be passed to the algorithm
-  /// through the constructor.
-  ///
-  /// The time complexity of the algorithm is \f$ O(nm^2) \f$ in
-  /// worst case. Always try the Preflow algorithm instead of this if
-  /// you just want to compute the optimal flow.
-  ///
-  /// \tparam GR The type of the digraph the algorithm runs on.
-  /// \tparam CAP The type of the capacity map. The default map
-  /// type is \ref concepts::Digraph::ArcMap "GR::ArcMap<int>".
-  /// \tparam TR The traits class that defines various types used by the
-  /// algorithm. By default, it is \ref EdmondsKarpDefaultTraits
-  /// "EdmondsKarpDefaultTraits<GR, CAP>".
-  /// In most cases, this parameter should not be set directly,
-  /// consider to use the named template parameters instead.
-
-#ifdef DOXYGEN
-  template <typename GR, typename CAP, typename TR>
-#else
-  template <typename GR,
-            typename CAP = typename GR::template ArcMap<int>,
-            typename TR = EdmondsKarpDefaultTraits<GR, CAP> >
-#endif
-  class EdmondsKarp {
-  public:
-
-    /// \brief The \ref lemon::EdmondsKarpDefaultTraits "traits class"
-    /// of the algorithm.
-    typedef TR Traits;
-    /// The type of the digraph the algorithm runs on.
-    typedef typename Traits::Digraph Digraph;
-    /// The type of the capacity map.
-    typedef typename Traits::CapacityMap CapacityMap;
-    /// The type of the flow values.
-    typedef typename Traits::Value Value;
-
-    /// The type of the flow map.
-    typedef typename Traits::FlowMap FlowMap;
-    /// The type of the tolerance.
-    typedef typename Traits::Tolerance Tolerance;
-
-  private:
-
-    TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
-    typedef typename Digraph::template NodeMap<Arc> PredMap;
-
-    const Digraph& _graph;
-    const CapacityMap* _capacity;
-
-    Node _source, _target;
-
-    FlowMap* _flow;
-    bool _local_flow;
-
-    PredMap* _pred;
-    std::vector<Node> _queue;
-
-    Tolerance _tolerance;
-    Value _flow_value;
-
-    void createStructures() {
-      if (!_flow) {
-        _flow = Traits::createFlowMap(_graph);
-        _local_flow = true;
-      }
-      if (!_pred) {
-        _pred = new PredMap(_graph);
-      }
-      _queue.resize(countNodes(_graph));
-    }
-
-    void destroyStructures() {
-      if (_local_flow) {
-        delete _flow;
-      }
-      if (_pred) {
-        delete _pred;
-      }
-    }
-
-  public:
-
-    typedef EdmondsKarp Create;
-
-    ///\name Named template parameters
-
-    ///@{
-
-    template <typename T>
-    struct SetFlowMapTraits : public Traits {
-      typedef T FlowMap;
-      static FlowMap *createFlowMap(const Digraph&) {
-        LEMON_ASSERT(false, "FlowMap is not initialized");
-        return 0;
-      }
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// FlowMap type
-    ///
-    /// \ref named-templ-param "Named parameter" for setting FlowMap
-    /// type
-    template <typename T>
-    struct SetFlowMap
-      : public EdmondsKarp<Digraph, CapacityMap, SetFlowMapTraits<T> > {
-      typedef EdmondsKarp<Digraph, CapacityMap, SetFlowMapTraits<T> > Create;
-    };
-
-    /// @}
-
-  protected:
-
-    EdmondsKarp() {}
-
-  public:
-
-    /// \brief The constructor of the class.
-    ///
-    /// The constructor of the class.
-    /// \param digraph The digraph the algorithm runs on.
-    /// \param capacity The capacity of the arcs.
-    /// \param source The source node.
-    /// \param target The target node.
-    EdmondsKarp(const Digraph& digraph, const CapacityMap& capacity,
-                Node source, Node target)
-      : _graph(digraph), _capacity(&capacity), _source(source), _target(target),
-        _flow(0), _local_flow(false), _pred(0), _tolerance(), _flow_value()
-    {
-      LEMON_ASSERT(_source != _target,
-                   "Flow source and target are the same nodes.");
-    }
-
-    /// \brief Destructor.
-    ///
-    /// Destructor.
-    ~EdmondsKarp() {
-      destroyStructures();
-    }
-
-    /// \brief Sets the capacity map.
-    ///
-    /// Sets the capacity map.
-    /// \return <tt>(*this)</tt>
-    EdmondsKarp& capacityMap(const CapacityMap& map) {
-      _capacity = &map;
-      return *this;
-    }
-
-    /// \brief Sets the flow map.
-    ///
-    /// Sets the flow map.
-    /// If you don't use this function before calling \ref run() or
-    /// \ref init(), an instance will be allocated automatically.
-    /// The destructor deallocates this automatically allocated map,
-    /// of course.
-    /// \return <tt>(*this)</tt>
-    EdmondsKarp& flowMap(FlowMap& map) {
-      if (_local_flow) {
-        delete _flow;
-        _local_flow = false;
-      }
-      _flow = &map;
-      return *this;
-    }
-
-    /// \brief Sets the source node.
-    ///
-    /// Sets the source node.
-    /// \return <tt>(*this)</tt>
-    EdmondsKarp& source(const Node& node) {
-      _source = node;
-      return *this;
-    }
-
-    /// \brief Sets the target node.
-    ///
-    /// Sets the target node.
-    /// \return <tt>(*this)</tt>
-    EdmondsKarp& target(const Node& node) {
-      _target = node;
-      return *this;
-    }
-
-    /// \brief Sets the tolerance used by algorithm.
-    ///
-    /// Sets the tolerance used by algorithm.
-    /// \return <tt>(*this)</tt>
-    EdmondsKarp& tolerance(const Tolerance& tolerance) {
-      _tolerance = tolerance;
-      return *this;
-    }
-
-    /// \brief Returns a const reference to the tolerance.
-    ///
-    /// Returns a const reference to the tolerance object used by
-    /// the algorithm.
-    const Tolerance& tolerance() const {
-      return _tolerance;
-    }
-
-    /// \name Execution control
-    /// The simplest way to execute the algorithm is to use \ref run().\n
-    /// If you need better control on the initial solution or the execution,
-    /// you have to call one of the \ref init() functions first, then
-    /// \ref start() or multiple times the \ref augment() function.
-
-    ///@{
-
-    /// \brief Initializes the algorithm.
-    ///
-    /// Initializes the internal data structures and sets the initial
-    /// flow to zero on each arc.
-    void init() {
-      createStructures();
-      for (ArcIt it(_graph); it != INVALID; ++it) {
-        _flow->set(it, 0);
-      }
-      _flow_value = 0;
-    }
-
-    /// \brief Initializes the algorithm using the given flow map.
-    ///
-    /// Initializes the internal data structures and sets the initial
-    /// flow to the given \c flowMap. The \c flowMap should
-    /// contain a feasible flow, i.e. at each node excluding the source
-    /// and the target, the incoming flow should be equal to the
-    /// outgoing flow.
-    template <typename FlowMap>
-    void init(const FlowMap& flowMap) {
-      createStructures();
-      for (ArcIt e(_graph); e != INVALID; ++e) {
-        _flow->set(e, flowMap[e]);
-      }
-      _flow_value = 0;
-      for (OutArcIt jt(_graph, _source); jt != INVALID; ++jt) {
-        _flow_value += (*_flow)[jt];
-      }
-      for (InArcIt jt(_graph, _source); jt != INVALID; ++jt) {
-        _flow_value -= (*_flow)[jt];
-      }
-    }
-
-    /// \brief Initializes the algorithm using the given flow map.
-    ///
-    /// Initializes the internal data structures and sets the initial
-    /// flow to the given \c flowMap. The \c flowMap should
-    /// contain a feasible flow, i.e. at each node excluding the source
-    /// and the target, the incoming flow should be equal to the
-    /// outgoing flow.
-    /// \return \c false when the given \c flowMap does not contain a
-    /// feasible flow.
-    template <typename FlowMap>
-    bool checkedInit(const FlowMap& flowMap) {
-      createStructures();
-      for (ArcIt e(_graph); e != INVALID; ++e) {
-        _flow->set(e, flowMap[e]);
-      }
-      for (NodeIt it(_graph); it != INVALID; ++it) {
-        if (it == _source || it == _target) continue;
-        Value outFlow = 0;
-        for (OutArcIt jt(_graph, it); jt != INVALID; ++jt) {
-          outFlow += (*_flow)[jt];
-        }
-        Value inFlow = 0;
-        for (InArcIt jt(_graph, it); jt != INVALID; ++jt) {
-          inFlow += (*_flow)[jt];
-        }
-        if (_tolerance.different(outFlow, inFlow)) {
-          return false;
-        }
-      }
-      for (ArcIt it(_graph); it != INVALID; ++it) {
-        if (_tolerance.less((*_flow)[it], 0)) return false;
-        if (_tolerance.less((*_capacity)[it], (*_flow)[it])) return false;
-      }
-      _flow_value = 0;
-      for (OutArcIt jt(_graph, _source); jt != INVALID; ++jt) {
-        _flow_value += (*_flow)[jt];
-      }
-      for (InArcIt jt(_graph, _source); jt != INVALID; ++jt) {
-        _flow_value -= (*_flow)[jt];
-      }
-      return true;
-    }
-
-    /// \brief Augments the solution along a shortest path.
-    ///
-    /// Augments the solution along a shortest path. This function searches a
-    /// shortest path between the source and the target
-    /// in the residual digraph by the Bfs algoritm.
-    /// Then it increases the flow on this path with the minimal residual
-    /// capacity on the path. If there is no such path, it gives back
-    /// false.
-    /// \return \c false when the augmenting did not success, i.e. the
-    /// current flow is a feasible and optimal solution.
-    bool augment() {
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        _pred->set(n, INVALID);
-      }
-
-      int first = 0, last = 1;
-
-      _queue[0] = _source;
-      _pred->set(_source, OutArcIt(_graph, _source));
-
-      while (first != last && (*_pred)[_target] == INVALID) {
-        Node n = _queue[first++];
-
-        for (OutArcIt e(_graph, n); e != INVALID; ++e) {
-          Value rem = (*_capacity)[e] - (*_flow)[e];
-          Node t = _graph.target(e);
-          if (_tolerance.positive(rem) && (*_pred)[t] == INVALID) {
-            _pred->set(t, e);
-            _queue[last++] = t;
-          }
-        }
-        for (InArcIt e(_graph, n); e != INVALID; ++e) {
-          Value rem = (*_flow)[e];
-          Node t = _graph.source(e);
-          if (_tolerance.positive(rem) && (*_pred)[t] == INVALID) {
-            _pred->set(t, e);
-            _queue[last++] = t;
-          }
-        }
-      }
-
-      if ((*_pred)[_target] != INVALID) {
-        Node n = _target;
-        Arc e = (*_pred)[n];
-
-        Value prem = (*_capacity)[e] - (*_flow)[e];
-        n = _graph.source(e);
-        while (n != _source) {
-          e = (*_pred)[n];
-          if (_graph.target(e) == n) {
-            Value rem = (*_capacity)[e] - (*_flow)[e];
-            if (rem < prem) prem = rem;
-            n = _graph.source(e);
-          } else {
-            Value rem = (*_flow)[e];
-            if (rem < prem) prem = rem;
-            n = _graph.target(e);
-          }
-        }
-
-        n = _target;
-        e = (*_pred)[n];
-
-        _flow->set(e, (*_flow)[e] + prem);
-        n = _graph.source(e);
-        while (n != _source) {
-          e = (*_pred)[n];
-          if (_graph.target(e) == n) {
-            _flow->set(e, (*_flow)[e] + prem);
-            n = _graph.source(e);
-          } else {
-            _flow->set(e, (*_flow)[e] - prem);
-            n = _graph.target(e);
-          }
-        }
-
-        _flow_value += prem;
-        return true;
-      } else {
-        return false;
-      }
-    }
-
-    /// \brief Executes the algorithm
-    ///
-    /// Executes the algorithm by performing augmenting phases until the
-    /// optimal solution is reached.
-    /// \pre One of the \ref init() functions must be called before
-    /// using this function.
-    void start() {
-      while (augment()) {}
-    }
-
-    /// \brief Runs the algorithm.
-    ///
-    /// Runs the Edmonds-Karp algorithm.
-    /// \note ek.run() is just a shortcut of the following code.
-    ///\code
-    /// ek.init();
-    /// ek.start();
-    ///\endcode
-    void run() {
-      init();
-      start();
-    }
-
-    /// @}
-
-    /// \name Query Functions
-    /// The result of the Edmonds-Karp algorithm can be obtained using these
-    /// functions.\n
-    /// Either \ref run() or \ref start() should be called before using them.
-
-    ///@{
-
-    /// \brief Returns the value of the maximum flow.
-    ///
-    /// Returns the value of the maximum flow found by the algorithm.
-    ///
-    /// \pre Either \ref run() or \ref init() must be called before
-    /// using this function.
-    Value flowValue() const {
-      return _flow_value;
-    }
-
-    /// \brief Returns the flow value on the given arc.
-    ///
-    /// Returns the flow value on the given arc.
-    ///
-    /// \pre Either \ref run() or \ref init() must be called before
-    /// using this function.
-    Value flow(const Arc& arc) const {
-      return (*_flow)[arc];
-    }
-
-    /// \brief Returns a const reference to the flow map.
-    ///
-    /// Returns a const reference to the arc map storing the found flow.
-    ///
-    /// \pre Either \ref run() or \ref init() must be called before
-    /// using this function.
-    const FlowMap& flowMap() const {
-      return *_flow;
-    }
-
-    /// \brief Returns \c true when the node is on the source side of the
-    /// minimum cut.
-    ///
-    /// Returns true when the node is on the source side of the found
-    /// minimum cut.
-    ///
-    /// \pre Either \ref run() or \ref init() must be called before
-    /// using this function.
-    bool minCut(const Node& node) const {
-      return ((*_pred)[node] != INVALID) || node == _source;
-    }
-
-    /// \brief Gives back a minimum value cut.
-    ///
-    /// Sets \c cutMap to the characteristic vector of a minimum value
-    /// cut. \c cutMap should be a \ref concepts::WriteMap "writable"
-    /// node map with \c bool (or convertible) value type.
-    ///
-    /// \note This function calls \ref minCut() for each node, so it runs in
-    /// O(n) time.
-    ///
-    /// \pre Either \ref run() or \ref init() must be called before
-    /// using this function.
-    template <typename CutMap>
-    void minCutMap(CutMap& cutMap) const {
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        cutMap.set(n, (*_pred)[n] != INVALID);
-      }
-      cutMap.set(_source, true);
-    }
-
-    /// @}
-
-  };
-
-}
-
-#endif
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/euler.h
===================================================================
--- lemon/euler.h	(revision 1270)
+++ lemon/euler.h	(revision 695)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -27,5 +27,5 @@
 /// \ingroup graph_properties
 /// \file
-/// \brief Euler tour iterators and a function for checking the \e Eulerian
+/// \brief Euler tour iterators and a function for checking the \e Eulerian 
 /// property.
 ///
@@ -37,10 +37,10 @@
   ///Euler tour iterator for digraphs.
 
-  /// \ingroup graph_properties
+  /// \ingroup graph_prop
   ///This iterator provides an Euler tour (Eulerian circuit) of a \e directed
   ///graph (if there exists) and it converts to the \c Arc type of the digraph.
   ///
   ///For example, if the given digraph has an Euler tour (i.e it has only one
-  ///non-trivial component and the in-degree is equal to the out-degree
+  ///non-trivial component and the in-degree is equal to the out-degree 
   ///for all nodes), then the following code will put the arcs of \c g
   ///to the vector \c et according to an Euler tour of \c g.
@@ -139,5 +139,5 @@
   ///and \c Edge types of the graph.
   ///
-  ///For example, if the given graph has an Euler tour (i.e it has only one
+  ///For example, if the given graph has an Euler tour (i.e it has only one 
   ///non-trivial component and the degree of each node is even),
   ///the following code will print the arc IDs according to an
@@ -148,5 +148,5 @@
   ///  }
   ///\endcode
-  ///Although this iterator is for undirected graphs, it still returns
+  ///Although this iterator is for undirected graphs, it still returns 
   ///arcs in order to indicate the direction of the tour.
   ///(But arcs convert to edges, of course.)
@@ -234,5 +234,5 @@
     /// Postfix incrementation.
     ///
-    ///\warning This incrementation returns an \c Arc (which converts to
+    ///\warning This incrementation returns an \c Arc (which converts to 
     ///an \c Edge), not an \ref EulerIt, as one may expect.
     Arc operator++(int)
Index: lemon/fourary_heap.h
===================================================================
--- lemon/fourary_heap.h	(revision 753)
+++ lemon/fourary_heap.h	(revision 753)
@@ -0,0 +1,342 @@
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library.
+ *
+ * Copyright (C) 2003-2009
+ * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
+ * (Egervary Research Group on Combinatorial Optimization, EGRES).
+ *
+ * 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_FOURARY_HEAP_H
+#define LEMON_FOURARY_HEAP_H
+
+///\ingroup heaps
+///\file
+///\brief Fourary heap implementation.
+
+#include <vector>
+#include <utility>
+#include <functional>
+
+namespace lemon {
+
+  /// \ingroup heaps
+  ///
+  ///\brief Fourary heap data structure.
+  ///
+  /// This class implements the \e fourary \e heap data structure.
+  /// It fully conforms to the \ref concepts::Heap "heap concept".
+  ///
+  /// The fourary heap is a specialization of the \ref KaryHeap "K-ary heap"
+  /// for <tt>K=4</tt>. It is similar to the \ref BinHeap "binary heap",
+  /// but its nodes have at most four children, instead of two.
+  ///
+  /// \tparam PR Type of the priorities of the items.
+  /// \tparam IM A read-writable item map with \c int values, used
+  /// internally to handle the cross references.
+  /// \tparam CMP A functor class for comparing the priorities.
+  /// The default is \c std::less<PR>.
+  ///
+  ///\sa BinHeap
+  ///\sa KaryHeap
+#ifdef DOXYGEN
+  template <typename PR, typename IM, typename CMP>
+#else
+  template <typename PR, typename IM, typename CMP = std::less<PR> >
+#endif
+  class FouraryHeap {
+  public:
+    /// Type of the item-int map.
+    typedef IM ItemIntMap;
+    /// Type of the priorities.
+    typedef PR Prio;
+    /// Type of the items stored in the heap.
+    typedef typename ItemIntMap::Key Item;
+    /// Type of the item-priority pairs.
+    typedef std::pair<Item,Prio> Pair;
+    /// Functor type for comparing the priorities.
+    typedef CMP Compare;
+
+    /// \brief Type to represent the states of the items.
+    ///
+    /// Each item has a state associated to it. It can be "in heap",
+    /// "pre-heap" or "post-heap". The latter two are indifferent from the
+    /// heap's point of view, but may be useful to the user.
+    ///
+    /// The item-int map must be initialized in such way that it assigns
+    /// \c PRE_HEAP (<tt>-1</tt>) to any element to be put in the heap.
+    enum State {
+      IN_HEAP = 0,    ///< = 0.
+      PRE_HEAP = -1,  ///< = -1.
+      POST_HEAP = -2  ///< = -2.
+    };
+
+  private:
+    std::vector<Pair> _data;
+    Compare _comp;
+    ItemIntMap &_iim;
+
+  public:
+    /// \brief Constructor.
+    ///
+    /// Constructor.
+    /// \param map A map that assigns \c int values to the items.
+    /// It is used internally to handle the cross references.
+    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
+    explicit FouraryHeap(ItemIntMap &map) : _iim(map) {}
+
+    /// \brief Constructor.
+    ///
+    /// Constructor.
+    /// \param map A map that assigns \c int values to the items.
+    /// It is used internally to handle the cross references.
+    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
+    /// \param comp The function object used for comparing the priorities.
+    FouraryHeap(ItemIntMap &map, const Compare &comp)
+      : _iim(map), _comp(comp) {}
+
+    /// \brief The number of items stored in the heap.
+    ///
+    /// This function returns the number of items stored in the heap.
+    int size() const { return _data.size(); }
+
+    /// \brief Check if the heap is empty.
+    ///
+    /// This function returns \c true if the heap is empty.
+    bool empty() const { return _data.empty(); }
+
+    /// \brief Make the heap empty.
+    ///
+    /// This functon makes the heap empty.
+    /// It does not change the cross reference map. If you want to reuse
+    /// a heap that is not surely empty, you should first clear it and
+    /// then you should set the cross reference map to \c PRE_HEAP
+    /// for each item.
+    void clear() { _data.clear(); }
+
+  private:
+    static int parent(int i) { return (i-1)/4; }
+    static int firstChild(int i) { return 4*i+1; }
+
+    bool less(const Pair &p1, const Pair &p2) const {
+      return _comp(p1.second, p2.second);
+    }
+
+    void bubbleUp(int hole, Pair p) {
+      int par = parent(hole);
+      while( hole>0 && less(p,_data[par]) ) {
+        move(_data[par],hole);
+        hole = par;
+        par = parent(hole);
+      }
+      move(p, hole);
+    }
+
+    void bubbleDown(int hole, Pair p, int length) {
+      if( length>1 ) {
+        int child = firstChild(hole);
+        while( child+3<length ) {
+          int min=child;
+          if( less(_data[++child], _data[min]) ) min=child;
+          if( less(_data[++child], _data[min]) ) min=child;
+          if( less(_data[++child], _data[min]) ) min=child;
+          if( !less(_data[min], p) )
+            goto ok;
+          move(_data[min], hole);
+          hole = min;
+          child = firstChild(hole);
+        }
+        if ( child<length ) {
+          int min = child;
+          if( ++child<length && less(_data[child], _data[min]) ) min=child;
+          if( ++child<length && less(_data[child], _data[min]) ) min=child;
+          if( less(_data[min], p) ) {
+            move(_data[min], hole);
+            hole = min;
+          }
+        }
+      }
+    ok:
+      move(p, hole);
+    }
+
+    void move(const Pair &p, int i) {
+      _data[i] = p;
+      _iim.set(p.first, i);
+    }
+
+  public:
+    /// \brief Insert a pair of item and priority into the heap.
+    ///
+    /// This function inserts \c p.first to the heap with priority
+    /// \c p.second.
+    /// \param p The pair to insert.
+    /// \pre \c p.first must not be stored in the heap.
+    void push(const Pair &p) {
+      int n = _data.size();
+      _data.resize(n+1);
+      bubbleUp(n, p);
+    }
+
+    /// \brief Insert an item into the heap with the given priority.
+    ///
+    /// This function inserts the given item into the heap with the
+    /// given priority.
+    /// \param i The item to insert.
+    /// \param p The priority of the item.
+    /// \pre \e i must not be stored in the heap.
+    void push(const Item &i, const Prio &p) { push(Pair(i,p)); }
+
+    /// \brief Return the item having minimum priority.
+    ///
+    /// This function returns the item having minimum priority.
+    /// \pre The heap must be non-empty.
+    Item top() const { return _data[0].first; }
+
+    /// \brief The minimum priority.
+    ///
+    /// This function returns the minimum priority.
+    /// \pre The heap must be non-empty.
+    Prio prio() const { return _data[0].second; }
+
+    /// \brief Remove the item having minimum priority.
+    ///
+    /// This function removes the item having minimum priority.
+    /// \pre The heap must be non-empty.
+    void pop() {
+      int n = _data.size()-1;
+      _iim.set(_data[0].first, POST_HEAP);
+      if (n>0) bubbleDown(0, _data[n], n);
+      _data.pop_back();
+    }
+
+    /// \brief Remove the given item from the heap.
+    ///
+    /// This function removes the given item from the heap if it is
+    /// already stored.
+    /// \param i The item to delete.
+    /// \pre \e i must be in the heap.
+    void erase(const Item &i) {
+      int h = _iim[i];
+      int n = _data.size()-1;
+      _iim.set(_data[h].first, POST_HEAP);
+      if( h<n ) {
+        if( less(_data[parent(h)], _data[n]) )
+          bubbleDown(h, _data[n], n);
+        else
+          bubbleUp(h, _data[n]);
+      }
+      _data.pop_back();
+    }
+
+    /// \brief The priority of the given item.
+    ///
+    /// This function returns the priority of the given item.
+    /// \param i The item.
+    /// \pre \e i must be in the heap.
+    Prio operator[](const Item &i) const {
+      int idx = _iim[i];
+      return _data[idx].second;
+    }
+
+    /// \brief Set the priority of an item or insert it, if it is
+    /// not stored in the heap.
+    ///
+    /// This method sets the priority of the given item if it is
+    /// already stored in the heap. Otherwise it inserts the given
+    /// item into the heap with the given priority.
+    /// \param i The item.
+    /// \param p The priority.
+    void set(const Item &i, const Prio &p) {
+      int idx = _iim[i];
+      if( idx < 0 )
+        push(i,p);
+      else if( _comp(p, _data[idx].second) )
+        bubbleUp(idx, Pair(i,p));
+      else
+        bubbleDown(idx, Pair(i,p), _data.size());
+    }
+
+    /// \brief Decrease the priority of an item to the given value.
+    ///
+    /// This function decreases the priority of an item to the given value.
+    /// \param i The item.
+    /// \param p The priority.
+    /// \pre \e i must be stored in the heap with priority at least \e p.
+    void decrease(const Item &i, const Prio &p) {
+      int idx = _iim[i];
+      bubbleUp(idx, Pair(i,p));
+    }
+
+    /// \brief Increase the priority of an item to the given value.
+    ///
+    /// This function increases the priority of an item to the given value.
+    /// \param i The item.
+    /// \param p The priority.
+    /// \pre \e i must be stored in the heap with priority at most \e p.
+    void increase(const Item &i, const Prio &p) {
+      int idx = _iim[i];
+      bubbleDown(idx, Pair(i,p), _data.size());
+    }
+
+    /// \brief Return the state of an item.
+    ///
+    /// This method returns \c PRE_HEAP if the given item has never
+    /// been in the heap, \c IN_HEAP if it is in the heap at the moment,
+    /// and \c POST_HEAP otherwise.
+    /// In the latter case it is possible that the item will get back
+    /// to the heap again.
+    /// \param i The item.
+    State state(const Item &i) const {
+      int s = _iim[i];
+      if (s>=0) s=0;
+      return State(s);
+    }
+
+    /// \brief Set the state of an item in the heap.
+    ///
+    /// This function sets the state of the given item in the heap.
+    /// It can be used to manually clear the heap when it is important
+    /// to achive better time complexity.
+    /// \param i The item.
+    /// \param st The state. It should not be \c IN_HEAP.
+    void state(const Item& i, State st) {
+      switch (st) {
+        case POST_HEAP:
+        case PRE_HEAP:
+          if (state(i) == IN_HEAP) erase(i);
+          _iim[i] = st;
+          break;
+        case IN_HEAP:
+          break;
+      }
+    }
+
+    /// \brief Replace an item in the heap.
+    ///
+    /// This function replaces item \c i with item \c j.
+    /// Item \c i must be in the heap, while \c j must be out of the heap.
+    /// After calling this method, item \c i will be out of the
+    /// heap and \c j will be in the heap with the same prioriority
+    /// as item \c i had before.
+    void replace(const Item& i, const Item& j) {
+      int idx = _iim[i];
+      _iim.set(i, _iim[j]);
+      _iim.set(j, idx);
+      _data[idx].first = j;
+    }
+
+  }; // class FouraryHeap
+
+} // namespace lemon
+
+#endif // LEMON_FOURARY_HEAP_H
Index: mon/fractional_matching.h
===================================================================
--- lemon/fractional_matching.h	(revision 1270)
+++ 	(revision )
@@ -1,2139 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2013
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * 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_FRACTIONAL_MATCHING_H
-#define LEMON_FRACTIONAL_MATCHING_H
-
-#include <vector>
-#include <queue>
-#include <set>
-#include <limits>
-
-#include <lemon/core.h>
-#include <lemon/unionfind.h>
-#include <lemon/bin_heap.h>
-#include <lemon/maps.h>
-#include <lemon/assert.h>
-#include <lemon/elevator.h>
-
-///\ingroup matching
-///\file
-///\brief Fractional matching algorithms in general graphs.
-
-namespace lemon {
-
-  /// \brief Default traits class of MaxFractionalMatching class.
-  ///
-  /// Default traits class of MaxFractionalMatching class.
-  /// \tparam GR Graph type.
-  template <typename GR>
-  struct MaxFractionalMatchingDefaultTraits {
-
-    /// \brief The type of the graph the algorithm runs on.
-    typedef GR Graph;
-
-    /// \brief The type of the map that stores the matching.
-    ///
-    /// The type of the map that stores the matching arcs.
-    /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
-    typedef typename Graph::template NodeMap<typename GR::Arc> MatchingMap;
-
-    /// \brief Instantiates a MatchingMap.
-    ///
-    /// This function instantiates a \ref MatchingMap.
-    /// \param graph The graph for which we would like to define
-    /// the matching map.
-    static MatchingMap* createMatchingMap(const Graph& graph) {
-      return new MatchingMap(graph);
-    }
-
-    /// \brief The elevator type used by MaxFractionalMatching algorithm.
-    ///
-    /// The elevator type used by MaxFractionalMatching algorithm.
-    ///
-    /// \sa Elevator
-    /// \sa LinkedElevator
-    typedef LinkedElevator<Graph, typename Graph::Node> Elevator;
-
-    /// \brief Instantiates an Elevator.
-    ///
-    /// This function instantiates an \ref Elevator.
-    /// \param graph The graph for which we would like to define
-    /// the elevator.
-    /// \param max_level The maximum level of the elevator.
-    static Elevator* createElevator(const Graph& graph, int max_level) {
-      return new Elevator(graph, max_level);
-    }
-  };
-
-  /// \ingroup matching
-  ///
-  /// \brief Max cardinality fractional matching
-  ///
-  /// This class provides an implementation of fractional matching
-  /// algorithm based on push-relabel principle.
-  ///
-  /// The maximum cardinality fractional matching is a relaxation of the
-  /// maximum cardinality matching problem where the odd set constraints
-  /// are omitted.
-  /// It can be formulated with the following linear program.
-  /// \f[ \sum_{e \in \delta(u)}x_e \le 1 \quad \forall u\in V\f]
-  /// \f[x_e \ge 0\quad \forall e\in E\f]
-  /// \f[\max \sum_{e\in E}x_e\f]
-  /// where \f$\delta(X)\f$ is the set of edges incident to a node in
-  /// \f$X\f$. The result can be represented as the union of a
-  /// matching with one value edges and a set of odd length cycles
-  /// with half value edges.
-  ///
-  /// The algorithm calculates an optimal fractional matching and a
-  /// barrier. The number of adjacents of any node set minus the size
-  /// of node set is a lower bound on the uncovered nodes in the
-  /// graph. For maximum matching a barrier is computed which
-  /// maximizes this difference.
-  ///
-  /// The algorithm can be executed with the run() function.  After it
-  /// the matching (the primal solution) and the barrier (the dual
-  /// solution) can be obtained using the query functions.
-  ///
-  /// The primal solution is multiplied by
-  /// \ref MaxFractionalMatching::primalScale "2".
-  ///
-  /// \tparam GR The undirected graph type the algorithm runs on.
-#ifdef DOXYGEN
-  template <typename GR, typename TR>
-#else
-  template <typename GR,
-            typename TR = MaxFractionalMatchingDefaultTraits<GR> >
-#endif
-  class MaxFractionalMatching {
-  public:
-
-    /// \brief The \ref lemon::MaxFractionalMatchingDefaultTraits
-    /// "traits class" of the algorithm.
-    typedef TR Traits;
-    /// The type of the graph the algorithm runs on.
-    typedef typename TR::Graph Graph;
-    /// The type of the matching map.
-    typedef typename TR::MatchingMap MatchingMap;
-    /// The type of the elevator.
-    typedef typename TR::Elevator Elevator;
-
-    /// \brief Scaling factor for primal solution
-    ///
-    /// Scaling factor for primal solution.
-    static const int primalScale = 2;
-
-  private:
-
-    const Graph &_graph;
-    int _node_num;
-    bool _allow_loops;
-    int _empty_level;
-
-    TEMPLATE_GRAPH_TYPEDEFS(Graph);
-
-    bool _local_matching;
-    MatchingMap *_matching;
-
-    bool _local_level;
-    Elevator *_level;
-
-    typedef typename Graph::template NodeMap<int> InDegMap;
-    InDegMap *_indeg;
-
-    void createStructures() {
-      _node_num = countNodes(_graph);
-
-      if (!_matching) {
-        _local_matching = true;
-        _matching = Traits::createMatchingMap(_graph);
-      }
-      if (!_level) {
-        _local_level = true;
-        _level = Traits::createElevator(_graph, _node_num);
-      }
-      if (!_indeg) {
-        _indeg = new InDegMap(_graph);
-      }
-    }
-
-    void destroyStructures() {
-      if (_local_matching) {
-        delete _matching;
-      }
-      if (_local_level) {
-        delete _level;
-      }
-      if (_indeg) {
-        delete _indeg;
-      }
-    }
-
-    void postprocessing() {
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        if ((*_indeg)[n] != 0) continue;
-        _indeg->set(n, -1);
-        Node u = n;
-        while ((*_matching)[u] != INVALID) {
-          Node v = _graph.target((*_matching)[u]);
-          _indeg->set(v, -1);
-          Arc a = _graph.oppositeArc((*_matching)[u]);
-          u = _graph.target((*_matching)[v]);
-          _indeg->set(u, -1);
-          _matching->set(v, a);
-        }
-      }
-
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        if ((*_indeg)[n] != 1) continue;
-        _indeg->set(n, -1);
-
-        int num = 1;
-        Node u = _graph.target((*_matching)[n]);
-        while (u != n) {
-          _indeg->set(u, -1);
-          u = _graph.target((*_matching)[u]);
-          ++num;
-        }
-        if (num % 2 == 0 && num > 2) {
-          Arc prev = _graph.oppositeArc((*_matching)[n]);
-          Node v = _graph.target((*_matching)[n]);
-          u = _graph.target((*_matching)[v]);
-          _matching->set(v, prev);
-          while (u != n) {
-            prev = _graph.oppositeArc((*_matching)[u]);
-            v = _graph.target((*_matching)[u]);
-            u = _graph.target((*_matching)[v]);
-            _matching->set(v, prev);
-          }
-        }
-      }
-    }
-
-  public:
-
-    typedef MaxFractionalMatching Create;
-
-    ///\name Named Template Parameters
-
-    ///@{
-
-    template <typename T>
-    struct SetMatchingMapTraits : public Traits {
-      typedef T MatchingMap;
-      static MatchingMap *createMatchingMap(const Graph&) {
-        LEMON_ASSERT(false, "MatchingMap is not initialized");
-        return 0; // ignore warnings
-      }
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// MatchingMap type
-    ///
-    /// \ref named-templ-param "Named parameter" for setting MatchingMap
-    /// type.
-    template <typename T>
-    struct SetMatchingMap
-      : public MaxFractionalMatching<Graph, SetMatchingMapTraits<T> > {
-      typedef MaxFractionalMatching<Graph, SetMatchingMapTraits<T> > Create;
-    };
-
-    template <typename T>
-    struct SetElevatorTraits : public Traits {
-      typedef T Elevator;
-      static Elevator *createElevator(const Graph&, int) {
-        LEMON_ASSERT(false, "Elevator is not initialized");
-        return 0; // ignore warnings
-      }
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// Elevator type
-    ///
-    /// \ref named-templ-param "Named parameter" for setting Elevator
-    /// type. If this named parameter is used, then an external
-    /// elevator object must be passed to the algorithm using the
-    /// \ref elevator(Elevator&) "elevator()" function before calling
-    /// \ref run() or \ref init().
-    /// \sa SetStandardElevator
-    template <typename T>
-    struct SetElevator
-      : public MaxFractionalMatching<Graph, SetElevatorTraits<T> > {
-      typedef MaxFractionalMatching<Graph, SetElevatorTraits<T> > Create;
-    };
-
-    template <typename T>
-    struct SetStandardElevatorTraits : public Traits {
-      typedef T Elevator;
-      static Elevator *createElevator(const Graph& graph, int max_level) {
-        return new Elevator(graph, max_level);
-      }
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// Elevator type with automatic allocation
-    ///
-    /// \ref named-templ-param "Named parameter" for setting Elevator
-    /// type with automatic allocation.
-    /// The Elevator should have standard constructor interface to be
-    /// able to automatically created by the algorithm (i.e. the
-    /// graph and the maximum level should be passed to it).
-    /// However an external elevator object could also be passed to the
-    /// algorithm with the \ref elevator(Elevator&) "elevator()" function
-    /// before calling \ref run() or \ref init().
-    /// \sa SetElevator
-    template <typename T>
-    struct SetStandardElevator
-      : public MaxFractionalMatching<Graph, SetStandardElevatorTraits<T> > {
-      typedef MaxFractionalMatching<Graph,
-                                    SetStandardElevatorTraits<T> > Create;
-    };
-
-    /// @}
-
-  protected:
-
-    MaxFractionalMatching() {}
-
-  public:
-
-    /// \brief Constructor
-    ///
-    /// Constructor.
-    ///
-    MaxFractionalMatching(const Graph &graph, bool allow_loops = true)
-      : _graph(graph), _allow_loops(allow_loops),
-        _local_matching(false), _matching(0),
-        _local_level(false), _level(0),  _indeg(0)
-    {}
-
-    ~MaxFractionalMatching() {
-      destroyStructures();
-    }
-
-    /// \brief Sets the matching map.
-    ///
-    /// Sets the matching map.
-    /// If you don't use this function before calling \ref run() or
-    /// \ref init(), an instance will be allocated automatically.
-    /// The destructor deallocates this automatically allocated map,
-    /// of course.
-    /// \return <tt>(*this)</tt>
-    MaxFractionalMatching& matchingMap(MatchingMap& map) {
-      if (_local_matching) {
-        delete _matching;
-        _local_matching = false;
-      }
-      _matching = &map;
-      return *this;
-    }
-
-    /// \brief Sets the elevator used by algorithm.
-    ///
-    /// Sets the elevator used by algorithm.
-    /// If you don't use this function before calling \ref run() or
-    /// \ref init(), an instance will be allocated automatically.
-    /// The destructor deallocates this automatically allocated elevator,
-    /// of course.
-    /// \return <tt>(*this)</tt>
-    MaxFractionalMatching& elevator(Elevator& elevator) {
-      if (_local_level) {
-        delete _level;
-        _local_level = false;
-      }
-      _level = &elevator;
-      return *this;
-    }
-
-    /// \brief Returns a const reference to the elevator.
-    ///
-    /// Returns a const reference to the elevator.
-    ///
-    /// \pre Either \ref run() or \ref init() must be called before
-    /// using this function.
-    const Elevator& elevator() const {
-      return *_level;
-    }
-
-    /// \name Execution control
-    /// The simplest way to execute the algorithm is to use one of the
-    /// member functions called \c run(). \n
-    /// If you need more control on the execution, first
-    /// you must call \ref init() and then one variant of the start()
-    /// member.
-
-    /// @{
-
-    /// \brief Initializes the internal data structures.
-    ///
-    /// Initializes the internal data structures and sets the initial
-    /// matching.
-    void init() {
-      createStructures();
-
-      _level->initStart();
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        _indeg->set(n, 0);
-        _matching->set(n, INVALID);
-        _level->initAddItem(n);
-      }
-      _level->initFinish();
-
-      _empty_level = _node_num;
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        for (OutArcIt a(_graph, n); a != INVALID; ++a) {
-          if (_graph.target(a) == n && !_allow_loops) continue;
-          _matching->set(n, a);
-          Node v = _graph.target((*_matching)[n]);
-          _indeg->set(v, (*_indeg)[v] + 1);
-          break;
-        }
-      }
-
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        if ((*_indeg)[n] == 0) {
-          _level->activate(n);
-        }
-      }
-    }
-
-    /// \brief Starts the algorithm and computes a fractional matching
-    ///
-    /// The algorithm computes a maximum fractional matching.
-    ///
-    /// \param postprocess The algorithm computes first a matching
-    /// which is a union of a matching with one value edges, cycles
-    /// with half value edges and even length paths with half value
-    /// edges. If the parameter is true, then after the push-relabel
-    /// algorithm it postprocesses the matching to contain only
-    /// matching edges and half value odd cycles.
-    void start(bool postprocess = true) {
-      Node n;
-      while ((n = _level->highestActive()) != INVALID) {
-        int level = _level->highestActiveLevel();
-        int new_level = _level->maxLevel();
-        for (InArcIt a(_graph, n); a != INVALID; ++a) {
-          Node u = _graph.source(a);
-          if (n == u && !_allow_loops) continue;
-          Node v = _graph.target((*_matching)[u]);
-          if ((*_level)[v] < level) {
-            _indeg->set(v, (*_indeg)[v] - 1);
-            if ((*_indeg)[v] == 0) {
-              _level->activate(v);
-            }
-            _matching->set(u, a);
-            _indeg->set(n, (*_indeg)[n] + 1);
-            _level->deactivate(n);
-            goto no_more_push;
-          } else if (new_level > (*_level)[v]) {
-            new_level = (*_level)[v];
-          }
-        }
-
-        if (new_level + 1 < _level->maxLevel()) {
-          _level->liftHighestActive(new_level + 1);
-        } else {
-          _level->liftHighestActiveToTop();
-        }
-        if (_level->emptyLevel(level)) {
-          _level->liftToTop(level);
-        }
-      no_more_push:
-        ;
-      }
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        if ((*_matching)[n] == INVALID) continue;
-        Node u = _graph.target((*_matching)[n]);
-        if ((*_indeg)[u] > 1) {
-          _indeg->set(u, (*_indeg)[u] - 1);
-          _matching->set(n, INVALID);
-        }
-      }
-      if (postprocess) {
-        postprocessing();
-      }
-    }
-
-    /// \brief Starts the algorithm and computes a perfect fractional
-    /// matching
-    ///
-    /// The algorithm computes a perfect fractional matching. If it
-    /// does not exists, then the algorithm returns false and the
-    /// matching is undefined and the barrier.
-    ///
-    /// \param postprocess The algorithm computes first a matching
-    /// which is a union of a matching with one value edges, cycles
-    /// with half value edges and even length paths with half value
-    /// edges. If the parameter is true, then after the push-relabel
-    /// algorithm it postprocesses the matching to contain only
-    /// matching edges and half value odd cycles.
-    bool startPerfect(bool postprocess = true) {
-      Node n;
-      while ((n = _level->highestActive()) != INVALID) {
-        int level = _level->highestActiveLevel();
-        int new_level = _level->maxLevel();
-        for (InArcIt a(_graph, n); a != INVALID; ++a) {
-          Node u = _graph.source(a);
-          if (n == u && !_allow_loops) continue;
-          Node v = _graph.target((*_matching)[u]);
-          if ((*_level)[v] < level) {
-            _indeg->set(v, (*_indeg)[v] - 1);
-            if ((*_indeg)[v] == 0) {
-              _level->activate(v);
-            }
-            _matching->set(u, a);
-            _indeg->set(n, (*_indeg)[n] + 1);
-            _level->deactivate(n);
-            goto no_more_push;
-          } else if (new_level > (*_level)[v]) {
-            new_level = (*_level)[v];
-          }
-        }
-
-        if (new_level + 1 < _level->maxLevel()) {
-          _level->liftHighestActive(new_level + 1);
-        } else {
-          _level->liftHighestActiveToTop();
-          _empty_level = _level->maxLevel() - 1;
-          return false;
-        }
-        if (_level->emptyLevel(level)) {
-          _level->liftToTop(level);
-          _empty_level = level;
-          return false;
-        }
-      no_more_push:
-        ;
-      }
-      if (postprocess) {
-        postprocessing();
-      }
-      return true;
-    }
-
-    /// \brief Runs the algorithm
-    ///
-    /// Just a shortcut for the next code:
-    ///\code
-    /// init();
-    /// start();
-    ///\endcode
-    void run(bool postprocess = true) {
-      init();
-      start(postprocess);
-    }
-
-    /// \brief Runs the algorithm to find a perfect fractional matching
-    ///
-    /// Just a shortcut for the next code:
-    ///\code
-    /// init();
-    /// startPerfect();
-    ///\endcode
-    bool runPerfect(bool postprocess = true) {
-      init();
-      return startPerfect(postprocess);
-    }
-
-    ///@}
-
-    /// \name Query Functions
-    /// The result of the %Matching algorithm can be obtained using these
-    /// functions.\n
-    /// Before the use of these functions,
-    /// either run() or start() must be called.
-    ///@{
-
-
-    /// \brief Return the number of covered nodes in the matching.
-    ///
-    /// This function returns the number of covered nodes in the matching.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    int matchingSize() const {
-      int num = 0;
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        if ((*_matching)[n] != INVALID) {
-          ++num;
-        }
-      }
-      return num;
-    }
-
-    /// \brief Returns a const reference to the matching map.
-    ///
-    /// Returns a const reference to the node map storing the found
-    /// fractional matching. This method can be called after
-    /// running the algorithm.
-    ///
-    /// \pre Either \ref run() or \ref init() must be called before
-    /// using this function.
-    const MatchingMap& matchingMap() const {
-      return *_matching;
-    }
-
-    /// \brief Return \c true if the given edge is in the matching.
-    ///
-    /// This function returns \c true if the given edge is in the
-    /// found matching. The result is scaled by \ref primalScale
-    /// "primal scale".
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    int matching(const Edge& edge) const {
-      return (edge == (*_matching)[_graph.u(edge)] ? 1 : 0) +
-        (edge == (*_matching)[_graph.v(edge)] ? 1 : 0);
-    }
-
-    /// \brief Return the fractional matching arc (or edge) incident
-    /// to the given node.
-    ///
-    /// This function returns one of the fractional matching arc (or
-    /// edge) incident to the given node in the found matching or \c
-    /// INVALID if the node is not covered by the matching or if the
-    /// node is on an odd length cycle then it is the successor edge
-    /// on the cycle.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    Arc matching(const Node& node) const {
-      return (*_matching)[node];
-    }
-
-    /// \brief Returns true if the node is in the barrier
-    ///
-    /// The barrier is a subset of the nodes. If the nodes in the
-    /// barrier have less adjacent nodes than the size of the barrier,
-    /// then at least as much nodes cannot be covered as the
-    /// difference of the two subsets.
-    bool barrier(const Node& node) const {
-      return (*_level)[node] >= _empty_level;
-    }
-
-    /// @}
-
-  };
-
-  /// \ingroup matching
-  ///
-  /// \brief Weighted fractional matching in general graphs
-  ///
-  /// This class provides an efficient implementation of fractional
-  /// matching algorithm. The implementation uses priority queues and
-  /// provides \f$O(nm\log n)\f$ time complexity.
-  ///
-  /// The maximum weighted fractional matching is a relaxation of the
-  /// maximum weighted matching problem where the odd set constraints
-  /// are omitted.
-  /// It can be formulated with the following linear program.
-  /// \f[ \sum_{e \in \delta(u)}x_e \le 1 \quad \forall u\in V\f]
-  /// \f[x_e \ge 0\quad \forall e\in E\f]
-  /// \f[\max \sum_{e\in E}x_ew_e\f]
-  /// where \f$\delta(X)\f$ is the set of edges incident to a node in
-  /// \f$X\f$. The result must be the union of a matching with one
-  /// value edges and a set of odd length cycles with half value edges.
-  ///
-  /// The algorithm calculates an optimal fractional matching and a
-  /// proof of the optimality. The solution of the dual problem can be
-  /// used to check the result of the algorithm. The dual linear
-  /// problem is the following.
-  /// \f[ y_u + y_v \ge w_{uv} \quad \forall uv\in E\f]
-  /// \f[y_u \ge 0 \quad \forall u \in V\f]
-  /// \f[\min \sum_{u \in V}y_u \f]
-  ///
-  /// The algorithm can be executed with the run() function.
-  /// After it the matching (the primal solution) and the dual solution
-  /// can be obtained using the query functions.
-  ///
-  /// The primal solution is multiplied by
-  /// \ref MaxWeightedFractionalMatching::primalScale "2".
-  /// If the value type is integer, then the dual
-  /// solution is scaled by
-  /// \ref MaxWeightedFractionalMatching::dualScale "4".
-  ///
-  /// \tparam GR The undirected graph type the algorithm runs on.
-  /// \tparam WM The type edge weight map. The default type is
-  /// \ref concepts::Graph::EdgeMap "GR::EdgeMap<int>".
-#ifdef DOXYGEN
-  template <typename GR, typename WM>
-#else
-  template <typename GR,
-            typename WM = typename GR::template EdgeMap<int> >
-#endif
-  class MaxWeightedFractionalMatching {
-  public:
-
-    /// The graph type of the algorithm
-    typedef GR Graph;
-    /// The type of the edge weight map
-    typedef WM WeightMap;
-    /// The value type of the edge weights
-    typedef typename WeightMap::Value Value;
-
-    /// The type of the matching map
-    typedef typename Graph::template NodeMap<typename Graph::Arc>
-    MatchingMap;
-
-    /// \brief Scaling factor for primal solution
-    ///
-    /// Scaling factor for primal solution.
-    static const int primalScale = 2;
-
-    /// \brief Scaling factor for dual solution
-    ///
-    /// Scaling factor for dual solution. It is equal to 4 or 1
-    /// according to the value type.
-    static const int dualScale =
-      std::numeric_limits<Value>::is_integer ? 4 : 1;
-
-  private:
-
-    TEMPLATE_GRAPH_TYPEDEFS(Graph);
-
-    typedef typename Graph::template NodeMap<Value> NodePotential;
-
-    const Graph& _graph;
-    const WeightMap& _weight;
-
-    MatchingMap* _matching;
-    NodePotential* _node_potential;
-
-    int _node_num;
-    bool _allow_loops;
-
-    enum Status {
-      EVEN = -1, MATCHED = 0, ODD = 1
-    };
-
-    typedef typename Graph::template NodeMap<Status> StatusMap;
-    StatusMap* _status;
-
-    typedef typename Graph::template NodeMap<Arc> PredMap;
-    PredMap* _pred;
-
-    typedef ExtendFindEnum<IntNodeMap> TreeSet;
-
-    IntNodeMap *_tree_set_index;
-    TreeSet *_tree_set;
-
-    IntNodeMap *_delta1_index;
-    BinHeap<Value, IntNodeMap> *_delta1;
-
-    IntNodeMap *_delta2_index;
-    BinHeap<Value, IntNodeMap> *_delta2;
-
-    IntEdgeMap *_delta3_index;
-    BinHeap<Value, IntEdgeMap> *_delta3;
-
-    Value _delta_sum;
-
-    void createStructures() {
-      _node_num = countNodes(_graph);
-
-      if (!_matching) {
-        _matching = new MatchingMap(_graph);
-      }
-      if (!_node_potential) {
-        _node_potential = new NodePotential(_graph);
-      }
-      if (!_status) {
-        _status = new StatusMap(_graph);
-      }
-      if (!_pred) {
-        _pred = new PredMap(_graph);
-      }
-      if (!_tree_set) {
-        _tree_set_index = new IntNodeMap(_graph);
-        _tree_set = new TreeSet(*_tree_set_index);
-      }
-      if (!_delta1) {
-        _delta1_index = new IntNodeMap(_graph);
-        _delta1 = new BinHeap<Value, IntNodeMap>(*_delta1_index);
-      }
-      if (!_delta2) {
-        _delta2_index = new IntNodeMap(_graph);
-        _delta2 = new BinHeap<Value, IntNodeMap>(*_delta2_index);
-      }
-      if (!_delta3) {
-        _delta3_index = new IntEdgeMap(_graph);
-        _delta3 = new BinHeap<Value, IntEdgeMap>(*_delta3_index);
-      }
-    }
-
-    void destroyStructures() {
-      if (_matching) {
-        delete _matching;
-      }
-      if (_node_potential) {
-        delete _node_potential;
-      }
-      if (_status) {
-        delete _status;
-      }
-      if (_pred) {
-        delete _pred;
-      }
-      if (_tree_set) {
-        delete _tree_set_index;
-        delete _tree_set;
-      }
-      if (_delta1) {
-        delete _delta1_index;
-        delete _delta1;
-      }
-      if (_delta2) {
-        delete _delta2_index;
-        delete _delta2;
-      }
-      if (_delta3) {
-        delete _delta3_index;
-        delete _delta3;
-      }
-    }
-
-    void matchedToEven(Node node, int tree) {
-      _tree_set->insert(node, tree);
-      _node_potential->set(node, (*_node_potential)[node] + _delta_sum);
-      _delta1->push(node, (*_node_potential)[node]);
-
-      if (_delta2->state(node) == _delta2->IN_HEAP) {
-        _delta2->erase(node);
-      }
-
-      for (InArcIt a(_graph, node); a != INVALID; ++a) {
-        Node v = _graph.source(a);
-        Value rw = (*_node_potential)[node] + (*_node_potential)[v] -
-          dualScale * _weight[a];
-        if (node == v) {
-          if (_allow_loops && _graph.direction(a)) {
-            _delta3->push(a, rw / 2);
-          }
-        } else if ((*_status)[v] == EVEN) {
-          _delta3->push(a, rw / 2);
-        } else if ((*_status)[v] == MATCHED) {
-          if (_delta2->state(v) != _delta2->IN_HEAP) {
-            _pred->set(v, a);
-            _delta2->push(v, rw);
-          } else if ((*_delta2)[v] > rw) {
-            _pred->set(v, a);
-            _delta2->decrease(v, rw);
-          }
-        }
-      }
-    }
-
-    void matchedToOdd(Node node, int tree) {
-      _tree_set->insert(node, tree);
-      _node_potential->set(node, (*_node_potential)[node] - _delta_sum);
-
-      if (_delta2->state(node) == _delta2->IN_HEAP) {
-        _delta2->erase(node);
-      }
-    }
-
-    void evenToMatched(Node node, int tree) {
-      _delta1->erase(node);
-      _node_potential->set(node, (*_node_potential)[node] - _delta_sum);
-      Arc min = INVALID;
-      Value minrw = std::numeric_limits<Value>::max();
-      for (InArcIt a(_graph, node); a != INVALID; ++a) {
-        Node v = _graph.source(a);
-        Value rw = (*_node_potential)[node] + (*_node_potential)[v] -
-          dualScale * _weight[a];
-
-        if (node == v) {
-          if (_allow_loops && _graph.direction(a)) {
-            _delta3->erase(a);
-          }
-        } else if ((*_status)[v] == EVEN) {
-          _delta3->erase(a);
-          if (minrw > rw) {
-            min = _graph.oppositeArc(a);
-            minrw = rw;
-          }
-        } else if ((*_status)[v]  == MATCHED) {
-          if ((*_pred)[v] == a) {
-            Arc mina = INVALID;
-            Value minrwa = std::numeric_limits<Value>::max();
-            for (OutArcIt aa(_graph, v); aa != INVALID; ++aa) {
-              Node va = _graph.target(aa);
-              if ((*_status)[va] != EVEN ||
-                  _tree_set->find(va) == tree) continue;
-              Value rwa = (*_node_potential)[v] + (*_node_potential)[va] -
-                dualScale * _weight[aa];
-              if (minrwa > rwa) {
-                minrwa = rwa;
-                mina = aa;
-              }
-            }
-            if (mina != INVALID) {
-              _pred->set(v, mina);
-              _delta2->increase(v, minrwa);
-            } else {
-              _pred->set(v, INVALID);
-              _delta2->erase(v);
-            }
-          }
-        }
-      }
-      if (min != INVALID) {
-        _pred->set(node, min);
-        _delta2->push(node, minrw);
-      } else {
-        _pred->set(node, INVALID);
-      }
-    }
-
-    void oddToMatched(Node node) {
-      _node_potential->set(node, (*_node_potential)[node] + _delta_sum);
-      Arc min = INVALID;
-      Value minrw = std::numeric_limits<Value>::max();
-      for (InArcIt a(_graph, node); a != INVALID; ++a) {
-        Node v = _graph.source(a);
-        if ((*_status)[v] != EVEN) continue;
-        Value rw = (*_node_potential)[node] + (*_node_potential)[v] -
-          dualScale * _weight[a];
-
-        if (minrw > rw) {
-          min = _graph.oppositeArc(a);
-          minrw = rw;
-        }
-      }
-      if (min != INVALID) {
-        _pred->set(node, min);
-        _delta2->push(node, minrw);
-      } else {
-        _pred->set(node, INVALID);
-      }
-    }
-
-    void alternatePath(Node even, int tree) {
-      Node odd;
-
-      _status->set(even, MATCHED);
-      evenToMatched(even, tree);
-
-      Arc prev = (*_matching)[even];
-      while (prev != INVALID) {
-        odd = _graph.target(prev);
-        even = _graph.target((*_pred)[odd]);
-        _matching->set(odd, (*_pred)[odd]);
-        _status->set(odd, MATCHED);
-        oddToMatched(odd);
-
-        prev = (*_matching)[even];
-        _status->set(even, MATCHED);
-        _matching->set(even, _graph.oppositeArc((*_matching)[odd]));
-        evenToMatched(even, tree);
-      }
-    }
-
-    void destroyTree(int tree) {
-      for (typename TreeSet::ItemIt n(*_tree_set, tree); n != INVALID; ++n) {
-        if ((*_status)[n] == EVEN) {
-          _status->set(n, MATCHED);
-          evenToMatched(n, tree);
-        } else if ((*_status)[n] == ODD) {
-          _status->set(n, MATCHED);
-          oddToMatched(n);
-        }
-      }
-      _tree_set->eraseClass(tree);
-    }
-
-
-    void unmatchNode(const Node& node) {
-      int tree = _tree_set->find(node);
-
-      alternatePath(node, tree);
-      destroyTree(tree);
-
-      _matching->set(node, INVALID);
-    }
-
-
-    void augmentOnEdge(const Edge& edge) {
-      Node left = _graph.u(edge);
-      int left_tree = _tree_set->find(left);
-
-      alternatePath(left, left_tree);
-      destroyTree(left_tree);
-      _matching->set(left, _graph.direct(edge, true));
-
-      Node right = _graph.v(edge);
-      int right_tree = _tree_set->find(right);
-
-      alternatePath(right, right_tree);
-      destroyTree(right_tree);
-      _matching->set(right, _graph.direct(edge, false));
-    }
-
-    void augmentOnArc(const Arc& arc) {
-      Node left = _graph.source(arc);
-      _status->set(left, MATCHED);
-      _matching->set(left, arc);
-      _pred->set(left, arc);
-
-      Node right = _graph.target(arc);
-      int right_tree = _tree_set->find(right);
-
-      alternatePath(right, right_tree);
-      destroyTree(right_tree);
-      _matching->set(right, _graph.oppositeArc(arc));
-    }
-
-    void extendOnArc(const Arc& arc) {
-      Node base = _graph.target(arc);
-      int tree = _tree_set->find(base);
-
-      Node odd = _graph.source(arc);
-      _tree_set->insert(odd, tree);
-      _status->set(odd, ODD);
-      matchedToOdd(odd, tree);
-      _pred->set(odd, arc);
-
-      Node even = _graph.target((*_matching)[odd]);
-      _tree_set->insert(even, tree);
-      _status->set(even, EVEN);
-      matchedToEven(even, tree);
-    }
-
-    void cycleOnEdge(const Edge& edge, int tree) {
-      Node nca = INVALID;
-      std::vector<Node> left_path, right_path;
-
-      {
-        std::set<Node> left_set, right_set;
-        Node left = _graph.u(edge);
-        left_path.push_back(left);
-        left_set.insert(left);
-
-        Node right = _graph.v(edge);
-        right_path.push_back(right);
-        right_set.insert(right);
-
-        while (true) {
-
-          if (left_set.find(right) != left_set.end()) {
-            nca = right;
-            break;
-          }
-
-          if ((*_matching)[left] == INVALID) break;
-
-          left = _graph.target((*_matching)[left]);
-          left_path.push_back(left);
-          left = _graph.target((*_pred)[left]);
-          left_path.push_back(left);
-
-          left_set.insert(left);
-
-          if (right_set.find(left) != right_set.end()) {
-            nca = left;
-            break;
-          }
-
-          if ((*_matching)[right] == INVALID) break;
-
-          right = _graph.target((*_matching)[right]);
-          right_path.push_back(right);
-          right = _graph.target((*_pred)[right]);
-          right_path.push_back(right);
-
-          right_set.insert(right);
-
-        }
-
-        if (nca == INVALID) {
-          if ((*_matching)[left] == INVALID) {
-            nca = right;
-            while (left_set.find(nca) == left_set.end()) {
-              nca = _graph.target((*_matching)[nca]);
-              right_path.push_back(nca);
-              nca = _graph.target((*_pred)[nca]);
-              right_path.push_back(nca);
-            }
-          } else {
-            nca = left;
-            while (right_set.find(nca) == right_set.end()) {
-              nca = _graph.target((*_matching)[nca]);
-              left_path.push_back(nca);
-              nca = _graph.target((*_pred)[nca]);
-              left_path.push_back(nca);
-            }
-          }
-        }
-      }
-
-      alternatePath(nca, tree);
-      Arc prev;
-
-      prev = _graph.direct(edge, true);
-      for (int i = 0; left_path[i] != nca; i += 2) {
-        _matching->set(left_path[i], prev);
-        _status->set(left_path[i], MATCHED);
-        evenToMatched(left_path[i], tree);
-
-        prev = _graph.oppositeArc((*_pred)[left_path[i + 1]]);
-        _status->set(left_path[i + 1], MATCHED);
-        oddToMatched(left_path[i + 1]);
-      }
-      _matching->set(nca, prev);
-
-      for (int i = 0; right_path[i] != nca; i += 2) {
-        _status->set(right_path[i], MATCHED);
-        evenToMatched(right_path[i], tree);
-
-        _matching->set(right_path[i + 1], (*_pred)[right_path[i + 1]]);
-        _status->set(right_path[i + 1], MATCHED);
-        oddToMatched(right_path[i + 1]);
-      }
-
-      destroyTree(tree);
-    }
-
-    void extractCycle(const Arc &arc) {
-      Node left = _graph.source(arc);
-      Node odd = _graph.target((*_matching)[left]);
-      Arc prev;
-      while (odd != left) {
-        Node even = _graph.target((*_matching)[odd]);
-        prev = (*_matching)[odd];
-        odd = _graph.target((*_matching)[even]);
-        _matching->set(even, _graph.oppositeArc(prev));
-      }
-      _matching->set(left, arc);
-
-      Node right = _graph.target(arc);
-      int right_tree = _tree_set->find(right);
-      alternatePath(right, right_tree);
-      destroyTree(right_tree);
-      _matching->set(right, _graph.oppositeArc(arc));
-    }
-
-  public:
-
-    /// \brief Constructor
-    ///
-    /// Constructor.
-    MaxWeightedFractionalMatching(const Graph& graph, const WeightMap& weight,
-                                  bool allow_loops = true)
-      : _graph(graph), _weight(weight), _matching(0),
-      _node_potential(0), _node_num(0), _allow_loops(allow_loops),
-      _status(0),  _pred(0),
-      _tree_set_index(0), _tree_set(0),
-
-      _delta1_index(0), _delta1(0),
-      _delta2_index(0), _delta2(0),
-      _delta3_index(0), _delta3(0),
-
-      _delta_sum() {}
-
-    ~MaxWeightedFractionalMatching() {
-      destroyStructures();
-    }
-
-    /// \name Execution Control
-    /// The simplest way to execute the algorithm is to use the
-    /// \ref run() member function.
-
-    ///@{
-
-    /// \brief Initialize the algorithm
-    ///
-    /// This function initializes the algorithm.
-    void init() {
-      createStructures();
-
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        (*_delta1_index)[n] = _delta1->PRE_HEAP;
-        (*_delta2_index)[n] = _delta2->PRE_HEAP;
-      }
-      for (EdgeIt e(_graph); e != INVALID; ++e) {
-        (*_delta3_index)[e] = _delta3->PRE_HEAP;
-      }
-
-      _delta1->clear();
-      _delta2->clear();
-      _delta3->clear();
-      _tree_set->clear();
-
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        Value max = 0;
-        for (OutArcIt e(_graph, n); e != INVALID; ++e) {
-          if (_graph.target(e) == n && !_allow_loops) continue;
-          if ((dualScale * _weight[e]) / 2 > max) {
-            max = (dualScale * _weight[e]) / 2;
-          }
-        }
-        _node_potential->set(n, max);
-        _delta1->push(n, max);
-
-        _tree_set->insert(n);
-
-        _matching->set(n, INVALID);
-        _status->set(n, EVEN);
-      }
-
-      for (EdgeIt e(_graph); e != INVALID; ++e) {
-        Node left = _graph.u(e);
-        Node right = _graph.v(e);
-        if (left == right && !_allow_loops) continue;
-        _delta3->push(e, ((*_node_potential)[left] +
-                          (*_node_potential)[right] -
-                          dualScale * _weight[e]) / 2);
-      }
-    }
-
-    /// \brief Start the algorithm
-    ///
-    /// This function starts the algorithm.
-    ///
-    /// \pre \ref init() must be called before using this function.
-    void start() {
-      enum OpType {
-        D1, D2, D3
-      };
-
-      int unmatched = _node_num;
-      while (unmatched > 0) {
-        Value d1 = !_delta1->empty() ?
-          _delta1->prio() : std::numeric_limits<Value>::max();
-
-        Value d2 = !_delta2->empty() ?
-          _delta2->prio() : std::numeric_limits<Value>::max();
-
-        Value d3 = !_delta3->empty() ?
-          _delta3->prio() : std::numeric_limits<Value>::max();
-
-        _delta_sum = d3; OpType ot = D3;
-        if (d1 < _delta_sum) { _delta_sum = d1; ot = D1; }
-        if (d2 < _delta_sum) { _delta_sum = d2; ot = D2; }
-
-        switch (ot) {
-        case D1:
-          {
-            Node n = _delta1->top();
-            unmatchNode(n);
-            --unmatched;
-          }
-          break;
-        case D2:
-          {
-            Node n = _delta2->top();
-            Arc a = (*_pred)[n];
-            if ((*_matching)[n] == INVALID) {
-              augmentOnArc(a);
-              --unmatched;
-            } else {
-              Node v = _graph.target((*_matching)[n]);
-              if ((*_matching)[n] !=
-                  _graph.oppositeArc((*_matching)[v])) {
-                extractCycle(a);
-                --unmatched;
-              } else {
-                extendOnArc(a);
-              }
-            }
-          } break;
-        case D3:
-          {
-            Edge e = _delta3->top();
-
-            Node left = _graph.u(e);
-            Node right = _graph.v(e);
-
-            int left_tree = _tree_set->find(left);
-            int right_tree = _tree_set->find(right);
-
-            if (left_tree == right_tree) {
-              cycleOnEdge(e, left_tree);
-              --unmatched;
-            } else {
-              augmentOnEdge(e);
-              unmatched -= 2;
-            }
-          } break;
-        }
-      }
-    }
-
-    /// \brief Run the algorithm.
-    ///
-    /// This method runs the \c %MaxWeightedFractionalMatching algorithm.
-    ///
-    /// \note mwfm.run() is just a shortcut of the following code.
-    /// \code
-    ///   mwfm.init();
-    ///   mwfm.start();
-    /// \endcode
-    void run() {
-      init();
-      start();
-    }
-
-    /// @}
-
-    /// \name Primal Solution
-    /// Functions to get the primal solution, i.e. the maximum weighted
-    /// matching.\n
-    /// Either \ref run() or \ref start() function should be called before
-    /// using them.
-
-    /// @{
-
-    /// \brief Return the weight of the matching.
-    ///
-    /// This function returns the weight of the found matching. This
-    /// value is scaled by \ref primalScale "primal scale".
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    Value matchingWeight() const {
-      Value sum = 0;
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        if ((*_matching)[n] != INVALID) {
-          sum += _weight[(*_matching)[n]];
-        }
-      }
-      return sum * primalScale / 2;
-    }
-
-    /// \brief Return the number of covered nodes in the matching.
-    ///
-    /// This function returns the number of covered nodes in the matching.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    int matchingSize() const {
-      int num = 0;
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        if ((*_matching)[n] != INVALID) {
-          ++num;
-        }
-      }
-      return num;
-    }
-
-    /// \brief Return \c true if the given edge is in the matching.
-    ///
-    /// This function returns \c true if the given edge is in the
-    /// found matching. The result is scaled by \ref primalScale
-    /// "primal scale".
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    int matching(const Edge& edge) const {
-      return (edge == (*_matching)[_graph.u(edge)] ? 1 : 0)
-        + (edge == (*_matching)[_graph.v(edge)] ? 1 : 0);
-    }
-
-    /// \brief Return the fractional matching arc (or edge) incident
-    /// to the given node.
-    ///
-    /// This function returns one of the fractional matching arc (or
-    /// edge) incident to the given node in the found matching or \c
-    /// INVALID if the node is not covered by the matching or if the
-    /// node is on an odd length cycle then it is the successor edge
-    /// on the cycle.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    Arc matching(const Node& node) const {
-      return (*_matching)[node];
-    }
-
-    /// \brief Return a const reference to the matching map.
-    ///
-    /// This function returns a const reference to a node map that stores
-    /// the matching arc (or edge) incident to each node.
-    const MatchingMap& matchingMap() const {
-      return *_matching;
-    }
-
-    /// @}
-
-    /// \name Dual Solution
-    /// Functions to get the dual solution.\n
-    /// Either \ref run() or \ref start() function should be called before
-    /// using them.
-
-    /// @{
-
-    /// \brief Return the value of the dual solution.
-    ///
-    /// This function returns the value of the dual solution.
-    /// It should be equal to the primal value scaled by \ref dualScale
-    /// "dual scale".
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    Value dualValue() const {
-      Value sum = 0;
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        sum += nodeValue(n);
-      }
-      return sum;
-    }
-
-    /// \brief Return the dual value (potential) of the given node.
-    ///
-    /// This function returns the dual value (potential) of the given node.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    Value nodeValue(const Node& n) const {
-      return (*_node_potential)[n];
-    }
-
-    /// @}
-
-  };
-
-  /// \ingroup matching
-  ///
-  /// \brief Weighted fractional perfect matching in general graphs
-  ///
-  /// This class provides an efficient implementation of fractional
-  /// matching algorithm. The implementation uses priority queues and
-  /// provides \f$O(nm\log n)\f$ time complexity.
-  ///
-  /// The maximum weighted fractional perfect matching is a relaxation
-  /// of the maximum weighted perfect matching problem where the odd
-  /// set constraints are omitted.
-  /// It can be formulated with the following linear program.
-  /// \f[ \sum_{e \in \delta(u)}x_e = 1 \quad \forall u\in V\f]
-  /// \f[x_e \ge 0\quad \forall e\in E\f]
-  /// \f[\max \sum_{e\in E}x_ew_e\f]
-  /// where \f$\delta(X)\f$ is the set of edges incident to a node in
-  /// \f$X\f$. The result must be the union of a matching with one
-  /// value edges and a set of odd length cycles with half value edges.
-  ///
-  /// The algorithm calculates an optimal fractional matching and a
-  /// proof of the optimality. The solution of the dual problem can be
-  /// used to check the result of the algorithm. The dual linear
-  /// problem is the following.
-  /// \f[ y_u + y_v \ge w_{uv} \quad \forall uv\in E\f]
-  /// \f[\min \sum_{u \in V}y_u \f]
-  ///
-  /// The algorithm can be executed with the run() function.
-  /// After it the matching (the primal solution) and the dual solution
-  /// can be obtained using the query functions.
-  ///
-  /// The primal solution is multiplied by
-  /// \ref MaxWeightedPerfectFractionalMatching::primalScale "2".
-  /// If the value type is integer, then the dual
-  /// solution is scaled by
-  /// \ref MaxWeightedPerfectFractionalMatching::dualScale "4".
-  ///
-  /// \tparam GR The undirected graph type the algorithm runs on.
-  /// \tparam WM The type edge weight map. The default type is
-  /// \ref concepts::Graph::EdgeMap "GR::EdgeMap<int>".
-#ifdef DOXYGEN
-  template <typename GR, typename WM>
-#else
-  template <typename GR,
-            typename WM = typename GR::template EdgeMap<int> >
-#endif
-  class MaxWeightedPerfectFractionalMatching {
-  public:
-
-    /// The graph type of the algorithm
-    typedef GR Graph;
-    /// The type of the edge weight map
-    typedef WM WeightMap;
-    /// The value type of the edge weights
-    typedef typename WeightMap::Value Value;
-
-    /// The type of the matching map
-    typedef typename Graph::template NodeMap<typename Graph::Arc>
-    MatchingMap;
-
-    /// \brief Scaling factor for primal solution
-    ///
-    /// Scaling factor for primal solution.
-    static const int primalScale = 2;
-
-    /// \brief Scaling factor for dual solution
-    ///
-    /// Scaling factor for dual solution. It is equal to 4 or 1
-    /// according to the value type.
-    static const int dualScale =
-      std::numeric_limits<Value>::is_integer ? 4 : 1;
-
-  private:
-
-    TEMPLATE_GRAPH_TYPEDEFS(Graph);
-
-    typedef typename Graph::template NodeMap<Value> NodePotential;
-
-    const Graph& _graph;
-    const WeightMap& _weight;
-
-    MatchingMap* _matching;
-    NodePotential* _node_potential;
-
-    int _node_num;
-    bool _allow_loops;
-
-    enum Status {
-      EVEN = -1, MATCHED = 0, ODD = 1
-    };
-
-    typedef typename Graph::template NodeMap<Status> StatusMap;
-    StatusMap* _status;
-
-    typedef typename Graph::template NodeMap<Arc> PredMap;
-    PredMap* _pred;
-
-    typedef ExtendFindEnum<IntNodeMap> TreeSet;
-
-    IntNodeMap *_tree_set_index;
-    TreeSet *_tree_set;
-
-    IntNodeMap *_delta2_index;
-    BinHeap<Value, IntNodeMap> *_delta2;
-
-    IntEdgeMap *_delta3_index;
-    BinHeap<Value, IntEdgeMap> *_delta3;
-
-    Value _delta_sum;
-
-    void createStructures() {
-      _node_num = countNodes(_graph);
-
-      if (!_matching) {
-        _matching = new MatchingMap(_graph);
-      }
-      if (!_node_potential) {
-        _node_potential = new NodePotential(_graph);
-      }
-      if (!_status) {
-        _status = new StatusMap(_graph);
-      }
-      if (!_pred) {
-        _pred = new PredMap(_graph);
-      }
-      if (!_tree_set) {
-        _tree_set_index = new IntNodeMap(_graph);
-        _tree_set = new TreeSet(*_tree_set_index);
-      }
-      if (!_delta2) {
-        _delta2_index = new IntNodeMap(_graph);
-        _delta2 = new BinHeap<Value, IntNodeMap>(*_delta2_index);
-      }
-      if (!_delta3) {
-        _delta3_index = new IntEdgeMap(_graph);
-        _delta3 = new BinHeap<Value, IntEdgeMap>(*_delta3_index);
-      }
-    }
-
-    void destroyStructures() {
-      if (_matching) {
-        delete _matching;
-      }
-      if (_node_potential) {
-        delete _node_potential;
-      }
-      if (_status) {
-        delete _status;
-      }
-      if (_pred) {
-        delete _pred;
-      }
-      if (_tree_set) {
-        delete _tree_set_index;
-        delete _tree_set;
-      }
-      if (_delta2) {
-        delete _delta2_index;
-        delete _delta2;
-      }
-      if (_delta3) {
-        delete _delta3_index;
-        delete _delta3;
-      }
-    }
-
-    void matchedToEven(Node node, int tree) {
-      _tree_set->insert(node, tree);
-      _node_potential->set(node, (*_node_potential)[node] + _delta_sum);
-
-      if (_delta2->state(node) == _delta2->IN_HEAP) {
-        _delta2->erase(node);
-      }
-
-      for (InArcIt a(_graph, node); a != INVALID; ++a) {
-        Node v = _graph.source(a);
-        Value rw = (*_node_potential)[node] + (*_node_potential)[v] -
-          dualScale * _weight[a];
-        if (node == v) {
-          if (_allow_loops && _graph.direction(a)) {
-            _delta3->push(a, rw / 2);
-          }
-        } else if ((*_status)[v] == EVEN) {
-          _delta3->push(a, rw / 2);
-        } else if ((*_status)[v] == MATCHED) {
-          if (_delta2->state(v) != _delta2->IN_HEAP) {
-            _pred->set(v, a);
-            _delta2->push(v, rw);
-          } else if ((*_delta2)[v] > rw) {
-            _pred->set(v, a);
-            _delta2->decrease(v, rw);
-          }
-        }
-      }
-    }
-
-    void matchedToOdd(Node node, int tree) {
-      _tree_set->insert(node, tree);
-      _node_potential->set(node, (*_node_potential)[node] - _delta_sum);
-
-      if (_delta2->state(node) == _delta2->IN_HEAP) {
-        _delta2->erase(node);
-      }
-    }
-
-    void evenToMatched(Node node, int tree) {
-      _node_potential->set(node, (*_node_potential)[node] - _delta_sum);
-      Arc min = INVALID;
-      Value minrw = std::numeric_limits<Value>::max();
-      for (InArcIt a(_graph, node); a != INVALID; ++a) {
-        Node v = _graph.source(a);
-        Value rw = (*_node_potential)[node] + (*_node_potential)[v] -
-          dualScale * _weight[a];
-
-        if (node == v) {
-          if (_allow_loops && _graph.direction(a)) {
-            _delta3->erase(a);
-          }
-        } else if ((*_status)[v] == EVEN) {
-          _delta3->erase(a);
-          if (minrw > rw) {
-            min = _graph.oppositeArc(a);
-            minrw = rw;
-          }
-        } else if ((*_status)[v]  == MATCHED) {
-          if ((*_pred)[v] == a) {
-            Arc mina = INVALID;
-            Value minrwa = std::numeric_limits<Value>::max();
-            for (OutArcIt aa(_graph, v); aa != INVALID; ++aa) {
-              Node va = _graph.target(aa);
-              if ((*_status)[va] != EVEN ||
-                  _tree_set->find(va) == tree) continue;
-              Value rwa = (*_node_potential)[v] + (*_node_potential)[va] -
-                dualScale * _weight[aa];
-              if (minrwa > rwa) {
-                minrwa = rwa;
-                mina = aa;
-              }
-            }
-            if (mina != INVALID) {
-              _pred->set(v, mina);
-              _delta2->increase(v, minrwa);
-            } else {
-              _pred->set(v, INVALID);
-              _delta2->erase(v);
-            }
-          }
-        }
-      }
-      if (min != INVALID) {
-        _pred->set(node, min);
-        _delta2->push(node, minrw);
-      } else {
-        _pred->set(node, INVALID);
-      }
-    }
-
-    void oddToMatched(Node node) {
-      _node_potential->set(node, (*_node_potential)[node] + _delta_sum);
-      Arc min = INVALID;
-      Value minrw = std::numeric_limits<Value>::max();
-      for (InArcIt a(_graph, node); a != INVALID; ++a) {
-        Node v = _graph.source(a);
-        if ((*_status)[v] != EVEN) continue;
-        Value rw = (*_node_potential)[node] + (*_node_potential)[v] -
-          dualScale * _weight[a];
-
-        if (minrw > rw) {
-          min = _graph.oppositeArc(a);
-          minrw = rw;
-        }
-      }
-      if (min != INVALID) {
-        _pred->set(node, min);
-        _delta2->push(node, minrw);
-      } else {
-        _pred->set(node, INVALID);
-      }
-    }
-
-    void alternatePath(Node even, int tree) {
-      Node odd;
-
-      _status->set(even, MATCHED);
-      evenToMatched(even, tree);
-
-      Arc prev = (*_matching)[even];
-      while (prev != INVALID) {
-        odd = _graph.target(prev);
-        even = _graph.target((*_pred)[odd]);
-        _matching->set(odd, (*_pred)[odd]);
-        _status->set(odd, MATCHED);
-        oddToMatched(odd);
-
-        prev = (*_matching)[even];
-        _status->set(even, MATCHED);
-        _matching->set(even, _graph.oppositeArc((*_matching)[odd]));
-        evenToMatched(even, tree);
-      }
-    }
-
-    void destroyTree(int tree) {
-      for (typename TreeSet::ItemIt n(*_tree_set, tree); n != INVALID; ++n) {
-        if ((*_status)[n] == EVEN) {
-          _status->set(n, MATCHED);
-          evenToMatched(n, tree);
-        } else if ((*_status)[n] == ODD) {
-          _status->set(n, MATCHED);
-          oddToMatched(n);
-        }
-      }
-      _tree_set->eraseClass(tree);
-    }
-
-    void augmentOnEdge(const Edge& edge) {
-      Node left = _graph.u(edge);
-      int left_tree = _tree_set->find(left);
-
-      alternatePath(left, left_tree);
-      destroyTree(left_tree);
-      _matching->set(left, _graph.direct(edge, true));
-
-      Node right = _graph.v(edge);
-      int right_tree = _tree_set->find(right);
-
-      alternatePath(right, right_tree);
-      destroyTree(right_tree);
-      _matching->set(right, _graph.direct(edge, false));
-    }
-
-    void augmentOnArc(const Arc& arc) {
-      Node left = _graph.source(arc);
-      _status->set(left, MATCHED);
-      _matching->set(left, arc);
-      _pred->set(left, arc);
-
-      Node right = _graph.target(arc);
-      int right_tree = _tree_set->find(right);
-
-      alternatePath(right, right_tree);
-      destroyTree(right_tree);
-      _matching->set(right, _graph.oppositeArc(arc));
-    }
-
-    void extendOnArc(const Arc& arc) {
-      Node base = _graph.target(arc);
-      int tree = _tree_set->find(base);
-
-      Node odd = _graph.source(arc);
-      _tree_set->insert(odd, tree);
-      _status->set(odd, ODD);
-      matchedToOdd(odd, tree);
-      _pred->set(odd, arc);
-
-      Node even = _graph.target((*_matching)[odd]);
-      _tree_set->insert(even, tree);
-      _status->set(even, EVEN);
-      matchedToEven(even, tree);
-    }
-
-    void cycleOnEdge(const Edge& edge, int tree) {
-      Node nca = INVALID;
-      std::vector<Node> left_path, right_path;
-
-      {
-        std::set<Node> left_set, right_set;
-        Node left = _graph.u(edge);
-        left_path.push_back(left);
-        left_set.insert(left);
-
-        Node right = _graph.v(edge);
-        right_path.push_back(right);
-        right_set.insert(right);
-
-        while (true) {
-
-          if (left_set.find(right) != left_set.end()) {
-            nca = right;
-            break;
-          }
-
-          if ((*_matching)[left] == INVALID) break;
-
-          left = _graph.target((*_matching)[left]);
-          left_path.push_back(left);
-          left = _graph.target((*_pred)[left]);
-          left_path.push_back(left);
-
-          left_set.insert(left);
-
-          if (right_set.find(left) != right_set.end()) {
-            nca = left;
-            break;
-          }
-
-          if ((*_matching)[right] == INVALID) break;
-
-          right = _graph.target((*_matching)[right]);
-          right_path.push_back(right);
-          right = _graph.target((*_pred)[right]);
-          right_path.push_back(right);
-
-          right_set.insert(right);
-
-        }
-
-        if (nca == INVALID) {
-          if ((*_matching)[left] == INVALID) {
-            nca = right;
-            while (left_set.find(nca) == left_set.end()) {
-              nca = _graph.target((*_matching)[nca]);
-              right_path.push_back(nca);
-              nca = _graph.target((*_pred)[nca]);
-              right_path.push_back(nca);
-            }
-          } else {
-            nca = left;
-            while (right_set.find(nca) == right_set.end()) {
-              nca = _graph.target((*_matching)[nca]);
-              left_path.push_back(nca);
-              nca = _graph.target((*_pred)[nca]);
-              left_path.push_back(nca);
-            }
-          }
-        }
-      }
-
-      alternatePath(nca, tree);
-      Arc prev;
-
-      prev = _graph.direct(edge, true);
-      for (int i = 0; left_path[i] != nca; i += 2) {
-        _matching->set(left_path[i], prev);
-        _status->set(left_path[i], MATCHED);
-        evenToMatched(left_path[i], tree);
-
-        prev = _graph.oppositeArc((*_pred)[left_path[i + 1]]);
-        _status->set(left_path[i + 1], MATCHED);
-        oddToMatched(left_path[i + 1]);
-      }
-      _matching->set(nca, prev);
-
-      for (int i = 0; right_path[i] != nca; i += 2) {
-        _status->set(right_path[i], MATCHED);
-        evenToMatched(right_path[i], tree);
-
-        _matching->set(right_path[i + 1], (*_pred)[right_path[i + 1]]);
-        _status->set(right_path[i + 1], MATCHED);
-        oddToMatched(right_path[i + 1]);
-      }
-
-      destroyTree(tree);
-    }
-
-    void extractCycle(const Arc &arc) {
-      Node left = _graph.source(arc);
-      Node odd = _graph.target((*_matching)[left]);
-      Arc prev;
-      while (odd != left) {
-        Node even = _graph.target((*_matching)[odd]);
-        prev = (*_matching)[odd];
-        odd = _graph.target((*_matching)[even]);
-        _matching->set(even, _graph.oppositeArc(prev));
-      }
-      _matching->set(left, arc);
-
-      Node right = _graph.target(arc);
-      int right_tree = _tree_set->find(right);
-      alternatePath(right, right_tree);
-      destroyTree(right_tree);
-      _matching->set(right, _graph.oppositeArc(arc));
-    }
-
-  public:
-
-    /// \brief Constructor
-    ///
-    /// Constructor.
-    MaxWeightedPerfectFractionalMatching(const Graph& graph,
-                                         const WeightMap& weight,
-                                         bool allow_loops = true)
-      : _graph(graph), _weight(weight), _matching(0),
-      _node_potential(0), _node_num(0), _allow_loops(allow_loops),
-      _status(0),  _pred(0),
-      _tree_set_index(0), _tree_set(0),
-
-      _delta2_index(0), _delta2(0),
-      _delta3_index(0), _delta3(0),
-
-      _delta_sum() {}
-
-    ~MaxWeightedPerfectFractionalMatching() {
-      destroyStructures();
-    }
-
-    /// \name Execution Control
-    /// The simplest way to execute the algorithm is to use the
-    /// \ref run() member function.
-
-    ///@{
-
-    /// \brief Initialize the algorithm
-    ///
-    /// This function initializes the algorithm.
-    void init() {
-      createStructures();
-
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        (*_delta2_index)[n] = _delta2->PRE_HEAP;
-      }
-      for (EdgeIt e(_graph); e != INVALID; ++e) {
-        (*_delta3_index)[e] = _delta3->PRE_HEAP;
-      }
-
-      _delta2->clear();
-      _delta3->clear();
-      _tree_set->clear();
-
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        Value max = - std::numeric_limits<Value>::max();
-        for (OutArcIt e(_graph, n); e != INVALID; ++e) {
-          if (_graph.target(e) == n && !_allow_loops) continue;
-          if ((dualScale * _weight[e]) / 2 > max) {
-            max = (dualScale * _weight[e]) / 2;
-          }
-        }
-        _node_potential->set(n, max);
-
-        _tree_set->insert(n);
-
-        _matching->set(n, INVALID);
-        _status->set(n, EVEN);
-      }
-
-      for (EdgeIt e(_graph); e != INVALID; ++e) {
-        Node left = _graph.u(e);
-        Node right = _graph.v(e);
-        if (left == right && !_allow_loops) continue;
-        _delta3->push(e, ((*_node_potential)[left] +
-                          (*_node_potential)[right] -
-                          dualScale * _weight[e]) / 2);
-      }
-    }
-
-    /// \brief Start the algorithm
-    ///
-    /// This function starts the algorithm.
-    ///
-    /// \pre \ref init() must be called before using this function.
-    bool start() {
-      enum OpType {
-        D2, D3
-      };
-
-      int unmatched = _node_num;
-      while (unmatched > 0) {
-        Value d2 = !_delta2->empty() ?
-          _delta2->prio() : std::numeric_limits<Value>::max();
-
-        Value d3 = !_delta3->empty() ?
-          _delta3->prio() : std::numeric_limits<Value>::max();
-
-        _delta_sum = d3; OpType ot = D3;
-        if (d2 < _delta_sum) { _delta_sum = d2; ot = D2; }
-
-        if (_delta_sum == std::numeric_limits<Value>::max()) {
-          return false;
-        }
-
-        switch (ot) {
-        case D2:
-          {
-            Node n = _delta2->top();
-            Arc a = (*_pred)[n];
-            if ((*_matching)[n] == INVALID) {
-              augmentOnArc(a);
-              --unmatched;
-            } else {
-              Node v = _graph.target((*_matching)[n]);
-              if ((*_matching)[n] !=
-                  _graph.oppositeArc((*_matching)[v])) {
-                extractCycle(a);
-                --unmatched;
-              } else {
-                extendOnArc(a);
-              }
-            }
-          } break;
-        case D3:
-          {
-            Edge e = _delta3->top();
-
-            Node left = _graph.u(e);
-            Node right = _graph.v(e);
-
-            int left_tree = _tree_set->find(left);
-            int right_tree = _tree_set->find(right);
-
-            if (left_tree == right_tree) {
-              cycleOnEdge(e, left_tree);
-              --unmatched;
-            } else {
-              augmentOnEdge(e);
-              unmatched -= 2;
-            }
-          } break;
-        }
-      }
-      return true;
-    }
-
-    /// \brief Run the algorithm.
-    ///
-    /// This method runs the \c %MaxWeightedPerfectFractionalMatching
-    /// algorithm.
-    ///
-    /// \note mwfm.run() is just a shortcut of the following code.
-    /// \code
-    ///   mwpfm.init();
-    ///   mwpfm.start();
-    /// \endcode
-    bool run() {
-      init();
-      return start();
-    }
-
-    /// @}
-
-    /// \name Primal Solution
-    /// Functions to get the primal solution, i.e. the maximum weighted
-    /// matching.\n
-    /// Either \ref run() or \ref start() function should be called before
-    /// using them.
-
-    /// @{
-
-    /// \brief Return the weight of the matching.
-    ///
-    /// This function returns the weight of the found matching. This
-    /// value is scaled by \ref primalScale "primal scale".
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    Value matchingWeight() const {
-      Value sum = 0;
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        if ((*_matching)[n] != INVALID) {
-          sum += _weight[(*_matching)[n]];
-        }
-      }
-      return sum * primalScale / 2;
-    }
-
-    /// \brief Return the number of covered nodes in the matching.
-    ///
-    /// This function returns the number of covered nodes in the matching.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    int matchingSize() const {
-      int num = 0;
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        if ((*_matching)[n] != INVALID) {
-          ++num;
-        }
-      }
-      return num;
-    }
-
-    /// \brief Return \c true if the given edge is in the matching.
-    ///
-    /// This function returns \c true if the given edge is in the
-    /// found matching. The result is scaled by \ref primalScale
-    /// "primal scale".
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    int matching(const Edge& edge) const {
-      return (edge == (*_matching)[_graph.u(edge)] ? 1 : 0)
-        + (edge == (*_matching)[_graph.v(edge)] ? 1 : 0);
-    }
-
-    /// \brief Return the fractional matching arc (or edge) incident
-    /// to the given node.
-    ///
-    /// This function returns one of the fractional matching arc (or
-    /// edge) incident to the given node in the found matching or \c
-    /// INVALID if the node is not covered by the matching or if the
-    /// node is on an odd length cycle then it is the successor edge
-    /// on the cycle.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    Arc matching(const Node& node) const {
-      return (*_matching)[node];
-    }
-
-    /// \brief Return a const reference to the matching map.
-    ///
-    /// This function returns a const reference to a node map that stores
-    /// the matching arc (or edge) incident to each node.
-    const MatchingMap& matchingMap() const {
-      return *_matching;
-    }
-
-    /// @}
-
-    /// \name Dual Solution
-    /// Functions to get the dual solution.\n
-    /// Either \ref run() or \ref start() function should be called before
-    /// using them.
-
-    /// @{
-
-    /// \brief Return the value of the dual solution.
-    ///
-    /// This function returns the value of the dual solution.
-    /// It should be equal to the primal value scaled by \ref dualScale
-    /// "dual scale".
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    Value dualValue() const {
-      Value sum = 0;
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        sum += nodeValue(n);
-      }
-      return sum;
-    }
-
-    /// \brief Return the dual value (potential) of the given node.
-    ///
-    /// This function returns the dual value (potential) of the given node.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    Value nodeValue(const Node& n) const {
-      return (*_node_potential)[n];
-    }
-
-    /// @}
-
-  };
-
-} //END OF NAMESPACE LEMON
-
-#endif //LEMON_FRACTIONAL_MATCHING_H
Index: lemon/full_graph.h
===================================================================
--- lemon/full_graph.h	(revision 1270)
+++ lemon/full_graph.h	(revision 834)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -204,5 +204,5 @@
     /// \brief Returns the node with the given index.
     ///
-    /// Returns the node with the given index. Since this structure is
+    /// Returns the node with the given index. Since this structure is 
     /// completely static, the nodes can be indexed with integers from
     /// the range <tt>[0..nodeNum()-1]</tt>.
@@ -213,5 +213,5 @@
     /// \brief Returns the index of the given node.
     ///
-    /// Returns the index of the given node. Since this structure is
+    /// Returns the index of the given node. Since this structure is 
     /// completely static, the nodes can be indexed with integers from
     /// the range <tt>[0..nodeNum()-1]</tt>.
@@ -583,5 +583,5 @@
     /// \brief Returns the node with the given index.
     ///
-    /// Returns the node with the given index. Since this structure is
+    /// Returns the node with the given index. Since this structure is 
     /// completely static, the nodes can be indexed with integers from
     /// the range <tt>[0..nodeNum()-1]</tt>.
@@ -592,5 +592,5 @@
     /// \brief Returns the index of the given node.
     ///
-    /// Returns the index of the given node. Since this structure is
+    /// Returns the index of the given node. Since this structure is 
     /// completely static, the nodes can be indexed with integers from
     /// the range <tt>[0..nodeNum()-1]</tt>.
@@ -622,458 +622,4 @@
   };
 
-  class FullBpGraphBase {
-
-  protected:
-
-    int _red_num, _blue_num;
-    int _node_num, _edge_num;
-
-  public:
-
-    typedef FullBpGraphBase Graph;
-
-    class Node;
-    class Arc;
-    class Edge;
-
-    class Node {
-      friend class FullBpGraphBase;
-    protected:
-
-      int _id;
-      explicit Node(int id) { _id = id;}
-
-    public:
-      Node() {}
-      Node (Invalid) { _id = -1; }
-      bool operator==(const Node& node) const {return _id == node._id;}
-      bool operator!=(const Node& node) const {return _id != node._id;}
-      bool operator<(const Node& node) const {return _id < node._id;}
-    };
-
-    class RedNode : public Node {
-      friend class FullBpGraphBase;
-    protected:
-
-      explicit RedNode(int pid) : Node(pid) {}
-
-    public:
-      RedNode() {}
-      RedNode(const RedNode& node) : Node(node) {}
-      RedNode(Invalid) : Node(INVALID){}
-    };
-
-    class BlueNode : public Node {
-      friend class FullBpGraphBase;
-    protected:
-
-      explicit BlueNode(int pid) : Node(pid) {}
-
-    public:
-      BlueNode() {}
-      BlueNode(const BlueNode& node) : Node(node) {}
-      BlueNode(Invalid) : Node(INVALID){}
-    };
-
-    class Edge {
-      friend class FullBpGraphBase;
-    protected:
-
-      int _id;
-      explicit Edge(int id) { _id = id;}
-
-    public:
-      Edge() {}
-      Edge (Invalid) { _id = -1; }
-      bool operator==(const Edge& arc) const {return _id == arc._id;}
-      bool operator!=(const Edge& arc) const {return _id != arc._id;}
-      bool operator<(const Edge& arc) const {return _id < arc._id;}
-    };
-
-    class Arc {
-      friend class FullBpGraphBase;
-    protected:
-
-      int _id;
-      explicit Arc(int id) { _id = id;}
-
-    public:
-      operator Edge() const {
-        return _id != -1 ? edgeFromId(_id / 2) : INVALID;
-      }
-
-      Arc() {}
-      Arc (Invalid) { _id = -1; }
-      bool operator==(const Arc& arc) const {return _id == arc._id;}
-      bool operator!=(const Arc& arc) const {return _id != arc._id;}
-      bool operator<(const Arc& arc) const {return _id < arc._id;}
-    };
-
-
-  protected:
-
-    FullBpGraphBase()
-      : _red_num(0), _blue_num(0), _node_num(0), _edge_num(0) {}
-
-    void construct(int redNum, int blueNum) {
-      _red_num = redNum; _blue_num = blueNum;
-      _node_num = redNum + blueNum; _edge_num = redNum * blueNum;
-    }
-
-  public:
-
-    typedef True NodeNumTag;
-    typedef True EdgeNumTag;
-    typedef True ArcNumTag;
-
-    int nodeNum() const { return _node_num; }
-    int redNum() const { return _red_num; }
-    int blueNum() const { return _blue_num; }
-    int edgeNum() const { return _edge_num; }
-    int arcNum() const { return 2 * _edge_num; }
-
-    int maxNodeId() const { return _node_num - 1; }
-    int maxRedId() const { return _red_num - 1; }
-    int maxBlueId() const { return _blue_num - 1; }
-    int maxEdgeId() const { return _edge_num - 1; }
-    int maxArcId() const { return 2 * _edge_num - 1; }
-
-    bool red(Node n) const { return n._id < _red_num; }
-    bool blue(Node n) const { return n._id >= _red_num; }
-
-    static RedNode asRedNodeUnsafe(Node n) { return RedNode(n._id); }
-    static BlueNode asBlueNodeUnsafe(Node n) { return BlueNode(n._id); }
-
-    Node source(Arc a) const {
-      if (a._id & 1) {
-        return Node((a._id >> 1) % _red_num);
-      } else {
-        return Node((a._id >> 1) / _red_num + _red_num);
-      }
-    }
-    Node target(Arc a) const {
-      if (a._id & 1) {
-        return Node((a._id >> 1) / _red_num + _red_num);
-      } else {
-        return Node((a._id >> 1) % _red_num);
-      }
-    }
-
-    RedNode redNode(Edge e) const {
-      return RedNode(e._id % _red_num);
-    }
-    BlueNode blueNode(Edge e) const {
-      return BlueNode(e._id / _red_num + _red_num);
-    }
-
-    static bool direction(Arc a) {
-      return (a._id & 1) == 1;
-    }
-
-    static Arc direct(Edge e, bool d) {
-      return Arc(e._id * 2 + (d ? 1 : 0));
-    }
-
-    void first(Node& node) const {
-      node._id = _node_num - 1;
-    }
-
-    static void next(Node& node) {
-      --node._id;
-    }
-
-    void first(RedNode& node) const {
-      node._id = _red_num - 1;
-    }
-
-    static void next(RedNode& node) {
-      --node._id;
-    }
-
-    void first(BlueNode& node) const {
-      if (_red_num == _node_num) node._id = -1;
-      else node._id = _node_num - 1;
-    }
-
-    void next(BlueNode& node) const {
-      if (node._id == _red_num) node._id = -1;
-      else --node._id;
-    }
-
-    void first(Arc& arc) const {
-      arc._id = 2 * _edge_num - 1;
-    }
-
-    static void next(Arc& arc) {
-      --arc._id;
-    }
-
-    void first(Edge& arc) const {
-      arc._id = _edge_num - 1;
-    }
-
-    static void next(Edge& arc) {
-      --arc._id;
-    }
-
-    void firstOut(Arc &a, const Node& v) const {
-      if (v._id < _red_num) {
-        a._id = 2 * (v._id + _red_num * (_blue_num - 1)) + 1;
-      } else {
-        a._id = 2 * (_red_num - 1 + _red_num * (v._id - _red_num));
-      }
-    }
-    void nextOut(Arc &a) const {
-      if (a._id & 1) {
-        a._id -= 2 * _red_num;
-        if (a._id < 0) a._id = -1;
-      } else {
-        if (a._id % (2 * _red_num) == 0) a._id = -1;
-        else a._id -= 2;
-      }
-    }
-
-    void firstIn(Arc &a, const Node& v) const {
-      if (v._id < _red_num) {
-        a._id = 2 * (v._id + _red_num * (_blue_num - 1));
-      } else {
-        a._id = 2 * (_red_num - 1 + _red_num * (v._id - _red_num)) + 1;
-      }
-    }
-    void nextIn(Arc &a) const {
-      if (a._id & 1) {
-        if (a._id % (2 * _red_num) == 1) a._id = -1;
-        else a._id -= 2;
-      } else {
-        a._id -= 2 * _red_num;
-        if (a._id < 0) a._id = -1;
-      }
-    }
-
-    void firstInc(Edge &e, bool& d, const Node& v) const {
-      if (v._id < _red_num) {
-        d = true;
-        e._id = v._id + _red_num * (_blue_num - 1);
-      } else {
-        d = false;
-        e._id = _red_num - 1 + _red_num * (v._id - _red_num);
-      }
-    }
-    void nextInc(Edge &e, bool& d) const {
-      if (d) {
-        e._id -= _red_num;
-        if (e._id < 0) e._id = -1;
-      } else {
-        if (e._id % _red_num == 0) e._id = -1;
-        else --e._id;
-      }
-    }
-
-    static int id(const Node& v) { return v._id; }
-    int id(const RedNode& v) const { return v._id; }
-    int id(const BlueNode& v) const { return v._id - _red_num; }
-    static int id(Arc e) { return e._id; }
-    static int id(Edge e) { return e._id; }
-
-    static Node nodeFromId(int id) { return Node(id);}
-    static Arc arcFromId(int id) { return Arc(id);}
-    static Edge edgeFromId(int id) { return Edge(id);}
-
-    bool valid(Node n) const {
-      return n._id >= 0 && n._id < _node_num;
-    }
-    bool valid(Arc a) const {
-      return a._id >= 0 && a._id < 2 * _edge_num;
-    }
-    bool valid(Edge e) const {
-      return e._id >= 0 && e._id < _edge_num;
-    }
-
-    RedNode redNode(int index) const {
-      return RedNode(index);
-    }
-
-    int index(RedNode n) const {
-      return n._id;
-    }
-
-    BlueNode blueNode(int index) const {
-      return BlueNode(index + _red_num);
-    }
-
-    int index(BlueNode n) const {
-      return n._id - _red_num;
-    }
-
-    void clear() {
-      _red_num = 0; _blue_num = 0;
-      _node_num = 0; _edge_num = 0;
-    }
-
-    Edge edge(const Node& u, const Node& v) const {
-      if (u._id < _red_num) {
-        if (v._id < _red_num) {
-          return Edge(-1);
-        } else {
-          return Edge(u._id + _red_num * (v._id - _red_num));
-        }
-      } else {
-        if (v._id < _red_num) {
-          return Edge(v._id + _red_num * (u._id - _red_num));
-        } else {
-          return Edge(-1);
-        }
-      }
-    }
-
-    Arc arc(const Node& u, const Node& v) const {
-      if (u._id < _red_num) {
-        if (v._id < _red_num) {
-          return Arc(-1);
-        } else {
-          return Arc(2 * (u._id + _red_num * (v._id - _red_num)) + 1);
-        }
-      } else {
-        if (v._id < _red_num) {
-          return Arc(2 * (v._id + _red_num * (u._id - _red_num)));
-        } else {
-          return Arc(-1);
-        }
-      }
-    }
-
-    typedef True FindEdgeTag;
-    typedef True FindArcTag;
-
-    Edge findEdge(Node u, Node v, Edge prev = INVALID) const {
-      return prev != INVALID ? INVALID : edge(u, v);
-    }
-
-    Arc findArc(Node s, Node t, Arc prev = INVALID) const {
-      return prev != INVALID ? INVALID : arc(s, t);
-    }
-
-  };
-
-  typedef BpGraphExtender<FullBpGraphBase> ExtendedFullBpGraphBase;
-
-  /// \ingroup graphs
-  ///
-  /// \brief An undirected full bipartite graph class.
-  ///
-  /// FullBpGraph is a simple and fast implmenetation of undirected
-  /// full bipartite graphs. It contains an edge between every
-  /// red-blue pairs of nodes, therefore the number of edges is
-  /// <tt>nr*nb</tt>.  This class is completely static and it needs
-  /// constant memory space.  Thus you can neither add nor delete
-  /// nodes or edges, however the structure can be resized using
-  /// resize().
-  ///
-  /// This type fully conforms to the \ref concepts::BpGraph "BpGraph concept".
-  /// Most of its member functions and nested classes are documented
-  /// only in the concept class.
-  ///
-  /// This class provides constant time counting for nodes, edges and arcs.
-  ///
-  /// \sa FullGraph
-  class FullBpGraph : public ExtendedFullBpGraphBase {
-  public:
-
-    typedef ExtendedFullBpGraphBase Parent;
-
-    /// \brief Default constructor.
-    ///
-    /// Default constructor. The number of nodes and edges will be zero.
-    FullBpGraph() { construct(0, 0); }
-
-    /// \brief Constructor
-    ///
-    /// Constructor.
-    /// \param redNum The number of the red nodes.
-    /// \param blueNum The number of the blue nodes.
-    FullBpGraph(int redNum, int blueNum) { construct(redNum, blueNum); }
-
-    /// \brief Resizes the graph
-    ///
-    /// This function resizes the graph. It fully destroys and
-    /// rebuilds the structure, therefore the maps of the graph will be
-    /// reallocated automatically and the previous values will be lost.
-    void resize(int redNum, int blueNum) {
-      Parent::notifier(Arc()).clear();
-      Parent::notifier(Edge()).clear();
-      Parent::notifier(Node()).clear();
-      Parent::notifier(BlueNode()).clear();
-      Parent::notifier(RedNode()).clear();
-      construct(redNum, blueNum);
-      Parent::notifier(RedNode()).build();
-      Parent::notifier(BlueNode()).build();
-      Parent::notifier(Node()).build();
-      Parent::notifier(Edge()).build();
-      Parent::notifier(Arc()).build();
-    }
-
-    using Parent::redNode;
-    using Parent::blueNode;
-
-    /// \brief Returns the red node with the given index.
-    ///
-    /// Returns the red node with the given index. Since this
-    /// structure is completely static, the red nodes can be indexed
-    /// with integers from the range <tt>[0..redNum()-1]</tt>.
-    /// \sa redIndex()
-    RedNode redNode(int index) const { return Parent::redNode(index); }
-
-    /// \brief Returns the index of the given red node.
-    ///
-    /// Returns the index of the given red node. Since this structure
-    /// is completely static, the red nodes can be indexed with
-    /// integers from the range <tt>[0..redNum()-1]</tt>.
-    ///
-    /// \sa operator()()
-    int index(RedNode node) const { return Parent::index(node); }
-
-    /// \brief Returns the blue node with the given index.
-    ///
-    /// Returns the blue node with the given index. Since this
-    /// structure is completely static, the blue nodes can be indexed
-    /// with integers from the range <tt>[0..blueNum()-1]</tt>.
-    /// \sa blueIndex()
-    BlueNode blueNode(int index) const { return Parent::blueNode(index); }
-
-    /// \brief Returns the index of the given blue node.
-    ///
-    /// Returns the index of the given blue node. Since this structure
-    /// is completely static, the blue nodes can be indexed with
-    /// integers from the range <tt>[0..blueNum()-1]</tt>.
-    ///
-    /// \sa operator()()
-    int index(BlueNode node) const { return Parent::index(node); }
-
-    /// \brief Returns the edge which connects the given nodes.
-    ///
-    /// Returns the edge which connects the given nodes.
-    Edge edge(const Node& u, const Node& v) const {
-      return Parent::edge(u, v);
-    }
-
-    /// \brief Returns the arc which connects the given nodes.
-    ///
-    /// Returns the arc which connects the given nodes.
-    Arc arc(const Node& u, const Node& v) const {
-      return Parent::arc(u, v);
-    }
-
-    /// \brief Number of nodes.
-    int nodeNum() const { return Parent::nodeNum(); }
-    /// \brief Number of red nodes.
-    int redNum() const { return Parent::redNum(); }
-    /// \brief Number of blue nodes.
-    int blueNum() const { return Parent::blueNum(); }
-    /// \brief Number of arcs.
-    int arcNum() const { return Parent::arcNum(); }
-    /// \brief Number of edges.
-    int edgeNum() const { return Parent::edgeNum(); }
-  };
-
 
 } //namespace lemon
Index: lemon/glpk.cc
===================================================================
--- lemon/glpk.cc	(revision 1336)
+++ lemon/glpk.cc	(revision 793)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -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);
   }
@@ -60,5 +60,5 @@
   }
 
-  int GlpkBase::_addRow(Value lo, ExprIterator b,
+  int GlpkBase::_addRow(Value lo, ExprIterator b, 
                         ExprIterator e, Value up) {
     int i = glp_add_rows(lp, 1);
@@ -69,9 +69,9 @@
       } else {
         glp_set_row_bnds(lp, i, GLP_UP, lo, up);
-      }
+      }    
     } else {
       if (up == INF) {
         glp_set_row_bnds(lp, i, GLP_LO, lo, up);
-      } else if (lo != up) {
+      } else if (lo != up) {        
         glp_set_row_bnds(lp, i, GLP_DB, lo, up);
       } else {
@@ -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);
   }
 
@@ -557,4 +557,6 @@
   void GlpkBase::_clear() {
     glp_erase_prob(lp);
+    rows.clear();
+    cols.clear();
   }
 
@@ -581,13 +583,4 @@
       break;
     }
-  }
-
-  void GlpkBase::_write(std::string file, std::string format) const
-  {
-    if(format == "MPS")
-      glp_write_mps(lp, GLP_MPS_FILE, 0, file.c_str());
-    else if(format == "LP")
-      glp_write_lp(lp, 0, file.c_str());
-    else throw UnsupportedFormatError(format);
   }
 
@@ -1008,5 +1001,3 @@
   const char* GlpkMip::_solverName() const { return "GlpkMip"; }
 
-
-
 } //END OF NAMESPACE LEMON
Index: lemon/glpk.h
===================================================================
--- lemon/glpk.h	(revision 1336)
+++ lemon/glpk.h	(revision 793)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -26,26 +26,14 @@
 #include <lemon/lp_base.h>
 
+// forward declaration
+#if !defined _GLP_PROB && !defined GLP_PROB
+#define _GLP_PROB
+#define GLP_PROB
+typedef struct { double _opaque_prob; } glp_prob;
+/* LP/MIP problem object */
+#endif
+
 namespace lemon {
 
-  namespace _solver_bits {
-    class VoidPtr {
-    private:
-      void *_ptr;
-    public:
-      VoidPtr() : _ptr(0) {}
-
-      template <typename T>
-      VoidPtr(T* ptr) : _ptr(reinterpret_cast<void*>(ptr)) {}
-
-      template <typename T>
-      VoidPtr& operator=(T* ptr) {
-        _ptr = reinterpret_cast<void*>(ptr);
-        return *this;
-      }
-
-      template <typename T>
-      operator T*() const { return reinterpret_cast<T*>(_ptr); }
-    };
-  }
 
   /// \brief Base interface for the GLPK LP and MIP solver
@@ -56,5 +44,6 @@
   protected:
 
-    _solver_bits::VoidPtr lp;
+    typedef glp_prob LPX;
+    glp_prob* lp;
 
     GlpkBase();
@@ -115,6 +104,4 @@
 
     virtual void _messageLevel(MessageLevel level);
-
-    virtual void _write(std::string file, std::string format) const;
 
   private:
@@ -127,36 +114,23 @@
       }
     };
-
+    
     static FreeEnvHelper freeEnvHelper;
 
   protected:
-
+    
     int _message_level;
-
+    
   public:
 
     ///Pointer to the underlying GLPK data structure.
-    _solver_bits::VoidPtr lpx() {return lp;}
+    LPX *lpx() {return lp;}
     ///Const pointer to the underlying GLPK data structure.
-    _solver_bits::VoidPtr lpx() const {return lp;}
+    const LPX *lpx() const {return lp;}
 
     ///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)); }
-
-#ifdef DOXYGEN
-    /// Write the problem or the solution to a file in the given format
-
-    /// This function writes the problem or the solution
-    /// to a file in the given format.
-    /// Trying to write in an unsupported format will trigger
-    /// \ref LpBase::UnsupportedFormatError.
-    /// \param file The file path
-    /// \param format The output file format.
-    /// Supportted formats are "MPS" and "LP".
-    void write(std::string file, std::string format = "MPS") const {}
-#endif
+    int lpxCol(Col c) const { return cols(id(c)); }
 
   };
Index: lemon/gomory_hu.h
===================================================================
--- lemon/gomory_hu.h	(revision 1270)
+++ lemon/gomory_hu.h	(revision 833)
@@ -1,7 +1,7 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
+/* -*- C++ -*-
  *
- * This file is a part of LEMON, a generic C++ optimization library.
+ * This file is a part of LEMON, a generic C++ optimization library
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -28,5 +28,5 @@
 
 /// \ingroup min_cut
-/// \file
+/// \file 
 /// \brief Gomory-Hu cut tree in graphs.
 
@@ -39,5 +39,5 @@
   /// The Gomory-Hu tree is a tree on the node set of a given graph, but it
   /// may contain edges which are not in the original graph. It has the
-  /// property that the minimum capacity edge of the path between two nodes
+  /// property that the minimum capacity edge of the path between two nodes 
   /// in this tree has the same weight as the minimum cut in the graph
   /// between these nodes. Moreover the components obtained by removing
@@ -45,7 +45,7 @@
   /// Therefore once this tree is computed, the minimum cut between any pair
   /// of nodes can easily be obtained.
-  ///
+  /// 
   /// The algorithm calculates \e n-1 distinct minimum cuts (currently with
-  /// the \ref Preflow algorithm), thus it has \f$O(n^3\sqrt{m})\f$ overall
+  /// the \ref Preflow algorithm), thus it has \f$O(n^3\sqrt{e})\f$ overall
   /// time complexity. It calculates a rooted Gomory-Hu tree.
   /// The structure of the tree and the edge weights can be
@@ -61,8 +61,8 @@
 #ifdef DOXYGEN
   template <typename GR,
-            typename CAP>
+	    typename CAP>
 #else
   template <typename GR,
-            typename CAP = typename GR::template EdgeMap<int> >
+	    typename CAP = typename GR::template EdgeMap<int> >
 #endif
   class GomoryHu {
@@ -75,5 +75,5 @@
     /// The value type of capacities
     typedef typename Capacity::Value Value;
-
+    
   private:
 
@@ -90,11 +90,11 @@
     void createStructures() {
       if (!_pred) {
-        _pred = new typename Graph::template NodeMap<Node>(_graph);
+	_pred = new typename Graph::template NodeMap<Node>(_graph);
       }
       if (!_weight) {
-        _weight = new typename Graph::template NodeMap<Value>(_graph);
+	_weight = new typename Graph::template NodeMap<Value>(_graph);
       }
       if (!_order) {
-        _order = new typename Graph::template NodeMap<int>(_graph);
+	_order = new typename Graph::template NodeMap<int>(_graph);
       }
     }
@@ -102,14 +102,14 @@
     void destroyStructures() {
       if (_pred) {
-        delete _pred;
+	delete _pred;
       }
       if (_weight) {
-        delete _weight;
+	delete _weight;
       }
       if (_order) {
-        delete _order;
-      }
-    }
-
+	delete _order;
+      }
+    }
+  
   public:
 
@@ -119,7 +119,7 @@
     /// \param graph The undirected graph the algorithm runs on.
     /// \param capacity The edge capacity map.
-    GomoryHu(const Graph& graph, const Capacity& capacity)
+    GomoryHu(const Graph& graph, const Capacity& capacity) 
       : _graph(graph), _capacity(capacity),
-        _pred(0), _weight(0), _order(0)
+	_pred(0), _weight(0), _order(0) 
     {
       checkConcept<concepts::ReadMap<Edge, Value>, Capacity>();
@@ -135,5 +135,5 @@
 
   private:
-
+  
     // Initialize the internal data structures
     void init() {
@@ -146,5 +146,5 @@
       }
       (*_pred)[_root] = INVALID;
-      (*_weight)[_root] = std::numeric_limits<Value>::max();
+      (*_weight)[_root] = std::numeric_limits<Value>::max(); 
     }
 
@@ -155,25 +155,25 @@
 
       for (NodeIt n(_graph); n != INVALID; ++n) {
-        if (n == _root) continue;
-
-        Node pn = (*_pred)[n];
-        fa.source(n);
-        fa.target(pn);
-
-        fa.runMinCut();
-
-        (*_weight)[n] = fa.flowValue();
-
-        for (NodeIt nn(_graph); nn != INVALID; ++nn) {
-          if (nn != n && fa.minCut(nn) && (*_pred)[nn] == pn) {
-            (*_pred)[nn] = n;
-          }
-        }
-        if ((*_pred)[pn] != INVALID && fa.minCut((*_pred)[pn])) {
-          (*_pred)[n] = (*_pred)[pn];
-          (*_pred)[pn] = n;
-          (*_weight)[n] = (*_weight)[pn];
-          (*_weight)[pn] = fa.flowValue();
-        }
+	if (n == _root) continue;
+
+	Node pn = (*_pred)[n];
+	fa.source(n);
+	fa.target(pn);
+
+	fa.runMinCut();
+
+	(*_weight)[n] = fa.flowValue();
+
+	for (NodeIt nn(_graph); nn != INVALID; ++nn) {
+	  if (nn != n && fa.minCut(nn) && (*_pred)[nn] == pn) {
+	    (*_pred)[nn] = n;
+	  }
+	}
+	if ((*_pred)[pn] != INVALID && fa.minCut((*_pred)[pn])) {
+	  (*_pred)[n] = (*_pred)[pn];
+	  (*_pred)[pn] = n;
+	  (*_weight)[n] = (*_weight)[pn];
+	  (*_weight)[pn] = fa.flowValue();
+	}
       }
 
@@ -182,14 +182,14 @@
 
       for (NodeIt n(_graph); n != INVALID; ++n) {
-        std::vector<Node> st;
-        Node nn = n;
-        while ((*_order)[nn] == -1) {
-          st.push_back(nn);
-          nn = (*_pred)[nn];
-        }
-        while (!st.empty()) {
-          (*_order)[st.back()] = index++;
-          st.pop_back();
-        }
+	std::vector<Node> st;
+	Node nn = n;
+	while ((*_order)[nn] == -1) {
+	  st.push_back(nn);
+	  nn = (*_pred)[nn];
+	}
+	while (!st.empty()) {
+	  (*_order)[st.back()] = index++;
+	  st.pop_back();
+	}
       }
     }
@@ -198,5 +198,5 @@
 
     ///\name Execution Control
-
+ 
     ///@{
 
@@ -208,5 +208,5 @@
       start();
     }
-
+    
     /// @}
 
@@ -233,5 +233,5 @@
     /// Gomory-Hu tree.
     ///
-    /// This function returns the weight of the predecessor edge of the
+    /// This function returns the weight of the predecessor edge of the 
     /// given node in the Gomory-Hu tree.
     /// If \c node is the root of the tree, the result is undefined.
@@ -255,5 +255,5 @@
     ///
     /// This function returns the minimum cut value between the nodes
-    /// \c s and \c t.
+    /// \c s and \c t. 
     /// It finds the nearest common ancestor of the given nodes in the
     /// Gomory-Hu tree and calculates the minimum weight edge on the
@@ -264,13 +264,13 @@
       Node sn = s, tn = t;
       Value value = std::numeric_limits<Value>::max();
-
+      
       while (sn != tn) {
-        if ((*_order)[sn] < (*_order)[tn]) {
-          if ((*_weight)[tn] <= value) value = (*_weight)[tn];
-          tn = (*_pred)[tn];
-        } else {
-          if ((*_weight)[sn] <= value) value = (*_weight)[sn];
-          sn = (*_pred)[sn];
-        }
+	if ((*_order)[sn] < (*_order)[tn]) {
+	  if ((*_weight)[tn] <= value) value = (*_weight)[tn];
+	  tn = (*_pred)[tn];
+	} else {
+	  if ((*_weight)[sn] <= value) value = (*_weight)[sn];
+	  sn = (*_pred)[sn];
+	}
       }
       return value;
@@ -303,21 +303,21 @@
       Node rn = INVALID;
       Value value = std::numeric_limits<Value>::max();
-
+      
       while (sn != tn) {
-        if ((*_order)[sn] < (*_order)[tn]) {
-          if ((*_weight)[tn] <= value) {
-            rn = tn;
+	if ((*_order)[sn] < (*_order)[tn]) {
+	  if ((*_weight)[tn] <= value) {
+	    rn = tn;
             s_root = false;
-            value = (*_weight)[tn];
-          }
-          tn = (*_pred)[tn];
-        } else {
-          if ((*_weight)[sn] <= value) {
-            rn = sn;
+	    value = (*_weight)[tn];
+	  }
+	  tn = (*_pred)[tn];
+	} else {
+	  if ((*_weight)[sn] <= value) {
+	    rn = sn;
             s_root = true;
-            value = (*_weight)[sn];
-          }
-          sn = (*_pred)[sn];
-        }
+	    value = (*_weight)[sn];
+	  }
+	  sn = (*_pred)[sn];
+	}
       }
 
@@ -330,16 +330,16 @@
       std::vector<Node> st;
       for (NodeIt n(_graph); n != INVALID; ++n) {
-        st.clear();
+	st.clear();
         Node nn = n;
-        while (!reached[nn]) {
-          st.push_back(nn);
-          nn = (*_pred)[nn];
-        }
-        while (!st.empty()) {
-          cutMap.set(st.back(), cutMap[nn]);
-          st.pop_back();
-        }
-      }
-
+	while (!reached[nn]) {
+	  st.push_back(nn);
+	  nn = (*_pred)[nn];
+	}
+	while (!st.empty()) {
+	  cutMap.set(st.back(), cutMap[nn]);
+	  st.pop_back();
+	}
+      }
+      
       return value;
     }
@@ -350,5 +350,5 @@
 
     /// Iterate on the nodes of a minimum cut
-
+    
     /// This iterator class lists the nodes of a minimum cut found by
     /// GomoryHu. Before using it, you must allocate a GomoryHu class
@@ -443,9 +443,9 @@
       }
     };
-
+    
     friend class MinCutEdgeIt;
-
+    
     /// Iterate on the edges of a minimum cut
-
+    
     /// This iterator class lists the edges of a minimum cut found by
     /// GomoryHu. Before using it, you must allocate a GomoryHu class
@@ -480,5 +480,5 @@
           }
       }
-
+      
     public:
       /// Constructor
@@ -549,5 +549,5 @@
       }
       /// Postfix incrementation
-
+      
       /// Postfix incrementation.
       ///
Index: lemon/graph_to_eps.h
===================================================================
--- lemon/graph_to_eps.h	(revision 1340)
+++ lemon/graph_to_eps.h	(revision 833)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -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);
@@ -684,7 +685,7 @@
 #else
       os << bits::getWinFormattedDate();
-      os << std::endl;
 #endif
     }
+    os << std::endl;
 
     if (_autoArcWidthScale) {
Index: mon/greedy_tsp.h
===================================================================
--- lemon/greedy_tsp.h	(revision 1270)
+++ 	(revision )
@@ -1,251 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2013
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * 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_GREEDY_TSP_H
-#define LEMON_GREEDY_TSP_H
-
-/// \ingroup tsp
-/// \file
-/// \brief Greedy algorithm for symmetric TSP
-
-#include <vector>
-#include <algorithm>
-#include <lemon/full_graph.h>
-#include <lemon/unionfind.h>
-
-namespace lemon {
-
-  /// \ingroup tsp
-  ///
-  /// \brief Greedy algorithm for symmetric TSP.
-  ///
-  /// GreedyTsp implements the greedy heuristic for solving
-  /// symmetric \ref tsp "TSP".
-  ///
-  /// This algorithm is quite similar to the \ref NearestNeighborTsp
-  /// "nearest neighbor" heuristic, but it maintains a set of disjoint paths.
-  /// At each step, the shortest possible edge is added to these paths
-  /// as long as it does not create a cycle of less than n edges and it does
-  /// not increase the degree of any node above two.
-  ///
-  /// This method runs in O(n<sup>2</sup>) time.
-  /// It quickly finds a relatively short tour for most TSP instances,
-  /// but it could also yield a really bad (or even the worst) solution
-  /// in special cases.
-  ///
-  /// \tparam CM Type of the cost map.
-  template <typename CM>
-  class GreedyTsp
-  {
-    public:
-
-      /// Type of the cost map
-      typedef CM CostMap;
-      /// Type of the edge costs
-      typedef typename CM::Value Cost;
-
-    private:
-
-      GRAPH_TYPEDEFS(FullGraph);
-
-      const FullGraph &_gr;
-      const CostMap &_cost;
-      Cost _sum;
-      std::vector<Node> _path;
-
-    private:
-
-      // Functor class to compare edges by their costs
-      class EdgeComp {
-      private:
-        const CostMap &_cost;
-
-      public:
-        EdgeComp(const CostMap &cost) : _cost(cost) {}
-
-        bool operator()(const Edge &a, const Edge &b) const {
-          return _cost[a] < _cost[b];
-        }
-      };
-
-    public:
-
-      /// \brief Constructor
-      ///
-      /// Constructor.
-      /// \param gr The \ref FullGraph "full graph" the algorithm runs on.
-      /// \param cost The cost map.
-      GreedyTsp(const FullGraph &gr, const CostMap &cost)
-        : _gr(gr), _cost(cost) {}
-
-      /// \name Execution Control
-      /// @{
-
-      /// \brief Runs the algorithm.
-      ///
-      /// This function runs the algorithm.
-      ///
-      /// \return The total cost of the found tour.
-      Cost run() {
-        _path.clear();
-
-        if (_gr.nodeNum() == 0) return _sum = 0;
-        else if (_gr.nodeNum() == 1) {
-          _path.push_back(_gr(0));
-          return _sum = 0;
-        }
-
-        std::vector<int> plist;
-        plist.resize(_gr.nodeNum()*2, -1);
-
-        std::vector<Edge> sorted_edges;
-        sorted_edges.reserve(_gr.edgeNum());
-        for (EdgeIt e(_gr); e != INVALID; ++e)
-          sorted_edges.push_back(e);
-        std::sort(sorted_edges.begin(), sorted_edges.end(), EdgeComp(_cost));
-
-        FullGraph::NodeMap<int> item_int_map(_gr);
-        UnionFind<FullGraph::NodeMap<int> > union_find(item_int_map);
-        for (NodeIt n(_gr); n != INVALID; ++n)
-          union_find.insert(n);
-
-        FullGraph::NodeMap<int> degree(_gr, 0);
-
-        int nodesNum = 0, i = 0;
-        while (nodesNum != _gr.nodeNum()-1) {
-          Edge e = sorted_edges[i++];
-          Node u = _gr.u(e),
-               v = _gr.v(e);
-
-          if (degree[u] <= 1 && degree[v] <= 1) {
-            if (union_find.join(u, v)) {
-              const int uid = _gr.id(u),
-                        vid = _gr.id(v);
-
-              plist[uid*2 + degree[u]] = vid;
-              plist[vid*2 + degree[v]] = uid;
-
-              ++degree[u];
-              ++degree[v];
-              ++nodesNum;
-            }
-          }
-        }
-
-        for (int i=0, n=-1; i<_gr.nodeNum()*2; ++i) {
-          if (plist[i] == -1) {
-            if (n==-1) {
-              n = i;
-            } else {
-              plist[n] = i/2;
-              plist[i] = n/2;
-              break;
-            }
-          }
-        }
-
-        for (int i=0, next=0, last=-1; i!=_gr.nodeNum(); ++i) {
-          _path.push_back(_gr.nodeFromId(next));
-          if (plist[2*next] != last) {
-            last = next;
-            next = plist[2*next];
-          } else {
-            last = next;
-            next = plist[2*next+1];
-          }
-        }
-
-        _sum = _cost[_gr.edge(_path.back(), _path.front())];
-        for (int i = 0; i < int(_path.size())-1; ++i) {
-          _sum += _cost[_gr.edge(_path[i], _path[i+1])];
-        }
-
-        return _sum;
-      }
-
-      /// @}
-
-      /// \name Query Functions
-      /// @{
-
-      /// \brief The total cost of the found tour.
-      ///
-      /// This function returns the total cost of the found tour.
-      ///
-      /// \pre run() must be called before using this function.
-      Cost tourCost() const {
-        return _sum;
-      }
-
-      /// \brief Returns a const reference to the node sequence of the
-      /// found tour.
-      ///
-      /// This function returns a const reference to a vector
-      /// that stores the node sequence of the found tour.
-      ///
-      /// \pre run() must be called before using this function.
-      const std::vector<Node>& tourNodes() const {
-        return _path;
-      }
-
-      /// \brief Gives back the node sequence of the found tour.
-      ///
-      /// This function copies the node sequence of the found tour into
-      /// an STL container through the given output iterator. The
-      /// <tt>value_type</tt> of the container must be <tt>FullGraph::Node</tt>.
-      /// For example,
-      /// \code
-      /// std::vector<FullGraph::Node> nodes(countNodes(graph));
-      /// tsp.tourNodes(nodes.begin());
-      /// \endcode
-      /// or
-      /// \code
-      /// std::list<FullGraph::Node> nodes;
-      /// tsp.tourNodes(std::back_inserter(nodes));
-      /// \endcode
-      ///
-      /// \pre run() must be called before using this function.
-      template <typename Iterator>
-      void tourNodes(Iterator out) const {
-        std::copy(_path.begin(), _path.end(), out);
-      }
-
-      /// \brief Gives back the found tour as a path.
-      ///
-      /// This function copies the found tour as a list of arcs/edges into
-      /// the given \ref lemon::concepts::Path "path structure".
-      ///
-      /// \pre run() must be called before using this function.
-      template <typename Path>
-      void tour(Path &path) const {
-        path.clear();
-        for (int i = 0; i < int(_path.size()) - 1; ++i) {
-          path.addBack(_gr.arc(_path[i], _path[i+1]));
-        }
-        if (int(_path.size()) >= 2) {
-          path.addBack(_gr.arc(_path.back(), _path.front()));
-        }
-      }
-
-      /// @}
-
-  };
-
-}; // namespace lemon
-
-#endif
Index: mon/grosso_locatelli_pullan_mc.h
===================================================================
--- lemon/grosso_locatelli_pullan_mc.h	(revision 1270)
+++ 	(revision )
@@ -1,840 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2013
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * 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_GROSSO_LOCATELLI_PULLAN_MC_H
-#define LEMON_GROSSO_LOCATELLI_PULLAN_MC_H
-
-/// \ingroup approx_algs
-///
-/// \file
-/// \brief The iterated local search algorithm of Grosso, Locatelli, and Pullan
-/// for the maximum clique problem
-
-#include <vector>
-#include <limits>
-#include <lemon/core.h>
-#include <lemon/random.h>
-
-namespace lemon {
-
-  /// \addtogroup approx_algs
-  /// @{
-
-  /// \brief Implementation of the iterated local search algorithm of Grosso,
-  /// Locatelli, and Pullan for the maximum clique problem
-  ///
-  /// \ref GrossoLocatelliPullanMc implements the iterated local search
-  /// algorithm of Grosso, Locatelli, and Pullan for solving the \e maximum
-  /// \e clique \e problem \cite grosso08maxclique.
-  /// It is to find the largest complete subgraph (\e clique) in an
-  /// undirected graph, i.e., the largest set of nodes where each
-  /// pair of nodes is connected.
-  ///
-  /// This class provides a simple but highly efficient and robust heuristic
-  /// method that quickly finds a quite large clique, but not necessarily the
-  /// largest one.
-  /// The algorithm performs a certain number of iterations to find several
-  /// cliques and selects the largest one among them. Various limits can be
-  /// specified to control the running time and the effectiveness of the
-  /// search process.
-  ///
-  /// \tparam GR The undirected graph type the algorithm runs on.
-  ///
-  /// \note %GrossoLocatelliPullanMc provides three different node selection
-  /// rules, from which the most powerful one is used by default.
-  /// For more information, see \ref SelectionRule.
-  template <typename GR>
-  class GrossoLocatelliPullanMc
-  {
-  public:
-
-    /// \brief Constants for specifying the node selection rule.
-    ///
-    /// Enum type containing constants for specifying the node selection rule
-    /// for the \ref run() function.
-    ///
-    /// During the algorithm, nodes are selected for addition to the current
-    /// clique according to the applied rule.
-    /// In general, the PENALTY_BASED rule turned out to be the most powerful
-    /// and the most robust, thus it is the default option.
-    /// However, another selection rule can be specified using the \ref run()
-    /// function with the proper parameter.
-    enum SelectionRule {
-
-      /// A node is selected randomly without any evaluation at each step.
-      RANDOM,
-
-      /// A node of maximum degree is selected randomly at each step.
-      DEGREE_BASED,
-
-      /// A node of minimum penalty is selected randomly at each step.
-      /// The node penalties are updated adaptively after each stage of the
-      /// search process.
-      PENALTY_BASED
-    };
-
-    /// \brief Constants for the causes of search termination.
-    ///
-    /// Enum type containing constants for the different causes of search
-    /// termination. The \ref run() function returns one of these values.
-    enum TerminationCause {
-
-      /// The iteration count limit is reached.
-      ITERATION_LIMIT,
-
-      /// The step count limit is reached.
-      STEP_LIMIT,
-
-      /// The clique size limit is reached.
-      SIZE_LIMIT
-    };
-
-  private:
-
-    TEMPLATE_GRAPH_TYPEDEFS(GR);
-
-    typedef std::vector<int> IntVector;
-    typedef std::vector<char> BoolVector;
-    typedef std::vector<BoolVector> BoolMatrix;
-    // Note: vector<char> is used instead of vector<bool> for efficiency reasons
-
-    // The underlying graph
-    const GR &_graph;
-    IntNodeMap _id;
-
-    // Internal matrix representation of the graph
-    BoolMatrix _gr;
-    int _n;
-
-    // Search options
-    bool _delta_based_restart;
-    int _restart_delta_limit;
-
-    // Search limits
-    int _iteration_limit;
-    int _step_limit;
-    int _size_limit;
-
-    // The current clique
-    BoolVector _clique;
-    int _size;
-
-    // The best clique found so far
-    BoolVector _best_clique;
-    int _best_size;
-
-    // The "distances" of the nodes from the current clique.
-    // _delta[u] is the number of nodes in the clique that are
-    // not connected with u.
-    IntVector _delta;
-
-    // The current tabu set
-    BoolVector _tabu;
-
-    // Random number generator
-    Random _rnd;
-
-  private:
-
-    // Implementation of the RANDOM node selection rule.
-    class RandomSelectionRule
-    {
-    private:
-
-      // References to the algorithm instance
-      const BoolVector &_clique;
-      const IntVector  &_delta;
-      const BoolVector &_tabu;
-      Random &_rnd;
-
-      // Pivot rule data
-      int _n;
-
-    public:
-
-      // Constructor
-      RandomSelectionRule(GrossoLocatelliPullanMc &mc) :
-        _clique(mc._clique), _delta(mc._delta), _tabu(mc._tabu),
-        _rnd(mc._rnd), _n(mc._n)
-      {}
-
-      // Return a node index for a feasible add move or -1 if no one exists
-      int nextFeasibleAddNode() const {
-        int start_node = _rnd[_n];
-        for (int i = start_node; i != _n; i++) {
-          if (_delta[i] == 0 && !_tabu[i]) return i;
-        }
-        for (int i = 0; i != start_node; i++) {
-          if (_delta[i] == 0 && !_tabu[i]) return i;
-        }
-        return -1;
-      }
-
-      // Return a node index for a feasible swap move or -1 if no one exists
-      int nextFeasibleSwapNode() const {
-        int start_node = _rnd[_n];
-        for (int i = start_node; i != _n; i++) {
-          if (!_clique[i] && _delta[i] == 1 && !_tabu[i]) return i;
-        }
-        for (int i = 0; i != start_node; i++) {
-          if (!_clique[i] && _delta[i] == 1 && !_tabu[i]) return i;
-        }
-        return -1;
-      }
-
-      // Return a node index for an add move or -1 if no one exists
-      int nextAddNode() const {
-        int start_node = _rnd[_n];
-        for (int i = start_node; i != _n; i++) {
-          if (_delta[i] == 0) return i;
-        }
-        for (int i = 0; i != start_node; i++) {
-          if (_delta[i] == 0) return i;
-        }
-        return -1;
-      }
-
-      // Update internal data structures between stages (if necessary)
-      void update() {}
-
-    }; //class RandomSelectionRule
-
-
-    // Implementation of the DEGREE_BASED node selection rule.
-    class DegreeBasedSelectionRule
-    {
-    private:
-
-      // References to the algorithm instance
-      const BoolVector &_clique;
-      const IntVector  &_delta;
-      const BoolVector &_tabu;
-      Random &_rnd;
-
-      // Pivot rule data
-      int _n;
-      IntVector _deg;
-
-    public:
-
-      // Constructor
-      DegreeBasedSelectionRule(GrossoLocatelliPullanMc &mc) :
-        _clique(mc._clique), _delta(mc._delta), _tabu(mc._tabu),
-        _rnd(mc._rnd), _n(mc._n), _deg(_n)
-      {
-        for (int i = 0; i != _n; i++) {
-          int d = 0;
-          BoolVector &row = mc._gr[i];
-          for (int j = 0; j != _n; j++) {
-            if (row[j]) d++;
-          }
-          _deg[i] = d;
-        }
-      }
-
-      // Return a node index for a feasible add move or -1 if no one exists
-      int nextFeasibleAddNode() const {
-        int start_node = _rnd[_n];
-        int node = -1, max_deg = -1;
-        for (int i = start_node; i != _n; i++) {
-          if (_delta[i] == 0 && !_tabu[i] && _deg[i] > max_deg) {
-            node = i;
-            max_deg = _deg[i];
-          }
-        }
-        for (int i = 0; i != start_node; i++) {
-          if (_delta[i] == 0 && !_tabu[i] && _deg[i] > max_deg) {
-            node = i;
-            max_deg = _deg[i];
-          }
-        }
-        return node;
-      }
-
-      // Return a node index for a feasible swap move or -1 if no one exists
-      int nextFeasibleSwapNode() const {
-        int start_node = _rnd[_n];
-        int node = -1, max_deg = -1;
-        for (int i = start_node; i != _n; i++) {
-          if (!_clique[i] && _delta[i] == 1 && !_tabu[i] &&
-              _deg[i] > max_deg) {
-            node = i;
-            max_deg = _deg[i];
-          }
-        }
-        for (int i = 0; i != start_node; i++) {
-          if (!_clique[i] && _delta[i] == 1 && !_tabu[i] &&
-              _deg[i] > max_deg) {
-            node = i;
-            max_deg = _deg[i];
-          }
-        }
-        return node;
-      }
-
-      // Return a node index for an add move or -1 if no one exists
-      int nextAddNode() const {
-        int start_node = _rnd[_n];
-        int node = -1, max_deg = -1;
-        for (int i = start_node; i != _n; i++) {
-          if (_delta[i] == 0 && _deg[i] > max_deg) {
-            node = i;
-            max_deg = _deg[i];
-          }
-        }
-        for (int i = 0; i != start_node; i++) {
-          if (_delta[i] == 0 && _deg[i] > max_deg) {
-            node = i;
-            max_deg = _deg[i];
-          }
-        }
-        return node;
-      }
-
-      // Update internal data structures between stages (if necessary)
-      void update() {}
-
-    }; //class DegreeBasedSelectionRule
-
-
-    // Implementation of the PENALTY_BASED node selection rule.
-    class PenaltyBasedSelectionRule
-    {
-    private:
-
-      // References to the algorithm instance
-      const BoolVector &_clique;
-      const IntVector  &_delta;
-      const BoolVector &_tabu;
-      Random &_rnd;
-
-      // Pivot rule data
-      int _n;
-      IntVector _penalty;
-
-    public:
-
-      // Constructor
-      PenaltyBasedSelectionRule(GrossoLocatelliPullanMc &mc) :
-        _clique(mc._clique), _delta(mc._delta), _tabu(mc._tabu),
-        _rnd(mc._rnd), _n(mc._n), _penalty(_n, 0)
-      {}
-
-      // Return a node index for a feasible add move or -1 if no one exists
-      int nextFeasibleAddNode() const {
-        int start_node = _rnd[_n];
-        int node = -1, min_p = std::numeric_limits<int>::max();
-        for (int i = start_node; i != _n; i++) {
-          if (_delta[i] == 0 && !_tabu[i] && _penalty[i] < min_p) {
-            node = i;
-            min_p = _penalty[i];
-          }
-        }
-        for (int i = 0; i != start_node; i++) {
-          if (_delta[i] == 0 && !_tabu[i] && _penalty[i] < min_p) {
-            node = i;
-            min_p = _penalty[i];
-          }
-        }
-        return node;
-      }
-
-      // Return a node index for a feasible swap move or -1 if no one exists
-      int nextFeasibleSwapNode() const {
-        int start_node = _rnd[_n];
-        int node = -1, min_p = std::numeric_limits<int>::max();
-        for (int i = start_node; i != _n; i++) {
-          if (!_clique[i] && _delta[i] == 1 && !_tabu[i] &&
-              _penalty[i] < min_p) {
-            node = i;
-            min_p = _penalty[i];
-          }
-        }
-        for (int i = 0; i != start_node; i++) {
-          if (!_clique[i] && _delta[i] == 1 && !_tabu[i] &&
-              _penalty[i] < min_p) {
-            node = i;
-            min_p = _penalty[i];
-          }
-        }
-        return node;
-      }
-
-      // Return a node index for an add move or -1 if no one exists
-      int nextAddNode() const {
-        int start_node = _rnd[_n];
-        int node = -1, min_p = std::numeric_limits<int>::max();
-        for (int i = start_node; i != _n; i++) {
-          if (_delta[i] == 0 && _penalty[i] < min_p) {
-            node = i;
-            min_p = _penalty[i];
-          }
-        }
-        for (int i = 0; i != start_node; i++) {
-          if (_delta[i] == 0 && _penalty[i] < min_p) {
-            node = i;
-            min_p = _penalty[i];
-          }
-        }
-        return node;
-      }
-
-      // Update internal data structures between stages (if necessary)
-      void update() {}
-
-    }; //class PenaltyBasedSelectionRule
-
-  public:
-
-    /// \brief Constructor.
-    ///
-    /// Constructor.
-    /// The global \ref rnd "random number generator instance" is used
-    /// during the algorithm.
-    ///
-    /// \param graph The undirected graph the algorithm runs on.
-    GrossoLocatelliPullanMc(const GR& graph) :
-      _graph(graph), _id(_graph), _rnd(rnd)
-    {
-      initOptions();
-    }
-
-    /// \brief Constructor with random seed.
-    ///
-    /// Constructor with random seed.
-    ///
-    /// \param graph The undirected graph the algorithm runs on.
-    /// \param seed Seed value for the internal random number generator
-    /// that is used during the algorithm.
-    GrossoLocatelliPullanMc(const GR& graph, int seed) :
-      _graph(graph), _id(_graph), _rnd(seed)
-    {
-      initOptions();
-    }
-
-    /// \brief Constructor with random number generator.
-    ///
-    /// Constructor with random number generator.
-    ///
-    /// \param graph The undirected graph the algorithm runs on.
-    /// \param random A random number generator that is used during the
-    /// algorithm.
-    GrossoLocatelliPullanMc(const GR& graph, const Random& random) :
-      _graph(graph), _id(_graph), _rnd(random)
-    {
-      initOptions();
-    }
-
-    /// \name Execution Control
-    /// The \ref run() function can be used to execute the algorithm.\n
-    /// The functions \ref iterationLimit(int), \ref stepLimit(int), and
-    /// \ref sizeLimit(int) can be used to specify various limits for the
-    /// search process.
-
-    /// @{
-
-    /// \brief Sets the maximum number of iterations.
-    ///
-    /// This function sets the maximum number of iterations.
-    /// Each iteration of the algorithm finds a maximal clique (but not
-    /// necessarily the largest one) by performing several search steps
-    /// (node selections).
-    ///
-    /// This limit controls the running time and the success of the
-    /// algorithm. For larger values, the algorithm runs slower, but it more
-    /// likely finds larger cliques. For smaller values, the algorithm is
-    /// faster but probably gives worse results.
-    ///
-    /// The default value is \c 1000.
-    /// \c -1 means that number of iterations is not limited.
-    ///
-    /// \warning You should specify a reasonable limit for the number of
-    /// iterations and/or the number of search steps.
-    ///
-    /// \return <tt>(*this)</tt>
-    ///
-    /// \sa stepLimit(int)
-    /// \sa sizeLimit(int)
-    GrossoLocatelliPullanMc& iterationLimit(int limit) {
-      _iteration_limit = limit;
-      return *this;
-    }
-
-    /// \brief Sets the maximum number of search steps.
-    ///
-    /// This function sets the maximum number of elementary search steps.
-    /// Each iteration of the algorithm finds a maximal clique (but not
-    /// necessarily the largest one) by performing several search steps
-    /// (node selections).
-    ///
-    /// This limit controls the running time and the success of the
-    /// algorithm. For larger values, the algorithm runs slower, but it more
-    /// likely finds larger cliques. For smaller values, the algorithm is
-    /// faster but probably gives worse results.
-    ///
-    /// The default value is \c -1, which means that number of steps
-    /// is not limited explicitly. However, the number of iterations is
-    /// limited and each iteration performs a finite number of search steps.
-    ///
-    /// \warning You should specify a reasonable limit for the number of
-    /// iterations and/or the number of search steps.
-    ///
-    /// \return <tt>(*this)</tt>
-    ///
-    /// \sa iterationLimit(int)
-    /// \sa sizeLimit(int)
-    GrossoLocatelliPullanMc& stepLimit(int limit) {
-      _step_limit = limit;
-      return *this;
-    }
-
-    /// \brief Sets the desired clique size.
-    ///
-    /// This function sets the desired clique size that serves as a search
-    /// limit. If a clique of this size (or a larger one) is found, then the
-    /// algorithm terminates.
-    ///
-    /// This function is especially useful if you know an exact upper bound
-    /// for the size of the cliques in the graph or if any clique above
-    /// a certain size limit is sufficient for your application.
-    ///
-    /// The default value is \c -1, which means that the size limit is set to
-    /// the number of nodes in the graph.
-    ///
-    /// \return <tt>(*this)</tt>
-    ///
-    /// \sa iterationLimit(int)
-    /// \sa stepLimit(int)
-    GrossoLocatelliPullanMc& sizeLimit(int limit) {
-      _size_limit = limit;
-      return *this;
-    }
-
-    /// \brief The maximum number of iterations.
-    ///
-    /// This function gives back the maximum number of iterations.
-    /// \c -1 means that no limit is specified.
-    ///
-    /// \sa iterationLimit(int)
-    int iterationLimit() const {
-      return _iteration_limit;
-    }
-
-    /// \brief The maximum number of search steps.
-    ///
-    /// This function gives back the maximum number of search steps.
-    /// \c -1 means that no limit is specified.
-    ///
-    /// \sa stepLimit(int)
-    int stepLimit() const {
-      return _step_limit;
-    }
-
-    /// \brief The desired clique size.
-    ///
-    /// This function gives back the desired clique size that serves as a
-    /// search limit. \c -1 means that this limit is set to the number of
-    /// nodes in the graph.
-    ///
-    /// \sa sizeLimit(int)
-    int sizeLimit() const {
-      return _size_limit;
-    }
-
-    /// \brief Runs the algorithm.
-    ///
-    /// This function runs the algorithm. If one of the specified limits
-    /// is reached, the search process terminates.
-    ///
-    /// \param rule The node selection rule. For more information, see
-    /// \ref SelectionRule.
-    ///
-    /// \return The termination cause of the search. For more information,
-    /// see \ref TerminationCause.
-    TerminationCause run(SelectionRule rule = PENALTY_BASED)
-    {
-      init();
-      switch (rule) {
-        case RANDOM:
-          return start<RandomSelectionRule>();
-        case DEGREE_BASED:
-          return start<DegreeBasedSelectionRule>();
-        default:
-          return start<PenaltyBasedSelectionRule>();
-      }
-    }
-
-    /// @}
-
-    /// \name Query Functions
-    /// The results of the algorithm can be obtained using these functions.\n
-    /// The run() function must be called before using them.
-
-    /// @{
-
-    /// \brief The size of the found clique
-    ///
-    /// This function returns the size of the found clique.
-    ///
-    /// \pre run() must be called before using this function.
-    int cliqueSize() const {
-      return _best_size;
-    }
-
-    /// \brief Gives back the found clique in a \c bool node map
-    ///
-    /// This function gives back the characteristic vector of the found
-    /// clique in the given node map.
-    /// It must be a \ref concepts::WriteMap "writable" node map with
-    /// \c bool (or convertible) value type.
-    ///
-    /// \pre run() must be called before using this function.
-    template <typename CliqueMap>
-    void cliqueMap(CliqueMap &map) const {
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        map[n] = static_cast<bool>(_best_clique[_id[n]]);
-      }
-    }
-
-    /// \brief Iterator to list the nodes of the found clique
-    ///
-    /// This iterator class lists the nodes of the found clique.
-    /// Before using it, you must allocate a GrossoLocatelliPullanMc instance
-    /// and call its \ref GrossoLocatelliPullanMc::run() "run()" method.
-    ///
-    /// The following example prints out the IDs of the nodes in the found
-    /// clique.
-    /// \code
-    ///   GrossoLocatelliPullanMc<Graph> mc(g);
-    ///   mc.run();
-    ///   for (GrossoLocatelliPullanMc<Graph>::CliqueNodeIt n(mc);
-    ///        n != INVALID; ++n)
-    ///   {
-    ///     std::cout << g.id(n) << std::endl;
-    ///   }
-    /// \endcode
-    class CliqueNodeIt
-    {
-    private:
-      NodeIt _it;
-      BoolNodeMap _map;
-
-    public:
-
-      /// Constructor
-
-      /// Constructor.
-      /// \param mc The algorithm instance.
-      CliqueNodeIt(const GrossoLocatelliPullanMc &mc)
-       : _map(mc._graph)
-      {
-        mc.cliqueMap(_map);
-        for (_it = NodeIt(mc._graph); _it != INVALID && !_map[_it]; ++_it) ;
-      }
-
-      /// Conversion to \c Node
-      operator Node() const { return _it; }
-
-      bool operator==(Invalid) const { return _it == INVALID; }
-      bool operator!=(Invalid) const { return _it != INVALID; }
-
-      /// Next node
-      CliqueNodeIt &operator++() {
-        for (++_it; _it != INVALID && !_map[_it]; ++_it) ;
-        return *this;
-      }
-
-      /// Postfix incrementation
-
-      /// Postfix incrementation.
-      ///
-      /// \warning This incrementation returns a \c Node, not a
-      /// \c CliqueNodeIt as one may expect.
-      typename GR::Node operator++(int) {
-        Node n=*this;
-        ++(*this);
-        return n;
-      }
-
-    };
-
-    /// @}
-
-  private:
-
-    // Initialize search options and limits
-    void initOptions() {
-      // Search options
-      _delta_based_restart = true;
-      _restart_delta_limit = 4;
-
-      // Search limits
-      _iteration_limit = 1000;
-      _step_limit = -1;             // this is disabled by default
-      _size_limit = -1;             // this is disabled by default
-    }
-
-    // Adds a node to the current clique
-    void addCliqueNode(int u) {
-      if (_clique[u]) return;
-      _clique[u] = true;
-      _size++;
-      BoolVector &row = _gr[u];
-      for (int i = 0; i != _n; i++) {
-        if (!row[i]) _delta[i]++;
-      }
-    }
-
-    // Removes a node from the current clique
-    void delCliqueNode(int u) {
-      if (!_clique[u]) return;
-      _clique[u] = false;
-      _size--;
-      BoolVector &row = _gr[u];
-      for (int i = 0; i != _n; i++) {
-        if (!row[i]) _delta[i]--;
-      }
-    }
-
-    // Initialize data structures
-    void init() {
-      _n = countNodes(_graph);
-      int ui = 0;
-      for (NodeIt u(_graph); u != INVALID; ++u) {
-        _id[u] = ui++;
-      }
-      _gr.clear();
-      _gr.resize(_n, BoolVector(_n, false));
-      ui = 0;
-      for (NodeIt u(_graph); u != INVALID; ++u) {
-        for (IncEdgeIt e(_graph, u); e != INVALID; ++e) {
-          int vi = _id[_graph.runningNode(e)];
-          _gr[ui][vi] = true;
-          _gr[vi][ui] = true;
-        }
-        ++ui;
-      }
-
-      _clique.clear();
-      _clique.resize(_n, false);
-      _size = 0;
-      _best_clique.clear();
-      _best_clique.resize(_n, false);
-      _best_size = 0;
-      _delta.clear();
-      _delta.resize(_n, 0);
-      _tabu.clear();
-      _tabu.resize(_n, false);
-    }
-
-    // Executes the algorithm
-    template <typename SelectionRuleImpl>
-    TerminationCause start() {
-      if (_n == 0) return SIZE_LIMIT;
-      if (_n == 1) {
-        _best_clique[0] = true;
-        _best_size = 1;
-        return SIZE_LIMIT;
-      }
-
-      // Iterated local search algorithm
-      const int max_size = _size_limit >= 0 ? _size_limit : _n;
-      const int max_restart = _iteration_limit >= 0 ?
-        _iteration_limit : std::numeric_limits<int>::max();
-      const int max_select = _step_limit >= 0 ?
-        _step_limit : std::numeric_limits<int>::max();
-
-      SelectionRuleImpl sel_method(*this);
-      int select = 0, restart = 0;
-      IntVector restart_nodes;
-      while (select < max_select && restart < max_restart) {
-
-        // Perturbation/restart
-        restart++;
-        if (_delta_based_restart) {
-          restart_nodes.clear();
-          for (int i = 0; i != _n; i++) {
-            if (_delta[i] >= _restart_delta_limit)
-              restart_nodes.push_back(i);
-          }
-        }
-        int rs_node = -1;
-        if (restart_nodes.size() > 0) {
-          rs_node = restart_nodes[_rnd[restart_nodes.size()]];
-        } else {
-          rs_node = _rnd[_n];
-        }
-        BoolVector &row = _gr[rs_node];
-        for (int i = 0; i != _n; i++) {
-          if (_clique[i] && !row[i]) delCliqueNode(i);
-        }
-        addCliqueNode(rs_node);
-
-        // Local search
-        _tabu.clear();
-        _tabu.resize(_n, false);
-        bool tabu_empty = true;
-        int max_swap = _size;
-        while (select < max_select) {
-          select++;
-          int u;
-          if ((u = sel_method.nextFeasibleAddNode()) != -1) {
-            // Feasible add move
-            addCliqueNode(u);
-            if (tabu_empty) max_swap = _size;
-          }
-          else if ((u = sel_method.nextFeasibleSwapNode()) != -1) {
-            // Feasible swap move
-            int v = -1;
-            BoolVector &row = _gr[u];
-            for (int i = 0; i != _n; i++) {
-              if (_clique[i] && !row[i]) {
-                v = i;
-                break;
-              }
-            }
-            addCliqueNode(u);
-            delCliqueNode(v);
-            _tabu[v] = true;
-            tabu_empty = false;
-            if (--max_swap <= 0) break;
-          }
-          else if ((u = sel_method.nextAddNode()) != -1) {
-            // Non-feasible add move
-            addCliqueNode(u);
-          }
-          else break;
-        }
-        if (_size > _best_size) {
-          _best_clique = _clique;
-          _best_size = _size;
-          if (_best_size >= max_size) return SIZE_LIMIT;
-        }
-        sel_method.update();
-      }
-
-      return (restart >= max_restart ? ITERATION_LIMIT : STEP_LIMIT);
-    }
-
-  }; //class GrossoLocatelliPullanMc
-
-  ///@}
-
-} //namespace lemon
-
-#endif //LEMON_GROSSO_LOCATELLI_PULLAN_MC_H
Index: lemon/hao_orlin.h
===================================================================
--- lemon/hao_orlin.h	(revision 1270)
+++ lemon/hao_orlin.h	(revision 644)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -32,5 +32,5 @@
 /// \brief Implementation of the Hao-Orlin algorithm.
 ///
-/// Implementation of the Hao-Orlin algorithm for finding a minimum cut
+/// Implementation of the Hao-Orlin algorithm for finding a minimum cut 
 /// in a digraph.
 
@@ -42,5 +42,5 @@
   ///
   /// This class implements the Hao-Orlin algorithm for finding a minimum
-  /// value cut in a directed graph \f$D=(V,A)\f$.
+  /// value cut in a directed graph \f$D=(V,A)\f$. 
   /// It takes a fixed node \f$ source \in V \f$ and
   /// consists of two phases: in the first phase it determines a
@@ -54,10 +54,10 @@
   /// preflow push-relabel algorithm. Our implementation calculates
   /// the minimum cut in \f$ O(n^2\sqrt{m}) \f$ time (we use the
-  /// highest-label rule), or in \f$O(nm)\f$ for unit capacities. A notable
-  /// use of this algorithm is testing network reliability.
+  /// highest-label rule), or in \f$O(nm)\f$ for unit capacities. The
+  /// purpose of such algorithm is e.g. testing network reliability.
   ///
   /// For an undirected graph you can run just the first phase of the
   /// algorithm or you can use the algorithm of Nagamochi and Ibaraki,
-  /// which solves the undirected problem in \f$ O(nm + n^2 \log n) \f$
+  /// which solves the undirected problem in \f$ O(nm + n^2 \log n) \f$ 
   /// time. It is implemented in the NagamochiIbaraki algorithm class.
   ///
@@ -77,5 +77,5 @@
   class HaoOrlin {
   public:
-
+   
     /// The digraph type of the algorithm
     typedef GR Digraph;
@@ -164,21 +164,4 @@
         delete _flow;
       }
-    }
-
-    /// \brief Set the tolerance used by the algorithm.
-    ///
-    /// This function sets the tolerance object used by the algorithm.
-    /// \return <tt>(*this)</tt>
-    HaoOrlin& tolerance(const Tolerance& tolerance) {
-      _tolerance = tolerance;
-      return *this;
-    }
-
-    /// \brief Returns a const reference to the tolerance.
-    ///
-    /// This function returns a const reference to the tolerance object
-    /// used by the algorithm.
-    const Tolerance& tolerance() const {
-      return _tolerance;
     }
 
@@ -865,5 +848,5 @@
     ///
     /// This function initializes the internal data structures. It creates
-    /// the maps and some bucket structures for the algorithm.
+    /// the maps and some bucket structures for the algorithm. 
     /// The given node is used as the source node for the push-relabel
     /// algorithm.
@@ -913,6 +896,4 @@
     /// source-side (i.e. a set \f$ X\subsetneq V \f$ with
     /// \f$ source \in X \f$ and minimal outgoing capacity).
-    /// It updates the stored cut if (and only if) the newly found one
-    /// is better.
     ///
     /// \pre \ref init() must be called before using this function.
@@ -927,6 +908,4 @@
     /// sink-side (i.e. a set \f$ X\subsetneq V \f$ with
     /// \f$ source \notin X \f$ and minimal outgoing capacity).
-    /// It updates the stored cut if (and only if) the newly found one
-    /// is better.
     ///
     /// \pre \ref init() must be called before using this function.
@@ -938,6 +917,6 @@
     /// \brief Run the algorithm.
     ///
-    /// This function runs the algorithm. It chooses source node,
-    /// then calls \ref init(), \ref calculateOut()
+    /// This function runs the algorithm. It finds nodes \c source and
+    /// \c target arbitrarily and then calls \ref init(), \ref calculateOut()
     /// and \ref calculateIn().
     void run() {
@@ -949,7 +928,7 @@
     /// \brief Run the algorithm.
     ///
-    /// This function runs the algorithm. It calls \ref init(),
-    /// \ref calculateOut() and \ref calculateIn() with the given
-    /// source node.
+    /// This function runs the algorithm. It uses the given \c source node, 
+    /// finds a proper \c target node and then calls the \ref init(),
+    /// \ref calculateOut() and \ref calculateIn().
     void run(const Node& s) {
       init(s);
@@ -963,5 +942,5 @@
     /// The result of the %HaoOrlin algorithm
     /// can be obtained using these functions.\n
-    /// \ref run(), \ref calculateOut() or \ref calculateIn()
+    /// \ref run(), \ref calculateOut() or \ref calculateIn() 
     /// should be called before using them.
 
@@ -970,9 +949,7 @@
     /// \brief Return the value of the minimum cut.
     ///
-    /// This function returns the value of the best cut found by the
-    /// previously called \ref run(), \ref calculateOut() or \ref
-    /// calculateIn().
-    ///
-    /// \pre \ref run(), \ref calculateOut() or \ref calculateIn()
+    /// This function returns the value of the minimum cut.
+    ///
+    /// \pre \ref run(), \ref calculateOut() or \ref calculateIn() 
     /// must be called before using this function.
     Value minCutValue() const {
@@ -983,11 +960,7 @@
     /// \brief Return a minimum cut.
     ///
-    /// This function gives the best cut found by the
-    /// previously called \ref run(), \ref calculateOut() or \ref
-    /// calculateIn().
-    ///
-    /// It sets \c cutMap to the characteristic vector of the found
-    /// minimum value cut - a non-empty set \f$ X\subsetneq V \f$
-    /// of minimum outgoing capacity (i.e. \c cutMap will be \c true exactly
+    /// This function sets \c cutMap to the characteristic vector of a
+    /// minimum value cut: it will give a non-empty set \f$ X\subsetneq V \f$
+    /// with minimal outgoing capacity (i.e. \c cutMap will be \c true exactly
     /// for the nodes of \f$ X \f$).
     ///
@@ -997,5 +970,5 @@
     /// \return The value of the minimum cut.
     ///
-    /// \pre \ref run(), \ref calculateOut() or \ref calculateIn()
+    /// \pre \ref run(), \ref calculateOut() or \ref calculateIn() 
     /// must be called before using this function.
     template <typename CutMap>
Index: lemon/hartmann_orlin.h
===================================================================
--- lemon/hartmann_orlin.h	(revision 859)
+++ lemon/hartmann_orlin.h	(revision 859)
@@ -0,0 +1,642 @@
+/* -*- C++ -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library
+ *
+ * Copyright (C) 2003-2008
+ * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
+ * (Egervary Research Group on Combinatorial Optimization, EGRES).
+ *
+ * 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_HARTMANN_ORLIN_H
+#define LEMON_HARTMANN_ORLIN_H
+
+/// \ingroup min_mean_cycle
+///
+/// \file
+/// \brief Hartmann-Orlin's algorithm for finding a minimum mean cycle.
+
+#include <vector>
+#include <limits>
+#include <lemon/core.h>
+#include <lemon/path.h>
+#include <lemon/tolerance.h>
+#include <lemon/connectivity.h>
+
+namespace lemon {
+
+  /// \brief Default traits class of HartmannOrlin algorithm.
+  ///
+  /// Default traits class of HartmannOrlin algorithm.
+  /// \tparam GR The type of the digraph.
+  /// \tparam LEN The type of the length map.
+  /// It must conform to the \ref concepts::Rea_data "Rea_data" concept.
+#ifdef DOXYGEN
+  template <typename GR, typename LEN>
+#else
+  template <typename GR, typename LEN,
+    bool integer = std::numeric_limits<typename LEN::Value>::is_integer>
+#endif
+  struct HartmannOrlinDefaultTraits
+  {
+    /// The type of the digraph
+    typedef GR Digraph;
+    /// The type of the length map
+    typedef LEN LengthMap;
+    /// The type of the arc lengths
+    typedef typename LengthMap::Value Value;
+
+    /// \brief The large value type used for internal computations
+    ///
+    /// The large value type used for internal computations.
+    /// It is \c long \c long if the \c Value type is integer,
+    /// otherwise it is \c double.
+    /// \c Value must be convertible to \c LargeValue.
+    typedef double LargeValue;
+
+    /// The tolerance type used for internal computations
+    typedef lemon::Tolerance<LargeValue> Tolerance;
+
+    /// \brief The path type of the found cycles
+    ///
+    /// The path type of the found cycles.
+    /// It must conform to the \ref lemon::concepts::Path "Path" concept
+    /// and it must have an \c addFront() function.
+    typedef lemon::Path<Digraph> Path;
+  };
+
+  // Default traits class for integer value types
+  template <typename GR, typename LEN>
+  struct HartmannOrlinDefaultTraits<GR, LEN, true>
+  {
+    typedef GR Digraph;
+    typedef LEN LengthMap;
+    typedef typename LengthMap::Value Value;
+#ifdef LEMON_HAVE_LONG_LONG
+    typedef long long LargeValue;
+#else
+    typedef long LargeValue;
+#endif
+    typedef lemon::Tolerance<LargeValue> Tolerance;
+    typedef lemon::Path<Digraph> Path;
+  };
+
+
+  /// \addtogroup min_mean_cycle
+  /// @{
+
+  /// \brief Implementation of the Hartmann-Orlin algorithm for finding
+  /// a minimum mean cycle.
+  ///
+  /// This class implements the Hartmann-Orlin algorithm for finding
+  /// a directed cycle of minimum mean length (cost) in a digraph
+  /// \ref amo93networkflows, \ref dasdan98minmeancycle.
+  /// It is an improved version of \ref Karp "Karp"'s original algorithm,
+  /// it applies an efficient early termination scheme.
+  /// It runs in time O(ne) and uses space O(n<sup>2</sup>+e).
+  ///
+  /// \tparam GR The type of the digraph the algorithm runs on.
+  /// \tparam LEN The type of the length map. The default
+  /// map type is \ref concepts::Digraph::ArcMap "GR::ArcMap<int>".
+#ifdef DOXYGEN
+  template <typename GR, typename LEN, typename TR>
+#else
+  template < typename GR,
+             typename LEN = typename GR::template ArcMap<int>,
+             typename TR = HartmannOrlinDefaultTraits<GR, LEN> >
+#endif
+  class HartmannOrlin
+  {
+  public:
+
+    /// The type of the digraph
+    typedef typename TR::Digraph Digraph;
+    /// The type of the length map
+    typedef typename TR::LengthMap LengthMap;
+    /// The type of the arc lengths
+    typedef typename TR::Value Value;
+
+    /// \brief The large value type
+    ///
+    /// The large value type used for internal computations.
+    /// Using the \ref HartmannOrlinDefaultTraits "default traits class",
+    /// it is \c long \c long if the \c Value type is integer,
+    /// otherwise it is \c double.
+    typedef typename TR::LargeValue LargeValue;
+
+    /// The tolerance type
+    typedef typename TR::Tolerance Tolerance;
+
+    /// \brief The path type of the found cycles
+    ///
+    /// The path type of the found cycles.
+    /// Using the \ref HartmannOrlinDefaultTraits "default traits class",
+    /// it is \ref lemon::Path "Path<Digraph>".
+    typedef typename TR::Path Path;
+
+    /// The \ref HartmannOrlinDefaultTraits "traits class" of the algorithm
+    typedef TR Traits;
+
+  private:
+
+    TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
+
+    // Data sturcture for path data
+    struct PathData
+    {
+      LargeValue dist;
+      Arc pred;
+      PathData(LargeValue d, Arc p = INVALID) :
+        dist(d), pred(p) {}
+    };
+
+    typedef typename Digraph::template NodeMap<std::vector<PathData> >
+      PathDataNodeMap;
+
+  private:
+
+    // The digraph the algorithm runs on
+    const Digraph &_gr;
+    // The length of the arcs
+    const LengthMap &_length;
+
+    // Data for storing the strongly connected components
+    int _comp_num;
+    typename Digraph::template NodeMap<int> _comp;
+    std::vector<std::vector<Node> > _comp_nodes;
+    std::vector<Node>* _nodes;
+    typename Digraph::template NodeMap<std::vector<Arc> > _out_arcs;
+
+    // Data for the found cycles
+    bool _curr_found, _best_found;
+    LargeValue _curr_length, _best_length;
+    int _curr_size, _best_size;
+    Node _curr_node, _best_node;
+    int _curr_level, _best_level;
+
+    Path *_cycle_path;
+    bool _local_path;
+
+    // Node map for storing path data
+    PathDataNodeMap _data;
+    // The processed nodes in the last round
+    std::vector<Node> _process;
+
+    Tolerance _tolerance;
+
+    // Infinite constant
+    const LargeValue INF;
+
+  public:
+
+    /// \name Named Template Parameters
+    /// @{
+
+    template <typename T>
+    struct SetLargeValueTraits : public Traits {
+      typedef T LargeValue;
+      typedef lemon::Tolerance<T> Tolerance;
+    };
+
+    /// \brief \ref named-templ-param "Named parameter" for setting
+    /// \c LargeValue type.
+    ///
+    /// \ref named-templ-param "Named parameter" for setting \c LargeValue
+    /// type. It is used for internal computations in the algorithm.
+    template <typename T>
+    struct SetLargeValue
+      : public HartmannOrlin<GR, LEN, SetLargeValueTraits<T> > {
+      typedef HartmannOrlin<GR, LEN, SetLargeValueTraits<T> > Create;
+    };
+
+    template <typename T>
+    struct SetPathTraits : public Traits {
+      typedef T Path;
+    };
+
+    /// \brief \ref named-templ-param "Named parameter" for setting
+    /// \c %Path type.
+    ///
+    /// \ref named-templ-param "Named parameter" for setting the \c %Path
+    /// type of the found cycles.
+    /// It must conform to the \ref lemon::concepts::Path "Path" concept
+    /// and it must have an \c addFront() function.
+    template <typename T>
+    struct SetPath
+      : public HartmannOrlin<GR, LEN, SetPathTraits<T> > {
+      typedef HartmannOrlin<GR, LEN, SetPathTraits<T> > Create;
+    };
+
+    /// @}
+
+  public:
+
+    /// \brief Constructor.
+    ///
+    /// The constructor of the class.
+    ///
+    /// \param digraph The digraph the algorithm runs on.
+    /// \param length The lengths (costs) of the arcs.
+    HartmannOrlin( const Digraph &digraph,
+                   const LengthMap &length ) :
+      _gr(digraph), _length(length), _comp(digraph), _out_arcs(digraph),
+      _best_found(false), _best_length(0), _best_size(1),
+      _cycle_path(NULL), _local_path(false), _data(digraph),
+      INF(std::numeric_limits<LargeValue>::has_infinity ?
+          std::numeric_limits<LargeValue>::infinity() :
+          std::numeric_limits<LargeValue>::max())
+    {}
+
+    /// Destructor.
+    ~HartmannOrlin() {
+      if (_local_path) delete _cycle_path;
+    }
+
+    /// \brief Set the path structure for storing the found cycle.
+    ///
+    /// This function sets an external path structure for storing the
+    /// found cycle.
+    ///
+    /// If you don't call this function before calling \ref run() or
+    /// \ref findMinMean(), it will allocate a local \ref Path "path"
+    /// structure. The destuctor deallocates this automatically
+    /// allocated object, of course.
+    ///
+    /// \note The algorithm calls only the \ref lemon::Path::addFront()
+    /// "addFront()" function of the given path structure.
+    ///
+    /// \return <tt>(*this)</tt>
+    HartmannOrlin& cycle(Path &path) {
+      if (_local_path) {
+        delete _cycle_path;
+        _local_path = false;
+      }
+      _cycle_path = &path;
+      return *this;
+    }
+
+    /// \brief Set the tolerance used by the algorithm.
+    ///
+    /// This function sets the tolerance object used by the algorithm.
+    ///
+    /// \return <tt>(*this)</tt>
+    HartmannOrlin& tolerance(const Tolerance& tolerance) {
+      _tolerance = tolerance;
+      return *this;
+    }
+
+    /// \brief Return a const reference to the tolerance.
+    ///
+    /// This function returns a const reference to the tolerance object
+    /// used by the algorithm.
+    const Tolerance& tolerance() const {
+      return _tolerance;
+    }
+
+    /// \name Execution control
+    /// The simplest way to execute the algorithm is to call the \ref run()
+    /// function.\n
+    /// If you only need the minimum mean length, you may call
+    /// \ref findMinMean().
+
+    /// @{
+
+    /// \brief Run the algorithm.
+    ///
+    /// This function runs the algorithm.
+    /// It can be called more than once (e.g. if the underlying digraph
+    /// and/or the arc lengths have been modified).
+    ///
+    /// \return \c true if a directed cycle exists in the digraph.
+    ///
+    /// \note <tt>mmc.run()</tt> is just a shortcut of the following code.
+    /// \code
+    ///   return mmc.findMinMean() && mmc.findCycle();
+    /// \endcode
+    bool run() {
+      return findMinMean() && findCycle();
+    }
+
+    /// \brief Find the minimum cycle mean.
+    ///
+    /// This function finds the minimum mean length of the directed
+    /// cycles in the digraph.
+    ///
+    /// \return \c true if a directed cycle exists in the digraph.
+    bool findMinMean() {
+      // Initialization and find strongly connected components
+      init();
+      findComponents();
+      
+      // Find the minimum cycle mean in the components
+      for (int comp = 0; comp < _comp_num; ++comp) {
+        if (!initComponent(comp)) continue;
+        processRounds();
+        
+        // Update the best cycle (global minimum mean cycle)
+        if ( _curr_found && (!_best_found || 
+             _curr_length * _best_size < _best_length * _curr_size) ) {
+          _best_found = true;
+          _best_length = _curr_length;
+          _best_size = _curr_size;
+          _best_node = _curr_node;
+          _best_level = _curr_level;
+        }
+      }
+      return _best_found;
+    }
+
+    /// \brief Find a minimum mean directed cycle.
+    ///
+    /// This function finds a directed cycle of minimum mean length
+    /// in the digraph using the data computed by findMinMean().
+    ///
+    /// \return \c true if a directed cycle exists in the digraph.
+    ///
+    /// \pre \ref findMinMean() must be called before using this function.
+    bool findCycle() {
+      if (!_best_found) return false;
+      IntNodeMap reached(_gr, -1);
+      int r = _best_level + 1;
+      Node u = _best_node;
+      while (reached[u] < 0) {
+        reached[u] = --r;
+        u = _gr.source(_data[u][r].pred);
+      }
+      r = reached[u];
+      Arc e = _data[u][r].pred;
+      _cycle_path->addFront(e);
+      _best_length = _length[e];
+      _best_size = 1;
+      Node v;
+      while ((v = _gr.source(e)) != u) {
+        e = _data[v][--r].pred;
+        _cycle_path->addFront(e);
+        _best_length += _length[e];
+        ++_best_size;
+      }
+      return true;
+    }
+
+    /// @}
+
+    /// \name Query Functions
+    /// The results of the algorithm can be obtained using these
+    /// functions.\n
+    /// The algorithm should be executed before using them.
+
+    /// @{
+
+    /// \brief Return the total length of the found cycle.
+    ///
+    /// This function returns the total length of the found cycle.
+    ///
+    /// \pre \ref run() or \ref findMinMean() must be called before
+    /// using this function.
+    LargeValue cycleLength() const {
+      return _best_length;
+    }
+
+    /// \brief Return the number of arcs on the found cycle.
+    ///
+    /// This function returns the number of arcs on the found cycle.
+    ///
+    /// \pre \ref run() or \ref findMinMean() must be called before
+    /// using this function.
+    int cycleArcNum() const {
+      return _best_size;
+    }
+
+    /// \brief Return the mean length of the found cycle.
+    ///
+    /// This function returns the mean length of the found cycle.
+    ///
+    /// \note <tt>alg.cycleMean()</tt> is just a shortcut of the
+    /// following code.
+    /// \code
+    ///   return static_cast<double>(alg.cycleLength()) / alg.cycleArcNum();
+    /// \endcode
+    ///
+    /// \pre \ref run() or \ref findMinMean() must be called before
+    /// using this function.
+    double cycleMean() const {
+      return static_cast<double>(_best_length) / _best_size;
+    }
+
+    /// \brief Return the found cycle.
+    ///
+    /// This function returns a const reference to the path structure
+    /// storing the found cycle.
+    ///
+    /// \pre \ref run() or \ref findCycle() must be called before using
+    /// this function.
+    const Path& cycle() const {
+      return *_cycle_path;
+    }
+
+    ///@}
+
+  private:
+
+    // Initialization
+    void init() {
+      if (!_cycle_path) {
+        _local_path = true;
+        _cycle_path = new Path;
+      }
+      _cycle_path->clear();
+      _best_found = false;
+      _best_length = 0;
+      _best_size = 1;
+      _cycle_path->clear();
+      for (NodeIt u(_gr); u != INVALID; ++u)
+        _data[u].clear();
+    }
+
+    // Find strongly connected components and initialize _comp_nodes
+    // and _out_arcs
+    void findComponents() {
+      _comp_num = stronglyConnectedComponents(_gr, _comp);
+      _comp_nodes.resize(_comp_num);
+      if (_comp_num == 1) {
+        _comp_nodes[0].clear();
+        for (NodeIt n(_gr); n != INVALID; ++n) {
+          _comp_nodes[0].push_back(n);
+          _out_arcs[n].clear();
+          for (OutArcIt a(_gr, n); a != INVALID; ++a) {
+            _out_arcs[n].push_back(a);
+          }
+        }
+      } else {
+        for (int i = 0; i < _comp_num; ++i)
+          _comp_nodes[i].clear();
+        for (NodeIt n(_gr); n != INVALID; ++n) {
+          int k = _comp[n];
+          _comp_nodes[k].push_back(n);
+          _out_arcs[n].clear();
+          for (OutArcIt a(_gr, n); a != INVALID; ++a) {
+            if (_comp[_gr.target(a)] == k) _out_arcs[n].push_back(a);
+          }
+        }
+      }
+    }
+
+    // Initialize path data for the current component
+    bool initComponent(int comp) {
+      _nodes = &(_comp_nodes[comp]);
+      int n = _nodes->size();
+      if (n < 1 || (n == 1 && _out_arcs[(*_nodes)[0]].size() == 0)) {
+        return false;
+      }      
+      for (int i = 0; i < n; ++i) {
+        _data[(*_nodes)[i]].resize(n + 1, PathData(INF));
+      }
+      return true;
+    }
+
+    // Process all rounds of computing path data for the current component.
+    // _data[v][k] is the length of a shortest directed walk from the root
+    // node to node v containing exactly k arcs.
+    void processRounds() {
+      Node start = (*_nodes)[0];
+      _data[start][0] = PathData(0);
+      _process.clear();
+      _process.push_back(start);
+
+      int k, n = _nodes->size();
+      int next_check = 4;
+      bool terminate = false;
+      for (k = 1; k <= n && int(_process.size()) < n && !terminate; ++k) {
+        processNextBuildRound(k);
+        if (k == next_check || k == n) {
+          terminate = checkTermination(k);
+          next_check = next_check * 3 / 2;
+        }
+      }
+      for ( ; k <= n && !terminate; ++k) {
+        processNextFullRound(k);
+        if (k == next_check || k == n) {
+          terminate = checkTermination(k);
+          next_check = next_check * 3 / 2;
+        }
+      }
+    }
+
+    // Process one round and rebuild _process
+    void processNextBuildRound(int k) {
+      std::vector<Node> next;
+      Node u, v;
+      Arc e;
+      LargeValue d;
+      for (int i = 0; i < int(_process.size()); ++i) {
+        u = _process[i];
+        for (int j = 0; j < int(_out_arcs[u].size()); ++j) {
+          e = _out_arcs[u][j];
+          v = _gr.target(e);
+          d = _data[u][k-1].dist + _length[e];
+          if (_tolerance.less(d, _data[v][k].dist)) {
+            if (_data[v][k].dist == INF) next.push_back(v);
+            _data[v][k] = PathData(d, e);
+          }
+        }
+      }
+      _process.swap(next);
+    }
+
+    // Process one round using _nodes instead of _process
+    void processNextFullRound(int k) {
+      Node u, v;
+      Arc e;
+      LargeValue d;
+      for (int i = 0; i < int(_nodes->size()); ++i) {
+        u = (*_nodes)[i];
+        for (int j = 0; j < int(_out_arcs[u].size()); ++j) {
+          e = _out_arcs[u][j];
+          v = _gr.target(e);
+          d = _data[u][k-1].dist + _length[e];
+          if (_tolerance.less(d, _data[v][k].dist)) {
+            _data[v][k] = PathData(d, e);
+          }
+        }
+      }
+    }
+    
+    // Check early termination
+    bool checkTermination(int k) {
+      typedef std::pair<int, int> Pair;
+      typename GR::template NodeMap<Pair> level(_gr, Pair(-1, 0));
+      typename GR::template NodeMap<LargeValue> pi(_gr);
+      int n = _nodes->size();
+      LargeValue length;
+      int size;
+      Node u;
+      
+      // Search for cycles that are already found
+      _curr_found = false;
+      for (int i = 0; i < n; ++i) {
+        u = (*_nodes)[i];
+        if (_data[u][k].dist == INF) continue;
+        for (int j = k; j >= 0; --j) {
+          if (level[u].first == i && level[u].second > 0) {
+            // A cycle is found
+            length = _data[u][level[u].second].dist - _data[u][j].dist;
+            size = level[u].second - j;
+            if (!_curr_found || length * _curr_size < _curr_length * size) {
+              _curr_length = length;
+              _curr_size = size;
+              _curr_node = u;
+              _curr_level = level[u].second;
+              _curr_found = true;
+            }
+          }
+          level[u] = Pair(i, j);
+          if (j != 0) {
+	    u = _gr.source(_data[u][j].pred);
+	  }
+        }
+      }
+
+      // If at least one cycle is found, check the optimality condition
+      LargeValue d;
+      if (_curr_found && k < n) {
+        // Find node potentials
+        for (int i = 0; i < n; ++i) {
+          u = (*_nodes)[i];
+          pi[u] = INF;
+          for (int j = 0; j <= k; ++j) {
+            if (_data[u][j].dist < INF) {
+              d = _data[u][j].dist * _curr_size - j * _curr_length;
+              if (_tolerance.less(d, pi[u])) pi[u] = d;
+            }
+          }
+        }
+
+        // Check the optimality condition for all arcs
+        bool done = true;
+        for (ArcIt a(_gr); a != INVALID; ++a) {
+          if (_tolerance.less(_length[a] * _curr_size - _curr_length,
+                              pi[_gr.target(a)] - pi[_gr.source(a)]) ) {
+            done = false;
+            break;
+          }
+        }
+        return done;
+      }
+      return (k == n);
+    }
+
+  }; //class HartmannOrlin
+
+  ///@}
+
+} //namespace lemon
+
+#endif //LEMON_HARTMANN_ORLIN_H
Index: mon/hartmann_orlin_mmc.h
===================================================================
--- lemon/hartmann_orlin_mmc.h	(revision 1270)
+++ 	(revision )
@@ -1,654 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2013
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * 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_HARTMANN_ORLIN_MMC_H
-#define LEMON_HARTMANN_ORLIN_MMC_H
-
-/// \ingroup min_mean_cycle
-///
-/// \file
-/// \brief Hartmann-Orlin's algorithm for finding a minimum mean cycle.
-
-#include <vector>
-#include <limits>
-#include <lemon/core.h>
-#include <lemon/path.h>
-#include <lemon/tolerance.h>
-#include <lemon/connectivity.h>
-
-namespace lemon {
-
-  /// \brief Default traits class of HartmannOrlinMmc class.
-  ///
-  /// Default traits class of HartmannOrlinMmc class.
-  /// \tparam GR The type of the digraph.
-  /// \tparam CM The type of the cost map.
-  /// It must conform to the \ref concepts::ReadMap "ReadMap" concept.
-#ifdef DOXYGEN
-  template <typename GR, typename CM>
-#else
-  template <typename GR, typename CM,
-    bool integer = std::numeric_limits<typename CM::Value>::is_integer>
-#endif
-  struct HartmannOrlinMmcDefaultTraits
-  {
-    /// The type of the digraph
-    typedef GR Digraph;
-    /// The type of the cost map
-    typedef CM CostMap;
-    /// The type of the arc costs
-    typedef typename CostMap::Value Cost;
-
-    /// \brief The large cost type used for internal computations
-    ///
-    /// The large cost type used for internal computations.
-    /// It is \c long \c long if the \c Cost type is integer,
-    /// otherwise it is \c double.
-    /// \c Cost must be convertible to \c LargeCost.
-    typedef double LargeCost;
-
-    /// The tolerance type used for internal computations
-    typedef lemon::Tolerance<LargeCost> Tolerance;
-
-    /// \brief The path type of the found cycles
-    ///
-    /// The path type of the found cycles.
-    /// It must conform to the \ref lemon::concepts::Path "Path" concept
-    /// and it must have an \c addFront() function.
-    typedef lemon::Path<Digraph> Path;
-  };
-
-  // Default traits class for integer cost types
-  template <typename GR, typename CM>
-  struct HartmannOrlinMmcDefaultTraits<GR, CM, true>
-  {
-    typedef GR Digraph;
-    typedef CM CostMap;
-    typedef typename CostMap::Value Cost;
-#ifdef LEMON_HAVE_LONG_LONG
-    typedef long long LargeCost;
-#else
-    typedef long LargeCost;
-#endif
-    typedef lemon::Tolerance<LargeCost> Tolerance;
-    typedef lemon::Path<Digraph> Path;
-  };
-
-
-  /// \addtogroup min_mean_cycle
-  /// @{
-
-  /// \brief Implementation of the Hartmann-Orlin algorithm for finding
-  /// a minimum mean cycle.
-  ///
-  /// This class implements the Hartmann-Orlin algorithm for finding
-  /// a directed cycle of minimum mean cost in a digraph
-  /// \cite hartmann93finding, \cite dasdan98minmeancycle.
-  /// This method is based on \ref KarpMmc "Karp"'s original algorithm, but
-  /// applies an early termination scheme. It makes the algorithm
-  /// significantly faster for some problem instances, but slower for others.
-  /// The algorithm runs in time O(nm) and uses space O(n<sup>2</sup>+m).
-  ///
-  /// \tparam GR The type of the digraph the algorithm runs on.
-  /// \tparam CM The type of the cost map. The default
-  /// map type is \ref concepts::Digraph::ArcMap "GR::ArcMap<int>".
-  /// \tparam TR The traits class that defines various types used by the
-  /// algorithm. By default, it is \ref HartmannOrlinMmcDefaultTraits
-  /// "HartmannOrlinMmcDefaultTraits<GR, CM>".
-  /// In most cases, this parameter should not be set directly,
-  /// consider to use the named template parameters instead.
-#ifdef DOXYGEN
-  template <typename GR, typename CM, typename TR>
-#else
-  template < typename GR,
-             typename CM = typename GR::template ArcMap<int>,
-             typename TR = HartmannOrlinMmcDefaultTraits<GR, CM> >
-#endif
-  class HartmannOrlinMmc
-  {
-  public:
-
-    /// The type of the digraph
-    typedef typename TR::Digraph Digraph;
-    /// The type of the cost map
-    typedef typename TR::CostMap CostMap;
-    /// The type of the arc costs
-    typedef typename TR::Cost Cost;
-
-    /// \brief The large cost type
-    ///
-    /// The large cost type used for internal computations.
-    /// By default, it is \c long \c long if the \c Cost type is integer,
-    /// otherwise it is \c double.
-    typedef typename TR::LargeCost LargeCost;
-
-    /// The tolerance type
-    typedef typename TR::Tolerance Tolerance;
-
-    /// \brief The path type of the found cycles
-    ///
-    /// The path type of the found cycles.
-    /// Using the \ref lemon::HartmannOrlinMmcDefaultTraits
-    /// "default traits class",
-    /// it is \ref lemon::Path "Path<Digraph>".
-    typedef typename TR::Path Path;
-
-    /// \brief The
-    /// \ref lemon::HartmannOrlinMmcDefaultTraits "traits class"
-    /// of the algorithm
-    typedef TR Traits;
-
-  private:
-
-    TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
-
-    // Data sturcture for path data
-    struct PathData
-    {
-      LargeCost dist;
-      Arc pred;
-      PathData(LargeCost d, Arc p = INVALID) :
-        dist(d), pred(p) {}
-    };
-
-    typedef typename Digraph::template NodeMap<std::vector<PathData> >
-      PathDataNodeMap;
-
-  private:
-
-    // The digraph the algorithm runs on
-    const Digraph &_gr;
-    // The cost of the arcs
-    const CostMap &_cost;
-
-    // Data for storing the strongly connected components
-    int _comp_num;
-    typename Digraph::template NodeMap<int> _comp;
-    std::vector<std::vector<Node> > _comp_nodes;
-    std::vector<Node>* _nodes;
-    typename Digraph::template NodeMap<std::vector<Arc> > _out_arcs;
-
-    // Data for the found cycles
-    bool _curr_found, _best_found;
-    LargeCost _curr_cost, _best_cost;
-    int _curr_size, _best_size;
-    Node _curr_node, _best_node;
-    int _curr_level, _best_level;
-
-    Path *_cycle_path;
-    bool _local_path;
-
-    // Node map for storing path data
-    PathDataNodeMap _data;
-    // The processed nodes in the last round
-    std::vector<Node> _process;
-
-    Tolerance _tolerance;
-
-    // Infinite constant
-    const LargeCost INF;
-
-  public:
-
-    /// \name Named Template Parameters
-    /// @{
-
-    template <typename T>
-    struct SetLargeCostTraits : public Traits {
-      typedef T LargeCost;
-      typedef lemon::Tolerance<T> Tolerance;
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// \c LargeCost type.
-    ///
-    /// \ref named-templ-param "Named parameter" for setting \c LargeCost
-    /// type. It is used for internal computations in the algorithm.
-    template <typename T>
-    struct SetLargeCost
-      : public HartmannOrlinMmc<GR, CM, SetLargeCostTraits<T> > {
-      typedef HartmannOrlinMmc<GR, CM, SetLargeCostTraits<T> > Create;
-    };
-
-    template <typename T>
-    struct SetPathTraits : public Traits {
-      typedef T Path;
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// \c %Path type.
-    ///
-    /// \ref named-templ-param "Named parameter" for setting the \c %Path
-    /// type of the found cycles.
-    /// It must conform to the \ref lemon::concepts::Path "Path" concept
-    /// and it must have an \c addFront() function.
-    template <typename T>
-    struct SetPath
-      : public HartmannOrlinMmc<GR, CM, SetPathTraits<T> > {
-      typedef HartmannOrlinMmc<GR, CM, SetPathTraits<T> > Create;
-    };
-
-    /// @}
-
-  protected:
-
-    HartmannOrlinMmc() {}
-
-  public:
-
-    /// \brief Constructor.
-    ///
-    /// The constructor of the class.
-    ///
-    /// \param digraph The digraph the algorithm runs on.
-    /// \param cost The costs of the arcs.
-    HartmannOrlinMmc( const Digraph &digraph,
-                      const CostMap &cost ) :
-      _gr(digraph), _cost(cost), _comp(digraph), _out_arcs(digraph),
-      _best_found(false), _best_cost(0), _best_size(1),
-      _cycle_path(NULL), _local_path(false), _data(digraph),
-      INF(std::numeric_limits<LargeCost>::has_infinity ?
-          std::numeric_limits<LargeCost>::infinity() :
-          std::numeric_limits<LargeCost>::max())
-    {}
-
-    /// Destructor.
-    ~HartmannOrlinMmc() {
-      if (_local_path) delete _cycle_path;
-    }
-
-    /// \brief Set the path structure for storing the found cycle.
-    ///
-    /// This function sets an external path structure for storing the
-    /// found cycle.
-    ///
-    /// If you don't call this function before calling \ref run() or
-    /// \ref findCycleMean(), a local \ref Path "path" structure
-    /// will be allocated. The destuctor deallocates this automatically
-    /// allocated object, of course.
-    ///
-    /// \note The algorithm calls only the \ref lemon::Path::addFront()
-    /// "addFront()" function of the given path structure.
-    ///
-    /// \return <tt>(*this)</tt>
-    HartmannOrlinMmc& cycle(Path &path) {
-      if (_local_path) {
-        delete _cycle_path;
-        _local_path = false;
-      }
-      _cycle_path = &path;
-      return *this;
-    }
-
-    /// \brief Set the tolerance used by the algorithm.
-    ///
-    /// This function sets the tolerance object used by the algorithm.
-    ///
-    /// \return <tt>(*this)</tt>
-    HartmannOrlinMmc& tolerance(const Tolerance& tolerance) {
-      _tolerance = tolerance;
-      return *this;
-    }
-
-    /// \brief Return a const reference to the tolerance.
-    ///
-    /// This function returns a const reference to the tolerance object
-    /// used by the algorithm.
-    const Tolerance& tolerance() const {
-      return _tolerance;
-    }
-
-    /// \name Execution control
-    /// The simplest way to execute the algorithm is to call the \ref run()
-    /// function.\n
-    /// If you only need the minimum mean cost, you may call
-    /// \ref findCycleMean().
-
-    /// @{
-
-    /// \brief Run the algorithm.
-    ///
-    /// This function runs the algorithm.
-    /// It can be called more than once (e.g. if the underlying digraph
-    /// and/or the arc costs have been modified).
-    ///
-    /// \return \c true if a directed cycle exists in the digraph.
-    ///
-    /// \note <tt>mmc.run()</tt> is just a shortcut of the following code.
-    /// \code
-    ///   return mmc.findCycleMean() && mmc.findCycle();
-    /// \endcode
-    bool run() {
-      return findCycleMean() && findCycle();
-    }
-
-    /// \brief Find the minimum cycle mean.
-    ///
-    /// This function finds the minimum mean cost of the directed
-    /// cycles in the digraph.
-    ///
-    /// \return \c true if a directed cycle exists in the digraph.
-    bool findCycleMean() {
-      // Initialization and find strongly connected components
-      init();
-      findComponents();
-
-      // Find the minimum cycle mean in the components
-      for (int comp = 0; comp < _comp_num; ++comp) {
-        if (!initComponent(comp)) continue;
-        processRounds();
-
-        // Update the best cycle (global minimum mean cycle)
-        if ( _curr_found && (!_best_found ||
-             _curr_cost * _best_size < _best_cost * _curr_size) ) {
-          _best_found = true;
-          _best_cost = _curr_cost;
-          _best_size = _curr_size;
-          _best_node = _curr_node;
-          _best_level = _curr_level;
-        }
-      }
-      return _best_found;
-    }
-
-    /// \brief Find a minimum mean directed cycle.
-    ///
-    /// This function finds a directed cycle of minimum mean cost
-    /// in the digraph using the data computed by findCycleMean().
-    ///
-    /// \return \c true if a directed cycle exists in the digraph.
-    ///
-    /// \pre \ref findCycleMean() must be called before using this function.
-    bool findCycle() {
-      if (!_best_found) return false;
-      IntNodeMap reached(_gr, -1);
-      int r = _best_level + 1;
-      Node u = _best_node;
-      while (reached[u] < 0) {
-        reached[u] = --r;
-        u = _gr.source(_data[u][r].pred);
-      }
-      r = reached[u];
-      Arc e = _data[u][r].pred;
-      _cycle_path->addFront(e);
-      _best_cost = _cost[e];
-      _best_size = 1;
-      Node v;
-      while ((v = _gr.source(e)) != u) {
-        e = _data[v][--r].pred;
-        _cycle_path->addFront(e);
-        _best_cost += _cost[e];
-        ++_best_size;
-      }
-      return true;
-    }
-
-    /// @}
-
-    /// \name Query Functions
-    /// The results of the algorithm can be obtained using these
-    /// functions.\n
-    /// The algorithm should be executed before using them.
-
-    /// @{
-
-    /// \brief Return the total cost of the found cycle.
-    ///
-    /// This function returns the total cost of the found cycle.
-    ///
-    /// \pre \ref run() or \ref findCycleMean() must be called before
-    /// using this function.
-    Cost cycleCost() const {
-      return static_cast<Cost>(_best_cost);
-    }
-
-    /// \brief Return the number of arcs on the found cycle.
-    ///
-    /// This function returns the number of arcs on the found cycle.
-    ///
-    /// \pre \ref run() or \ref findCycleMean() must be called before
-    /// using this function.
-    int cycleSize() const {
-      return _best_size;
-    }
-
-    /// \brief Return the mean cost of the found cycle.
-    ///
-    /// This function returns the mean cost of the found cycle.
-    ///
-    /// \note <tt>alg.cycleMean()</tt> is just a shortcut of the
-    /// following code.
-    /// \code
-    ///   return static_cast<double>(alg.cycleCost()) / alg.cycleSize();
-    /// \endcode
-    ///
-    /// \pre \ref run() or \ref findCycleMean() must be called before
-    /// using this function.
-    double cycleMean() const {
-      return static_cast<double>(_best_cost) / _best_size;
-    }
-
-    /// \brief Return the found cycle.
-    ///
-    /// This function returns a const reference to the path structure
-    /// storing the found cycle.
-    ///
-    /// \pre \ref run() or \ref findCycle() must be called before using
-    /// this function.
-    const Path& cycle() const {
-      return *_cycle_path;
-    }
-
-    ///@}
-
-  private:
-
-    // Initialization
-    void init() {
-      if (!_cycle_path) {
-        _local_path = true;
-        _cycle_path = new Path;
-      }
-      _cycle_path->clear();
-      _best_found = false;
-      _best_cost = 0;
-      _best_size = 1;
-      _cycle_path->clear();
-      for (NodeIt u(_gr); u != INVALID; ++u)
-        _data[u].clear();
-    }
-
-    // Find strongly connected components and initialize _comp_nodes
-    // and _out_arcs
-    void findComponents() {
-      _comp_num = stronglyConnectedComponents(_gr, _comp);
-      _comp_nodes.resize(_comp_num);
-      if (_comp_num == 1) {
-        _comp_nodes[0].clear();
-        for (NodeIt n(_gr); n != INVALID; ++n) {
-          _comp_nodes[0].push_back(n);
-          _out_arcs[n].clear();
-          for (OutArcIt a(_gr, n); a != INVALID; ++a) {
-            _out_arcs[n].push_back(a);
-          }
-        }
-      } else {
-        for (int i = 0; i < _comp_num; ++i)
-          _comp_nodes[i].clear();
-        for (NodeIt n(_gr); n != INVALID; ++n) {
-          int k = _comp[n];
-          _comp_nodes[k].push_back(n);
-          _out_arcs[n].clear();
-          for (OutArcIt a(_gr, n); a != INVALID; ++a) {
-            if (_comp[_gr.target(a)] == k) _out_arcs[n].push_back(a);
-          }
-        }
-      }
-    }
-
-    // Initialize path data for the current component
-    bool initComponent(int comp) {
-      _nodes = &(_comp_nodes[comp]);
-      int n = _nodes->size();
-      if (n < 1 || (n == 1 && _out_arcs[(*_nodes)[0]].size() == 0)) {
-        return false;
-      }
-      for (int i = 0; i < n; ++i) {
-        _data[(*_nodes)[i]].resize(n + 1, PathData(INF));
-      }
-      return true;
-    }
-
-    // Process all rounds of computing path data for the current component.
-    // _data[v][k] is the cost of a shortest directed walk from the root
-    // node to node v containing exactly k arcs.
-    void processRounds() {
-      Node start = (*_nodes)[0];
-      _data[start][0] = PathData(0);
-      _process.clear();
-      _process.push_back(start);
-
-      int k, n = _nodes->size();
-      int next_check = 4;
-      bool terminate = false;
-      for (k = 1; k <= n && int(_process.size()) < n && !terminate; ++k) {
-        processNextBuildRound(k);
-        if (k == next_check || k == n) {
-          terminate = checkTermination(k);
-          next_check = next_check * 3 / 2;
-        }
-      }
-      for ( ; k <= n && !terminate; ++k) {
-        processNextFullRound(k);
-        if (k == next_check || k == n) {
-          terminate = checkTermination(k);
-          next_check = next_check * 3 / 2;
-        }
-      }
-    }
-
-    // Process one round and rebuild _process
-    void processNextBuildRound(int k) {
-      std::vector<Node> next;
-      Node u, v;
-      Arc e;
-      LargeCost d;
-      for (int i = 0; i < int(_process.size()); ++i) {
-        u = _process[i];
-        for (int j = 0; j < int(_out_arcs[u].size()); ++j) {
-          e = _out_arcs[u][j];
-          v = _gr.target(e);
-          d = _data[u][k-1].dist + _cost[e];
-          if (_tolerance.less(d, _data[v][k].dist)) {
-            if (_data[v][k].dist == INF) next.push_back(v);
-            _data[v][k] = PathData(d, e);
-          }
-        }
-      }
-      _process.swap(next);
-    }
-
-    // Process one round using _nodes instead of _process
-    void processNextFullRound(int k) {
-      Node u, v;
-      Arc e;
-      LargeCost d;
-      for (int i = 0; i < int(_nodes->size()); ++i) {
-        u = (*_nodes)[i];
-        for (int j = 0; j < int(_out_arcs[u].size()); ++j) {
-          e = _out_arcs[u][j];
-          v = _gr.target(e);
-          d = _data[u][k-1].dist + _cost[e];
-          if (_tolerance.less(d, _data[v][k].dist)) {
-            _data[v][k] = PathData(d, e);
-          }
-        }
-      }
-    }
-
-    // Check early termination
-    bool checkTermination(int k) {
-      typedef std::pair<int, int> Pair;
-      typename GR::template NodeMap<Pair> level(_gr, Pair(-1, 0));
-      typename GR::template NodeMap<LargeCost> pi(_gr);
-      int n = _nodes->size();
-      LargeCost cost;
-      int size;
-      Node u;
-
-      // Search for cycles that are already found
-      _curr_found = false;
-      for (int i = 0; i < n; ++i) {
-        u = (*_nodes)[i];
-        if (_data[u][k].dist == INF) continue;
-        for (int j = k; j >= 0; --j) {
-          if (level[u].first == i && level[u].second > 0) {
-            // A cycle is found
-            cost = _data[u][level[u].second].dist - _data[u][j].dist;
-            size = level[u].second - j;
-            if (!_curr_found || cost * _curr_size < _curr_cost * size) {
-              _curr_cost = cost;
-              _curr_size = size;
-              _curr_node = u;
-              _curr_level = level[u].second;
-              _curr_found = true;
-            }
-          }
-          level[u] = Pair(i, j);
-          if (j != 0) {
-            u = _gr.source(_data[u][j].pred);
-          }
-        }
-      }
-
-      // If at least one cycle is found, check the optimality condition
-      LargeCost d;
-      if (_curr_found && k < n) {
-        // Find node potentials
-        for (int i = 0; i < n; ++i) {
-          u = (*_nodes)[i];
-          pi[u] = INF;
-          for (int j = 0; j <= k; ++j) {
-            if (_data[u][j].dist < INF) {
-              d = _data[u][j].dist * _curr_size - j * _curr_cost;
-              if (_tolerance.less(d, pi[u])) pi[u] = d;
-            }
-          }
-        }
-
-        // Check the optimality condition for all arcs
-        bool done = true;
-        for (ArcIt a(_gr); a != INVALID; ++a) {
-          if (_tolerance.less(_cost[a] * _curr_size - _curr_cost,
-                              pi[_gr.target(a)] - pi[_gr.source(a)]) ) {
-            done = false;
-            break;
-          }
-        }
-        return done;
-      }
-      return (k == n);
-    }
-
-  }; //class HartmannOrlinMmc
-
-  ///@}
-
-} //namespace lemon
-
-#endif //LEMON_HARTMANN_ORLIN_MMC_H
Index: lemon/howard.h
===================================================================
--- lemon/howard.h	(revision 818)
+++ lemon/howard.h	(revision 818)
@@ -0,0 +1,597 @@
+/* -*- C++ -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library
+ *
+ * Copyright (C) 2003-2008
+ * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
+ * (Egervary Research Group on Combinatorial Optimization, EGRES).
+ *
+ * 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_HOWARD_H
+#define LEMON_HOWARD_H
+
+/// \ingroup min_mean_cycle
+///
+/// \file
+/// \brief Howard's algorithm for finding a minimum mean cycle.
+
+#include <vector>
+#include <limits>
+#include <lemon/core.h>
+#include <lemon/path.h>
+#include <lemon/tolerance.h>
+#include <lemon/connectivity.h>
+
+namespace lemon {
+
+  /// \brief Default traits class of Howard class.
+  ///
+  /// Default traits class of Howard class.
+  /// \tparam GR The type of the digraph.
+  /// \tparam LEN The type of the length map.
+  /// It must conform to the \ref concepts::ReadMap "ReadMap" concept.
+#ifdef DOXYGEN
+  template <typename GR, typename LEN>
+#else
+  template <typename GR, typename LEN,
+    bool integer = std::numeric_limits<typename LEN::Value>::is_integer>
+#endif
+  struct HowardDefaultTraits
+  {
+    /// The type of the digraph
+    typedef GR Digraph;
+    /// The type of the length map
+    typedef LEN LengthMap;
+    /// The type of the arc lengths
+    typedef typename LengthMap::Value Value;
+
+    /// \brief The large value type used for internal computations
+    ///
+    /// The large value type used for internal computations.
+    /// It is \c long \c long if the \c Value type is integer,
+    /// otherwise it is \c double.
+    /// \c Value must be convertible to \c LargeValue.
+    typedef double LargeValue;
+
+    /// The tolerance type used for internal computations
+    typedef lemon::Tolerance<LargeValue> Tolerance;
+
+    /// \brief The path type of the found cycles
+    ///
+    /// The path type of the found cycles.
+    /// It must conform to the \ref lemon::concepts::Path "Path" concept
+    /// and it must have an \c addBack() function.
+    typedef lemon::Path<Digraph> Path;
+  };
+
+  // Default traits class for integer value types
+  template <typename GR, typename LEN>
+  struct HowardDefaultTraits<GR, LEN, true>
+  {
+    typedef GR Digraph;
+    typedef LEN LengthMap;
+    typedef typename LengthMap::Value Value;
+#ifdef LEMON_HAVE_LONG_LONG
+    typedef long long LargeValue;
+#else
+    typedef long LargeValue;
+#endif
+    typedef lemon::Tolerance<LargeValue> Tolerance;
+    typedef lemon::Path<Digraph> Path;
+  };
+
+
+  /// \addtogroup min_mean_cycle
+  /// @{
+
+  /// \brief Implementation of Howard's algorithm for finding a minimum
+  /// mean cycle.
+  ///
+  /// This class implements Howard's policy iteration algorithm for finding
+  /// a directed cycle of minimum mean length (cost) in a digraph
+  /// \ref amo93networkflows, \ref dasdan98minmeancycle.
+  /// This class provides the most efficient algorithm for the
+  /// minimum mean cycle problem, though the best known theoretical
+  /// bound on its running time is exponential.
+  ///
+  /// \tparam GR The type of the digraph the algorithm runs on.
+  /// \tparam LEN The type of the length map. The default
+  /// map type is \ref concepts::Digraph::ArcMap "GR::ArcMap<int>".
+#ifdef DOXYGEN
+  template <typename GR, typename LEN, typename TR>
+#else
+  template < typename GR,
+             typename LEN = typename GR::template ArcMap<int>,
+             typename TR = HowardDefaultTraits<GR, LEN> >
+#endif
+  class Howard
+  {
+  public:
+  
+    /// The type of the digraph
+    typedef typename TR::Digraph Digraph;
+    /// The type of the length map
+    typedef typename TR::LengthMap LengthMap;
+    /// The type of the arc lengths
+    typedef typename TR::Value Value;
+
+    /// \brief The large value type
+    ///
+    /// The large value type used for internal computations.
+    /// Using the \ref HowardDefaultTraits "default traits class",
+    /// it is \c long \c long if the \c Value type is integer,
+    /// otherwise it is \c double.
+    typedef typename TR::LargeValue LargeValue;
+
+    /// The tolerance type
+    typedef typename TR::Tolerance Tolerance;
+
+    /// \brief The path type of the found cycles
+    ///
+    /// The path type of the found cycles.
+    /// Using the \ref HowardDefaultTraits "default traits class",
+    /// it is \ref lemon::Path "Path<Digraph>".
+    typedef typename TR::Path Path;
+
+    /// The \ref HowardDefaultTraits "traits class" of the algorithm
+    typedef TR Traits;
+
+  private:
+
+    TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
+  
+    // The digraph the algorithm runs on
+    const Digraph &_gr;
+    // The length of the arcs
+    const LengthMap &_length;
+
+    // Data for the found cycles
+    bool _curr_found, _best_found;
+    LargeValue _curr_length, _best_length;
+    int _curr_size, _best_size;
+    Node _curr_node, _best_node;
+
+    Path *_cycle_path;
+    bool _local_path;
+
+    // Internal data used by the algorithm
+    typename Digraph::template NodeMap<Arc> _policy;
+    typename Digraph::template NodeMap<bool> _reached;
+    typename Digraph::template NodeMap<int> _level;
+    typename Digraph::template NodeMap<LargeValue> _dist;
+
+    // Data for storing the strongly connected components
+    int _comp_num;
+    typename Digraph::template NodeMap<int> _comp;
+    std::vector<std::vector<Node> > _comp_nodes;
+    std::vector<Node>* _nodes;
+    typename Digraph::template NodeMap<std::vector<Arc> > _in_arcs;
+    
+    // Queue used for BFS search
+    std::vector<Node> _queue;
+    int _qfront, _qback;
+
+    Tolerance _tolerance;
+  
+    // Infinite constant
+    const LargeValue INF;
+
+  public:
+  
+    /// \name Named Template Parameters
+    /// @{
+
+    template <typename T>
+    struct SetLargeValueTraits : public Traits {
+      typedef T LargeValue;
+      typedef lemon::Tolerance<T> Tolerance;
+    };
+
+    /// \brief \ref named-templ-param "Named parameter" for setting
+    /// \c LargeValue type.
+    ///
+    /// \ref named-templ-param "Named parameter" for setting \c LargeValue
+    /// type. It is used for internal computations in the algorithm.
+    template <typename T>
+    struct SetLargeValue
+      : public Howard<GR, LEN, SetLargeValueTraits<T> > {
+      typedef Howard<GR, LEN, SetLargeValueTraits<T> > Create;
+    };
+
+    template <typename T>
+    struct SetPathTraits : public Traits {
+      typedef T Path;
+    };
+
+    /// \brief \ref named-templ-param "Named parameter" for setting
+    /// \c %Path type.
+    ///
+    /// \ref named-templ-param "Named parameter" for setting the \c %Path
+    /// type of the found cycles.
+    /// It must conform to the \ref lemon::concepts::Path "Path" concept
+    /// and it must have an \c addBack() function.
+    template <typename T>
+    struct SetPath
+      : public Howard<GR, LEN, SetPathTraits<T> > {
+      typedef Howard<GR, LEN, SetPathTraits<T> > Create;
+    };
+    
+    /// @}
+
+  public:
+
+    /// \brief Constructor.
+    ///
+    /// The constructor of the class.
+    ///
+    /// \param digraph The digraph the algorithm runs on.
+    /// \param length The lengths (costs) of the arcs.
+    Howard( const Digraph &digraph,
+            const LengthMap &length ) :
+      _gr(digraph), _length(length), _best_found(false),
+      _best_length(0), _best_size(1), _cycle_path(NULL), _local_path(false),
+      _policy(digraph), _reached(digraph), _level(digraph), _dist(digraph),
+      _comp(digraph), _in_arcs(digraph),
+      INF(std::numeric_limits<LargeValue>::has_infinity ?
+          std::numeric_limits<LargeValue>::infinity() :
+          std::numeric_limits<LargeValue>::max())
+    {}
+
+    /// Destructor.
+    ~Howard() {
+      if (_local_path) delete _cycle_path;
+    }
+
+    /// \brief Set the path structure for storing the found cycle.
+    ///
+    /// This function sets an external path structure for storing the
+    /// found cycle.
+    ///
+    /// If you don't call this function before calling \ref run() or
+    /// \ref findMinMean(), it will allocate a local \ref Path "path"
+    /// structure. The destuctor deallocates this automatically
+    /// allocated object, of course.
+    ///
+    /// \note The algorithm calls only the \ref lemon::Path::addBack()
+    /// "addBack()" function of the given path structure.
+    ///
+    /// \return <tt>(*this)</tt>
+    Howard& cycle(Path &path) {
+      if (_local_path) {
+        delete _cycle_path;
+        _local_path = false;
+      }
+      _cycle_path = &path;
+      return *this;
+    }
+
+    /// \brief Set the tolerance used by the algorithm.
+    ///
+    /// This function sets the tolerance object used by the algorithm.
+    ///
+    /// \return <tt>(*this)</tt>
+    Howard& tolerance(const Tolerance& tolerance) {
+      _tolerance = tolerance;
+      return *this;
+    }
+
+    /// \brief Return a const reference to the tolerance.
+    ///
+    /// This function returns a const reference to the tolerance object
+    /// used by the algorithm.
+    const Tolerance& tolerance() const {
+      return _tolerance;
+    }
+
+    /// \name Execution control
+    /// The simplest way to execute the algorithm is to call the \ref run()
+    /// function.\n
+    /// If you only need the minimum mean length, you may call
+    /// \ref findMinMean().
+
+    /// @{
+
+    /// \brief Run the algorithm.
+    ///
+    /// This function runs the algorithm.
+    /// It can be called more than once (e.g. if the underlying digraph
+    /// and/or the arc lengths have been modified).
+    ///
+    /// \return \c true if a directed cycle exists in the digraph.
+    ///
+    /// \note <tt>mmc.run()</tt> is just a shortcut of the following code.
+    /// \code
+    ///   return mmc.findMinMean() && mmc.findCycle();
+    /// \endcode
+    bool run() {
+      return findMinMean() && findCycle();
+    }
+
+    /// \brief Find the minimum cycle mean.
+    ///
+    /// This function finds the minimum mean length of the directed
+    /// cycles in the digraph.
+    ///
+    /// \return \c true if a directed cycle exists in the digraph.
+    bool findMinMean() {
+      // Initialize and find strongly connected components
+      init();
+      findComponents();
+      
+      // Find the minimum cycle mean in the components
+      for (int comp = 0; comp < _comp_num; ++comp) {
+        // Find the minimum mean cycle in the current component
+        if (!buildPolicyGraph(comp)) continue;
+        while (true) {
+          findPolicyCycle();
+          if (!computeNodeDistances()) break;
+        }
+        // Update the best cycle (global minimum mean cycle)
+        if ( _curr_found && (!_best_found ||
+             _curr_length * _best_size < _best_length * _curr_size) ) {
+          _best_found = true;
+          _best_length = _curr_length;
+          _best_size = _curr_size;
+          _best_node = _curr_node;
+        }
+      }
+      return _best_found;
+    }
+
+    /// \brief Find a minimum mean directed cycle.
+    ///
+    /// This function finds a directed cycle of minimum mean length
+    /// in the digraph using the data computed by findMinMean().
+    ///
+    /// \return \c true if a directed cycle exists in the digraph.
+    ///
+    /// \pre \ref findMinMean() must be called before using this function.
+    bool findCycle() {
+      if (!_best_found) return false;
+      _cycle_path->addBack(_policy[_best_node]);
+      for ( Node v = _best_node;
+            (v = _gr.target(_policy[v])) != _best_node; ) {
+        _cycle_path->addBack(_policy[v]);
+      }
+      return true;
+    }
+
+    /// @}
+
+    /// \name Query Functions
+    /// The results of the algorithm can be obtained using these
+    /// functions.\n
+    /// The algorithm should be executed before using them.
+
+    /// @{
+
+    /// \brief Return the total length of the found cycle.
+    ///
+    /// This function returns the total length of the found cycle.
+    ///
+    /// \pre \ref run() or \ref findMinMean() must be called before
+    /// using this function.
+    LargeValue cycleLength() const {
+      return _best_length;
+    }
+
+    /// \brief Return the number of arcs on the found cycle.
+    ///
+    /// This function returns the number of arcs on the found cycle.
+    ///
+    /// \pre \ref run() or \ref findMinMean() must be called before
+    /// using this function.
+    int cycleArcNum() const {
+      return _best_size;
+    }
+
+    /// \brief Return the mean length of the found cycle.
+    ///
+    /// This function returns the mean length of the found cycle.
+    ///
+    /// \note <tt>alg.cycleMean()</tt> is just a shortcut of the
+    /// following code.
+    /// \code
+    ///   return static_cast<double>(alg.cycleLength()) / alg.cycleArcNum();
+    /// \endcode
+    ///
+    /// \pre \ref run() or \ref findMinMean() must be called before
+    /// using this function.
+    double cycleMean() const {
+      return static_cast<double>(_best_length) / _best_size;
+    }
+
+    /// \brief Return the found cycle.
+    ///
+    /// This function returns a const reference to the path structure
+    /// storing the found cycle.
+    ///
+    /// \pre \ref run() or \ref findCycle() must be called before using
+    /// this function.
+    const Path& cycle() const {
+      return *_cycle_path;
+    }
+
+    ///@}
+
+  private:
+
+    // Initialize
+    void init() {
+      if (!_cycle_path) {
+        _local_path = true;
+        _cycle_path = new Path;
+      }
+      _queue.resize(countNodes(_gr));
+      _best_found = false;
+      _best_length = 0;
+      _best_size = 1;
+      _cycle_path->clear();
+    }
+    
+    // Find strongly connected components and initialize _comp_nodes
+    // and _in_arcs
+    void findComponents() {
+      _comp_num = stronglyConnectedComponents(_gr, _comp);
+      _comp_nodes.resize(_comp_num);
+      if (_comp_num == 1) {
+        _comp_nodes[0].clear();
+        for (NodeIt n(_gr); n != INVALID; ++n) {
+          _comp_nodes[0].push_back(n);
+          _in_arcs[n].clear();
+          for (InArcIt a(_gr, n); a != INVALID; ++a) {
+            _in_arcs[n].push_back(a);
+          }
+        }
+      } else {
+        for (int i = 0; i < _comp_num; ++i)
+          _comp_nodes[i].clear();
+        for (NodeIt n(_gr); n != INVALID; ++n) {
+          int k = _comp[n];
+          _comp_nodes[k].push_back(n);
+          _in_arcs[n].clear();
+          for (InArcIt a(_gr, n); a != INVALID; ++a) {
+            if (_comp[_gr.source(a)] == k) _in_arcs[n].push_back(a);
+          }
+        }
+      }
+    }
+
+    // Build the policy graph in the given strongly connected component
+    // (the out-degree of every node is 1)
+    bool buildPolicyGraph(int comp) {
+      _nodes = &(_comp_nodes[comp]);
+      if (_nodes->size() < 1 ||
+          (_nodes->size() == 1 && _in_arcs[(*_nodes)[0]].size() == 0)) {
+        return false;
+      }
+      for (int i = 0; i < int(_nodes->size()); ++i) {
+        _dist[(*_nodes)[i]] = INF;
+      }
+      Node u, v;
+      Arc e;
+      for (int i = 0; i < int(_nodes->size()); ++i) {
+        v = (*_nodes)[i];
+        for (int j = 0; j < int(_in_arcs[v].size()); ++j) {
+          e = _in_arcs[v][j];
+          u = _gr.source(e);
+          if (_length[e] < _dist[u]) {
+            _dist[u] = _length[e];
+            _policy[u] = e;
+          }
+        }
+      }
+      return true;
+    }
+
+    // Find the minimum mean cycle in the policy graph
+    void findPolicyCycle() {
+      for (int i = 0; i < int(_nodes->size()); ++i) {
+        _level[(*_nodes)[i]] = -1;
+      }
+      LargeValue clength;
+      int csize;
+      Node u, v;
+      _curr_found = false;
+      for (int i = 0; i < int(_nodes->size()); ++i) {
+        u = (*_nodes)[i];
+        if (_level[u] >= 0) continue;
+        for (; _level[u] < 0; u = _gr.target(_policy[u])) {
+          _level[u] = i;
+        }
+        if (_level[u] == i) {
+          // A cycle is found
+          clength = _length[_policy[u]];
+          csize = 1;
+          for (v = u; (v = _gr.target(_policy[v])) != u; ) {
+            clength += _length[_policy[v]];
+            ++csize;
+          }
+          if ( !_curr_found ||
+               (clength * _curr_size < _curr_length * csize) ) {
+            _curr_found = true;
+            _curr_length = clength;
+            _curr_size = csize;
+            _curr_node = u;
+          }
+        }
+      }
+    }
+
+    // Contract the policy graph and compute node distances
+    bool computeNodeDistances() {
+      // Find the component of the main cycle and compute node distances
+      // using reverse BFS
+      for (int i = 0; i < int(_nodes->size()); ++i) {
+        _reached[(*_nodes)[i]] = false;
+      }
+      _qfront = _qback = 0;
+      _queue[0] = _curr_node;
+      _reached[_curr_node] = true;
+      _dist[_curr_node] = 0;
+      Node u, v;
+      Arc e;
+      while (_qfront <= _qback) {
+        v = _queue[_qfront++];
+        for (int j = 0; j < int(_in_arcs[v].size()); ++j) {
+          e = _in_arcs[v][j];
+          u = _gr.source(e);
+          if (_policy[u] == e && !_reached[u]) {
+            _reached[u] = true;
+            _dist[u] = _dist[v] + _length[e] * _curr_size - _curr_length;
+            _queue[++_qback] = u;
+          }
+        }
+      }
+
+      // Connect all other nodes to this component and compute node
+      // distances using reverse BFS
+      _qfront = 0;
+      while (_qback < int(_nodes->size())-1) {
+        v = _queue[_qfront++];
+        for (int j = 0; j < int(_in_arcs[v].size()); ++j) {
+          e = _in_arcs[v][j];
+          u = _gr.source(e);
+          if (!_reached[u]) {
+            _reached[u] = true;
+            _policy[u] = e;
+            _dist[u] = _dist[v] + _length[e] * _curr_size - _curr_length;
+            _queue[++_qback] = u;
+          }
+        }
+      }
+
+      // Improve node distances
+      bool improved = false;
+      for (int i = 0; i < int(_nodes->size()); ++i) {
+        v = (*_nodes)[i];
+        for (int j = 0; j < int(_in_arcs[v].size()); ++j) {
+          e = _in_arcs[v][j];
+          u = _gr.source(e);
+          LargeValue delta = _dist[v] + _length[e] * _curr_size - _curr_length;
+          if (_tolerance.less(delta, _dist[u])) {
+            _dist[u] = delta;
+            _policy[u] = e;
+            improved = true;
+          }
+        }
+      }
+      return improved;
+    }
+
+  }; //class Howard
+
+  ///@}
+
+} //namespace lemon
+
+#endif //LEMON_HOWARD_H
Index: mon/howard_mmc.h
===================================================================
--- lemon/howard_mmc.h	(revision 1271)
+++ 	(revision )
@@ -1,651 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2013
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * 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_HOWARD_MMC_H
-#define LEMON_HOWARD_MMC_H
-
-/// \ingroup min_mean_cycle
-///
-/// \file
-/// \brief Howard's algorithm for finding a minimum mean cycle.
-
-#include <vector>
-#include <limits>
-#include <lemon/core.h>
-#include <lemon/path.h>
-#include <lemon/tolerance.h>
-#include <lemon/connectivity.h>
-
-namespace lemon {
-
-  /// \brief Default traits class of HowardMmc class.
-  ///
-  /// Default traits class of HowardMmc class.
-  /// \tparam GR The type of the digraph.
-  /// \tparam CM The type of the cost map.
-  /// It must conform to the \ref concepts::ReadMap "ReadMap" concept.
-#ifdef DOXYGEN
-  template <typename GR, typename CM>
-#else
-  template <typename GR, typename CM,
-    bool integer = std::numeric_limits<typename CM::Value>::is_integer>
-#endif
-  struct HowardMmcDefaultTraits
-  {
-    /// The type of the digraph
-    typedef GR Digraph;
-    /// The type of the cost map
-    typedef CM CostMap;
-    /// The type of the arc costs
-    typedef typename CostMap::Value Cost;
-
-    /// \brief The large cost type used for internal computations
-    ///
-    /// The large cost type used for internal computations.
-    /// It is \c long \c long if the \c Cost type is integer,
-    /// otherwise it is \c double.
-    /// \c Cost must be convertible to \c LargeCost.
-    typedef double LargeCost;
-
-    /// The tolerance type used for internal computations
-    typedef lemon::Tolerance<LargeCost> Tolerance;
-
-    /// \brief The path type of the found cycles
-    ///
-    /// The path type of the found cycles.
-    /// It must conform to the \ref lemon::concepts::Path "Path" concept
-    /// and it must have an \c addBack() function.
-    typedef lemon::Path<Digraph> Path;
-  };
-
-  // Default traits class for integer cost types
-  template <typename GR, typename CM>
-  struct HowardMmcDefaultTraits<GR, CM, true>
-  {
-    typedef GR Digraph;
-    typedef CM CostMap;
-    typedef typename CostMap::Value Cost;
-#ifdef LEMON_HAVE_LONG_LONG
-    typedef long long LargeCost;
-#else
-    typedef long LargeCost;
-#endif
-    typedef lemon::Tolerance<LargeCost> Tolerance;
-    typedef lemon::Path<Digraph> Path;
-  };
-
-
-  /// \addtogroup min_mean_cycle
-  /// @{
-
-  /// \brief Implementation of Howard's algorithm for finding a minimum
-  /// mean cycle.
-  ///
-  /// This class implements Howard's policy iteration algorithm for finding
-  /// a directed cycle of minimum mean cost in a digraph
-  /// \cite dasdan98minmeancycle, \cite dasdan04experimental.
-  /// This class provides the most efficient algorithm for the
-  /// minimum mean cycle problem, though the best known theoretical
-  /// bound on its running time is exponential.
-  ///
-  /// \tparam GR The type of the digraph the algorithm runs on.
-  /// \tparam CM The type of the cost map. The default
-  /// map type is \ref concepts::Digraph::ArcMap "GR::ArcMap<int>".
-  /// \tparam TR The traits class that defines various types used by the
-  /// algorithm. By default, it is \ref HowardMmcDefaultTraits
-  /// "HowardMmcDefaultTraits<GR, CM>".
-  /// In most cases, this parameter should not be set directly,
-  /// consider to use the named template parameters instead.
-#ifdef DOXYGEN
-  template <typename GR, typename CM, typename TR>
-#else
-  template < typename GR,
-             typename CM = typename GR::template ArcMap<int>,
-             typename TR = HowardMmcDefaultTraits<GR, CM> >
-#endif
-  class HowardMmc
-  {
-  public:
-
-    /// The type of the digraph
-    typedef typename TR::Digraph Digraph;
-    /// The type of the cost map
-    typedef typename TR::CostMap CostMap;
-    /// The type of the arc costs
-    typedef typename TR::Cost Cost;
-
-    /// \brief The large cost type
-    ///
-    /// The large cost type used for internal computations.
-    /// By default, it is \c long \c long if the \c Cost type is integer,
-    /// otherwise it is \c double.
-    typedef typename TR::LargeCost LargeCost;
-
-    /// The tolerance type
-    typedef typename TR::Tolerance Tolerance;
-
-    /// \brief The path type of the found cycles
-    ///
-    /// The path type of the found cycles.
-    /// Using the \ref lemon::HowardMmcDefaultTraits "default traits class",
-    /// it is \ref lemon::Path "Path<Digraph>".
-    typedef typename TR::Path Path;
-
-    /// The \ref lemon::HowardMmcDefaultTraits "traits class" of the algorithm
-    typedef TR Traits;
-
-    /// \brief Constants for the causes of search termination.
-    ///
-    /// Enum type containing constants for the different causes of search
-    /// termination. The \ref findCycleMean() function returns one of
-    /// these values.
-    enum TerminationCause {
-
-      /// No directed cycle can be found in the digraph.
-      NO_CYCLE = 0,
-
-      /// Optimal solution (minimum cycle mean) is found.
-      OPTIMAL = 1,
-
-      /// The iteration count limit is reached.
-      ITERATION_LIMIT
-    };
-
-  private:
-
-    TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
-
-    // The digraph the algorithm runs on
-    const Digraph &_gr;
-    // The cost of the arcs
-    const CostMap &_cost;
-
-    // Data for the found cycles
-    bool _curr_found, _best_found;
-    LargeCost _curr_cost, _best_cost;
-    int _curr_size, _best_size;
-    Node _curr_node, _best_node;
-
-    Path *_cycle_path;
-    bool _local_path;
-
-    // Internal data used by the algorithm
-    typename Digraph::template NodeMap<Arc> _policy;
-    typename Digraph::template NodeMap<bool> _reached;
-    typename Digraph::template NodeMap<int> _level;
-    typename Digraph::template NodeMap<LargeCost> _dist;
-
-    // Data for storing the strongly connected components
-    int _comp_num;
-    typename Digraph::template NodeMap<int> _comp;
-    std::vector<std::vector<Node> > _comp_nodes;
-    std::vector<Node>* _nodes;
-    typename Digraph::template NodeMap<std::vector<Arc> > _in_arcs;
-
-    // Queue used for BFS search
-    std::vector<Node> _queue;
-    int _qfront, _qback;
-
-    Tolerance _tolerance;
-
-    // Infinite constant
-    const LargeCost INF;
-
-  public:
-
-    /// \name Named Template Parameters
-    /// @{
-
-    template <typename T>
-    struct SetLargeCostTraits : public Traits {
-      typedef T LargeCost;
-      typedef lemon::Tolerance<T> Tolerance;
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// \c LargeCost type.
-    ///
-    /// \ref named-templ-param "Named parameter" for setting \c LargeCost
-    /// type. It is used for internal computations in the algorithm.
-    template <typename T>
-    struct SetLargeCost
-      : public HowardMmc<GR, CM, SetLargeCostTraits<T> > {
-      typedef HowardMmc<GR, CM, SetLargeCostTraits<T> > Create;
-    };
-
-    template <typename T>
-    struct SetPathTraits : public Traits {
-      typedef T Path;
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// \c %Path type.
-    ///
-    /// \ref named-templ-param "Named parameter" for setting the \c %Path
-    /// type of the found cycles.
-    /// It must conform to the \ref lemon::concepts::Path "Path" concept
-    /// and it must have an \c addBack() function.
-    template <typename T>
-    struct SetPath
-      : public HowardMmc<GR, CM, SetPathTraits<T> > {
-      typedef HowardMmc<GR, CM, SetPathTraits<T> > Create;
-    };
-
-    /// @}
-
-  protected:
-
-    HowardMmc() {}
-
-  public:
-
-    /// \brief Constructor.
-    ///
-    /// The constructor of the class.
-    ///
-    /// \param digraph The digraph the algorithm runs on.
-    /// \param cost The costs of the arcs.
-    HowardMmc( const Digraph &digraph,
-               const CostMap &cost ) :
-      _gr(digraph), _cost(cost), _best_found(false),
-      _best_cost(0), _best_size(1), _cycle_path(NULL), _local_path(false),
-      _policy(digraph), _reached(digraph), _level(digraph), _dist(digraph),
-      _comp(digraph), _in_arcs(digraph),
-      INF(std::numeric_limits<LargeCost>::has_infinity ?
-          std::numeric_limits<LargeCost>::infinity() :
-          std::numeric_limits<LargeCost>::max())
-    {}
-
-    /// Destructor.
-    ~HowardMmc() {
-      if (_local_path) delete _cycle_path;
-    }
-
-    /// \brief Set the path structure for storing the found cycle.
-    ///
-    /// This function sets an external path structure for storing the
-    /// found cycle.
-    ///
-    /// If you don't call this function before calling \ref run() or
-    /// \ref findCycleMean(), a local \ref Path "path" structure
-    /// will be allocated. The destuctor deallocates this automatically
-    /// allocated object, of course.
-    ///
-    /// \note The algorithm calls only the \ref lemon::Path::addBack()
-    /// "addBack()" function of the given path structure.
-    ///
-    /// \return <tt>(*this)</tt>
-    HowardMmc& cycle(Path &path) {
-      if (_local_path) {
-        delete _cycle_path;
-        _local_path = false;
-      }
-      _cycle_path = &path;
-      return *this;
-    }
-
-    /// \brief Set the tolerance used by the algorithm.
-    ///
-    /// This function sets the tolerance object used by the algorithm.
-    ///
-    /// \return <tt>(*this)</tt>
-    HowardMmc& tolerance(const Tolerance& tolerance) {
-      _tolerance = tolerance;
-      return *this;
-    }
-
-    /// \brief Return a const reference to the tolerance.
-    ///
-    /// This function returns a const reference to the tolerance object
-    /// used by the algorithm.
-    const Tolerance& tolerance() const {
-      return _tolerance;
-    }
-
-    /// \name Execution control
-    /// The simplest way to execute the algorithm is to call the \ref run()
-    /// function.\n
-    /// If you only need the minimum mean cost, you may call
-    /// \ref findCycleMean().
-
-    /// @{
-
-    /// \brief Run the algorithm.
-    ///
-    /// This function runs the algorithm.
-    /// It can be called more than once (e.g. if the underlying digraph
-    /// and/or the arc costs have been modified).
-    ///
-    /// \return \c true if a directed cycle exists in the digraph.
-    ///
-    /// \note <tt>mmc.run()</tt> is just a shortcut of the following code.
-    /// \code
-    ///   return mmc.findCycleMean() && mmc.findCycle();
-    /// \endcode
-    bool run() {
-      return findCycleMean() && findCycle();
-    }
-
-    /// \brief Find the minimum cycle mean (or an upper bound).
-    ///
-    /// This function finds the minimum mean cost of the directed
-    /// cycles in the digraph (or an upper bound for it).
-    ///
-    /// By default, the function finds the exact minimum cycle mean,
-    /// but an optional limit can also be specified for the number of
-    /// iterations performed during the search process.
-    /// The return value indicates if the optimal solution is found
-    /// or the iteration limit is reached. In the latter case, an
-    /// approximate solution is provided, which corresponds to a directed
-    /// cycle whose mean cost is relatively small, but not necessarily
-    /// minimal.
-    ///
-    /// \param limit  The maximum allowed number of iterations during
-    /// the search process. Its default value implies that the algorithm
-    /// runs until it finds the exact optimal solution.
-    ///
-    /// \return The termination cause of the search process.
-    /// For more information, see \ref TerminationCause.
-    TerminationCause findCycleMean(int limit =
-                                   std::numeric_limits<int>::max()) {
-      // Initialize and find strongly connected components
-      init();
-      findComponents();
-
-      // Find the minimum cycle mean in the components
-      int iter_count = 0;
-      bool iter_limit_reached = false;
-      for (int comp = 0; comp < _comp_num; ++comp) {
-        // Find the minimum mean cycle in the current component
-        if (!buildPolicyGraph(comp)) continue;
-        while (true) {
-          if (++iter_count > limit) {
-            iter_limit_reached = true;
-            break;
-          }
-          findPolicyCycle();
-          if (!computeNodeDistances()) break;
-        }
-
-        // Update the best cycle (global minimum mean cycle)
-        if ( _curr_found && (!_best_found ||
-             _curr_cost * _best_size < _best_cost * _curr_size) ) {
-          _best_found = true;
-          _best_cost = _curr_cost;
-          _best_size = _curr_size;
-          _best_node = _curr_node;
-        }
-
-        if (iter_limit_reached) break;
-      }
-
-      if (iter_limit_reached) {
-        return ITERATION_LIMIT;
-      } else {
-        return _best_found ? OPTIMAL : NO_CYCLE;
-      }
-    }
-
-    /// \brief Find a minimum mean directed cycle.
-    ///
-    /// This function finds a directed cycle of minimum mean cost
-    /// in the digraph using the data computed by findCycleMean().
-    ///
-    /// \return \c true if a directed cycle exists in the digraph.
-    ///
-    /// \pre \ref findCycleMean() must be called before using this function.
-    bool findCycle() {
-      if (!_best_found) return false;
-      _cycle_path->addBack(_policy[_best_node]);
-      for ( Node v = _best_node;
-            (v = _gr.target(_policy[v])) != _best_node; ) {
-        _cycle_path->addBack(_policy[v]);
-      }
-      return true;
-    }
-
-    /// @}
-
-    /// \name Query Functions
-    /// The results of the algorithm can be obtained using these
-    /// functions.\n
-    /// The algorithm should be executed before using them.
-
-    /// @{
-
-    /// \brief Return the total cost of the found cycle.
-    ///
-    /// This function returns the total cost of the found cycle.
-    ///
-    /// \pre \ref run() or \ref findCycleMean() must be called before
-    /// using this function.
-    Cost cycleCost() const {
-      return static_cast<Cost>(_best_cost);
-    }
-
-    /// \brief Return the number of arcs on the found cycle.
-    ///
-    /// This function returns the number of arcs on the found cycle.
-    ///
-    /// \pre \ref run() or \ref findCycleMean() must be called before
-    /// using this function.
-    int cycleSize() const {
-      return _best_size;
-    }
-
-    /// \brief Return the mean cost of the found cycle.
-    ///
-    /// This function returns the mean cost of the found cycle.
-    ///
-    /// \note <tt>alg.cycleMean()</tt> is just a shortcut of the
-    /// following code.
-    /// \code
-    ///   return static_cast<double>(alg.cycleCost()) / alg.cycleSize();
-    /// \endcode
-    ///
-    /// \pre \ref run() or \ref findCycleMean() must be called before
-    /// using this function.
-    double cycleMean() const {
-      return static_cast<double>(_best_cost) / _best_size;
-    }
-
-    /// \brief Return the found cycle.
-    ///
-    /// This function returns a const reference to the path structure
-    /// storing the found cycle.
-    ///
-    /// \pre \ref run() or \ref findCycle() must be called before using
-    /// this function.
-    const Path& cycle() const {
-      return *_cycle_path;
-    }
-
-    ///@}
-
-  private:
-
-    // Initialize
-    void init() {
-      if (!_cycle_path) {
-        _local_path = true;
-        _cycle_path = new Path;
-      }
-      _queue.resize(countNodes(_gr));
-      _best_found = false;
-      _best_cost = 0;
-      _best_size = 1;
-      _cycle_path->clear();
-    }
-
-    // Find strongly connected components and initialize _comp_nodes
-    // and _in_arcs
-    void findComponents() {
-      _comp_num = stronglyConnectedComponents(_gr, _comp);
-      _comp_nodes.resize(_comp_num);
-      if (_comp_num == 1) {
-        _comp_nodes[0].clear();
-        for (NodeIt n(_gr); n != INVALID; ++n) {
-          _comp_nodes[0].push_back(n);
-          _in_arcs[n].clear();
-          for (InArcIt a(_gr, n); a != INVALID; ++a) {
-            _in_arcs[n].push_back(a);
-          }
-        }
-      } else {
-        for (int i = 0; i < _comp_num; ++i)
-          _comp_nodes[i].clear();
-        for (NodeIt n(_gr); n != INVALID; ++n) {
-          int k = _comp[n];
-          _comp_nodes[k].push_back(n);
-          _in_arcs[n].clear();
-          for (InArcIt a(_gr, n); a != INVALID; ++a) {
-            if (_comp[_gr.source(a)] == k) _in_arcs[n].push_back(a);
-          }
-        }
-      }
-    }
-
-    // Build the policy graph in the given strongly connected component
-    // (the out-degree of every node is 1)
-    bool buildPolicyGraph(int comp) {
-      _nodes = &(_comp_nodes[comp]);
-      if (_nodes->size() < 1 ||
-          (_nodes->size() == 1 && _in_arcs[(*_nodes)[0]].size() == 0)) {
-        return false;
-      }
-      for (int i = 0; i < int(_nodes->size()); ++i) {
-        _dist[(*_nodes)[i]] = INF;
-      }
-      Node u, v;
-      Arc e;
-      for (int i = 0; i < int(_nodes->size()); ++i) {
-        v = (*_nodes)[i];
-        for (int j = 0; j < int(_in_arcs[v].size()); ++j) {
-          e = _in_arcs[v][j];
-          u = _gr.source(e);
-          if (_cost[e] < _dist[u]) {
-            _dist[u] = _cost[e];
-            _policy[u] = e;
-          }
-        }
-      }
-      return true;
-    }
-
-    // Find the minimum mean cycle in the policy graph
-    void findPolicyCycle() {
-      for (int i = 0; i < int(_nodes->size()); ++i) {
-        _level[(*_nodes)[i]] = -1;
-      }
-      LargeCost ccost;
-      int csize;
-      Node u, v;
-      _curr_found = false;
-      for (int i = 0; i < int(_nodes->size()); ++i) {
-        u = (*_nodes)[i];
-        if (_level[u] >= 0) continue;
-        for (; _level[u] < 0; u = _gr.target(_policy[u])) {
-          _level[u] = i;
-        }
-        if (_level[u] == i) {
-          // A cycle is found
-          ccost = _cost[_policy[u]];
-          csize = 1;
-          for (v = u; (v = _gr.target(_policy[v])) != u; ) {
-            ccost += _cost[_policy[v]];
-            ++csize;
-          }
-          if ( !_curr_found ||
-               (ccost * _curr_size < _curr_cost * csize) ) {
-            _curr_found = true;
-            _curr_cost = ccost;
-            _curr_size = csize;
-            _curr_node = u;
-          }
-        }
-      }
-    }
-
-    // Contract the policy graph and compute node distances
-    bool computeNodeDistances() {
-      // Find the component of the main cycle and compute node distances
-      // using reverse BFS
-      for (int i = 0; i < int(_nodes->size()); ++i) {
-        _reached[(*_nodes)[i]] = false;
-      }
-      _qfront = _qback = 0;
-      _queue[0] = _curr_node;
-      _reached[_curr_node] = true;
-      _dist[_curr_node] = 0;
-      Node u, v;
-      Arc e;
-      while (_qfront <= _qback) {
-        v = _queue[_qfront++];
-        for (int j = 0; j < int(_in_arcs[v].size()); ++j) {
-          e = _in_arcs[v][j];
-          u = _gr.source(e);
-          if (_policy[u] == e && !_reached[u]) {
-            _reached[u] = true;
-            _dist[u] = _dist[v] + _cost[e] * _curr_size - _curr_cost;
-            _queue[++_qback] = u;
-          }
-        }
-      }
-
-      // Connect all other nodes to this component and compute node
-      // distances using reverse BFS
-      _qfront = 0;
-      while (_qback < int(_nodes->size())-1) {
-        v = _queue[_qfront++];
-        for (int j = 0; j < int(_in_arcs[v].size()); ++j) {
-          e = _in_arcs[v][j];
-          u = _gr.source(e);
-          if (!_reached[u]) {
-            _reached[u] = true;
-            _policy[u] = e;
-            _dist[u] = _dist[v] + _cost[e] * _curr_size - _curr_cost;
-            _queue[++_qback] = u;
-          }
-        }
-      }
-
-      // Improve node distances
-      bool improved = false;
-      for (int i = 0; i < int(_nodes->size()); ++i) {
-        v = (*_nodes)[i];
-        for (int j = 0; j < int(_in_arcs[v].size()); ++j) {
-          e = _in_arcs[v][j];
-          u = _gr.source(e);
-          LargeCost delta = _dist[v] + _cost[e] * _curr_size - _curr_cost;
-          if (_tolerance.less(delta, _dist[u])) {
-            _dist[u] = delta;
-            _policy[u] = e;
-            improved = true;
-          }
-        }
-      }
-      return improved;
-    }
-
-  }; //class HowardMmc
-
-  ///@}
-
-} //namespace lemon
-
-#endif //LEMON_HOWARD_MMC_H
Index: mon/insertion_tsp.h
===================================================================
--- lemon/insertion_tsp.h	(revision 1270)
+++ 	(revision )
@@ -1,533 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2013
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * 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_INSERTION_TSP_H
-#define LEMON_INSERTION_TSP_H
-
-/// \ingroup tsp
-/// \file
-/// \brief Insertion algorithm for symmetric TSP
-
-#include <vector>
-#include <functional>
-#include <lemon/full_graph.h>
-#include <lemon/maps.h>
-#include <lemon/random.h>
-
-namespace lemon {
-
-  /// \ingroup tsp
-  ///
-  /// \brief Insertion algorithm for symmetric TSP.
-  ///
-  /// InsertionTsp implements the insertion heuristic for solving
-  /// symmetric \ref tsp "TSP".
-  ///
-  /// This is a fast and effective tour construction method that has
-  /// many variants.
-  /// It starts with a subtour containing a few nodes of the graph and it
-  /// iteratively inserts the other nodes into this subtour according to a
-  /// certain node selection rule.
-  ///
-  /// This method is among the fastest TSP algorithms, and it typically
-  /// provides quite good solutions (usually much better than
-  /// \ref NearestNeighborTsp and \ref GreedyTsp).
-  ///
-  /// InsertionTsp implements four different node selection rules,
-  /// from which the most effective one (\e farthest \e node \e selection)
-  /// is used by default.
-  /// With this choice, the algorithm runs in O(n<sup>2</sup>) time.
-  /// For more information, see \ref SelectionRule.
-  ///
-  /// \tparam CM Type of the cost map.
-  template <typename CM>
-  class InsertionTsp
-  {
-    public:
-
-      /// Type of the cost map
-      typedef CM CostMap;
-      /// Type of the edge costs
-      typedef typename CM::Value Cost;
-
-    private:
-
-      GRAPH_TYPEDEFS(FullGraph);
-
-      const FullGraph &_gr;
-      const CostMap &_cost;
-      std::vector<Node> _notused;
-      std::vector<Node> _tour;
-      Cost _sum;
-
-    public:
-
-      /// \brief Constants for specifying the node selection rule.
-      ///
-      /// Enum type containing constants for specifying the node selection
-      /// rule for the \ref run() function.
-      ///
-      /// During the algorithm, nodes are selected for addition to the current
-      /// subtour according to the applied rule.
-      /// The FARTHEST method is one of the fastest selection rules, and
-      /// it is typically the most effective, thus it is the default
-      /// option. The RANDOM rule usually gives slightly worse results,
-      /// but it is more robust.
-      ///
-      /// The desired selection rule can be specified as a parameter of the
-      /// \ref run() function.
-      enum SelectionRule {
-
-        /// An unvisited node having minimum distance from the current
-        /// subtour is selected at each step.
-        /// The algorithm runs in O(n<sup>2</sup>) time using this
-        /// selection rule.
-        NEAREST,
-
-        /// An unvisited node having maximum distance from the current
-        /// subtour is selected at each step.
-        /// The algorithm runs in O(n<sup>2</sup>) time using this
-        /// selection rule.
-        FARTHEST,
-
-        /// An unvisited node whose insertion results in the least
-        /// increase of the subtour's total cost is selected at each step.
-        /// The algorithm runs in O(n<sup>3</sup>) time using this
-        /// selection rule, but in most cases, it is almost as fast as
-        /// with other rules.
-        CHEAPEST,
-
-        /// An unvisited node is selected randomly without any evaluation
-        /// at each step.
-        /// The global \ref rnd "random number generator instance" is used.
-        /// You can seed it before executing the algorithm, if you
-        /// would like to.
-        /// The algorithm runs in O(n<sup>2</sup>) time using this
-        /// selection rule.
-        RANDOM
-      };
-
-    public:
-
-      /// \brief Constructor
-      ///
-      /// Constructor.
-      /// \param gr The \ref FullGraph "full graph" the algorithm runs on.
-      /// \param cost The cost map.
-      InsertionTsp(const FullGraph &gr, const CostMap &cost)
-        : _gr(gr), _cost(cost) {}
-
-      /// \name Execution Control
-      /// @{
-
-      /// \brief Runs the algorithm.
-      ///
-      /// This function runs the algorithm.
-      ///
-      /// \param rule The node selection rule. For more information, see
-      /// \ref SelectionRule.
-      ///
-      /// \return The total cost of the found tour.
-      Cost run(SelectionRule rule = FARTHEST) {
-        _tour.clear();
-
-        if (_gr.nodeNum() == 0) return _sum = 0;
-        else if (_gr.nodeNum() == 1) {
-          _tour.push_back(_gr(0));
-          return _sum = 0;
-        }
-
-        switch (rule) {
-          case NEAREST:
-            init(true);
-            start<ComparingSelection<std::less<Cost> >,
-                  DefaultInsertion>();
-            break;
-          case FARTHEST:
-            init(false);
-            start<ComparingSelection<std::greater<Cost> >,
-                  DefaultInsertion>();
-            break;
-          case CHEAPEST:
-            init(true);
-            start<CheapestSelection, CheapestInsertion>();
-            break;
-          case RANDOM:
-            init(true);
-            start<RandomSelection, DefaultInsertion>();
-            break;
-        }
-        return _sum;
-      }
-
-      /// @}
-
-      /// \name Query Functions
-      /// @{
-
-      /// \brief The total cost of the found tour.
-      ///
-      /// This function returns the total cost of the found tour.
-      ///
-      /// \pre run() must be called before using this function.
-      Cost tourCost() const {
-        return _sum;
-      }
-
-      /// \brief Returns a const reference to the node sequence of the
-      /// found tour.
-      ///
-      /// This function returns a const reference to a vector
-      /// that stores the node sequence of the found tour.
-      ///
-      /// \pre run() must be called before using this function.
-      const std::vector<Node>& tourNodes() const {
-        return _tour;
-      }
-
-      /// \brief Gives back the node sequence of the found tour.
-      ///
-      /// This function copies the node sequence of the found tour into
-      /// an STL container through the given output iterator. The
-      /// <tt>value_type</tt> of the container must be <tt>FullGraph::Node</tt>.
-      /// For example,
-      /// \code
-      /// std::vector<FullGraph::Node> nodes(countNodes(graph));
-      /// tsp.tourNodes(nodes.begin());
-      /// \endcode
-      /// or
-      /// \code
-      /// std::list<FullGraph::Node> nodes;
-      /// tsp.tourNodes(std::back_inserter(nodes));
-      /// \endcode
-      ///
-      /// \pre run() must be called before using this function.
-      template <typename Iterator>
-      void tourNodes(Iterator out) const {
-        std::copy(_tour.begin(), _tour.end(), out);
-      }
-
-      /// \brief Gives back the found tour as a path.
-      ///
-      /// This function copies the found tour as a list of arcs/edges into
-      /// the given \ref lemon::concepts::Path "path structure".
-      ///
-      /// \pre run() must be called before using this function.
-      template <typename Path>
-      void tour(Path &path) const {
-        path.clear();
-        for (int i = 0; i < int(_tour.size()) - 1; ++i) {
-          path.addBack(_gr.arc(_tour[i], _tour[i+1]));
-        }
-        if (int(_tour.size()) >= 2) {
-          path.addBack(_gr.arc(_tour.back(), _tour.front()));
-        }
-      }
-
-      /// @}
-
-    private:
-
-      // Initializes the algorithm
-      void init(bool min) {
-        Edge min_edge = min ? mapMin(_gr, _cost) : mapMax(_gr, _cost);
-
-        _tour.clear();
-        _tour.push_back(_gr.u(min_edge));
-        _tour.push_back(_gr.v(min_edge));
-
-        _notused.clear();
-        for (NodeIt n(_gr); n!=INVALID; ++n) {
-          if (n != _gr.u(min_edge) && n != _gr.v(min_edge)) {
-            _notused.push_back(n);
-          }
-        }
-
-        _sum = _cost[min_edge] * 2;
-      }
-
-      // Executes the algorithm
-      template <class SelectionFunctor, class InsertionFunctor>
-      void start() {
-        SelectionFunctor selectNode(_gr, _cost, _tour, _notused);
-        InsertionFunctor insertNode(_gr, _cost, _tour, _sum);
-
-        for (int i=0; i<_gr.nodeNum()-2; ++i) {
-          insertNode.insert(selectNode.select());
-        }
-
-        _sum = _cost[_gr.edge(_tour.back(), _tour.front())];
-        for (int i = 0; i < int(_tour.size())-1; ++i) {
-          _sum += _cost[_gr.edge(_tour[i], _tour[i+1])];
-        }
-      }
-
-
-      // Implementation of the nearest and farthest selection rule
-      template <typename Comparator>
-      class ComparingSelection {
-        public:
-          ComparingSelection(const FullGraph &gr, const CostMap &cost,
-                  std::vector<Node> &tour, std::vector<Node> &notused)
-            : _gr(gr), _cost(cost), _tour(tour), _notused(notused),
-              _dist(gr, 0), _compare()
-          {
-            // Compute initial distances for the unused nodes
-            for (unsigned int i=0; i<_notused.size(); ++i) {
-              Node u = _notused[i];
-              Cost min_dist = _cost[_gr.edge(u, _tour[0])];
-              for (unsigned int j=1; j<_tour.size(); ++j) {
-                Cost curr = _cost[_gr.edge(u, _tour[j])];
-                if (curr < min_dist) {
-                  min_dist = curr;
-                }
-              }
-              _dist[u] = min_dist;
-            }
-          }
-
-          Node select() {
-
-            // Select an used node with minimum distance
-            Cost ins_dist = 0;
-            int ins_node = -1;
-            for (unsigned int i=0; i<_notused.size(); ++i) {
-              Cost curr = _dist[_notused[i]];
-              if (_compare(curr, ins_dist) || ins_node == -1) {
-                ins_dist = curr;
-                ins_node = i;
-              }
-            }
-
-            // Remove the selected node from the unused vector
-            Node sn = _notused[ins_node];
-            _notused[ins_node] = _notused.back();
-            _notused.pop_back();
-
-            // Update the distances of the remaining nodes
-            for (unsigned int i=0; i<_notused.size(); ++i) {
-              Node u = _notused[i];
-              Cost nc = _cost[_gr.edge(sn, u)];
-              if (nc < _dist[u]) {
-                _dist[u] = nc;
-              }
-            }
-
-            return sn;
-          }
-
-        private:
-          const FullGraph &_gr;
-          const CostMap &_cost;
-          std::vector<Node> &_tour;
-          std::vector<Node> &_notused;
-          FullGraph::NodeMap<Cost> _dist;
-          Comparator _compare;
-      };
-
-      // Implementation of the cheapest selection rule
-      class CheapestSelection {
-        private:
-          Cost costDiff(Node u, Node v, Node w) const {
-            return
-              _cost[_gr.edge(u, w)] +
-              _cost[_gr.edge(v, w)] -
-              _cost[_gr.edge(u, v)];
-          }
-
-        public:
-          CheapestSelection(const FullGraph &gr, const CostMap &cost,
-                            std::vector<Node> &tour, std::vector<Node> &notused)
-            : _gr(gr), _cost(cost), _tour(tour), _notused(notused),
-              _ins_cost(gr, 0), _ins_pos(gr, -1)
-          {
-            // Compute insertion cost and position for the unused nodes
-            for (unsigned int i=0; i<_notused.size(); ++i) {
-              Node u = _notused[i];
-              Cost min_cost = costDiff(_tour.back(), _tour.front(), u);
-              int min_pos = 0;
-              for (unsigned int j=1; j<_tour.size(); ++j) {
-                Cost curr_cost = costDiff(_tour[j-1], _tour[j], u);
-                if (curr_cost < min_cost) {
-                  min_cost = curr_cost;
-                  min_pos = j;
-                }
-              }
-              _ins_cost[u] = min_cost;
-              _ins_pos[u] = min_pos;
-            }
-          }
-
-          Cost select() {
-
-            // Select an used node with minimum insertion cost
-            Cost min_cost = 0;
-            int min_node = -1;
-            for (unsigned int i=0; i<_notused.size(); ++i) {
-              Cost curr_cost = _ins_cost[_notused[i]];
-              if (curr_cost < min_cost || min_node == -1) {
-                min_cost = curr_cost;
-                min_node = i;
-              }
-            }
-
-            // Remove the selected node from the unused vector
-            Node sn = _notused[min_node];
-            _notused[min_node] = _notused.back();
-            _notused.pop_back();
-
-            // Insert the selected node into the tour
-            const int ipos = _ins_pos[sn];
-            _tour.insert(_tour.begin() + ipos, sn);
-
-            // Update the insertion cost and position of the remaining nodes
-            for (unsigned int i=0; i<_notused.size(); ++i) {
-              Node u = _notused[i];
-              Cost curr_cost = _ins_cost[u];
-              int curr_pos = _ins_pos[u];
-
-              int ipos_prev = ipos == 0 ? _tour.size()-1 : ipos-1;
-              int ipos_next = ipos == int(_tour.size())-1 ? 0 : ipos+1;
-              Cost nc1 = costDiff(_tour[ipos_prev], _tour[ipos], u);
-              Cost nc2 = costDiff(_tour[ipos], _tour[ipos_next], u);
-
-              if (nc1 <= curr_cost || nc2 <= curr_cost) {
-                // A new position is better than the old one
-                if (nc1 <= nc2) {
-                  curr_cost = nc1;
-                  curr_pos = ipos;
-                } else {
-                  curr_cost = nc2;
-                  curr_pos = ipos_next;
-                }
-              }
-              else {
-                if (curr_pos == ipos) {
-                  // The minimum should be found again
-                  curr_cost = costDiff(_tour.back(), _tour.front(), u);
-                  curr_pos = 0;
-                  for (unsigned int j=1; j<_tour.size(); ++j) {
-                    Cost tmp_cost = costDiff(_tour[j-1], _tour[j], u);
-                    if (tmp_cost < curr_cost) {
-                      curr_cost = tmp_cost;
-                      curr_pos = j;
-                    }
-                  }
-                }
-                else if (curr_pos > ipos) {
-                  ++curr_pos;
-                }
-              }
-
-              _ins_cost[u] = curr_cost;
-              _ins_pos[u] = curr_pos;
-            }
-
-            return min_cost;
-          }
-
-        private:
-          const FullGraph &_gr;
-          const CostMap &_cost;
-          std::vector<Node> &_tour;
-          std::vector<Node> &_notused;
-          FullGraph::NodeMap<Cost> _ins_cost;
-          FullGraph::NodeMap<int> _ins_pos;
-      };
-
-      // Implementation of the random selection rule
-      class RandomSelection {
-        public:
-          RandomSelection(const FullGraph &, const CostMap &,
-                          std::vector<Node> &, std::vector<Node> &notused)
-            : _notused(notused) {}
-
-          Node select() const {
-            const int index = rnd[_notused.size()];
-            Node n = _notused[index];
-            _notused[index] = _notused.back();
-            _notused.pop_back();
-            return n;
-          }
-
-        private:
-          std::vector<Node> &_notused;
-      };
-
-
-      // Implementation of the default insertion method
-      class DefaultInsertion {
-        private:
-          Cost costDiff(Node u, Node v, Node w) const {
-            return
-              _cost[_gr.edge(u, w)] +
-              _cost[_gr.edge(v, w)] -
-              _cost[_gr.edge(u, v)];
-          }
-
-        public:
-          DefaultInsertion(const FullGraph &gr, const CostMap &cost,
-                           std::vector<Node> &tour, Cost &total_cost) :
-            _gr(gr), _cost(cost), _tour(tour), _total(total_cost) {}
-
-          void insert(Node n) const {
-            int min = 0;
-            Cost min_val =
-              costDiff(_tour.front(), _tour.back(), n);
-
-            for (unsigned int i=1; i<_tour.size(); ++i) {
-              Cost tmp = costDiff(_tour[i-1], _tour[i], n);
-              if (tmp < min_val) {
-                min = i;
-                min_val = tmp;
-              }
-            }
-
-            _tour.insert(_tour.begin()+min, n);
-            _total += min_val;
-          }
-
-        private:
-          const FullGraph &_gr;
-          const CostMap &_cost;
-          std::vector<Node> &_tour;
-          Cost &_total;
-      };
-
-      // Implementation of a special insertion method for the cheapest
-      // selection rule
-      class CheapestInsertion {
-        TEMPLATE_GRAPH_TYPEDEFS(FullGraph);
-        public:
-          CheapestInsertion(const FullGraph &, const CostMap &,
-                            std::vector<Node> &, Cost &total_cost) :
-            _total(total_cost) {}
-
-          void insert(Cost diff) const {
-            _total += diff;
-          }
-
-        private:
-          Cost &_total;
-      };
-
-  };
-
-}; // namespace lemon
-
-#endif
Index: lemon/karp.h
===================================================================
--- lemon/karp.h	(revision 819)
+++ lemon/karp.h	(revision 819)
@@ -0,0 +1,582 @@
+/* -*- C++ -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library
+ *
+ * Copyright (C) 2003-2008
+ * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
+ * (Egervary Research Group on Combinatorial Optimization, EGRES).
+ *
+ * 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_KARP_H
+#define LEMON_KARP_H
+
+/// \ingroup min_mean_cycle
+///
+/// \file
+/// \brief Karp's algorithm for finding a minimum mean cycle.
+
+#include <vector>
+#include <limits>
+#include <lemon/core.h>
+#include <lemon/path.h>
+#include <lemon/tolerance.h>
+#include <lemon/connectivity.h>
+
+namespace lemon {
+
+  /// \brief Default traits class of Karp algorithm.
+  ///
+  /// Default traits class of Karp algorithm.
+  /// \tparam GR The type of the digraph.
+  /// \tparam LEN The type of the length map.
+  /// It must conform to the \ref concepts::ReadMap "ReadMap" concept.
+#ifdef DOXYGEN
+  template <typename GR, typename LEN>
+#else
+  template <typename GR, typename LEN,
+    bool integer = std::numeric_limits<typename LEN::Value>::is_integer>
+#endif
+  struct KarpDefaultTraits
+  {
+    /// The type of the digraph
+    typedef GR Digraph;
+    /// The type of the length map
+    typedef LEN LengthMap;
+    /// The type of the arc lengths
+    typedef typename LengthMap::Value Value;
+
+    /// \brief The large value type used for internal computations
+    ///
+    /// The large value type used for internal computations.
+    /// It is \c long \c long if the \c Value type is integer,
+    /// otherwise it is \c double.
+    /// \c Value must be convertible to \c LargeValue.
+    typedef double LargeValue;
+
+    /// The tolerance type used for internal computations
+    typedef lemon::Tolerance<LargeValue> Tolerance;
+
+    /// \brief The path type of the found cycles
+    ///
+    /// The path type of the found cycles.
+    /// It must conform to the \ref lemon::concepts::Path "Path" concept
+    /// and it must have an \c addFront() function.
+    typedef lemon::Path<Digraph> Path;
+  };
+
+  // Default traits class for integer value types
+  template <typename GR, typename LEN>
+  struct KarpDefaultTraits<GR, LEN, true>
+  {
+    typedef GR Digraph;
+    typedef LEN LengthMap;
+    typedef typename LengthMap::Value Value;
+#ifdef LEMON_HAVE_LONG_LONG
+    typedef long long LargeValue;
+#else
+    typedef long LargeValue;
+#endif
+    typedef lemon::Tolerance<LargeValue> Tolerance;
+    typedef lemon::Path<Digraph> Path;
+  };
+
+
+  /// \addtogroup min_mean_cycle
+  /// @{
+
+  /// \brief Implementation of Karp's algorithm for finding a minimum
+  /// mean cycle.
+  ///
+  /// This class implements Karp's algorithm for finding a directed
+  /// cycle of minimum mean length (cost) in a digraph
+  /// \ref amo93networkflows, \ref dasdan98minmeancycle.
+  /// It runs in time O(ne) and uses space O(n<sup>2</sup>+e).
+  ///
+  /// \tparam GR The type of the digraph the algorithm runs on.
+  /// \tparam LEN The type of the length map. The default
+  /// map type is \ref concepts::Digraph::ArcMap "GR::ArcMap<int>".
+#ifdef DOXYGEN
+  template <typename GR, typename LEN, typename TR>
+#else
+  template < typename GR,
+             typename LEN = typename GR::template ArcMap<int>,
+             typename TR = KarpDefaultTraits<GR, LEN> >
+#endif
+  class Karp
+  {
+  public:
+
+    /// The type of the digraph
+    typedef typename TR::Digraph Digraph;
+    /// The type of the length map
+    typedef typename TR::LengthMap LengthMap;
+    /// The type of the arc lengths
+    typedef typename TR::Value Value;
+
+    /// \brief The large value type
+    ///
+    /// The large value type used for internal computations.
+    /// Using the \ref KarpDefaultTraits "default traits class",
+    /// it is \c long \c long if the \c Value type is integer,
+    /// otherwise it is \c double.
+    typedef typename TR::LargeValue LargeValue;
+
+    /// The tolerance type
+    typedef typename TR::Tolerance Tolerance;
+
+    /// \brief The path type of the found cycles
+    ///
+    /// The path type of the found cycles.
+    /// Using the \ref KarpDefaultTraits "default traits class",
+    /// it is \ref lemon::Path "Path<Digraph>".
+    typedef typename TR::Path Path;
+
+    /// The \ref KarpDefaultTraits "traits class" of the algorithm
+    typedef TR Traits;
+
+  private:
+
+    TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
+
+    // Data sturcture for path data
+    struct PathData
+    {
+      LargeValue dist;
+      Arc pred;
+      PathData(LargeValue d, Arc p = INVALID) :
+        dist(d), pred(p) {}
+    };
+
+    typedef typename Digraph::template NodeMap<std::vector<PathData> >
+      PathDataNodeMap;
+
+  private:
+
+    // The digraph the algorithm runs on
+    const Digraph &_gr;
+    // The length of the arcs
+    const LengthMap &_length;
+
+    // Data for storing the strongly connected components
+    int _comp_num;
+    typename Digraph::template NodeMap<int> _comp;
+    std::vector<std::vector<Node> > _comp_nodes;
+    std::vector<Node>* _nodes;
+    typename Digraph::template NodeMap<std::vector<Arc> > _out_arcs;
+
+    // Data for the found cycle
+    LargeValue _cycle_length;
+    int _cycle_size;
+    Node _cycle_node;
+
+    Path *_cycle_path;
+    bool _local_path;
+
+    // Node map for storing path data
+    PathDataNodeMap _data;
+    // The processed nodes in the last round
+    std::vector<Node> _process;
+
+    Tolerance _tolerance;
+    
+    // Infinite constant
+    const LargeValue INF;
+
+  public:
+
+    /// \name Named Template Parameters
+    /// @{
+
+    template <typename T>
+    struct SetLargeValueTraits : public Traits {
+      typedef T LargeValue;
+      typedef lemon::Tolerance<T> Tolerance;
+    };
+
+    /// \brief \ref named-templ-param "Named parameter" for setting
+    /// \c LargeValue type.
+    ///
+    /// \ref named-templ-param "Named parameter" for setting \c LargeValue
+    /// type. It is used for internal computations in the algorithm.
+    template <typename T>
+    struct SetLargeValue
+      : public Karp<GR, LEN, SetLargeValueTraits<T> > {
+      typedef Karp<GR, LEN, SetLargeValueTraits<T> > Create;
+    };
+
+    template <typename T>
+    struct SetPathTraits : public Traits {
+      typedef T Path;
+    };
+
+    /// \brief \ref named-templ-param "Named parameter" for setting
+    /// \c %Path type.
+    ///
+    /// \ref named-templ-param "Named parameter" for setting the \c %Path
+    /// type of the found cycles.
+    /// It must conform to the \ref lemon::concepts::Path "Path" concept
+    /// and it must have an \c addFront() function.
+    template <typename T>
+    struct SetPath
+      : public Karp<GR, LEN, SetPathTraits<T> > {
+      typedef Karp<GR, LEN, SetPathTraits<T> > Create;
+    };
+
+    /// @}
+
+  public:
+
+    /// \brief Constructor.
+    ///
+    /// The constructor of the class.
+    ///
+    /// \param digraph The digraph the algorithm runs on.
+    /// \param length The lengths (costs) of the arcs.
+    Karp( const Digraph &digraph,
+          const LengthMap &length ) :
+      _gr(digraph), _length(length), _comp(digraph), _out_arcs(digraph),
+      _cycle_length(0), _cycle_size(1), _cycle_node(INVALID),
+      _cycle_path(NULL), _local_path(false), _data(digraph),
+      INF(std::numeric_limits<LargeValue>::has_infinity ?
+          std::numeric_limits<LargeValue>::infinity() :
+          std::numeric_limits<LargeValue>::max())
+    {}
+
+    /// Destructor.
+    ~Karp() {
+      if (_local_path) delete _cycle_path;
+    }
+
+    /// \brief Set the path structure for storing the found cycle.
+    ///
+    /// This function sets an external path structure for storing the
+    /// found cycle.
+    ///
+    /// If you don't call this function before calling \ref run() or
+    /// \ref findMinMean(), it will allocate a local \ref Path "path"
+    /// structure. The destuctor deallocates this automatically
+    /// allocated object, of course.
+    ///
+    /// \note The algorithm calls only the \ref lemon::Path::addFront()
+    /// "addFront()" function of the given path structure.
+    ///
+    /// \return <tt>(*this)</tt>
+    Karp& cycle(Path &path) {
+      if (_local_path) {
+        delete _cycle_path;
+        _local_path = false;
+      }
+      _cycle_path = &path;
+      return *this;
+    }
+
+    /// \brief Set the tolerance used by the algorithm.
+    ///
+    /// This function sets the tolerance object used by the algorithm.
+    ///
+    /// \return <tt>(*this)</tt>
+    Karp& tolerance(const Tolerance& tolerance) {
+      _tolerance = tolerance;
+      return *this;
+    }
+
+    /// \brief Return a const reference to the tolerance.
+    ///
+    /// This function returns a const reference to the tolerance object
+    /// used by the algorithm.
+    const Tolerance& tolerance() const {
+      return _tolerance;
+    }
+
+    /// \name Execution control
+    /// The simplest way to execute the algorithm is to call the \ref run()
+    /// function.\n
+    /// If you only need the minimum mean length, you may call
+    /// \ref findMinMean().
+
+    /// @{
+
+    /// \brief Run the algorithm.
+    ///
+    /// This function runs the algorithm.
+    /// It can be called more than once (e.g. if the underlying digraph
+    /// and/or the arc lengths have been modified).
+    ///
+    /// \return \c true if a directed cycle exists in the digraph.
+    ///
+    /// \note <tt>mmc.run()</tt> is just a shortcut of the following code.
+    /// \code
+    ///   return mmc.findMinMean() && mmc.findCycle();
+    /// \endcode
+    bool run() {
+      return findMinMean() && findCycle();
+    }
+
+    /// \brief Find the minimum cycle mean.
+    ///
+    /// This function finds the minimum mean length of the directed
+    /// cycles in the digraph.
+    ///
+    /// \return \c true if a directed cycle exists in the digraph.
+    bool findMinMean() {
+      // Initialization and find strongly connected components
+      init();
+      findComponents();
+      
+      // Find the minimum cycle mean in the components
+      for (int comp = 0; comp < _comp_num; ++comp) {
+        if (!initComponent(comp)) continue;
+        processRounds();
+        updateMinMean();
+      }
+      return (_cycle_node != INVALID);
+    }
+
+    /// \brief Find a minimum mean directed cycle.
+    ///
+    /// This function finds a directed cycle of minimum mean length
+    /// in the digraph using the data computed by findMinMean().
+    ///
+    /// \return \c true if a directed cycle exists in the digraph.
+    ///
+    /// \pre \ref findMinMean() must be called before using this function.
+    bool findCycle() {
+      if (_cycle_node == INVALID) return false;
+      IntNodeMap reached(_gr, -1);
+      int r = _data[_cycle_node].size();
+      Node u = _cycle_node;
+      while (reached[u] < 0) {
+        reached[u] = --r;
+        u = _gr.source(_data[u][r].pred);
+      }
+      r = reached[u];
+      Arc e = _data[u][r].pred;
+      _cycle_path->addFront(e);
+      _cycle_length = _length[e];
+      _cycle_size = 1;
+      Node v;
+      while ((v = _gr.source(e)) != u) {
+        e = _data[v][--r].pred;
+        _cycle_path->addFront(e);
+        _cycle_length += _length[e];
+        ++_cycle_size;
+      }
+      return true;
+    }
+
+    /// @}
+
+    /// \name Query Functions
+    /// The results of the algorithm can be obtained using these
+    /// functions.\n
+    /// The algorithm should be executed before using them.
+
+    /// @{
+
+    /// \brief Return the total length of the found cycle.
+    ///
+    /// This function returns the total length of the found cycle.
+    ///
+    /// \pre \ref run() or \ref findMinMean() must be called before
+    /// using this function.
+    LargeValue cycleLength() const {
+      return _cycle_length;
+    }
+
+    /// \brief Return the number of arcs on the found cycle.
+    ///
+    /// This function returns the number of arcs on the found cycle.
+    ///
+    /// \pre \ref run() or \ref findMinMean() must be called before
+    /// using this function.
+    int cycleArcNum() const {
+      return _cycle_size;
+    }
+
+    /// \brief Return the mean length of the found cycle.
+    ///
+    /// This function returns the mean length of the found cycle.
+    ///
+    /// \note <tt>alg.cycleMean()</tt> is just a shortcut of the
+    /// following code.
+    /// \code
+    ///   return static_cast<double>(alg.cycleLength()) / alg.cycleArcNum();
+    /// \endcode
+    ///
+    /// \pre \ref run() or \ref findMinMean() must be called before
+    /// using this function.
+    double cycleMean() const {
+      return static_cast<double>(_cycle_length) / _cycle_size;
+    }
+
+    /// \brief Return the found cycle.
+    ///
+    /// This function returns a const reference to the path structure
+    /// storing the found cycle.
+    ///
+    /// \pre \ref run() or \ref findCycle() must be called before using
+    /// this function.
+    const Path& cycle() const {
+      return *_cycle_path;
+    }
+
+    ///@}
+
+  private:
+
+    // Initialization
+    void init() {
+      if (!_cycle_path) {
+        _local_path = true;
+        _cycle_path = new Path;
+      }
+      _cycle_path->clear();
+      _cycle_length = 0;
+      _cycle_size = 1;
+      _cycle_node = INVALID;
+      for (NodeIt u(_gr); u != INVALID; ++u)
+        _data[u].clear();
+    }
+
+    // Find strongly connected components and initialize _comp_nodes
+    // and _out_arcs
+    void findComponents() {
+      _comp_num = stronglyConnectedComponents(_gr, _comp);
+      _comp_nodes.resize(_comp_num);
+      if (_comp_num == 1) {
+        _comp_nodes[0].clear();
+        for (NodeIt n(_gr); n != INVALID; ++n) {
+          _comp_nodes[0].push_back(n);
+          _out_arcs[n].clear();
+          for (OutArcIt a(_gr, n); a != INVALID; ++a) {
+            _out_arcs[n].push_back(a);
+          }
+        }
+      } else {
+        for (int i = 0; i < _comp_num; ++i)
+          _comp_nodes[i].clear();
+        for (NodeIt n(_gr); n != INVALID; ++n) {
+          int k = _comp[n];
+          _comp_nodes[k].push_back(n);
+          _out_arcs[n].clear();
+          for (OutArcIt a(_gr, n); a != INVALID; ++a) {
+            if (_comp[_gr.target(a)] == k) _out_arcs[n].push_back(a);
+          }
+        }
+      }
+    }
+
+    // Initialize path data for the current component
+    bool initComponent(int comp) {
+      _nodes = &(_comp_nodes[comp]);
+      int n = _nodes->size();
+      if (n < 1 || (n == 1 && _out_arcs[(*_nodes)[0]].size() == 0)) {
+        return false;
+      }      
+      for (int i = 0; i < n; ++i) {
+        _data[(*_nodes)[i]].resize(n + 1, PathData(INF));
+      }
+      return true;
+    }
+
+    // Process all rounds of computing path data for the current component.
+    // _data[v][k] is the length of a shortest directed walk from the root
+    // node to node v containing exactly k arcs.
+    void processRounds() {
+      Node start = (*_nodes)[0];
+      _data[start][0] = PathData(0);
+      _process.clear();
+      _process.push_back(start);
+
+      int k, n = _nodes->size();
+      for (k = 1; k <= n && int(_process.size()) < n; ++k) {
+        processNextBuildRound(k);
+      }
+      for ( ; k <= n; ++k) {
+        processNextFullRound(k);
+      }
+    }
+
+    // Process one round and rebuild _process
+    void processNextBuildRound(int k) {
+      std::vector<Node> next;
+      Node u, v;
+      Arc e;
+      LargeValue d;
+      for (int i = 0; i < int(_process.size()); ++i) {
+        u = _process[i];
+        for (int j = 0; j < int(_out_arcs[u].size()); ++j) {
+          e = _out_arcs[u][j];
+          v = _gr.target(e);
+          d = _data[u][k-1].dist + _length[e];
+          if (_tolerance.less(d, _data[v][k].dist)) {
+            if (_data[v][k].dist == INF) next.push_back(v);
+            _data[v][k] = PathData(d, e);
+          }
+        }
+      }
+      _process.swap(next);
+    }
+
+    // Process one round using _nodes instead of _process
+    void processNextFullRound(int k) {
+      Node u, v;
+      Arc e;
+      LargeValue d;
+      for (int i = 0; i < int(_nodes->size()); ++i) {
+        u = (*_nodes)[i];
+        for (int j = 0; j < int(_out_arcs[u].size()); ++j) {
+          e = _out_arcs[u][j];
+          v = _gr.target(e);
+          d = _data[u][k-1].dist + _length[e];
+          if (_tolerance.less(d, _data[v][k].dist)) {
+            _data[v][k] = PathData(d, e);
+          }
+        }
+      }
+    }
+
+    // Update the minimum cycle mean
+    void updateMinMean() {
+      int n = _nodes->size();
+      for (int i = 0; i < n; ++i) {
+        Node u = (*_nodes)[i];
+        if (_data[u][n].dist == INF) continue;
+        LargeValue length, max_length = 0;
+        int size, max_size = 1;
+        bool found_curr = false;
+        for (int k = 0; k < n; ++k) {
+          if (_data[u][k].dist == INF) continue;
+          length = _data[u][n].dist - _data[u][k].dist;
+          size = n - k;
+          if (!found_curr || length * max_size > max_length * size) {
+            found_curr = true;
+            max_length = length;
+            max_size = size;
+          }
+        }
+        if ( found_curr && (_cycle_node == INVALID ||
+             max_length * _cycle_size < _cycle_length * max_size) ) {
+          _cycle_length = max_length;
+          _cycle_size = max_size;
+          _cycle_node = u;
+        }
+      }
+    }
+
+  }; //class Karp
+
+  ///@}
+
+} //namespace lemon
+
+#endif //LEMON_KARP_H
Index: mon/karp_mmc.h
===================================================================
--- lemon/karp_mmc.h	(revision 1270)
+++ 	(revision )
@@ -1,590 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2013
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * 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_KARP_MMC_H
-#define LEMON_KARP_MMC_H
-
-/// \ingroup min_mean_cycle
-///
-/// \file
-/// \brief Karp's algorithm for finding a minimum mean cycle.
-
-#include <vector>
-#include <limits>
-#include <lemon/core.h>
-#include <lemon/path.h>
-#include <lemon/tolerance.h>
-#include <lemon/connectivity.h>
-
-namespace lemon {
-
-  /// \brief Default traits class of KarpMmc class.
-  ///
-  /// Default traits class of KarpMmc class.
-  /// \tparam GR The type of the digraph.
-  /// \tparam CM The type of the cost map.
-  /// It must conform to the \ref concepts::ReadMap "ReadMap" concept.
-#ifdef DOXYGEN
-  template <typename GR, typename CM>
-#else
-  template <typename GR, typename CM,
-    bool integer = std::numeric_limits<typename CM::Value>::is_integer>
-#endif
-  struct KarpMmcDefaultTraits
-  {
-    /// The type of the digraph
-    typedef GR Digraph;
-    /// The type of the cost map
-    typedef CM CostMap;
-    /// The type of the arc costs
-    typedef typename CostMap::Value Cost;
-
-    /// \brief The large cost type used for internal computations
-    ///
-    /// The large cost type used for internal computations.
-    /// It is \c long \c long if the \c Cost type is integer,
-    /// otherwise it is \c double.
-    /// \c Cost must be convertible to \c LargeCost.
-    typedef double LargeCost;
-
-    /// The tolerance type used for internal computations
-    typedef lemon::Tolerance<LargeCost> Tolerance;
-
-    /// \brief The path type of the found cycles
-    ///
-    /// The path type of the found cycles.
-    /// It must conform to the \ref lemon::concepts::Path "Path" concept
-    /// and it must have an \c addFront() function.
-    typedef lemon::Path<Digraph> Path;
-  };
-
-  // Default traits class for integer cost types
-  template <typename GR, typename CM>
-  struct KarpMmcDefaultTraits<GR, CM, true>
-  {
-    typedef GR Digraph;
-    typedef CM CostMap;
-    typedef typename CostMap::Value Cost;
-#ifdef LEMON_HAVE_LONG_LONG
-    typedef long long LargeCost;
-#else
-    typedef long LargeCost;
-#endif
-    typedef lemon::Tolerance<LargeCost> Tolerance;
-    typedef lemon::Path<Digraph> Path;
-  };
-
-
-  /// \addtogroup min_mean_cycle
-  /// @{
-
-  /// \brief Implementation of Karp's algorithm for finding a minimum
-  /// mean cycle.
-  ///
-  /// This class implements Karp's algorithm for finding a directed
-  /// cycle of minimum mean cost in a digraph
-  /// \cite karp78characterization, \cite dasdan98minmeancycle.
-  /// It runs in time O(nm) and uses space O(n<sup>2</sup>+m).
-  ///
-  /// \tparam GR The type of the digraph the algorithm runs on.
-  /// \tparam CM The type of the cost map. The default
-  /// map type is \ref concepts::Digraph::ArcMap "GR::ArcMap<int>".
-  /// \tparam TR The traits class that defines various types used by the
-  /// algorithm. By default, it is \ref KarpMmcDefaultTraits
-  /// "KarpMmcDefaultTraits<GR, CM>".
-  /// In most cases, this parameter should not be set directly,
-  /// consider to use the named template parameters instead.
-#ifdef DOXYGEN
-  template <typename GR, typename CM, typename TR>
-#else
-  template < typename GR,
-             typename CM = typename GR::template ArcMap<int>,
-             typename TR = KarpMmcDefaultTraits<GR, CM> >
-#endif
-  class KarpMmc
-  {
-  public:
-
-    /// The type of the digraph
-    typedef typename TR::Digraph Digraph;
-    /// The type of the cost map
-    typedef typename TR::CostMap CostMap;
-    /// The type of the arc costs
-    typedef typename TR::Cost Cost;
-
-    /// \brief The large cost type
-    ///
-    /// The large cost type used for internal computations.
-    /// By default, it is \c long \c long if the \c Cost type is integer,
-    /// otherwise it is \c double.
-    typedef typename TR::LargeCost LargeCost;
-
-    /// The tolerance type
-    typedef typename TR::Tolerance Tolerance;
-
-    /// \brief The path type of the found cycles
-    ///
-    /// The path type of the found cycles.
-    /// Using the \ref lemon::KarpMmcDefaultTraits "default traits class",
-    /// it is \ref lemon::Path "Path<Digraph>".
-    typedef typename TR::Path Path;
-
-    /// The \ref lemon::KarpMmcDefaultTraits "traits class" of the algorithm
-    typedef TR Traits;
-
-  private:
-
-    TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
-
-    // Data sturcture for path data
-    struct PathData
-    {
-      LargeCost dist;
-      Arc pred;
-      PathData(LargeCost d, Arc p = INVALID) :
-        dist(d), pred(p) {}
-    };
-
-    typedef typename Digraph::template NodeMap<std::vector<PathData> >
-      PathDataNodeMap;
-
-  private:
-
-    // The digraph the algorithm runs on
-    const Digraph &_gr;
-    // The cost of the arcs
-    const CostMap &_cost;
-
-    // Data for storing the strongly connected components
-    int _comp_num;
-    typename Digraph::template NodeMap<int> _comp;
-    std::vector<std::vector<Node> > _comp_nodes;
-    std::vector<Node>* _nodes;
-    typename Digraph::template NodeMap<std::vector<Arc> > _out_arcs;
-
-    // Data for the found cycle
-    LargeCost _cycle_cost;
-    int _cycle_size;
-    Node _cycle_node;
-
-    Path *_cycle_path;
-    bool _local_path;
-
-    // Node map for storing path data
-    PathDataNodeMap _data;
-    // The processed nodes in the last round
-    std::vector<Node> _process;
-
-    Tolerance _tolerance;
-
-    // Infinite constant
-    const LargeCost INF;
-
-  public:
-
-    /// \name Named Template Parameters
-    /// @{
-
-    template <typename T>
-    struct SetLargeCostTraits : public Traits {
-      typedef T LargeCost;
-      typedef lemon::Tolerance<T> Tolerance;
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// \c LargeCost type.
-    ///
-    /// \ref named-templ-param "Named parameter" for setting \c LargeCost
-    /// type. It is used for internal computations in the algorithm.
-    template <typename T>
-    struct SetLargeCost
-      : public KarpMmc<GR, CM, SetLargeCostTraits<T> > {
-      typedef KarpMmc<GR, CM, SetLargeCostTraits<T> > Create;
-    };
-
-    template <typename T>
-    struct SetPathTraits : public Traits {
-      typedef T Path;
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// \c %Path type.
-    ///
-    /// \ref named-templ-param "Named parameter" for setting the \c %Path
-    /// type of the found cycles.
-    /// It must conform to the \ref lemon::concepts::Path "Path" concept
-    /// and it must have an \c addFront() function.
-    template <typename T>
-    struct SetPath
-      : public KarpMmc<GR, CM, SetPathTraits<T> > {
-      typedef KarpMmc<GR, CM, SetPathTraits<T> > Create;
-    };
-
-    /// @}
-
-  protected:
-
-    KarpMmc() {}
-
-  public:
-
-    /// \brief Constructor.
-    ///
-    /// The constructor of the class.
-    ///
-    /// \param digraph The digraph the algorithm runs on.
-    /// \param cost The costs of the arcs.
-    KarpMmc( const Digraph &digraph,
-             const CostMap &cost ) :
-      _gr(digraph), _cost(cost), _comp(digraph), _out_arcs(digraph),
-      _cycle_cost(0), _cycle_size(1), _cycle_node(INVALID),
-      _cycle_path(NULL), _local_path(false), _data(digraph),
-      INF(std::numeric_limits<LargeCost>::has_infinity ?
-          std::numeric_limits<LargeCost>::infinity() :
-          std::numeric_limits<LargeCost>::max())
-    {}
-
-    /// Destructor.
-    ~KarpMmc() {
-      if (_local_path) delete _cycle_path;
-    }
-
-    /// \brief Set the path structure for storing the found cycle.
-    ///
-    /// This function sets an external path structure for storing the
-    /// found cycle.
-    ///
-    /// If you don't call this function before calling \ref run() or
-    /// \ref findCycleMean(), a local \ref Path "path" structure
-    /// will be allocated. The destuctor deallocates this automatically
-    /// allocated object, of course.
-    ///
-    /// \note The algorithm calls only the \ref lemon::Path::addFront()
-    /// "addFront()" function of the given path structure.
-    ///
-    /// \return <tt>(*this)</tt>
-    KarpMmc& cycle(Path &path) {
-      if (_local_path) {
-        delete _cycle_path;
-        _local_path = false;
-      }
-      _cycle_path = &path;
-      return *this;
-    }
-
-    /// \brief Set the tolerance used by the algorithm.
-    ///
-    /// This function sets the tolerance object used by the algorithm.
-    ///
-    /// \return <tt>(*this)</tt>
-    KarpMmc& tolerance(const Tolerance& tolerance) {
-      _tolerance = tolerance;
-      return *this;
-    }
-
-    /// \brief Return a const reference to the tolerance.
-    ///
-    /// This function returns a const reference to the tolerance object
-    /// used by the algorithm.
-    const Tolerance& tolerance() const {
-      return _tolerance;
-    }
-
-    /// \name Execution control
-    /// The simplest way to execute the algorithm is to call the \ref run()
-    /// function.\n
-    /// If you only need the minimum mean cost, you may call
-    /// \ref findCycleMean().
-
-    /// @{
-
-    /// \brief Run the algorithm.
-    ///
-    /// This function runs the algorithm.
-    /// It can be called more than once (e.g. if the underlying digraph
-    /// and/or the arc costs have been modified).
-    ///
-    /// \return \c true if a directed cycle exists in the digraph.
-    ///
-    /// \note <tt>mmc.run()</tt> is just a shortcut of the following code.
-    /// \code
-    ///   return mmc.findCycleMean() && mmc.findCycle();
-    /// \endcode
-    bool run() {
-      return findCycleMean() && findCycle();
-    }
-
-    /// \brief Find the minimum cycle mean.
-    ///
-    /// This function finds the minimum mean cost of the directed
-    /// cycles in the digraph.
-    ///
-    /// \return \c true if a directed cycle exists in the digraph.
-    bool findCycleMean() {
-      // Initialization and find strongly connected components
-      init();
-      findComponents();
-
-      // Find the minimum cycle mean in the components
-      for (int comp = 0; comp < _comp_num; ++comp) {
-        if (!initComponent(comp)) continue;
-        processRounds();
-        updateMinMean();
-      }
-      return (_cycle_node != INVALID);
-    }
-
-    /// \brief Find a minimum mean directed cycle.
-    ///
-    /// This function finds a directed cycle of minimum mean cost
-    /// in the digraph using the data computed by findCycleMean().
-    ///
-    /// \return \c true if a directed cycle exists in the digraph.
-    ///
-    /// \pre \ref findCycleMean() must be called before using this function.
-    bool findCycle() {
-      if (_cycle_node == INVALID) return false;
-      IntNodeMap reached(_gr, -1);
-      int r = _data[_cycle_node].size();
-      Node u = _cycle_node;
-      while (reached[u] < 0) {
-        reached[u] = --r;
-        u = _gr.source(_data[u][r].pred);
-      }
-      r = reached[u];
-      Arc e = _data[u][r].pred;
-      _cycle_path->addFront(e);
-      _cycle_cost = _cost[e];
-      _cycle_size = 1;
-      Node v;
-      while ((v = _gr.source(e)) != u) {
-        e = _data[v][--r].pred;
-        _cycle_path->addFront(e);
-        _cycle_cost += _cost[e];
-        ++_cycle_size;
-      }
-      return true;
-    }
-
-    /// @}
-
-    /// \name Query Functions
-    /// The results of the algorithm can be obtained using these
-    /// functions.\n
-    /// The algorithm should be executed before using them.
-
-    /// @{
-
-    /// \brief Return the total cost of the found cycle.
-    ///
-    /// This function returns the total cost of the found cycle.
-    ///
-    /// \pre \ref run() or \ref findCycleMean() must be called before
-    /// using this function.
-    Cost cycleCost() const {
-      return static_cast<Cost>(_cycle_cost);
-    }
-
-    /// \brief Return the number of arcs on the found cycle.
-    ///
-    /// This function returns the number of arcs on the found cycle.
-    ///
-    /// \pre \ref run() or \ref findCycleMean() must be called before
-    /// using this function.
-    int cycleSize() const {
-      return _cycle_size;
-    }
-
-    /// \brief Return the mean cost of the found cycle.
-    ///
-    /// This function returns the mean cost of the found cycle.
-    ///
-    /// \note <tt>alg.cycleMean()</tt> is just a shortcut of the
-    /// following code.
-    /// \code
-    ///   return static_cast<double>(alg.cycleCost()) / alg.cycleSize();
-    /// \endcode
-    ///
-    /// \pre \ref run() or \ref findCycleMean() must be called before
-    /// using this function.
-    double cycleMean() const {
-      return static_cast<double>(_cycle_cost) / _cycle_size;
-    }
-
-    /// \brief Return the found cycle.
-    ///
-    /// This function returns a const reference to the path structure
-    /// storing the found cycle.
-    ///
-    /// \pre \ref run() or \ref findCycle() must be called before using
-    /// this function.
-    const Path& cycle() const {
-      return *_cycle_path;
-    }
-
-    ///@}
-
-  private:
-
-    // Initialization
-    void init() {
-      if (!_cycle_path) {
-        _local_path = true;
-        _cycle_path = new Path;
-      }
-      _cycle_path->clear();
-      _cycle_cost = 0;
-      _cycle_size = 1;
-      _cycle_node = INVALID;
-      for (NodeIt u(_gr); u != INVALID; ++u)
-        _data[u].clear();
-    }
-
-    // Find strongly connected components and initialize _comp_nodes
-    // and _out_arcs
-    void findComponents() {
-      _comp_num = stronglyConnectedComponents(_gr, _comp);
-      _comp_nodes.resize(_comp_num);
-      if (_comp_num == 1) {
-        _comp_nodes[0].clear();
-        for (NodeIt n(_gr); n != INVALID; ++n) {
-          _comp_nodes[0].push_back(n);
-          _out_arcs[n].clear();
-          for (OutArcIt a(_gr, n); a != INVALID; ++a) {
-            _out_arcs[n].push_back(a);
-          }
-        }
-      } else {
-        for (int i = 0; i < _comp_num; ++i)
-          _comp_nodes[i].clear();
-        for (NodeIt n(_gr); n != INVALID; ++n) {
-          int k = _comp[n];
-          _comp_nodes[k].push_back(n);
-          _out_arcs[n].clear();
-          for (OutArcIt a(_gr, n); a != INVALID; ++a) {
-            if (_comp[_gr.target(a)] == k) _out_arcs[n].push_back(a);
-          }
-        }
-      }
-    }
-
-    // Initialize path data for the current component
-    bool initComponent(int comp) {
-      _nodes = &(_comp_nodes[comp]);
-      int n = _nodes->size();
-      if (n < 1 || (n == 1 && _out_arcs[(*_nodes)[0]].size() == 0)) {
-        return false;
-      }
-      for (int i = 0; i < n; ++i) {
-        _data[(*_nodes)[i]].resize(n + 1, PathData(INF));
-      }
-      return true;
-    }
-
-    // Process all rounds of computing path data for the current component.
-    // _data[v][k] is the cost of a shortest directed walk from the root
-    // node to node v containing exactly k arcs.
-    void processRounds() {
-      Node start = (*_nodes)[0];
-      _data[start][0] = PathData(0);
-      _process.clear();
-      _process.push_back(start);
-
-      int k, n = _nodes->size();
-      for (k = 1; k <= n && int(_process.size()) < n; ++k) {
-        processNextBuildRound(k);
-      }
-      for ( ; k <= n; ++k) {
-        processNextFullRound(k);
-      }
-    }
-
-    // Process one round and rebuild _process
-    void processNextBuildRound(int k) {
-      std::vector<Node> next;
-      Node u, v;
-      Arc e;
-      LargeCost d;
-      for (int i = 0; i < int(_process.size()); ++i) {
-        u = _process[i];
-        for (int j = 0; j < int(_out_arcs[u].size()); ++j) {
-          e = _out_arcs[u][j];
-          v = _gr.target(e);
-          d = _data[u][k-1].dist + _cost[e];
-          if (_tolerance.less(d, _data[v][k].dist)) {
-            if (_data[v][k].dist == INF) next.push_back(v);
-            _data[v][k] = PathData(d, e);
-          }
-        }
-      }
-      _process.swap(next);
-    }
-
-    // Process one round using _nodes instead of _process
-    void processNextFullRound(int k) {
-      Node u, v;
-      Arc e;
-      LargeCost d;
-      for (int i = 0; i < int(_nodes->size()); ++i) {
-        u = (*_nodes)[i];
-        for (int j = 0; j < int(_out_arcs[u].size()); ++j) {
-          e = _out_arcs[u][j];
-          v = _gr.target(e);
-          d = _data[u][k-1].dist + _cost[e];
-          if (_tolerance.less(d, _data[v][k].dist)) {
-            _data[v][k] = PathData(d, e);
-          }
-        }
-      }
-    }
-
-    // Update the minimum cycle mean
-    void updateMinMean() {
-      int n = _nodes->size();
-      for (int i = 0; i < n; ++i) {
-        Node u = (*_nodes)[i];
-        if (_data[u][n].dist == INF) continue;
-        LargeCost cost, max_cost = 0;
-        int size, max_size = 1;
-        bool found_curr = false;
-        for (int k = 0; k < n; ++k) {
-          if (_data[u][k].dist == INF) continue;
-          cost = _data[u][n].dist - _data[u][k].dist;
-          size = n - k;
-          if (!found_curr || cost * max_size > max_cost * size) {
-            found_curr = true;
-            max_cost = cost;
-            max_size = size;
-          }
-        }
-        if ( found_curr && (_cycle_node == INVALID ||
-             max_cost * _cycle_size < _cycle_cost * max_size) ) {
-          _cycle_cost = max_cost;
-          _cycle_size = max_size;
-          _cycle_node = u;
-        }
-      }
-    }
-
-  }; //class KarpMmc
-
-  ///@}
-
-} //namespace lemon
-
-#endif //LEMON_KARP_MMC_H
Index: lemon/kary_heap.h
===================================================================
--- lemon/kary_heap.h	(revision 753)
+++ lemon/kary_heap.h	(revision 753)
@@ -0,0 +1,352 @@
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library.
+ *
+ * Copyright (C) 2003-2009
+ * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
+ * (Egervary Research Group on Combinatorial Optimization, EGRES).
+ *
+ * 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_KARY_HEAP_H
+#define LEMON_KARY_HEAP_H
+
+///\ingroup heaps
+///\file
+///\brief Fourary heap implementation.
+
+#include <vector>
+#include <utility>
+#include <functional>
+
+namespace lemon {
+
+  /// \ingroup heaps
+  ///
+  ///\brief K-ary heap data structure.
+  ///
+  /// This class implements the \e K-ary \e heap data structure.
+  /// It fully conforms to the \ref concepts::Heap "heap concept".
+  ///
+  /// The \ref KaryHeap "K-ary heap" is a generalization of the
+  /// \ref BinHeap "binary heap" structure, its nodes have at most
+  /// \c K children, instead of two.
+  /// \ref BinHeap and \ref FouraryHeap are specialized implementations
+  /// of this structure for <tt>K=2</tt> and <tt>K=4</tt>, respectively.
+  ///
+  /// \tparam PR Type of the priorities of the items.
+  /// \tparam IM A read-writable item map with \c int values, used
+  /// internally to handle the cross references.
+  /// \tparam K The degree of the heap, each node have at most \e K
+  /// children. The default is 16. Powers of two are suggested to use
+  /// so that the multiplications and divisions needed to traverse the
+  /// nodes of the heap could be performed faster.
+  /// \tparam CMP A functor class for comparing the priorities.
+  /// The default is \c std::less<PR>.
+  ///
+  ///\sa BinHeap
+  ///\sa FouraryHeap
+#ifdef DOXYGEN
+  template <typename PR, typename IM, int K, typename CMP>
+#else
+  template <typename PR, typename IM, int K = 16,
+            typename CMP = std::less<PR> >
+#endif
+  class KaryHeap {
+  public:
+    /// Type of the item-int map.
+    typedef IM ItemIntMap;
+    /// Type of the priorities.
+    typedef PR Prio;
+    /// Type of the items stored in the heap.
+    typedef typename ItemIntMap::Key Item;
+    /// Type of the item-priority pairs.
+    typedef std::pair<Item,Prio> Pair;
+    /// Functor type for comparing the priorities.
+    typedef CMP Compare;
+
+    /// \brief Type to represent the states of the items.
+    ///
+    /// Each item has a state associated to it. It can be "in heap",
+    /// "pre-heap" or "post-heap". The latter two are indifferent from the
+    /// heap's point of view, but may be useful to the user.
+    ///
+    /// The item-int map must be initialized in such way that it assigns
+    /// \c PRE_HEAP (<tt>-1</tt>) to any element to be put in the heap.
+    enum State {
+      IN_HEAP = 0,    ///< = 0.
+      PRE_HEAP = -1,  ///< = -1.
+      POST_HEAP = -2  ///< = -2.
+    };
+
+  private:
+    std::vector<Pair> _data;
+    Compare _comp;
+    ItemIntMap &_iim;
+
+  public:
+    /// \brief Constructor.
+    ///
+    /// Constructor.
+    /// \param map A map that assigns \c int values to the items.
+    /// It is used internally to handle the cross references.
+    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
+    explicit KaryHeap(ItemIntMap &map) : _iim(map) {}
+
+    /// \brief Constructor.
+    ///
+    /// Constructor.
+    /// \param map A map that assigns \c int values to the items.
+    /// It is used internally to handle the cross references.
+    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
+    /// \param comp The function object used for comparing the priorities.
+    KaryHeap(ItemIntMap &map, const Compare &comp)
+      : _iim(map), _comp(comp) {}
+
+    /// \brief The number of items stored in the heap.
+    ///
+    /// This function returns the number of items stored in the heap.
+    int size() const { return _data.size(); }
+
+    /// \brief Check if the heap is empty.
+    ///
+    /// This function returns \c true if the heap is empty.
+    bool empty() const { return _data.empty(); }
+
+    /// \brief Make the heap empty.
+    ///
+    /// This functon makes the heap empty.
+    /// It does not change the cross reference map. If you want to reuse
+    /// a heap that is not surely empty, you should first clear it and
+    /// then you should set the cross reference map to \c PRE_HEAP
+    /// for each item.
+    void clear() { _data.clear(); }
+
+  private:
+    int parent(int i) { return (i-1)/K; }
+    int firstChild(int i) { return K*i+1; }
+
+    bool less(const Pair &p1, const Pair &p2) const {
+      return _comp(p1.second, p2.second);
+    }
+
+    void bubbleUp(int hole, Pair p) {
+      int par = parent(hole);
+      while( hole>0 && less(p,_data[par]) ) {
+        move(_data[par],hole);
+        hole = par;
+        par = parent(hole);
+      }
+      move(p, hole);
+    }
+
+    void bubbleDown(int hole, Pair p, int length) {
+      if( length>1 ) {
+        int child = firstChild(hole);
+        while( child+K<=length ) {
+          int min=child;
+          for (int i=1; i<K; ++i) {
+            if( less(_data[child+i], _data[min]) )
+              min=child+i;
+          }
+          if( !less(_data[min], p) )
+            goto ok;
+          move(_data[min], hole);
+          hole = min;
+          child = firstChild(hole);
+        }
+        if ( child<length ) {
+          int min = child;
+          while (++child < length) {
+            if( less(_data[child], _data[min]) )
+              min=child;
+          }
+          if( less(_data[min], p) ) {
+            move(_data[min], hole);
+            hole = min;
+          }
+        }
+      }
+    ok:
+      move(p, hole);
+    }
+
+    void move(const Pair &p, int i) {
+      _data[i] = p;
+      _iim.set(p.first, i);
+    }
+
+  public:
+    /// \brief Insert a pair of item and priority into the heap.
+    ///
+    /// This function inserts \c p.first to the heap with priority
+    /// \c p.second.
+    /// \param p The pair to insert.
+    /// \pre \c p.first must not be stored in the heap.
+    void push(const Pair &p) {
+      int n = _data.size();
+      _data.resize(n+1);
+      bubbleUp(n, p);
+    }
+
+    /// \brief Insert an item into the heap with the given priority.
+    ///
+    /// This function inserts the given item into the heap with the
+    /// given priority.
+    /// \param i The item to insert.
+    /// \param p The priority of the item.
+    /// \pre \e i must not be stored in the heap.
+    void push(const Item &i, const Prio &p) { push(Pair(i,p)); }
+
+    /// \brief Return the item having minimum priority.
+    ///
+    /// This function returns the item having minimum priority.
+    /// \pre The heap must be non-empty.
+    Item top() const { return _data[0].first; }
+
+    /// \brief The minimum priority.
+    ///
+    /// This function returns the minimum priority.
+    /// \pre The heap must be non-empty.
+    Prio prio() const { return _data[0].second; }
+
+    /// \brief Remove the item having minimum priority.
+    ///
+    /// This function removes the item having minimum priority.
+    /// \pre The heap must be non-empty.
+    void pop() {
+      int n = _data.size()-1;
+      _iim.set(_data[0].first, POST_HEAP);
+      if (n>0) bubbleDown(0, _data[n], n);
+      _data.pop_back();
+    }
+
+    /// \brief Remove the given item from the heap.
+    ///
+    /// This function removes the given item from the heap if it is
+    /// already stored.
+    /// \param i The item to delete.
+    /// \pre \e i must be in the heap.
+    void erase(const Item &i) {
+      int h = _iim[i];
+      int n = _data.size()-1;
+      _iim.set(_data[h].first, POST_HEAP);
+      if( h<n ) {
+        if( less(_data[parent(h)], _data[n]) )
+          bubbleDown(h, _data[n], n);
+        else
+          bubbleUp(h, _data[n]);
+      }
+      _data.pop_back();
+    }
+
+    /// \brief The priority of the given item.
+    ///
+    /// This function returns the priority of the given item.
+    /// \param i The item.
+    /// \pre \e i must be in the heap.
+    Prio operator[](const Item &i) const {
+      int idx = _iim[i];
+      return _data[idx].second;
+    }
+
+    /// \brief Set the priority of an item or insert it, if it is
+    /// not stored in the heap.
+    ///
+    /// This method sets the priority of the given item if it is
+    /// already stored in the heap. Otherwise it inserts the given
+    /// item into the heap with the given priority.
+    /// \param i The item.
+    /// \param p The priority.
+    void set(const Item &i, const Prio &p) {
+      int idx = _iim[i];
+      if( idx<0 )
+        push(i,p);
+      else if( _comp(p, _data[idx].second) )
+        bubbleUp(idx, Pair(i,p));
+      else
+        bubbleDown(idx, Pair(i,p), _data.size());
+    }
+
+    /// \brief Decrease the priority of an item to the given value.
+    ///
+    /// This function decreases the priority of an item to the given value.
+    /// \param i The item.
+    /// \param p The priority.
+    /// \pre \e i must be stored in the heap with priority at least \e p.
+    void decrease(const Item &i, const Prio &p) {
+      int idx = _iim[i];
+      bubbleUp(idx, Pair(i,p));
+    }
+
+    /// \brief Increase the priority of an item to the given value.
+    ///
+    /// This function increases the priority of an item to the given value.
+    /// \param i The item.
+    /// \param p The priority.
+    /// \pre \e i must be stored in the heap with priority at most \e p.
+    void increase(const Item &i, const Prio &p) {
+      int idx = _iim[i];
+      bubbleDown(idx, Pair(i,p), _data.size());
+    }
+
+    /// \brief Return the state of an item.
+    ///
+    /// This method returns \c PRE_HEAP if the given item has never
+    /// been in the heap, \c IN_HEAP if it is in the heap at the moment,
+    /// and \c POST_HEAP otherwise.
+    /// In the latter case it is possible that the item will get back
+    /// to the heap again.
+    /// \param i The item.
+    State state(const Item &i) const {
+      int s = _iim[i];
+      if (s>=0) s=0;
+      return State(s);
+    }
+
+    /// \brief Set the state of an item in the heap.
+    ///
+    /// This function sets the state of the given item in the heap.
+    /// It can be used to manually clear the heap when it is important
+    /// to achive better time complexity.
+    /// \param i The item.
+    /// \param st The state. It should not be \c IN_HEAP.
+    void state(const Item& i, State st) {
+      switch (st) {
+        case POST_HEAP:
+        case PRE_HEAP:
+          if (state(i) == IN_HEAP) erase(i);
+          _iim[i] = st;
+          break;
+        case IN_HEAP:
+          break;
+      }
+    }
+
+    /// \brief Replace an item in the heap.
+    ///
+    /// This function replaces item \c i with item \c j.
+    /// Item \c i must be in the heap, while \c j must be out of the heap.
+    /// After calling this method, item \c i will be out of the
+    /// heap and \c j will be in the heap with the same prioriority
+    /// as item \c i had before.
+    void replace(const Item& i, const Item& j) {
+      int idx=_iim[i];
+      _iim.set(i, _iim[j]);
+      _iim.set(j, idx);
+      _data[idx].first=j;
+    }
+
+  }; // class KaryHeap
+
+} // namespace lemon
+
+#endif // LEMON_KARY_HEAP_H
Index: lemon/kruskal.h
===================================================================
--- lemon/kruskal.h	(revision 1270)
+++ lemon/kruskal.h	(revision 631)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -31,4 +31,7 @@
 ///\file
 ///\brief Kruskal's algorithm to compute a minimum cost spanning tree
+///
+///Kruskal's algorithm to compute a minimum cost spanning tree.
+///
 
 namespace lemon {
Index: lemon/lemon.pc.in
===================================================================
--- lemon/lemon.pc.in	(revision 1133)
+++ lemon/lemon.pc.in	(revision 705)
@@ -1,10 +1,10 @@
-prefix=@CMAKE_INSTALL_PREFIX@
-exec_prefix=@CMAKE_INSTALL_PREFIX@/bin
-libdir=@CMAKE_INSTALL_PREFIX@/lib
-includedir=@CMAKE_INSTALL_PREFIX@/include
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
 
-Name: @PROJECT_NAME@
+Name: @PACKAGE_NAME@
 Description: Library for Efficient Modeling and Optimization in Networks
-Version: @PROJECT_VERSION@
+Version: @PACKAGE_VERSION@
 Libs: -L${libdir} -lemon @GLPK_LIBS@ @CPLEX_LIBS@ @SOPLEX_LIBS@ @CLP_LIBS@ @CBC_LIBS@
 Cflags: -I${includedir}
Index: lemon/lgf_reader.h
===================================================================
--- lemon/lgf_reader.h	(revision 1361)
+++ lemon/lgf_reader.h	(revision 833)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -155,14 +155,14 @@
     };
 
-    template <typename Value,
-              typename Map = std::map<std::string, Value> >
+    template <typename Value>
     struct MapLookUpConverter {
-      const Map& _map;
-
-      MapLookUpConverter(const Map& map)
+      const std::map<std::string, Value>& _map;
+
+      MapLookUpConverter(const std::map<std::string, Value>& map)
         : _map(map) {}
 
       Value operator()(const std::string& str) {
-        typename Map::const_iterator it = _map.find(str);
+        typename std::map<std::string, Value>::const_iterator it =
+          _map.find(str);
         if (it == _map.end()) {
           std::ostringstream msg;
@@ -171,37 +171,4 @@
         }
         return it->second;
-      }
-    };
-
-    template <typename Value,
-              typename Map1 = std::map<std::string, Value>,
-              typename Map2 = std::map<std::string, Value> >
-    struct DoubleMapLookUpConverter {
-      const Map1& _map1;
-      const Map2& _map2;
-
-      DoubleMapLookUpConverter(const Map1& map1, const Map2& map2)
-        : _map1(map1), _map2(map2) {}
-
-      Value operator()(const std::string& str) {
-        typename Map1::const_iterator it1 = _map1.find(str);
-        typename Map2::const_iterator it2 = _map2.find(str);
-        if (it1 == _map1.end()) {
-          if (it2 == _map2.end()) {
-            std::ostringstream msg;
-            msg << "Item not found: " << str;
-            throw FormatError(msg.str());
-          } else {
-            return it2->second;
-          }
-        } else {
-          if (it2 == _map2.end()) {
-            return it1->second;
-          } else {
-            std::ostringstream msg;
-            msg << "Item is ambigous: " << str;
-            throw FormatError(msg.str());
-          }
-        }
       }
     };
@@ -596,5 +563,5 @@
     friend DigraphReader<TDGR> digraphReader(TDGR& digraph, std::istream& is);
     template <typename TDGR>
-    friend DigraphReader<TDGR> digraphReader(TDGR& digraph,
+    friend DigraphReader<TDGR> digraphReader(TDGR& digraph, 
                                              const std::string& fn);
     template <typename TDGR>
@@ -998,11 +965,4 @@
         int index = 0;
         while (_reader_bits::readToken(line, map)) {
-          if(map == "-") {
-              if(index!=0)
-                throw FormatError("'-' is not allowed as a map name");
-              else if (line >> std::ws >> c)
-                throw FormatError("Extra character at the end of line");
-              else break;
-            }
           if (maps.find(map) != maps.end()) {
             std::ostringstream msg;
@@ -1228,13 +1188,12 @@
 
   };
-
+  
   /// \ingroup lemon_io
   ///
-  /// \brief Return a \ref lemon::DigraphReader "DigraphReader" class
-  ///
-  /// This function just returns a \ref lemon::DigraphReader
-  /// "DigraphReader" class.
-  ///
-  /// With this function a digraph can be read from an
+  /// \brief Return a \ref DigraphReader class
+  ///
+  /// This function just returns a \ref DigraphReader class.
+  ///
+  /// With this function a digraph can be read from an 
   /// \ref lgf-format "LGF" file or input stream with several maps and
   /// attributes. For example, there is network flow problem on a
@@ -1245,5 +1204,5 @@
   ///\code
   ///ListDigraph digraph;
-  ///ListDigraph::ArcMap<int> cap(digraph);
+  ///ListDigraph::ArcMap<int> cm(digraph);
   ///ListDigraph::Node src, trg;
   ///digraphReader(digraph, std::cin).
@@ -1254,8 +1213,7 @@
   ///\endcode
   ///
-  /// For a complete documentation, please see the
-  /// \ref lemon::DigraphReader "DigraphReader"
+  /// For a complete documentation, please see the \ref DigraphReader
   /// class documentation.
-  /// \warning Don't forget to put the \ref lemon::DigraphReader::run() "run()"
+  /// \warning Don't forget to put the \ref DigraphReader::run() "run()"
   /// to the end of the parameter list.
   /// \relates DigraphReader
@@ -1292,5 +1250,5 @@
   template <typename GR>
   class GraphReader;
-
+ 
   template <typename TGR>
   GraphReader<TGR> graphReader(TGR& graph, std::istream& is = std::cin);
@@ -1429,5 +1387,5 @@
     friend GraphReader<TGR> graphReader(TGR& graph, std::istream& is);
     template <typename TGR>
-    friend GraphReader<TGR> graphReader(TGR& graph, const std::string& fn);
+    friend GraphReader<TGR> graphReader(TGR& graph, const std::string& fn); 
     template <typename TGR>
     friend GraphReader<TGR> graphReader(TGR& graph, const char *fn);
@@ -1877,11 +1835,4 @@
         int index = 0;
         while (_reader_bits::readToken(line, map)) {
-          if(map == "-") {
-              if(index!=0)
-                throw FormatError("'-' is not allowed as a map name");
-              else if (line >> std::ws >> c)
-                throw FormatError("Extra character at the end of line");
-              else break;
-            }
           if (maps.find(map) != maps.end()) {
             std::ostringstream msg;
@@ -2111,9 +2062,9 @@
   /// \ingroup lemon_io
   ///
-  /// \brief Return a \ref lemon::GraphReader "GraphReader" class
-  ///
-  /// This function just returns a \ref lemon::GraphReader "GraphReader" class.
-  ///
-  /// With this function a graph can be read from an
+  /// \brief Return a \ref GraphReader class
+  ///
+  /// This function just returns a \ref GraphReader class. 
+  ///
+  /// With this function a graph can be read from an 
   /// \ref lgf-format "LGF" file or input stream with several maps and
   /// attributes. For example, there is weighted matching problem on a
@@ -2129,8 +2080,7 @@
   ///\endcode
   ///
-  /// For a complete documentation, please see the
-  /// \ref lemon::GraphReader "GraphReader"
+  /// For a complete documentation, please see the \ref GraphReader
   /// class documentation.
-  /// \warning Don't forget to put the \ref lemon::GraphReader::run() "run()"
+  /// \warning Don't forget to put the \ref GraphReader::run() "run()"
   /// to the end of the parameter list.
   /// \relates GraphReader
@@ -2162,1072 +2112,4 @@
   GraphReader<TGR> graphReader(TGR& graph, const char* fn) {
     GraphReader<TGR> tmp(graph, fn);
-    return tmp;
-  }
-
-  template <typename BGR>
-  class BpGraphReader;
-
-  template <typename TBGR>
-  BpGraphReader<TBGR> bpGraphReader(TBGR& graph, std::istream& is = std::cin);
-  template <typename TBGR>
-  BpGraphReader<TBGR> bpGraphReader(TBGR& graph, const std::string& fn);
-  template <typename TBGR>
-  BpGraphReader<TBGR> bpGraphReader(TBGR& graph, const char *fn);
-
-  /// \ingroup lemon_io
-  ///
-  /// \brief \ref lgf-format "LGF" reader for bipartite graphs
-  ///
-  /// This utility reads an \ref lgf-format "LGF" file.
-  ///
-  /// It can be used almost the same way as \c GraphReader, but it
-  /// reads the red and blue nodes from separate sections, and these
-  /// sections can contain different set of maps.
-  ///
-  /// The red and blue node maps are read from the corresponding
-  /// sections. If a map is defined with the same name in both of
-  /// these sections, then it can be read as a node map.
-  template <typename BGR>
-  class BpGraphReader {
-  public:
-
-    typedef BGR Graph;
-
-  private:
-
-    TEMPLATE_BPGRAPH_TYPEDEFS(BGR);
-
-    std::istream* _is;
-    bool local_is;
-    std::string _filename;
-
-    BGR& _graph;
-
-    std::string _nodes_caption;
-    std::string _edges_caption;
-    std::string _attributes_caption;
-
-    typedef std::map<std::string, RedNode> RedNodeIndex;
-    RedNodeIndex _red_node_index;
-    typedef std::map<std::string, BlueNode> BlueNodeIndex;
-    BlueNodeIndex _blue_node_index;
-    typedef std::map<std::string, Edge> EdgeIndex;
-    EdgeIndex _edge_index;
-
-    typedef std::vector<std::pair<std::string,
-      _reader_bits::MapStorageBase<RedNode>*> > RedNodeMaps;
-    RedNodeMaps _red_node_maps;
-    typedef std::vector<std::pair<std::string,
-      _reader_bits::MapStorageBase<BlueNode>*> > BlueNodeMaps;
-    BlueNodeMaps _blue_node_maps;
-
-    typedef std::vector<std::pair<std::string,
-      _reader_bits::MapStorageBase<Edge>*> > EdgeMaps;
-    EdgeMaps _edge_maps;
-
-    typedef std::multimap<std::string, _reader_bits::ValueStorageBase*>
-      Attributes;
-    Attributes _attributes;
-
-    bool _use_nodes;
-    bool _use_edges;
-
-    bool _skip_nodes;
-    bool _skip_edges;
-
-    int line_num;
-    std::istringstream line;
-
-  public:
-
-    /// \brief Constructor
-    ///
-    /// Construct an undirected graph reader, which reads from the given
-    /// input stream.
-    BpGraphReader(BGR& graph, std::istream& is = std::cin)
-      : _is(&is), local_is(false), _graph(graph),
-        _use_nodes(false), _use_edges(false),
-        _skip_nodes(false), _skip_edges(false) {}
-
-    /// \brief Constructor
-    ///
-    /// Construct an undirected graph reader, which reads from the given
-    /// file.
-    BpGraphReader(BGR& graph, const std::string& fn)
-      : _is(new std::ifstream(fn.c_str())), local_is(true),
-        _filename(fn), _graph(graph),
-        _use_nodes(false), _use_edges(false),
-        _skip_nodes(false), _skip_edges(false) {
-      if (!(*_is)) {
-        delete _is;
-        throw IoError("Cannot open file", fn);
-      }
-    }
-
-    /// \brief Constructor
-    ///
-    /// Construct an undirected graph reader, which reads from the given
-    /// file.
-    BpGraphReader(BGR& graph, const char* fn)
-      : _is(new std::ifstream(fn)), local_is(true),
-        _filename(fn), _graph(graph),
-        _use_nodes(false), _use_edges(false),
-        _skip_nodes(false), _skip_edges(false) {
-      if (!(*_is)) {
-        delete _is;
-        throw IoError("Cannot open file", fn);
-      }
-    }
-
-    /// \brief Destructor
-    ~BpGraphReader() {
-      for (typename RedNodeMaps::iterator it = _red_node_maps.begin();
-           it != _red_node_maps.end(); ++it) {
-        delete it->second;
-      }
-
-      for (typename BlueNodeMaps::iterator it = _blue_node_maps.begin();
-           it != _blue_node_maps.end(); ++it) {
-        delete it->second;
-      }
-
-      for (typename EdgeMaps::iterator it = _edge_maps.begin();
-           it != _edge_maps.end(); ++it) {
-        delete it->second;
-      }
-
-      for (typename Attributes::iterator it = _attributes.begin();
-           it != _attributes.end(); ++it) {
-        delete it->second;
-      }
-
-      if (local_is) {
-        delete _is;
-      }
-
-    }
-
-  private:
-    template <typename TBGR>
-    friend BpGraphReader<TBGR> bpGraphReader(TBGR& graph, std::istream& is);
-    template <typename TBGR>
-    friend BpGraphReader<TBGR> bpGraphReader(TBGR& graph,
-                                             const std::string& fn);
-    template <typename TBGR>
-    friend BpGraphReader<TBGR> bpGraphReader(TBGR& graph, const char *fn);
-
-    BpGraphReader(BpGraphReader& other)
-      : _is(other._is), local_is(other.local_is), _graph(other._graph),
-        _use_nodes(other._use_nodes), _use_edges(other._use_edges),
-        _skip_nodes(other._skip_nodes), _skip_edges(other._skip_edges) {
-
-      other._is = 0;
-      other.local_is = false;
-
-      _red_node_index.swap(other._red_node_index);
-      _blue_node_index.swap(other._blue_node_index);
-      _edge_index.swap(other._edge_index);
-
-      _red_node_maps.swap(other._red_node_maps);
-      _blue_node_maps.swap(other._blue_node_maps);
-      _edge_maps.swap(other._edge_maps);
-      _attributes.swap(other._attributes);
-
-      _nodes_caption = other._nodes_caption;
-      _edges_caption = other._edges_caption;
-      _attributes_caption = other._attributes_caption;
-
-    }
-
-    BpGraphReader& operator=(const BpGraphReader&);
-
-  public:
-
-    /// \name Reading Rules
-    /// @{
-
-    /// \brief Node map reading rule
-    ///
-    /// Add a node map reading rule to the reader.
-    template <typename Map>
-    BpGraphReader& nodeMap(const std::string& caption, Map& map) {
-      checkConcept<concepts::WriteMap<Node, typename Map::Value>, Map>();
-      _reader_bits::MapStorageBase<RedNode>* red_storage =
-        new _reader_bits::MapStorage<RedNode, Map>(map);
-      _red_node_maps.push_back(std::make_pair(caption, red_storage));
-      _reader_bits::MapStorageBase<BlueNode>* blue_storage =
-        new _reader_bits::MapStorage<BlueNode, Map>(map);
-      _blue_node_maps.push_back(std::make_pair(caption, blue_storage));
-      return *this;
-    }
-
-    /// \brief Node map reading rule
-    ///
-    /// Add a node map reading rule with specialized converter to the
-    /// reader.
-    template <typename Map, typename Converter>
-    BpGraphReader& nodeMap(const std::string& caption, Map& map,
-                           const Converter& converter = Converter()) {
-      checkConcept<concepts::WriteMap<Node, typename Map::Value>, Map>();
-      _reader_bits::MapStorageBase<RedNode>* red_storage =
-        new _reader_bits::MapStorage<RedNode, Map, Converter>(map, converter);
-      _red_node_maps.push_back(std::make_pair(caption, red_storage));
-      _reader_bits::MapStorageBase<BlueNode>* blue_storage =
-        new _reader_bits::MapStorage<BlueNode, Map, Converter>(map, converter);
-      _blue_node_maps.push_back(std::make_pair(caption, blue_storage));
-      return *this;
-    }
-
-    /// Add a red node map reading rule to the reader.
-    template <typename Map>
-    BpGraphReader& redNodeMap(const std::string& caption, Map& map) {
-      checkConcept<concepts::WriteMap<RedNode, typename Map::Value>, Map>();
-      _reader_bits::MapStorageBase<RedNode>* storage =
-        new _reader_bits::MapStorage<RedNode, Map>(map);
-      _red_node_maps.push_back(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// \brief Red node map reading rule
-    ///
-    /// Add a red node map node reading rule with specialized converter to
-    /// the reader.
-    template <typename Map, typename Converter>
-    BpGraphReader& redNodeMap(const std::string& caption, Map& map,
-                              const Converter& converter = Converter()) {
-      checkConcept<concepts::WriteMap<RedNode, typename Map::Value>, Map>();
-      _reader_bits::MapStorageBase<RedNode>* storage =
-        new _reader_bits::MapStorage<RedNode, Map, Converter>(map, converter);
-      _red_node_maps.push_back(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// Add a blue node map reading rule to the reader.
-    template <typename Map>
-    BpGraphReader& blueNodeMap(const std::string& caption, Map& map) {
-      checkConcept<concepts::WriteMap<BlueNode, typename Map::Value>, Map>();
-      _reader_bits::MapStorageBase<BlueNode>* storage =
-        new _reader_bits::MapStorage<BlueNode, Map>(map);
-      _blue_node_maps.push_back(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// \brief Blue node map reading rule
-    ///
-    /// Add a blue node map reading rule with specialized converter to
-    /// the reader.
-    template <typename Map, typename Converter>
-    BpGraphReader& blueNodeMap(const std::string& caption, Map& map,
-                               const Converter& converter = Converter()) {
-      checkConcept<concepts::WriteMap<BlueNode, typename Map::Value>, Map>();
-      _reader_bits::MapStorageBase<BlueNode>* storage =
-        new _reader_bits::MapStorage<BlueNode, Map, Converter>(map, converter);
-      _blue_node_maps.push_back(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// \brief Edge map reading rule
-    ///
-    /// Add an edge map reading rule to the reader.
-    template <typename Map>
-    BpGraphReader& edgeMap(const std::string& caption, Map& map) {
-      checkConcept<concepts::WriteMap<Edge, typename Map::Value>, Map>();
-      _reader_bits::MapStorageBase<Edge>* storage =
-        new _reader_bits::MapStorage<Edge, Map>(map);
-      _edge_maps.push_back(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// \brief Edge map reading rule
-    ///
-    /// Add an edge map reading rule with specialized converter to the
-    /// reader.
-    template <typename Map, typename Converter>
-    BpGraphReader& edgeMap(const std::string& caption, Map& map,
-                          const Converter& converter = Converter()) {
-      checkConcept<concepts::WriteMap<Edge, typename Map::Value>, Map>();
-      _reader_bits::MapStorageBase<Edge>* storage =
-        new _reader_bits::MapStorage<Edge, Map, Converter>(map, converter);
-      _edge_maps.push_back(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// \brief Arc map reading rule
-    ///
-    /// Add an arc map reading rule to the reader.
-    template <typename Map>
-    BpGraphReader& arcMap(const std::string& caption, Map& map) {
-      checkConcept<concepts::WriteMap<Arc, typename Map::Value>, Map>();
-      _reader_bits::MapStorageBase<Edge>* forward_storage =
-        new _reader_bits::GraphArcMapStorage<Graph, true, Map>(_graph, map);
-      _edge_maps.push_back(std::make_pair('+' + caption, forward_storage));
-      _reader_bits::MapStorageBase<Edge>* backward_storage =
-        new _reader_bits::GraphArcMapStorage<BGR, false, Map>(_graph, map);
-      _edge_maps.push_back(std::make_pair('-' + caption, backward_storage));
-      return *this;
-    }
-
-    /// \brief Arc map reading rule
-    ///
-    /// Add an arc map reading rule with specialized converter to the
-    /// reader.
-    template <typename Map, typename Converter>
-    BpGraphReader& arcMap(const std::string& caption, Map& map,
-                          const Converter& converter = Converter()) {
-      checkConcept<concepts::WriteMap<Arc, typename Map::Value>, Map>();
-      _reader_bits::MapStorageBase<Edge>* forward_storage =
-        new _reader_bits::GraphArcMapStorage<BGR, true, Map, Converter>
-        (_graph, map, converter);
-      _edge_maps.push_back(std::make_pair('+' + caption, forward_storage));
-      _reader_bits::MapStorageBase<Edge>* backward_storage =
-        new _reader_bits::GraphArcMapStorage<BGR, false, Map, Converter>
-        (_graph, map, converter);
-      _edge_maps.push_back(std::make_pair('-' + caption, backward_storage));
-      return *this;
-    }
-
-    /// \brief Attribute reading rule
-    ///
-    /// Add an attribute reading rule to the reader.
-    template <typename Value>
-    BpGraphReader& attribute(const std::string& caption, Value& value) {
-      _reader_bits::ValueStorageBase* storage =
-        new _reader_bits::ValueStorage<Value>(value);
-      _attributes.insert(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// \brief Attribute reading rule
-    ///
-    /// Add an attribute reading rule with specialized converter to the
-    /// reader.
-    template <typename Value, typename Converter>
-    BpGraphReader& attribute(const std::string& caption, Value& value,
-                             const Converter& converter = Converter()) {
-      _reader_bits::ValueStorageBase* storage =
-        new _reader_bits::ValueStorage<Value, Converter>(value, converter);
-      _attributes.insert(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// \brief Node reading rule
-    ///
-    /// Add a node reading rule to reader.
-    BpGraphReader& node(const std::string& caption, Node& node) {
-      typedef _reader_bits::DoubleMapLookUpConverter<
-        Node, RedNodeIndex, BlueNodeIndex> Converter;
-      Converter converter(_red_node_index, _blue_node_index);
-      _reader_bits::ValueStorageBase* storage =
-        new _reader_bits::ValueStorage<Node, Converter>(node, converter);
-      _attributes.insert(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// \brief Red node reading rule
-    ///
-    /// Add a red node reading rule to reader.
-    BpGraphReader& redNode(const std::string& caption, RedNode& node) {
-      typedef _reader_bits::MapLookUpConverter<RedNode> Converter;
-      Converter converter(_red_node_index);
-      _reader_bits::ValueStorageBase* storage =
-        new _reader_bits::ValueStorage<RedNode, Converter>(node, converter);
-      _attributes.insert(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// \brief Blue node reading rule
-    ///
-    /// Add a blue node reading rule to reader.
-    BpGraphReader& blueNode(const std::string& caption, BlueNode& node) {
-      typedef _reader_bits::MapLookUpConverter<BlueNode> Converter;
-      Converter converter(_blue_node_index);
-      _reader_bits::ValueStorageBase* storage =
-        new _reader_bits::ValueStorage<BlueNode, Converter>(node, converter);
-      _attributes.insert(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// \brief Edge reading rule
-    ///
-    /// Add an edge reading rule to reader.
-    BpGraphReader& edge(const std::string& caption, Edge& edge) {
-      typedef _reader_bits::MapLookUpConverter<Edge> Converter;
-      Converter converter(_edge_index);
-      _reader_bits::ValueStorageBase* storage =
-        new _reader_bits::ValueStorage<Edge, Converter>(edge, converter);
-      _attributes.insert(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// \brief Arc reading rule
-    ///
-    /// Add an arc reading rule to reader.
-    BpGraphReader& arc(const std::string& caption, Arc& arc) {
-      typedef _reader_bits::GraphArcLookUpConverter<BGR> Converter;
-      Converter converter(_graph, _edge_index);
-      _reader_bits::ValueStorageBase* storage =
-        new _reader_bits::ValueStorage<Arc, Converter>(arc, converter);
-      _attributes.insert(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// @}
-
-    /// \name Select Section by Name
-    /// @{
-
-    /// \brief Set \c \@nodes section to be read
-    ///
-    /// Set \c \@nodes section to be read.
-    BpGraphReader& nodes(const std::string& caption) {
-      _nodes_caption = caption;
-      return *this;
-    }
-
-    /// \brief Set \c \@edges section to be read
-    ///
-    /// Set \c \@edges section to be read.
-    BpGraphReader& edges(const std::string& caption) {
-      _edges_caption = caption;
-      return *this;
-    }
-
-    /// \brief Set \c \@attributes section to be read
-    ///
-    /// Set \c \@attributes section to be read.
-    BpGraphReader& attributes(const std::string& caption) {
-      _attributes_caption = caption;
-      return *this;
-    }
-
-    /// @}
-
-    /// \name Using Previously Constructed Node or Edge Set
-    /// @{
-
-    /// \brief Use previously constructed node set
-    ///
-    /// Use previously constructed node set, and specify the node
-    /// label map.
-    template <typename Map>
-    BpGraphReader& useNodes(const Map& map) {
-      checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
-      LEMON_ASSERT(!_use_nodes, "Multiple usage of useNodes() member");
-      _use_nodes = true;
-      _writer_bits::DefaultConverter<typename Map::Value> converter;
-      for (RedNodeIt n(_graph); n != INVALID; ++n) {
-        _red_node_index.insert(std::make_pair(converter(map[n]), n));
-      }
-      for (BlueNodeIt n(_graph); n != INVALID; ++n) {
-        _blue_node_index.insert(std::make_pair(converter(map[n]), n));
-      }
-      return *this;
-    }
-
-    /// \brief Use previously constructed node set
-    ///
-    /// Use previously constructed node set, and specify the node
-    /// label map and a functor which converts the label map values to
-    /// \c std::string.
-    template <typename Map, typename Converter>
-    BpGraphReader& useNodes(const Map& map,
-                            const Converter& converter = Converter()) {
-      checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
-      LEMON_ASSERT(!_use_nodes, "Multiple usage of useNodes() member");
-      _use_nodes = true;
-      for (RedNodeIt n(_graph); n != INVALID; ++n) {
-        _red_node_index.insert(std::make_pair(converter(map[n]), n));
-      }
-      for (BlueNodeIt n(_graph); n != INVALID; ++n) {
-        _blue_node_index.insert(std::make_pair(converter(map[n]), n));
-      }
-      return *this;
-    }
-
-    /// \brief Use previously constructed edge set
-    ///
-    /// Use previously constructed edge set, and specify the edge
-    /// label map.
-    template <typename Map>
-    BpGraphReader& useEdges(const Map& map) {
-      checkConcept<concepts::ReadMap<Edge, typename Map::Value>, Map>();
-      LEMON_ASSERT(!_use_edges, "Multiple usage of useEdges() member");
-      _use_edges = true;
-      _writer_bits::DefaultConverter<typename Map::Value> converter;
-      for (EdgeIt a(_graph); a != INVALID; ++a) {
-        _edge_index.insert(std::make_pair(converter(map[a]), a));
-      }
-      return *this;
-    }
-
-    /// \brief Use previously constructed edge set
-    ///
-    /// Use previously constructed edge set, and specify the edge
-    /// label map and a functor which converts the label map values to
-    /// \c std::string.
-    template <typename Map, typename Converter>
-    BpGraphReader& useEdges(const Map& map,
-                            const Converter& converter = Converter()) {
-      checkConcept<concepts::ReadMap<Edge, typename Map::Value>, Map>();
-      LEMON_ASSERT(!_use_edges, "Multiple usage of useEdges() member");
-      _use_edges = true;
-      for (EdgeIt a(_graph); a != INVALID; ++a) {
-        _edge_index.insert(std::make_pair(converter(map[a]), a));
-      }
-      return *this;
-    }
-
-    /// \brief Skip the reading of node section
-    ///
-    /// Omit the reading of the node section. This implies that each node
-    /// map reading rule will be abandoned, and the nodes of the graph
-    /// will not be constructed, which usually cause that the edge set
-    /// could not be read due to lack of node name
-    /// could not be read due to lack of node name resolving.
-    /// Therefore \c skipEdges() function should also be used, or
-    /// \c useNodes() should be used to specify the label of the nodes.
-    BpGraphReader& skipNodes() {
-      LEMON_ASSERT(!_skip_nodes, "Skip nodes already set");
-      _skip_nodes = true;
-      return *this;
-    }
-
-    /// \brief Skip the reading of edge section
-    ///
-    /// Omit the reading of the edge section. This implies that each edge
-    /// map reading rule will be abandoned, and the edges of the graph
-    /// will not be constructed.
-    BpGraphReader& skipEdges() {
-      LEMON_ASSERT(!_skip_edges, "Skip edges already set");
-      _skip_edges = true;
-      return *this;
-    }
-
-    /// @}
-
-  private:
-
-    bool readLine() {
-      std::string str;
-      while(++line_num, std::getline(*_is, str)) {
-        line.clear(); line.str(str);
-        char c;
-        if (line >> std::ws >> c && c != '#') {
-          line.putback(c);
-          return true;
-        }
-      }
-      return false;
-    }
-
-    bool readSuccess() {
-      return static_cast<bool>(*_is);
-    }
-
-    void skipSection() {
-      char c;
-      while (readSuccess() && line >> c && c != '@') {
-        readLine();
-      }
-      if (readSuccess()) {
-        line.putback(c);
-      }
-    }
-
-    void readRedNodes() {
-
-      std::vector<int> map_index(_red_node_maps.size());
-      int map_num, label_index;
-
-      char c;
-      if (!readLine() || !(line >> c) || c == '@') {
-        if (readSuccess() && line) line.putback(c);
-        if (!_red_node_maps.empty())
-          throw FormatError("Cannot find map names");
-        return;
-      }
-      line.putback(c);
-
-      {
-        std::map<std::string, int> maps;
-
-        std::string map;
-        int index = 0;
-        while (_reader_bits::readToken(line, map)) {
-          if (maps.find(map) != maps.end()) {
-            std::ostringstream msg;
-            msg << "Multiple occurence of red node map: " << map;
-            throw FormatError(msg.str());
-          }
-          maps.insert(std::make_pair(map, index));
-          ++index;
-        }
-
-        for (int i = 0; i < static_cast<int>(_red_node_maps.size()); ++i) {
-          std::map<std::string, int>::iterator jt =
-            maps.find(_red_node_maps[i].first);
-          if (jt == maps.end()) {
-            std::ostringstream msg;
-            msg << "Map not found: " << _red_node_maps[i].first;
-            throw FormatError(msg.str());
-          }
-          map_index[i] = jt->second;
-        }
-
-        {
-          std::map<std::string, int>::iterator jt = maps.find("label");
-          if (jt != maps.end()) {
-            label_index = jt->second;
-          } else {
-            label_index = -1;
-          }
-        }
-        map_num = maps.size();
-      }
-
-      while (readLine() && line >> c && c != '@') {
-        line.putback(c);
-
-        std::vector<std::string> tokens(map_num);
-        for (int i = 0; i < map_num; ++i) {
-          if (!_reader_bits::readToken(line, tokens[i])) {
-            std::ostringstream msg;
-            msg << "Column not found (" << i + 1 << ")";
-            throw FormatError(msg.str());
-          }
-        }
-        if (line >> std::ws >> c)
-          throw FormatError("Extra character at the end of line");
-
-        RedNode n;
-        if (!_use_nodes) {
-          n = _graph.addRedNode();
-          if (label_index != -1)
-            _red_node_index.insert(std::make_pair(tokens[label_index], n));
-        } else {
-          if (label_index == -1)
-            throw FormatError("Label map not found");
-          typename std::map<std::string, RedNode>::iterator it =
-            _red_node_index.find(tokens[label_index]);
-          if (it == _red_node_index.end()) {
-            std::ostringstream msg;
-            msg << "Node with label not found: " << tokens[label_index];
-            throw FormatError(msg.str());
-          }
-          n = it->second;
-        }
-
-        for (int i = 0; i < static_cast<int>(_red_node_maps.size()); ++i) {
-          _red_node_maps[i].second->set(n, tokens[map_index[i]]);
-        }
-
-      }
-      if (readSuccess()) {
-        line.putback(c);
-      }
-    }
-
-    void readBlueNodes() {
-
-      std::vector<int> map_index(_blue_node_maps.size());
-      int map_num, label_index;
-
-      char c;
-      if (!readLine() || !(line >> c) || c == '@') {
-        if (readSuccess() && line) line.putback(c);
-        if (!_blue_node_maps.empty())
-          throw FormatError("Cannot find map names");
-        return;
-      }
-      line.putback(c);
-
-      {
-        std::map<std::string, int> maps;
-
-        std::string map;
-        int index = 0;
-        while (_reader_bits::readToken(line, map)) {
-          if (maps.find(map) != maps.end()) {
-            std::ostringstream msg;
-            msg << "Multiple occurence of blue node map: " << map;
-            throw FormatError(msg.str());
-          }
-          maps.insert(std::make_pair(map, index));
-          ++index;
-        }
-
-        for (int i = 0; i < static_cast<int>(_blue_node_maps.size()); ++i) {
-          std::map<std::string, int>::iterator jt =
-            maps.find(_blue_node_maps[i].first);
-          if (jt == maps.end()) {
-            std::ostringstream msg;
-            msg << "Map not found: " << _blue_node_maps[i].first;
-            throw FormatError(msg.str());
-          }
-          map_index[i] = jt->second;
-        }
-
-        {
-          std::map<std::string, int>::iterator jt = maps.find("label");
-          if (jt != maps.end()) {
-            label_index = jt->second;
-          } else {
-            label_index = -1;
-          }
-        }
-        map_num = maps.size();
-      }
-
-      while (readLine() && line >> c && c != '@') {
-        line.putback(c);
-
-        std::vector<std::string> tokens(map_num);
-        for (int i = 0; i < map_num; ++i) {
-          if (!_reader_bits::readToken(line, tokens[i])) {
-            std::ostringstream msg;
-            msg << "Column not found (" << i + 1 << ")";
-            throw FormatError(msg.str());
-          }
-        }
-        if (line >> std::ws >> c)
-          throw FormatError("Extra character at the end of line");
-
-        BlueNode n;
-        if (!_use_nodes) {
-          n = _graph.addBlueNode();
-          if (label_index != -1)
-            _blue_node_index.insert(std::make_pair(tokens[label_index], n));
-        } else {
-          if (label_index == -1)
-            throw FormatError("Label map not found");
-          typename std::map<std::string, BlueNode>::iterator it =
-            _blue_node_index.find(tokens[label_index]);
-          if (it == _blue_node_index.end()) {
-            std::ostringstream msg;
-            msg << "Node with label not found: " << tokens[label_index];
-            throw FormatError(msg.str());
-          }
-          n = it->second;
-        }
-
-        for (int i = 0; i < static_cast<int>(_blue_node_maps.size()); ++i) {
-          _blue_node_maps[i].second->set(n, tokens[map_index[i]]);
-        }
-
-      }
-      if (readSuccess()) {
-        line.putback(c);
-      }
-    }
-
-    void readEdges() {
-
-      std::vector<int> map_index(_edge_maps.size());
-      int map_num, label_index;
-
-      char c;
-      if (!readLine() || !(line >> c) || c == '@') {
-        if (readSuccess() && line) line.putback(c);
-        if (!_edge_maps.empty())
-          throw FormatError("Cannot find map names");
-        return;
-      }
-      line.putback(c);
-
-      {
-        std::map<std::string, int> maps;
-
-        std::string map;
-        int index = 0;
-        while (_reader_bits::readToken(line, map)) {
-          if (maps.find(map) != maps.end()) {
-            std::ostringstream msg;
-            msg << "Multiple occurence of edge map: " << map;
-            throw FormatError(msg.str());
-          }
-          maps.insert(std::make_pair(map, index));
-          ++index;
-        }
-
-        for (int i = 0; i < static_cast<int>(_edge_maps.size()); ++i) {
-          std::map<std::string, int>::iterator jt =
-            maps.find(_edge_maps[i].first);
-          if (jt == maps.end()) {
-            std::ostringstream msg;
-            msg << "Map not found: " << _edge_maps[i].first;
-            throw FormatError(msg.str());
-          }
-          map_index[i] = jt->second;
-        }
-
-        {
-          std::map<std::string, int>::iterator jt = maps.find("label");
-          if (jt != maps.end()) {
-            label_index = jt->second;
-          } else {
-            label_index = -1;
-          }
-        }
-        map_num = maps.size();
-      }
-
-      while (readLine() && line >> c && c != '@') {
-        line.putback(c);
-
-        std::string source_token;
-        std::string target_token;
-
-        if (!_reader_bits::readToken(line, source_token))
-          throw FormatError("Red node not found");
-
-        if (!_reader_bits::readToken(line, target_token))
-          throw FormatError("Blue node not found");
-
-        std::vector<std::string> tokens(map_num);
-        for (int i = 0; i < map_num; ++i) {
-          if (!_reader_bits::readToken(line, tokens[i])) {
-            std::ostringstream msg;
-            msg << "Column not found (" << i + 1 << ")";
-            throw FormatError(msg.str());
-          }
-        }
-        if (line >> std::ws >> c)
-          throw FormatError("Extra character at the end of line");
-
-        Edge e;
-        if (!_use_edges) {
-          typename RedNodeIndex::iterator rit =
-            _red_node_index.find(source_token);
-          if (rit == _red_node_index.end()) {
-            std::ostringstream msg;
-            msg << "Item not found: " << source_token;
-            throw FormatError(msg.str());
-          }
-          RedNode source = rit->second;
-          typename BlueNodeIndex::iterator it =
-            _blue_node_index.find(target_token);
-          if (it == _blue_node_index.end()) {
-            std::ostringstream msg;
-            msg << "Item not found: " << target_token;
-            throw FormatError(msg.str());
-          }
-          BlueNode target = it->second;
-
-          // It is checked that source is red and
-          // target is blue, so this should be safe:
-          e = _graph.addEdge(source, target);
-          if (label_index != -1)
-            _edge_index.insert(std::make_pair(tokens[label_index], e));
-        } else {
-          if (label_index == -1)
-            throw FormatError("Label map not found");
-          typename std::map<std::string, Edge>::iterator it =
-            _edge_index.find(tokens[label_index]);
-          if (it == _edge_index.end()) {
-            std::ostringstream msg;
-            msg << "Edge with label not found: " << tokens[label_index];
-            throw FormatError(msg.str());
-          }
-          e = it->second;
-        }
-
-        for (int i = 0; i < static_cast<int>(_edge_maps.size()); ++i) {
-          _edge_maps[i].second->set(e, tokens[map_index[i]]);
-        }
-
-      }
-      if (readSuccess()) {
-        line.putback(c);
-      }
-    }
-
-    void readAttributes() {
-
-      std::set<std::string> read_attr;
-
-      char c;
-      while (readLine() && line >> c && c != '@') {
-        line.putback(c);
-
-        std::string attr, token;
-        if (!_reader_bits::readToken(line, attr))
-          throw FormatError("Attribute name not found");
-        if (!_reader_bits::readToken(line, token))
-          throw FormatError("Attribute value not found");
-        if (line >> c)
-          throw FormatError("Extra character at the end of line");
-
-        {
-          std::set<std::string>::iterator it = read_attr.find(attr);
-          if (it != read_attr.end()) {
-            std::ostringstream msg;
-            msg << "Multiple occurence of attribute: " << attr;
-            throw FormatError(msg.str());
-          }
-          read_attr.insert(attr);
-        }
-
-        {
-          typename Attributes::iterator it = _attributes.lower_bound(attr);
-          while (it != _attributes.end() && it->first == attr) {
-            it->second->set(token);
-            ++it;
-          }
-        }
-
-      }
-      if (readSuccess()) {
-        line.putback(c);
-      }
-      for (typename Attributes::iterator it = _attributes.begin();
-           it != _attributes.end(); ++it) {
-        if (read_attr.find(it->first) == read_attr.end()) {
-          std::ostringstream msg;
-          msg << "Attribute not found: " << it->first;
-          throw FormatError(msg.str());
-        }
-      }
-    }
-
-  public:
-
-    /// \name Execution of the Reader
-    /// @{
-
-    /// \brief Start the batch processing
-    ///
-    /// This function starts the batch processing
-    void run() {
-
-      LEMON_ASSERT(_is != 0, "This reader assigned to an other reader");
-
-      bool red_nodes_done = _skip_nodes;
-      bool blue_nodes_done = _skip_nodes;
-      bool edges_done = _skip_edges;
-      bool attributes_done = false;
-
-      line_num = 0;
-      readLine();
-      skipSection();
-
-      while (readSuccess()) {
-        try {
-          char c;
-          std::string section, caption;
-          line >> c;
-          _reader_bits::readToken(line, section);
-          _reader_bits::readToken(line, caption);
-
-          if (line >> c)
-            throw FormatError("Extra character at the end of line");
-
-          if (section == "red_nodes" && !red_nodes_done) {
-            if (_nodes_caption.empty() || _nodes_caption == caption) {
-              readRedNodes();
-              red_nodes_done = true;
-            }
-          } else if (section == "blue_nodes" && !blue_nodes_done) {
-            if (_nodes_caption.empty() || _nodes_caption == caption) {
-              readBlueNodes();
-              blue_nodes_done = true;
-            }
-          } else if ((section == "edges" || section == "arcs") &&
-                     !edges_done) {
-            if (_edges_caption.empty() || _edges_caption == caption) {
-              readEdges();
-              edges_done = true;
-            }
-          } else if (section == "attributes" && !attributes_done) {
-            if (_attributes_caption.empty() || _attributes_caption == caption) {
-              readAttributes();
-              attributes_done = true;
-            }
-          } else {
-            readLine();
-            skipSection();
-          }
-        } catch (FormatError& error) {
-          error.line(line_num);
-          error.file(_filename);
-          throw;
-        }
-      }
-
-      if (!red_nodes_done) {
-        throw FormatError("Section @red_nodes not found");
-      }
-
-      if (!blue_nodes_done) {
-        throw FormatError("Section @blue_nodes not found");
-      }
-
-      if (!edges_done) {
-        throw FormatError("Section @edges not found");
-      }
-
-      if (!attributes_done && !_attributes.empty()) {
-        throw FormatError("Section @attributes not found");
-      }
-
-    }
-
-    /// @}
-
-  };
-
-  /// \ingroup lemon_io
-  ///
-  /// \brief Return a \ref lemon::BpGraphReader "BpGraphReader" class
-  ///
-  /// This function just returns a \ref lemon::BpGraphReader
-  /// "BpGraphReader" class.
-  ///
-  /// With this function a graph can be read from an
-  /// \ref lgf-format "LGF" file or input stream with several maps and
-  /// attributes. For example, there is bipartite weighted matching problem
-  /// on a graph, i.e. a graph with a \e weight map on the edges. This
-  /// graph can be read with the following code:
-  ///
-  ///\code
-  ///ListBpGraph graph;
-  ///ListBpGraph::EdgeMap<int> weight(graph);
-  ///bpGraphReader(graph, std::cin).
-  ///  edgeMap("weight", weight).
-  ///  run();
-  ///\endcode
-  ///
-  /// For a complete documentation, please see the
-  /// \ref lemon::BpGraphReader "BpGraphReader"
-  /// class documentation.
-  /// \warning Don't forget to put the \ref lemon::BpGraphReader::run() "run()"
-  /// to the end of the parameter list.
-  /// \relates BpGraphReader
-  /// \sa bpGraphReader(TBGR& graph, const std::string& fn)
-  /// \sa bpGraphReader(TBGR& graph, const char* fn)
-  template <typename TBGR>
-  BpGraphReader<TBGR> bpGraphReader(TBGR& graph, std::istream& is) {
-    BpGraphReader<TBGR> tmp(graph, is);
-    return tmp;
-  }
-
-  /// \brief Return a \ref BpGraphReader class
-  ///
-  /// This function just returns a \ref BpGraphReader class.
-  /// \relates BpGraphReader
-  /// \sa bpGraphReader(TBGR& graph, std::istream& is)
-  template <typename TBGR>
-  BpGraphReader<TBGR> bpGraphReader(TBGR& graph, const std::string& fn) {
-    BpGraphReader<TBGR> tmp(graph, fn);
-    return tmp;
-  }
-
-  /// \brief Return a \ref BpGraphReader class
-  ///
-  /// This function just returns a \ref BpGraphReader class.
-  /// \relates BpGraphReader
-  /// \sa bpGraphReader(TBGR& graph, std::istream& is)
-  template <typename TBGR>
-  BpGraphReader<TBGR> bpGraphReader(TBGR& graph, const char* fn) {
-    BpGraphReader<TBGR> tmp(graph, fn);
     return tmp;
   }
Index: lemon/lgf_writer.h
===================================================================
--- lemon/lgf_writer.h	(revision 1270)
+++ lemon/lgf_writer.h	(revision 646)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -192,47 +192,18 @@
     };
 
-    template <typename Value,
-              typename Map = std::map<Value, std::string> >
+    template <typename Value>
     struct MapLookUpConverter {
-      const Map& _map;
-
-      MapLookUpConverter(const Map& map)
+      const std::map<Value, std::string>& _map;
+
+      MapLookUpConverter(const std::map<Value, std::string>& map)
         : _map(map) {}
 
-      std::string operator()(const Value& value) {
-        typename Map::const_iterator it = _map.find(value);
+      std::string operator()(const Value& str) {
+        typename std::map<Value, std::string>::const_iterator it =
+          _map.find(str);
         if (it == _map.end()) {
           throw FormatError("Item not found");
         }
         return it->second;
-      }
-    };
-
-    template <typename Value,
-              typename Map1 = std::map<Value, std::string>,
-              typename Map2 = std::map<Value, std::string> >
-    struct DoubleMapLookUpConverter {
-      const Map1& _map1;
-      const Map2& _map2;
-
-      DoubleMapLookUpConverter(const Map1& map1, const Map2& map2)
-        : _map1(map1), _map2(map2) {}
-
-      std::string operator()(const Value& value) {
-        typename Map1::const_iterator it1 = _map1.find(value);
-        typename Map1::const_iterator it2 = _map2.find(value);
-        if (it1 == _map1.end()) {
-          if (it2 == _map2.end()) {
-            throw FormatError("Item not found");
-          } else {
-            return it2->second;
-          }
-        } else {
-          if (it2 == _map2.end()) {
-            return it1->second;
-          } else {
-            throw FormatError("Item is ambigous");
-          }
-        }
       }
     };
@@ -381,5 +352,5 @@
 
   template <typename TDGR>
-  DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
+  DigraphWriter<TDGR> digraphWriter(const TDGR& digraph, 
                                    std::ostream& os = std::cout);
   template <typename TDGR>
@@ -534,5 +505,5 @@
 
     template <typename TDGR>
-    friend DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
+    friend DigraphWriter<TDGR> digraphWriter(const TDGR& digraph, 
                                              std::ostream& os);
     template <typename TDGR>
@@ -945,8 +916,7 @@
   /// \ingroup lemon_io
   ///
-  /// \brief Return a \ref lemon::DigraphWriter "DigraphWriter" class
-  ///
-  /// This function just returns a \ref lemon::DigraphWriter
-  /// "DigraphWriter" class.
+  /// \brief Return a \ref DigraphWriter class
+  ///
+  /// This function just returns a \ref DigraphWriter class. 
   ///
   /// With this function a digraph can be write to a file or output
@@ -969,8 +939,7 @@
   ///\endcode
   ///
-  /// For a complete documentation, please see the
-  /// \ref lemon::DigraphWriter "DigraphWriter"
+  /// For a complete documentation, please see the \ref DigraphWriter
   /// class documentation.
-  /// \warning Don't forget to put the \ref lemon::DigraphWriter::run() "run()"
+  /// \warning Don't forget to put the \ref DigraphWriter::run() "run()"
   /// to the end of the parameter list.
   /// \relates DigraphWriter
@@ -989,5 +958,5 @@
   /// \sa digraphWriter(const TDGR& digraph, std::ostream& os)
   template <typename TDGR>
-  DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
+  DigraphWriter<TDGR> digraphWriter(const TDGR& digraph, 
                                     const std::string& fn) {
     DigraphWriter<TDGR> tmp(digraph, fn);
@@ -1018,5 +987,5 @@
   /// \ingroup lemon_io
   ///
-  /// \brief \ref lgf-format "LGF" writer for undirected graphs
+  /// \brief \ref lgf-format "LGF" writer for directed graphs
   ///
   /// This utility writes an \ref lgf-format "LGF" file.
@@ -1074,6 +1043,6 @@
     /// \brief Constructor
     ///
-    /// Construct an undirected graph writer, which writes to the
-    /// given output stream.
+    /// Construct a directed graph writer, which writes to the given
+    /// output stream.
     GraphWriter(const GR& graph, std::ostream& os = std::cout)
       : _os(&os), local_os(false), _graph(graph),
@@ -1082,5 +1051,5 @@
     /// \brief Constructor
     ///
-    /// Construct a undirected graph writer, which writes to the given
+    /// Construct a directed graph writer, which writes to the given
     /// output file.
     GraphWriter(const GR& graph, const std::string& fn)
@@ -1095,5 +1064,5 @@
     /// \brief Constructor
     ///
-    /// Construct a undirected graph writer, which writes to the given
+    /// Construct a directed graph writer, which writes to the given
     /// output file.
     GraphWriter(const GR& graph, const char* fn)
@@ -1133,9 +1102,9 @@
     friend GraphWriter<TGR> graphWriter(const TGR& graph, std::ostream& os);
     template <typename TGR>
-    friend GraphWriter<TGR> graphWriter(const TGR& graph,
+    friend GraphWriter<TGR> graphWriter(const TGR& graph, 
                                         const std::string& fn);
     template <typename TGR>
     friend GraphWriter<TGR> graphWriter(const TGR& graph, const char *fn);
-
+    
     GraphWriter(GraphWriter& other)
       : _os(other._os), local_os(other.local_os), _graph(other._graph),
@@ -1321,7 +1290,7 @@
     }
 
-    /// \brief Add an additional caption to the \c \@edges section
-    ///
-    /// Add an additional caption to the \c \@edges section.
+    /// \brief Add an additional caption to the \c \@arcs section
+    ///
+    /// Add an additional caption to the \c \@arcs section.
     GraphWriter& edges(const std::string& caption) {
       _edges_caption = caption;
@@ -1586,7 +1555,7 @@
   /// \ingroup lemon_io
   ///
-  /// \brief Return a \ref lemon::GraphWriter "GraphWriter" class
-  ///
-  /// This function just returns a \ref lemon::GraphWriter "GraphWriter" class.
+  /// \brief Return a \ref GraphWriter class
+  ///
+  /// This function just returns a \ref GraphWriter class. 
   ///
   /// With this function a graph can be write to a file or output
@@ -1605,8 +1574,7 @@
   ///\endcode
   ///
-  /// For a complete documentation, please see the
-  /// \ref lemon::GraphWriter "GraphWriter"
+  /// For a complete documentation, please see the \ref GraphWriter
   /// class documentation.
-  /// \warning Don't forget to put the \ref lemon::GraphWriter::run() "run()"
+  /// \warning Don't forget to put the \ref GraphWriter::run() "run()"
   /// to the end of the parameter list.
   /// \relates GraphWriter
@@ -1638,824 +1606,4 @@
   GraphWriter<TGR> graphWriter(const TGR& graph, const char* fn) {
     GraphWriter<TGR> tmp(graph, fn);
-    return tmp;
-  }
-
-  template <typename BGR>
-  class BpGraphWriter;
-
-  template <typename TBGR>
-  BpGraphWriter<TBGR> bpGraphWriter(const TBGR& graph,
-                                    std::ostream& os = std::cout);
-  template <typename TBGR>
-  BpGraphWriter<TBGR> bpGraphWriter(const TBGR& graph, const std::string& fn);
-  template <typename TBGR>
-  BpGraphWriter<TBGR> bpGraphWriter(const TBGR& graph, const char* fn);
-
-  /// \ingroup lemon_io
-  ///
-  /// \brief \ref lgf-format "LGF" writer for undirected bipartite graphs
-  ///
-  /// This utility writes an \ref lgf-format "LGF" file.
-  ///
-  /// It can be used almost the same way as \c GraphWriter, but it
-  /// reads the red and blue nodes from separate sections, and these
-  /// sections can contain different set of maps.
-  ///
-  /// The red and blue node maps are written to the corresponding
-  /// sections. The node maps are written to both of these sections
-  /// with the same map name.
-  template <typename BGR>
-  class BpGraphWriter {
-  public:
-
-    typedef BGR BpGraph;
-    TEMPLATE_BPGRAPH_TYPEDEFS(BGR);
-
-  private:
-
-
-    std::ostream* _os;
-    bool local_os;
-
-    const BGR& _graph;
-
-    std::string _nodes_caption;
-    std::string _edges_caption;
-    std::string _attributes_caption;
-
-    typedef std::map<Node, std::string> RedNodeIndex;
-    RedNodeIndex _red_node_index;
-    typedef std::map<Node, std::string> BlueNodeIndex;
-    BlueNodeIndex _blue_node_index;
-    typedef std::map<Edge, std::string> EdgeIndex;
-    EdgeIndex _edge_index;
-
-    typedef std::vector<std::pair<std::string,
-      _writer_bits::MapStorageBase<RedNode>* > > RedNodeMaps;
-    RedNodeMaps _red_node_maps;
-    typedef std::vector<std::pair<std::string,
-      _writer_bits::MapStorageBase<BlueNode>* > > BlueNodeMaps;
-    BlueNodeMaps _blue_node_maps;
-
-    typedef std::vector<std::pair<std::string,
-      _writer_bits::MapStorageBase<Edge>* > >EdgeMaps;
-    EdgeMaps _edge_maps;
-
-    typedef std::vector<std::pair<std::string,
-      _writer_bits::ValueStorageBase*> > Attributes;
-    Attributes _attributes;
-
-    bool _skip_nodes;
-    bool _skip_edges;
-
-  public:
-
-    /// \brief Constructor
-    ///
-    /// Construct a bipartite graph writer, which writes to the given
-    /// output stream.
-    BpGraphWriter(const BGR& graph, std::ostream& os = std::cout)
-      : _os(&os), local_os(false), _graph(graph),
-        _skip_nodes(false), _skip_edges(false) {}
-
-    /// \brief Constructor
-    ///
-    /// Construct a bipartite graph writer, which writes to the given
-    /// output file.
-    BpGraphWriter(const BGR& graph, const std::string& fn)
-      : _os(new std::ofstream(fn.c_str())), local_os(true), _graph(graph),
-        _skip_nodes(false), _skip_edges(false) {
-      if (!(*_os)) {
-        delete _os;
-        throw IoError("Cannot write file", fn);
-      }
-    }
-
-    /// \brief Constructor
-    ///
-    /// Construct a bipartite graph writer, which writes to the given
-    /// output file.
-    BpGraphWriter(const BGR& graph, const char* fn)
-      : _os(new std::ofstream(fn)), local_os(true), _graph(graph),
-        _skip_nodes(false), _skip_edges(false) {
-      if (!(*_os)) {
-        delete _os;
-        throw IoError("Cannot write file", fn);
-      }
-    }
-
-    /// \brief Destructor
-    ~BpGraphWriter() {
-      for (typename RedNodeMaps::iterator it = _red_node_maps.begin();
-           it != _red_node_maps.end(); ++it) {
-        delete it->second;
-      }
-
-      for (typename BlueNodeMaps::iterator it = _blue_node_maps.begin();
-           it != _blue_node_maps.end(); ++it) {
-        delete it->second;
-      }
-
-      for (typename EdgeMaps::iterator it = _edge_maps.begin();
-           it != _edge_maps.end(); ++it) {
-        delete it->second;
-      }
-
-      for (typename Attributes::iterator it = _attributes.begin();
-           it != _attributes.end(); ++it) {
-        delete it->second;
-      }
-
-      if (local_os) {
-        delete _os;
-      }
-    }
-
-  private:
-
-    template <typename TBGR>
-    friend BpGraphWriter<TBGR> bpGraphWriter(const TBGR& graph,
-                                             std::ostream& os);
-    template <typename TBGR>
-    friend BpGraphWriter<TBGR> bpGraphWriter(const TBGR& graph,
-                                             const std::string& fn);
-    template <typename TBGR>
-    friend BpGraphWriter<TBGR> bpGraphWriter(const TBGR& graph, const char *fn);
-
-    BpGraphWriter(BpGraphWriter& other)
-      : _os(other._os), local_os(other.local_os), _graph(other._graph),
-        _skip_nodes(other._skip_nodes), _skip_edges(other._skip_edges) {
-
-      other._os = 0;
-      other.local_os = false;
-
-      _red_node_index.swap(other._red_node_index);
-      _blue_node_index.swap(other._blue_node_index);
-      _edge_index.swap(other._edge_index);
-
-      _red_node_maps.swap(other._red_node_maps);
-      _blue_node_maps.swap(other._blue_node_maps);
-      _edge_maps.swap(other._edge_maps);
-      _attributes.swap(other._attributes);
-
-      _nodes_caption = other._nodes_caption;
-      _edges_caption = other._edges_caption;
-      _attributes_caption = other._attributes_caption;
-    }
-
-    BpGraphWriter& operator=(const BpGraphWriter&);
-
-  public:
-
-    /// \name Writing Rules
-    /// @{
-
-    /// \brief Node map writing rule
-    ///
-    /// Add a node map writing rule to the writer.
-    template <typename Map>
-    BpGraphWriter& nodeMap(const std::string& caption, const Map& map) {
-      checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
-      _writer_bits::MapStorageBase<RedNode>* red_storage =
-        new _writer_bits::MapStorage<RedNode, Map>(map);
-      _red_node_maps.push_back(std::make_pair(caption, red_storage));
-      _writer_bits::MapStorageBase<BlueNode>* blue_storage =
-        new _writer_bits::MapStorage<BlueNode, Map>(map);
-      _blue_node_maps.push_back(std::make_pair(caption, blue_storage));
-      return *this;
-    }
-
-    /// \brief Node map writing rule
-    ///
-    /// Add a node map writing rule with specialized converter to the
-    /// writer.
-    template <typename Map, typename Converter>
-    BpGraphWriter& nodeMap(const std::string& caption, const Map& map,
-                           const Converter& converter = Converter()) {
-      checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
-      _writer_bits::MapStorageBase<RedNode>* red_storage =
-        new _writer_bits::MapStorage<RedNode, Map, Converter>(map, converter);
-      _red_node_maps.push_back(std::make_pair(caption, red_storage));
-      _writer_bits::MapStorageBase<BlueNode>* blue_storage =
-        new _writer_bits::MapStorage<BlueNode, Map, Converter>(map, converter);
-      _blue_node_maps.push_back(std::make_pair(caption, blue_storage));
-      return *this;
-    }
-
-    /// \brief Red node map writing rule
-    ///
-    /// Add a red node map writing rule to the writer.
-    template <typename Map>
-    BpGraphWriter& redNodeMap(const std::string& caption, const Map& map) {
-      checkConcept<concepts::ReadMap<RedNode, typename Map::Value>, Map>();
-      _writer_bits::MapStorageBase<RedNode>* storage =
-        new _writer_bits::MapStorage<RedNode, Map>(map);
-      _red_node_maps.push_back(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// \brief Red node map writing rule
-    ///
-    /// Add a red node map writing rule with specialized converter to the
-    /// writer.
-    template <typename Map, typename Converter>
-    BpGraphWriter& redNodeMap(const std::string& caption, const Map& map,
-                              const Converter& converter = Converter()) {
-      checkConcept<concepts::ReadMap<RedNode, typename Map::Value>, Map>();
-      _writer_bits::MapStorageBase<RedNode>* storage =
-        new _writer_bits::MapStorage<RedNode, Map, Converter>(map, converter);
-      _red_node_maps.push_back(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// \brief Blue node map writing rule
-    ///
-    /// Add a blue node map writing rule to the writer.
-    template <typename Map>
-    BpGraphWriter& blueNodeMap(const std::string& caption, const Map& map) {
-      checkConcept<concepts::ReadMap<BlueNode, typename Map::Value>, Map>();
-      _writer_bits::MapStorageBase<BlueNode>* storage =
-        new _writer_bits::MapStorage<BlueNode, Map>(map);
-      _blue_node_maps.push_back(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// \brief Blue node map writing rule
-    ///
-    /// Add a blue node map writing rule with specialized converter to the
-    /// writer.
-    template <typename Map, typename Converter>
-    BpGraphWriter& blueNodeMap(const std::string& caption, const Map& map,
-                               const Converter& converter = Converter()) {
-      checkConcept<concepts::ReadMap<BlueNode, typename Map::Value>, Map>();
-      _writer_bits::MapStorageBase<BlueNode>* storage =
-        new _writer_bits::MapStorage<BlueNode, Map, Converter>(map, converter);
-      _blue_node_maps.push_back(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// \brief Edge map writing rule
-    ///
-    /// Add an edge map writing rule to the writer.
-    template <typename Map>
-    BpGraphWriter& edgeMap(const std::string& caption, const Map& map) {
-      checkConcept<concepts::ReadMap<Edge, typename Map::Value>, Map>();
-      _writer_bits::MapStorageBase<Edge>* storage =
-        new _writer_bits::MapStorage<Edge, Map>(map);
-      _edge_maps.push_back(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// \brief Edge map writing rule
-    ///
-    /// Add an edge map writing rule with specialized converter to the
-    /// writer.
-    template <typename Map, typename Converter>
-    BpGraphWriter& edgeMap(const std::string& caption, const Map& map,
-                          const Converter& converter = Converter()) {
-      checkConcept<concepts::ReadMap<Edge, typename Map::Value>, Map>();
-      _writer_bits::MapStorageBase<Edge>* storage =
-        new _writer_bits::MapStorage<Edge, Map, Converter>(map, converter);
-      _edge_maps.push_back(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// \brief Arc map writing rule
-    ///
-    /// Add an arc map writing rule to the writer.
-    template <typename Map>
-    BpGraphWriter& arcMap(const std::string& caption, const Map& map) {
-      checkConcept<concepts::ReadMap<Arc, typename Map::Value>, Map>();
-      _writer_bits::MapStorageBase<Edge>* forward_storage =
-        new _writer_bits::GraphArcMapStorage<BGR, true, Map>(_graph, map);
-      _edge_maps.push_back(std::make_pair('+' + caption, forward_storage));
-      _writer_bits::MapStorageBase<Edge>* backward_storage =
-        new _writer_bits::GraphArcMapStorage<BGR, false, Map>(_graph, map);
-      _edge_maps.push_back(std::make_pair('-' + caption, backward_storage));
-      return *this;
-    }
-
-    /// \brief Arc map writing rule
-    ///
-    /// Add an arc map writing rule with specialized converter to the
-    /// writer.
-    template <typename Map, typename Converter>
-    BpGraphWriter& arcMap(const std::string& caption, const Map& map,
-                          const Converter& converter = Converter()) {
-      checkConcept<concepts::ReadMap<Arc, typename Map::Value>, Map>();
-      _writer_bits::MapStorageBase<Edge>* forward_storage =
-        new _writer_bits::GraphArcMapStorage<BGR, true, Map, Converter>
-        (_graph, map, converter);
-      _edge_maps.push_back(std::make_pair('+' + caption, forward_storage));
-      _writer_bits::MapStorageBase<Edge>* backward_storage =
-        new _writer_bits::GraphArcMapStorage<BGR, false, Map, Converter>
-        (_graph, map, converter);
-      _edge_maps.push_back(std::make_pair('-' + caption, backward_storage));
-      return *this;
-    }
-
-    /// \brief Attribute writing rule
-    ///
-    /// Add an attribute writing rule to the writer.
-    template <typename Value>
-    BpGraphWriter& attribute(const std::string& caption, const Value& value) {
-      _writer_bits::ValueStorageBase* storage =
-        new _writer_bits::ValueStorage<Value>(value);
-      _attributes.push_back(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// \brief Attribute writing rule
-    ///
-    /// Add an attribute writing rule with specialized converter to the
-    /// writer.
-    template <typename Value, typename Converter>
-    BpGraphWriter& attribute(const std::string& caption, const Value& value,
-                             const Converter& converter = Converter()) {
-      _writer_bits::ValueStorageBase* storage =
-        new _writer_bits::ValueStorage<Value, Converter>(value, converter);
-      _attributes.push_back(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// \brief Node writing rule
-    ///
-    /// Add a node writing rule to the writer.
-    BpGraphWriter& node(const std::string& caption, const Node& node) {
-      typedef _writer_bits::DoubleMapLookUpConverter<
-        Node, RedNodeIndex, BlueNodeIndex> Converter;
-      Converter converter(_red_node_index, _blue_node_index);
-      _writer_bits::ValueStorageBase* storage =
-        new _writer_bits::ValueStorage<Node, Converter>(node, converter);
-      _attributes.push_back(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// \brief Red node writing rule
-    ///
-    /// Add a red node writing rule to the writer.
-    BpGraphWriter& redNode(const std::string& caption, const RedNode& node) {
-      typedef _writer_bits::MapLookUpConverter<Node> Converter;
-      Converter converter(_red_node_index);
-      _writer_bits::ValueStorageBase* storage =
-        new _writer_bits::ValueStorage<Node, Converter>(node, converter);
-      _attributes.push_back(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// \brief Blue node writing rule
-    ///
-    /// Add a blue node writing rule to the writer.
-    BpGraphWriter& blueNode(const std::string& caption, const BlueNode& node) {
-      typedef _writer_bits::MapLookUpConverter<Node> Converter;
-      Converter converter(_blue_node_index);
-      _writer_bits::ValueStorageBase* storage =
-        new _writer_bits::ValueStorage<Node, Converter>(node, converter);
-      _attributes.push_back(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// \brief Edge writing rule
-    ///
-    /// Add an edge writing rule to writer.
-    BpGraphWriter& edge(const std::string& caption, const Edge& edge) {
-      typedef _writer_bits::MapLookUpConverter<Edge> Converter;
-      Converter converter(_edge_index);
-      _writer_bits::ValueStorageBase* storage =
-        new _writer_bits::ValueStorage<Edge, Converter>(edge, converter);
-      _attributes.push_back(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// \brief Arc writing rule
-    ///
-    /// Add an arc writing rule to writer.
-    BpGraphWriter& arc(const std::string& caption, const Arc& arc) {
-      typedef _writer_bits::GraphArcLookUpConverter<BGR> Converter;
-      Converter converter(_graph, _edge_index);
-      _writer_bits::ValueStorageBase* storage =
-        new _writer_bits::ValueStorage<Arc, Converter>(arc, converter);
-      _attributes.push_back(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// \name Section Captions
-    /// @{
-
-    /// \brief Add an additional caption to the \c \@red_nodes and
-    /// \c \@blue_nodes section
-    ///
-    /// Add an additional caption to the \c \@red_nodes and \c
-    /// \@blue_nodes section.
-    BpGraphWriter& nodes(const std::string& caption) {
-      _nodes_caption = caption;
-      return *this;
-    }
-
-    /// \brief Add an additional caption to the \c \@edges section
-    ///
-    /// Add an additional caption to the \c \@edges section.
-    BpGraphWriter& edges(const std::string& caption) {
-      _edges_caption = caption;
-      return *this;
-    }
-
-    /// \brief Add an additional caption to the \c \@attributes section
-    ///
-    /// Add an additional caption to the \c \@attributes section.
-    BpGraphWriter& attributes(const std::string& caption) {
-      _attributes_caption = caption;
-      return *this;
-    }
-
-    /// \name Skipping Section
-    /// @{
-
-    /// \brief Skip writing the node set
-    ///
-    /// The \c \@red_nodes and \c \@blue_nodes section will not be
-    /// written to the stream.
-    BpGraphWriter& skipNodes() {
-      LEMON_ASSERT(!_skip_nodes, "Multiple usage of skipNodes() member");
-      _skip_nodes = true;
-      return *this;
-    }
-
-    /// \brief Skip writing edge set
-    ///
-    /// The \c \@edges section will not be written to the stream.
-    BpGraphWriter& skipEdges() {
-      LEMON_ASSERT(!_skip_edges, "Multiple usage of skipEdges() member");
-      _skip_edges = true;
-      return *this;
-    }
-
-    /// @}
-
-  private:
-
-    void writeRedNodes() {
-      _writer_bits::MapStorageBase<RedNode>* label = 0;
-      for (typename RedNodeMaps::iterator it = _red_node_maps.begin();
-           it != _red_node_maps.end(); ++it) {
-        if (it->first == "label") {
-          label = it->second;
-          break;
-        }
-      }
-
-      *_os << "@red_nodes";
-      if (!_nodes_caption.empty()) {
-        _writer_bits::writeToken(*_os << ' ', _nodes_caption);
-      }
-      *_os << std::endl;
-
-      if (label == 0) {
-        *_os << "label" << '\t';
-      }
-      for (typename RedNodeMaps::iterator it = _red_node_maps.begin();
-           it != _red_node_maps.end(); ++it) {
-        _writer_bits::writeToken(*_os, it->first) << '\t';
-      }
-      *_os << std::endl;
-
-      std::vector<RedNode> nodes;
-      for (RedNodeIt n(_graph); n != INVALID; ++n) {
-        nodes.push_back(n);
-      }
-
-      if (label == 0) {
-        IdMap<BGR, Node> id_map(_graph);
-        _writer_bits::MapLess<IdMap<BGR, Node> > id_less(id_map);
-        std::sort(nodes.begin(), nodes.end(), id_less);
-      } else {
-        label->sort(nodes);
-      }
-
-      for (int i = 0; i < static_cast<int>(nodes.size()); ++i) {
-        RedNode n = nodes[i];
-        if (label == 0) {
-          std::ostringstream os;
-          os << _graph.id(static_cast<Node>(n));
-          _writer_bits::writeToken(*_os, os.str());
-          *_os << '\t';
-          _red_node_index.insert(std::make_pair(n, os.str()));
-        }
-        for (typename RedNodeMaps::iterator it = _red_node_maps.begin();
-             it != _red_node_maps.end(); ++it) {
-          std::string value = it->second->get(n);
-          _writer_bits::writeToken(*_os, value);
-          if (it->first == "label") {
-            _red_node_index.insert(std::make_pair(n, value));
-          }
-          *_os << '\t';
-        }
-        *_os << std::endl;
-      }
-    }
-
-    void writeBlueNodes() {
-      _writer_bits::MapStorageBase<BlueNode>* label = 0;
-      for (typename BlueNodeMaps::iterator it = _blue_node_maps.begin();
-           it != _blue_node_maps.end(); ++it) {
-        if (it->first == "label") {
-          label = it->second;
-          break;
-        }
-      }
-
-      *_os << "@blue_nodes";
-      if (!_nodes_caption.empty()) {
-        _writer_bits::writeToken(*_os << ' ', _nodes_caption);
-      }
-      *_os << std::endl;
-
-      if (label == 0) {
-        *_os << "label" << '\t';
-      }
-      for (typename BlueNodeMaps::iterator it = _blue_node_maps.begin();
-           it != _blue_node_maps.end(); ++it) {
-        _writer_bits::writeToken(*_os, it->first) << '\t';
-      }
-      *_os << std::endl;
-
-      std::vector<BlueNode> nodes;
-      for (BlueNodeIt n(_graph); n != INVALID; ++n) {
-        nodes.push_back(n);
-      }
-
-      if (label == 0) {
-        IdMap<BGR, Node> id_map(_graph);
-        _writer_bits::MapLess<IdMap<BGR, Node> > id_less(id_map);
-        std::sort(nodes.begin(), nodes.end(), id_less);
-      } else {
-        label->sort(nodes);
-      }
-
-      for (int i = 0; i < static_cast<int>(nodes.size()); ++i) {
-        BlueNode n = nodes[i];
-        if (label == 0) {
-          std::ostringstream os;
-          os << _graph.id(static_cast<Node>(n));
-          _writer_bits::writeToken(*_os, os.str());
-          *_os << '\t';
-          _blue_node_index.insert(std::make_pair(n, os.str()));
-        }
-        for (typename BlueNodeMaps::iterator it = _blue_node_maps.begin();
-             it != _blue_node_maps.end(); ++it) {
-          std::string value = it->second->get(n);
-          _writer_bits::writeToken(*_os, value);
-          if (it->first == "label") {
-            _blue_node_index.insert(std::make_pair(n, value));
-          }
-          *_os << '\t';
-        }
-        *_os << std::endl;
-      }
-    }
-
-    void createRedNodeIndex() {
-      _writer_bits::MapStorageBase<RedNode>* label = 0;
-      for (typename RedNodeMaps::iterator it = _red_node_maps.begin();
-           it != _red_node_maps.end(); ++it) {
-        if (it->first == "label") {
-          label = it->second;
-          break;
-        }
-      }
-
-      if (label == 0) {
-        for (RedNodeIt n(_graph); n != INVALID; ++n) {
-          std::ostringstream os;
-          os << _graph.id(n);
-          _red_node_index.insert(std::make_pair(n, os.str()));
-        }
-      } else {
-        for (RedNodeIt n(_graph); n != INVALID; ++n) {
-          std::string value = label->get(n);
-          _red_node_index.insert(std::make_pair(n, value));
-        }
-      }
-    }
-
-    void createBlueNodeIndex() {
-      _writer_bits::MapStorageBase<BlueNode>* label = 0;
-      for (typename BlueNodeMaps::iterator it = _blue_node_maps.begin();
-           it != _blue_node_maps.end(); ++it) {
-        if (it->first == "label") {
-          label = it->second;
-          break;
-        }
-      }
-
-      if (label == 0) {
-        for (BlueNodeIt n(_graph); n != INVALID; ++n) {
-          std::ostringstream os;
-          os << _graph.id(n);
-          _blue_node_index.insert(std::make_pair(n, os.str()));
-        }
-      } else {
-        for (BlueNodeIt n(_graph); n != INVALID; ++n) {
-          std::string value = label->get(n);
-          _blue_node_index.insert(std::make_pair(n, value));
-        }
-      }
-    }
-
-    void writeEdges() {
-      _writer_bits::MapStorageBase<Edge>* label = 0;
-      for (typename EdgeMaps::iterator it = _edge_maps.begin();
-           it != _edge_maps.end(); ++it) {
-        if (it->first == "label") {
-          label = it->second;
-          break;
-        }
-      }
-
-      *_os << "@edges";
-      if (!_edges_caption.empty()) {
-        _writer_bits::writeToken(*_os << ' ', _edges_caption);
-      }
-      *_os << std::endl;
-
-      *_os << '\t' << '\t';
-      if (label == 0) {
-        *_os << "label" << '\t';
-      }
-      for (typename EdgeMaps::iterator it = _edge_maps.begin();
-           it != _edge_maps.end(); ++it) {
-        _writer_bits::writeToken(*_os, it->first) << '\t';
-      }
-      *_os << std::endl;
-
-      std::vector<Edge> edges;
-      for (EdgeIt n(_graph); n != INVALID; ++n) {
-        edges.push_back(n);
-      }
-
-      if (label == 0) {
-        IdMap<BGR, Edge> id_map(_graph);
-        _writer_bits::MapLess<IdMap<BGR, Edge> > id_less(id_map);
-        std::sort(edges.begin(), edges.end(), id_less);
-      } else {
-        label->sort(edges);
-      }
-
-      for (int i = 0; i < static_cast<int>(edges.size()); ++i) {
-        Edge e = edges[i];
-        _writer_bits::writeToken(*_os, _red_node_index.
-                                 find(_graph.redNode(e))->second);
-        *_os << '\t';
-        _writer_bits::writeToken(*_os, _blue_node_index.
-                                 find(_graph.blueNode(e))->second);
-        *_os << '\t';
-        if (label == 0) {
-          std::ostringstream os;
-          os << _graph.id(e);
-          _writer_bits::writeToken(*_os, os.str());
-          *_os << '\t';
-          _edge_index.insert(std::make_pair(e, os.str()));
-        }
-        for (typename EdgeMaps::iterator it = _edge_maps.begin();
-             it != _edge_maps.end(); ++it) {
-          std::string value = it->second->get(e);
-          _writer_bits::writeToken(*_os, value);
-          if (it->first == "label") {
-            _edge_index.insert(std::make_pair(e, value));
-          }
-          *_os << '\t';
-        }
-        *_os << std::endl;
-      }
-    }
-
-    void createEdgeIndex() {
-      _writer_bits::MapStorageBase<Edge>* label = 0;
-      for (typename EdgeMaps::iterator it = _edge_maps.begin();
-           it != _edge_maps.end(); ++it) {
-        if (it->first == "label") {
-          label = it->second;
-          break;
-        }
-      }
-
-      if (label == 0) {
-        for (EdgeIt e(_graph); e != INVALID; ++e) {
-          std::ostringstream os;
-          os << _graph.id(e);
-          _edge_index.insert(std::make_pair(e, os.str()));
-        }
-      } else {
-        for (EdgeIt e(_graph); e != INVALID; ++e) {
-          std::string value = label->get(e);
-          _edge_index.insert(std::make_pair(e, value));
-        }
-      }
-    }
-
-    void writeAttributes() {
-      if (_attributes.empty()) return;
-      *_os << "@attributes";
-      if (!_attributes_caption.empty()) {
-        _writer_bits::writeToken(*_os << ' ', _attributes_caption);
-      }
-      *_os << std::endl;
-      for (typename Attributes::iterator it = _attributes.begin();
-           it != _attributes.end(); ++it) {
-        _writer_bits::writeToken(*_os, it->first) << ' ';
-        _writer_bits::writeToken(*_os, it->second->get());
-        *_os << std::endl;
-      }
-    }
-
-  public:
-
-    /// \name Execution of the Writer
-    /// @{
-
-    /// \brief Start the batch processing
-    ///
-    /// This function starts the batch processing.
-    void run() {
-      if (!_skip_nodes) {
-        writeRedNodes();
-        writeBlueNodes();
-      } else {
-        createRedNodeIndex();
-        createBlueNodeIndex();
-      }
-      if (!_skip_edges) {
-        writeEdges();
-      } else {
-        createEdgeIndex();
-      }
-      writeAttributes();
-    }
-
-    /// \brief Give back the stream of the writer
-    ///
-    /// Give back the stream of the writer
-    std::ostream& ostream() {
-      return *_os;
-    }
-
-    /// @}
-  };
-
-  /// \ingroup lemon_io
-  ///
-  /// \brief Return a \ref lemon::BpGraphWriter "BpGraphWriter" class
-  ///
-  /// This function just returns a \ref lemon::BpGraphWriter
-  /// "BpGraphWriter" class.
-  ///
-  /// With this function a bipartite graph can be write to a file or output
-  /// stream in \ref lgf-format "LGF" format with several maps and
-  /// attributes. For example, with the following code a bipartite
-  /// weighted matching problem can be written to the standard output,
-  /// i.e. a graph with a \e weight map on the edges:
-  ///
-  ///\code
-  ///ListBpGraph graph;
-  ///ListBpGraph::EdgeMap<int> weight(graph);
-  ///  // Setting the weight map
-  ///bpGraphWriter(graph, std::cout).
-  ///  edgeMap("weight", weight).
-  ///  run();
-  ///\endcode
-  ///
-  /// For a complete documentation, please see the
-  /// \ref lemon::BpGraphWriter "BpGraphWriter"
-  /// class documentation.
-  /// \warning Don't forget to put the \ref lemon::BpGraphWriter::run() "run()"
-  /// to the end of the parameter list.
-  /// \relates BpGraphWriter
-  /// \sa bpGraphWriter(const TBGR& graph, const std::string& fn)
-  /// \sa bpGraphWriter(const TBGR& graph, const char* fn)
-  template <typename TBGR>
-  BpGraphWriter<TBGR> bpGraphWriter(const TBGR& graph, std::ostream& os) {
-    BpGraphWriter<TBGR> tmp(graph, os);
-    return tmp;
-  }
-
-  /// \brief Return a \ref BpGraphWriter class
-  ///
-  /// This function just returns a \ref BpGraphWriter class.
-  /// \relates BpGraphWriter
-  /// \sa graphWriter(const TBGR& graph, std::ostream& os)
-  template <typename TBGR>
-  BpGraphWriter<TBGR> bpGraphWriter(const TBGR& graph, const std::string& fn) {
-    BpGraphWriter<TBGR> tmp(graph, fn);
-    return tmp;
-  }
-
-  /// \brief Return a \ref BpGraphWriter class
-  ///
-  /// This function just returns a \ref BpGraphWriter class.
-  /// \relates BpGraphWriter
-  /// \sa graphWriter(const TBGR& graph, std::ostream& os)
-  template <typename TBGR>
-  BpGraphWriter<TBGR> bpGraphWriter(const TBGR& graph, const char* fn) {
-    BpGraphWriter<TBGR> tmp(graph, fn);
     return tmp;
   }
Index: lemon/list_graph.h
===================================================================
--- lemon/list_graph.h	(revision 1359)
+++ lemon/list_graph.h	(revision 835)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -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;
+      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_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;
+      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;
+        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;
+        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;
     }
 
@@ -446,6 +446,6 @@
     ///or changeTarget(), thus \c ArcIt and \c OutArcIt iterators are
     ///invalidated for the outgoing arcs of node \c v and \c InArcIt
-    ///iterators are invalidated for the incoming arcs of \c v.
-    ///Moreover all iterators referencing node \c v or the removed
+    ///iterators are invalidated for the incomming arcs of \c v.
+    ///Moreover all iterators referencing node \c v or the removed 
     ///loops are also invalidated. Other iterators remain valid.
     ///
@@ -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
@@ -553,5 +553,5 @@
     /// restore() function.
     ///
-    /// \note After a state is restored, you cannot restore a later state,
+    /// \note After a state is restored, you cannot restore a later state, 
     /// i.e. you cannot add the removed nodes and arcs again using
     /// another Snapshot instance.
@@ -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;
+      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;
+        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;
+      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_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;
+      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;
+        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;
+        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;
+      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;
+        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;
+      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);
+        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.
@@ -1308,5 +1308,5 @@
     /// or changeV(), thus all edge and arc iterators whose base node is
     /// \c b are invalidated.
-    /// Moreover all iterators referencing node \c b or the removed
+    /// Moreover all iterators referencing node \c b or the removed 
     /// loops are also invalidated. Other iterators remain valid.
     ///
@@ -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
@@ -1365,5 +1365,5 @@
     /// using the restore() function.
     ///
-    /// \note After a state is restored, you cannot restore a later state,
+    /// \note After a state is restored, you cannot restore a later state, 
     /// i.e. you cannot add the removed nodes and edges again using
     /// another Snapshot instance.
@@ -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]);
           }
@@ -1600,909 +1600,4 @@
 
   /// @}
-
-  class ListBpGraphBase {
-
-  protected:
-
-    struct NodeT {
-      int first_out;
-      int prev, next;
-      int partition_prev, partition_next;
-      int partition_index;
-      bool red;
-    };
-
-    struct ArcT {
-      int target;
-      int prev_out, next_out;
-    };
-
-    std::vector<NodeT> _nodes;
-
-    int first_node, first_red, first_blue;
-    int max_red, max_blue;
-
-    int first_free_red, first_free_blue;
-
-    std::vector<ArcT> _arcs;
-
-    int first_free_arc;
-
-  public:
-
-    typedef ListBpGraphBase BpGraph;
-
-    class Node {
-      friend class ListBpGraphBase;
-    protected:
-
-      int id;
-      explicit Node(int pid) { id = pid;}
-
-    public:
-      Node() {}
-      Node (Invalid) { id = -1; }
-      bool operator==(const Node& node) const {return id == node.id;}
-      bool operator!=(const Node& node) const {return id != node.id;}
-      bool operator<(const Node& node) const {return id < node.id;}
-    };
-
-    class RedNode : public Node {
-      friend class ListBpGraphBase;
-    protected:
-
-      explicit RedNode(int pid) : Node(pid) {}
-
-    public:
-      RedNode() {}
-      RedNode(const RedNode& node) : Node(node) {}
-      RedNode(Invalid) : Node(INVALID){}
-    };
-
-    class BlueNode : public Node {
-      friend class ListBpGraphBase;
-    protected:
-
-      explicit BlueNode(int pid) : Node(pid) {}
-
-    public:
-      BlueNode() {}
-      BlueNode(const BlueNode& node) : Node(node) {}
-      BlueNode(Invalid) : Node(INVALID){}
-    };
-
-    class Edge {
-      friend class ListBpGraphBase;
-    protected:
-
-      int id;
-      explicit Edge(int pid) { id = pid;}
-
-    public:
-      Edge() {}
-      Edge (Invalid) { id = -1; }
-      bool operator==(const Edge& edge) const {return id == edge.id;}
-      bool operator!=(const Edge& edge) const {return id != edge.id;}
-      bool operator<(const Edge& edge) const {return id < edge.id;}
-    };
-
-    class Arc {
-      friend class ListBpGraphBase;
-    protected:
-
-      int id;
-      explicit Arc(int pid) { id = pid;}
-
-    public:
-      operator Edge() const {
-        return id != -1 ? edgeFromId(id / 2) : INVALID;
-      }
-
-      Arc() {}
-      Arc (Invalid) { id = -1; }
-      bool operator==(const Arc& arc) const {return id == arc.id;}
-      bool operator!=(const Arc& arc) const {return id != arc.id;}
-      bool operator<(const Arc& arc) const {return id < arc.id;}
-    };
-
-    ListBpGraphBase()
-      : _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; }
-
-    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 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); }
-
-    RedNode redNode(Edge e) const {
-      return RedNode(_arcs[2 * e.id].target);
-    }
-    BlueNode blueNode(Edge e) const {
-      return BlueNode(_arcs[2 * e.id + 1].target);
-    }
-
-    static bool direction(Arc e) {
-      return (e.id & 1) == 1;
-    }
-
-    static Arc direct(Edge e, bool d) {
-      return Arc(e.id * 2 + (d ? 1 : 0));
-    }
-
-    void first(Node& node) const {
-      node.id = first_node;
-    }
-
-    void next(Node& node) const {
-      node.id = _nodes[node.id].next;
-    }
-
-    void first(RedNode& node) const {
-      node.id = first_red;
-    }
-
-    void next(RedNode& node) const {
-      node.id = _nodes[node.id].partition_next;
-    }
-
-    void first(BlueNode& node) const {
-      node.id = first_blue;
-    }
-
-    void next(BlueNode& node) const {
-      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;
-    }
-
-    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;
-      }
-    }
-
-    void first(Edge& e) const {
-      int n = first_node;
-      while (n != -1) {
-        e.id = _nodes[n].first_out;
-        while ((e.id & 1) != 1) {
-          e.id = _arcs[e.id].next_out;
-        }
-        if (e.id != -1) {
-          e.id /= 2;
-          return;
-        }
-        n = _nodes[n].next;
-      }
-      e.id = -1;
-    }
-
-    void next(Edge& e) const {
-      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;
-      }
-      if (e.id != -1) {
-        e.id /= 2;
-        return;
-      }
-      n = _nodes[n].next;
-      while (n != -1) {
-        e.id = _nodes[n].first_out;
-        while ((e.id & 1) != 1) {
-          e.id = _arcs[e.id].next_out;
-        }
-        if (e.id != -1) {
-          e.id /= 2;
-          return;
-        }
-        n = _nodes[n].next;
-      }
-      e.id = -1;
-    }
-
-    void firstOut(Arc &e, const Node& v) const {
-      e.id = _nodes[v.id].first_out;
-    }
-    void nextOut(Arc &e) const {
-      e.id = _arcs[e.id].next_out;
-    }
-
-    void firstIn(Arc &e, const Node& v) const {
-      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);
-      if (e.id == -2) e.id = -1;
-    }
-
-    void firstInc(Edge &e, bool& d, const Node& v) const {
-      int a = _nodes[v.id].first_out;
-      if (a != -1 ) {
-        e.id = a / 2;
-        d = ((a & 1) == 1);
-      } else {
-        e.id = -1;
-        d = true;
-      }
-    }
-    void nextInc(Edge &e, bool& d) const {
-      int a = (_arcs[(e.id * 2) | (d ? 1 : 0)].next_out);
-      if (a != -1 ) {
-        e.id = a / 2;
-        d = ((a & 1) == 1);
-      } else {
-        e.id = -1;
-        d = true;
-      }
-    }
-
-    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; }
-    static int id(Arc e) { return e.id; }
-    static int id(Edge e) { return e.id; }
-
-    static Node nodeFromId(int id) { return Node(id);}
-    static Arc arcFromId(int id) { return Arc(id);}
-    static Edge edgeFromId(int id) { return Edge(id);}
-
-    bool valid(Node n) const {
-      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;
-    }
-
-    bool valid(Edge e) const {
-      return e.id >= 0 && 2 * e.id < static_cast<int>(_arcs.size()) &&
-        _arcs[2 * e.id].prev_out != -2;
-    }
-
-    RedNode addRedNode() {
-      int n;
-
-      if(first_free_red==-1) {
-        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_node = 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;
-
-      return RedNode(n);
-    }
-
-    BlueNode addBlueNode() {
-      int n;
-
-      if(first_free_blue==-1) {
-        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_node = 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;
-
-      return BlueNode(n);
-    }
-
-    Edge addEdge(Node u, Node v) {
-      int n;
-
-      if (first_free_arc == -1) {
-        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);
-
-      return Edge(n / 2);
-    }
-
-    void erase(const Node& node) {
-      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;
-        } else {
-          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;
-        first_free_blue = n;
-      }
-      _nodes[n].prev = -2;
-    }
-
-    void erase(const Edge& edge) {
-      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;
-      first_free_arc = n;
-      _arcs[n].prev_out = -2;
-      _arcs[n | 1].prev_out = -2;
-
-    }
-
-    void 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;
-    }
-
-  protected:
-
-    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);
-    }
-
-    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;
-    }
-
-  };
-
-  typedef BpGraphExtender<ListBpGraphBase> ExtendedListBpGraphBase;
-
-
-  /// \addtogroup graphs
-  /// @{
-
-  ///A general undirected graph structure.
-
-  ///\ref ListBpGraph is a versatile and fast undirected graph
-  ///implementation based on linked lists that are stored in
-  ///\c std::vector structures.
-  ///
-  ///This type fully conforms to the \ref concepts::BpGraph "BpGraph concept"
-  ///and it also provides several useful additional functionalities.
-  ///Most of its member functions and nested classes are documented
-  ///only in the concept class.
-  ///
-  ///This class provides only linear time counting for nodes, edges and arcs.
-  ///
-  ///\sa concepts::BpGraph
-  ///\sa ListDigraph
-  class ListBpGraph : public ExtendedListBpGraphBase {
-    typedef ExtendedListBpGraphBase Parent;
-
-  private:
-    /// BpGraphs are \e not copy constructible. Use BpGraphCopy instead.
-    ListBpGraph(const ListBpGraph &) :ExtendedListBpGraphBase()  {};
-    /// \brief Assignment of a graph to another one is \e not allowed.
-    /// Use BpGraphCopy instead.
-    void operator=(const ListBpGraph &) {}
-  public:
-    /// Constructor
-
-    /// Constructor.
-    ///
-    ListBpGraph() {}
-
-    typedef Parent::IncEdgeIt IncEdgeIt;
-
-    /// \brief Add a new red node to the graph.
-    ///
-    /// This function adds a red new node to the graph.
-    /// \return The new node.
-    RedNode addRedNode() { return Parent::addRedNode(); }
-
-    /// \brief Add a new blue node to the graph.
-    ///
-    /// This function adds a blue new node to the graph.
-    /// \return The new node.
-    BlueNode addBlueNode() { return Parent::addBlueNode(); }
-
-    /// \brief Add a new edge to the graph.
-    ///
-    /// This function adds a new edge to the graph between nodes
-    /// \c u and \c v with inherent orientation from node \c u to
-    /// node \c v.
-    /// \return The new edge.
-    Edge addEdge(RedNode u, BlueNode v) {
-      return Parent::addEdge(u, v);
-    }
-    Edge addEdge(BlueNode v, RedNode u) {
-      return Parent::addEdge(u, v);
-    }
-
-    ///\brief Erase a node from the graph.
-    ///
-    /// This function erases the given node along with its incident arcs
-    /// from the graph.
-    ///
-    /// \note All iterators referencing the removed node or the incident
-    /// edges are invalidated, of course.
-    void erase(Node n) { Parent::erase(n); }
-
-    ///\brief Erase an edge from the graph.
-    ///
-    /// This function erases the given edge from the graph.
-    ///
-    /// \note All iterators referencing the removed edge are invalidated,
-    /// of course.
-    void erase(Edge e) { Parent::erase(e); }
-    /// Node validity check
-
-    /// This function gives back \c true if the given node is valid,
-    /// i.e. it is a real node of the graph.
-    ///
-    /// \warning A removed node could become valid again if new nodes are
-    /// added to the graph.
-    bool valid(Node n) const { return Parent::valid(n); }
-    /// Edge validity check
-
-    /// This function gives back \c true if the given edge is valid,
-    /// i.e. it is a real edge of the graph.
-    ///
-    /// \warning A removed edge could become valid again if new edges are
-    /// added to the graph.
-    bool valid(Edge e) const { return Parent::valid(e); }
-    /// Arc validity check
-
-    /// This function gives back \c true if the given arc is valid,
-    /// i.e. it is a real arc of the graph.
-    ///
-    /// \warning A removed arc could become valid again if new edges are
-    /// added to the graph.
-    bool valid(Arc a) const { return Parent::valid(a); }
-
-    /// \brief Change the red node of an edge.
-    ///
-    /// This function changes the red node of the given edge \c e to \c n.
-    ///
-    ///\note \c EdgeIt and \c ArcIt iterators referencing the
-    ///changed edge are invalidated and all other iterators whose
-    ///base node is the changed node are also invalidated.
-    ///
-    ///\warning This functionality cannot be used together with the
-    ///Snapshot feature.
-    void changeRed(Edge e, RedNode n) {
-      Parent::changeRed(e, n);
-    }
-    /// \brief Change the blue node of an edge.
-    ///
-    /// This function changes the blue node of the given edge \c e to \c n.
-    ///
-    ///\note \c EdgeIt iterators referencing the changed edge remain
-    ///valid, but \c ArcIt iterators referencing the changed edge and
-    ///all other iterators whose base node is the changed node are also
-    ///invalidated.
-    ///
-    ///\warning This functionality cannot be used together with the
-    ///Snapshot feature.
-    void changeBlue(Edge e, BlueNode n) {
-      Parent::changeBlue(e, n);
-    }
-
-    ///Clear the graph.
-
-    ///This function erases all nodes and arcs from the graph.
-    ///
-    ///\note All iterators of the graph are invalidated, of course.
-    void clear() {
-      Parent::clear();
-    }
-
-    /// Reserve memory for nodes.
-
-    /// Using this function, it is possible to avoid superfluous memory
-    /// allocation: if you know that the graph you want to build will
-    /// be large (e.g. it will contain millions of nodes and/or edges),
-    /// then it is worth reserving space for this amount before starting
-    /// to build the graph.
-    /// \sa reserveEdge()
-    void reserveNode(int n) { _nodes.reserve(n); };
-
-    /// Reserve memory for edges.
-
-    /// Using this function, it is possible to avoid superfluous memory
-    /// allocation: if you know that the graph you want to build will
-    /// be large (e.g. it will contain millions of nodes and/or edges),
-    /// then it is worth reserving space for this amount before starting
-    /// to build the graph.
-    /// \sa reserveNode()
-    void reserveEdge(int m) { _arcs.reserve(2 * m); };
-
-    /// \brief Class to make a snapshot of the graph and restore
-    /// it later.
-    ///
-    /// Class to make a snapshot of the graph and restore it later.
-    ///
-    /// The newly added nodes and edges can be removed
-    /// using the restore() function.
-    ///
-    /// \note After a state is restored, you cannot restore a later state,
-    /// i.e. you cannot add the removed nodes and edges again using
-    /// another Snapshot instance.
-    ///
-    /// \warning Node and edge deletions and other modifications
-    /// (e.g. changing the end-nodes of edges or contracting nodes)
-    /// cannot be restored. These events invalidate the snapshot.
-    /// However, the edges and nodes that were added to the graph after
-    /// making the current snapshot can be removed without invalidating it.
-    class Snapshot {
-    protected:
-
-      typedef Parent::NodeNotifier NodeNotifier;
-
-      class NodeObserverProxy : public NodeNotifier::ObserverBase {
-      public:
-
-        NodeObserverProxy(Snapshot& _snapshot)
-          : snapshot(_snapshot) {}
-
-        using NodeNotifier::ObserverBase::attach;
-        using NodeNotifier::ObserverBase::detach;
-        using NodeNotifier::ObserverBase::attached;
-
-      protected:
-
-        virtual void add(const Node& node) {
-          snapshot.addNode(node);
-        }
-        virtual void add(const std::vector<Node>& nodes) {
-          for (int i = nodes.size() - 1; i >= 0; --i) {
-            snapshot.addNode(nodes[i]);
-          }
-        }
-        virtual void erase(const Node& node) {
-          snapshot.eraseNode(node);
-        }
-        virtual void erase(const std::vector<Node>& nodes) {
-          for (int i = 0; i < int(nodes.size()); ++i) {
-            snapshot.eraseNode(nodes[i]);
-          }
-        }
-        virtual void build() {
-          Node node;
-          std::vector<Node> nodes;
-          for (notifier()->first(node); node != INVALID;
-               notifier()->next(node)) {
-            nodes.push_back(node);
-          }
-          for (int i = nodes.size() - 1; i >= 0; --i) {
-            snapshot.addNode(nodes[i]);
-          }
-        }
-        virtual void clear() {
-          Node node;
-          for (notifier()->first(node); node != INVALID;
-               notifier()->next(node)) {
-            snapshot.eraseNode(node);
-          }
-        }
-
-        Snapshot& snapshot;
-      };
-
-      class EdgeObserverProxy : public EdgeNotifier::ObserverBase {
-      public:
-
-        EdgeObserverProxy(Snapshot& _snapshot)
-          : snapshot(_snapshot) {}
-
-        using EdgeNotifier::ObserverBase::attach;
-        using EdgeNotifier::ObserverBase::detach;
-        using EdgeNotifier::ObserverBase::attached;
-
-      protected:
-
-        virtual void add(const Edge& edge) {
-          snapshot.addEdge(edge);
-        }
-        virtual void add(const std::vector<Edge>& edges) {
-          for (int i = edges.size() - 1; i >= 0; --i) {
-            snapshot.addEdge(edges[i]);
-          }
-        }
-        virtual void erase(const Edge& edge) {
-          snapshot.eraseEdge(edge);
-        }
-        virtual void erase(const std::vector<Edge>& edges) {
-          for (int i = 0; i < int(edges.size()); ++i) {
-            snapshot.eraseEdge(edges[i]);
-          }
-        }
-        virtual void build() {
-          Edge edge;
-          std::vector<Edge> edges;
-          for (notifier()->first(edge); edge != INVALID;
-               notifier()->next(edge)) {
-            edges.push_back(edge);
-          }
-          for (int i = edges.size() - 1; i >= 0; --i) {
-            snapshot.addEdge(edges[i]);
-          }
-        }
-        virtual void clear() {
-          Edge edge;
-          for (notifier()->first(edge); edge != INVALID;
-               notifier()->next(edge)) {
-            snapshot.eraseEdge(edge);
-          }
-        }
-
-        Snapshot& snapshot;
-      };
-
-      ListBpGraph *graph;
-
-      NodeObserverProxy node_observer_proxy;
-      EdgeObserverProxy edge_observer_proxy;
-
-      std::list<Node> added_nodes;
-      std::list<Edge> added_edges;
-
-
-      void addNode(const Node& node) {
-        added_nodes.push_front(node);
-      }
-      void eraseNode(const Node& node) {
-        std::list<Node>::iterator it =
-          std::find(added_nodes.begin(), added_nodes.end(), node);
-        if (it == added_nodes.end()) {
-          clear();
-          edge_observer_proxy.detach();
-          throw NodeNotifier::ImmediateDetach();
-        } else {
-          added_nodes.erase(it);
-        }
-      }
-
-      void addEdge(const Edge& edge) {
-        added_edges.push_front(edge);
-      }
-      void eraseEdge(const Edge& edge) {
-        std::list<Edge>::iterator it =
-          std::find(added_edges.begin(), added_edges.end(), edge);
-        if (it == added_edges.end()) {
-          clear();
-          node_observer_proxy.detach();
-          throw EdgeNotifier::ImmediateDetach();
-        } else {
-          added_edges.erase(it);
-        }
-      }
-
-      void attach(ListBpGraph &_graph) {
-        graph = &_graph;
-        node_observer_proxy.attach(graph->notifier(Node()));
-        edge_observer_proxy.attach(graph->notifier(Edge()));
-      }
-
-      void detach() {
-        node_observer_proxy.detach();
-        edge_observer_proxy.detach();
-      }
-
-      bool attached() const {
-        return node_observer_proxy.attached();
-      }
-
-      void clear() {
-        added_nodes.clear();
-        added_edges.clear();
-      }
-
-    public:
-
-      /// \brief Default constructor.
-      ///
-      /// Default constructor.
-      /// You have to call save() to actually make a snapshot.
-      Snapshot()
-        : graph(0), node_observer_proxy(*this),
-          edge_observer_proxy(*this) {}
-
-      /// \brief Constructor that immediately makes a snapshot.
-      ///
-      /// This constructor immediately makes a snapshot of the given graph.
-      Snapshot(ListBpGraph &gr)
-        : node_observer_proxy(*this),
-          edge_observer_proxy(*this) {
-        attach(gr);
-      }
-
-      /// \brief Make a snapshot.
-      ///
-      /// This function makes a snapshot of the given graph.
-      /// It can be called more than once. In case of a repeated
-      /// call, the previous snapshot gets lost.
-      void save(ListBpGraph &gr) {
-        if (attached()) {
-          detach();
-          clear();
-        }
-        attach(gr);
-      }
-
-      /// \brief Undo the changes until the last snapshot.
-      ///
-      /// This function undos the changes until the last snapshot
-      /// created by save() or Snapshot(ListBpGraph&).
-      ///
-      /// \warning This method invalidates the snapshot, i.e. repeated
-      /// restoring is not supported unless you call save() again.
-      void restore() {
-        detach();
-        for(std::list<Edge>::iterator it = added_edges.begin();
-            it != added_edges.end(); ++it) {
-          graph->erase(*it);
-        }
-        for(std::list<Node>::iterator it = added_nodes.begin();
-            it != added_nodes.end(); ++it) {
-          graph->erase(*it);
-        }
-        clear();
-      }
-
-      /// \brief Returns \c true if the snapshot is valid.
-      ///
-      /// This function returns \c true if the snapshot is valid.
-      bool valid() const {
-        return attached();
-      }
-    };
-  };
-
-  /// @}
 } //namespace lemon
 
Index: lemon/lp.h
===================================================================
--- lemon/lp.h	(revision 1340)
+++ lemon/lp.h	(revision 674)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -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 or \c CPLEX
 #define LEMON_DEFAULT_MIP SOLVER
   ///The default MIP solver.
@@ -74,22 +67,23 @@
   ///\ingroup lp_group
   ///
-  ///Currently, it is either \c GlpkMip, \c CplexMip , \c CbcMip
+  ///Currently, it is either \c GlpkMip or \c CplexMip
   typedef GlpkMip Mip;
 #else
-#if LEMON_DEFAULT_LP == LEMON_GLPK_
+#ifdef LEMON_HAVE_GLPK
+# define LEMON_DEFAULT_LP GLPK
   typedef GlpkLp Lp;
-#elif LEMON_DEFAULT_LP == LEMON_CPLEX_
+# define LEMON_DEFAULT_MIP GLPK
+  typedef GlpkMip Mip;
+#elif LEMON_HAVE_CPLEX
+# define LEMON_DEFAULT_LP CPLEX
   typedef CplexLp Lp;
-#elif LEMON_DEFAULT_LP == LEMON_SOPLEX_
+# define LEMON_DEFAULT_MIP CPLEX
+  typedef CplexMip Mip;
+#elif LEMON_HAVE_SOPLEX
+# define DEFAULT_LP SOPLEX
   typedef SoplexLp Lp;
-#elif LEMON_DEFAULT_LP == LEMON_CLP_
-  typedef ClpLp Lp;
-#endif
-#if LEMON_DEFAULT_MIP == LEMON_GLPK_
-  typedef GlpkMip Mip;
-#elif LEMON_DEFAULT_MIP == LEMON_CPLEX_
-  typedef CplexMip Mip;
-#elif LEMON_DEFAULT_MIP == LEMON_CBC_
-  typedef CbcMip Mip;
+#elif LEMON_HAVE_CLP
+# define DEFAULT_LP CLP
+  typedef ClpLp Lp;  
 #endif
 #endif
Index: lemon/lp_base.cc
===================================================================
--- lemon/lp_base.cc	(revision 1270)
+++ lemon/lp_base.cc	(revision 557)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/lp_base.h
===================================================================
--- lemon/lp_base.h	(revision 1353)
+++ lemon/lp_base.h	(revision 833)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -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:
@@ -85,5 +83,5 @@
       MESSAGE_VERBOSE
     };
-
+    
 
     ///The floating point type used by the solver
@@ -117,12 +115,12 @@
       typedef True LpCol;
       /// Default constructor
-
+      
       /// \warning The default constructor sets the Col to an
       /// undefined value.
       Col() {}
       /// Invalid constructor \& conversion.
-
+      
       /// This constructor initializes the Col to be invalid.
-      /// \sa Invalid for more details.
+      /// \sa Invalid for more details.      
       Col(const Invalid&) : _id(-1) {}
       /// Equality operator
@@ -159,47 +157,31 @@
     public:
       /// Default constructor
-
+      
       /// \warning The default constructor sets the iterator
       /// to an undefined value.
       ColIt() {}
       /// Sets the iterator to the first Col
-
+      
       /// Sets the iterator to the first Col.
       ///
       ColIt(const LpBase &solver) : _solver(&solver)
       {
-        _solver->_cols.firstItem(_id);
+        _solver->cols.firstItem(_id);
       }
       /// Invalid constructor \& conversion
-
+      
       /// Initialize the iterator to be invalid.
       /// \sa Invalid for more details.
       ColIt(const Invalid&) : Col(INVALID) {}
       /// Next column
-
+      
       /// Assign the iterator to the next column.
       ///
       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.
@@ -228,12 +210,12 @@
       typedef True LpRow;
       /// Default constructor
-
+      
       /// \warning The default constructor sets the Row to an
       /// undefined value.
       Row() {}
       /// Invalid constructor \& conversion.
-
+      
       /// This constructor initializes the Row to be invalid.
-      /// \sa Invalid for more details.
+      /// \sa Invalid for more details.      
       Row(const Invalid&) : _id(-1) {}
       /// Equality operator
@@ -243,5 +225,5 @@
       bool operator==(Row r) const  {return _id == r._id;}
       /// Inequality operator
-
+      
       /// \sa operator==(Row r)
       ///
@@ -270,47 +252,31 @@
     public:
       /// Default constructor
-
+      
       /// \warning The default constructor sets the iterator
       /// to an undefined value.
       RowIt() {}
       /// Sets the iterator to the first Row
-
+      
       /// Sets the iterator to the first Row.
       ///
       RowIt(const LpBase &solver) : _solver(&solver)
       {
-        _solver->_rows.firstItem(_id);
+        _solver->rows.firstItem(_id);
       }
       /// Invalid constructor \& conversion
-
+      
       /// Initialize the iterator to be invalid.
       /// \sa Invalid for more details.
       RowIt(const Invalid&) : Row(INVALID) {}
       /// Next row
-
+      
       /// Assign the iterator to the next row.
       ///
       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.
@@ -382,5 +348,5 @@
       typedef True SolverExpr;
       /// Default constructor
-
+      
       /// Construct an empty expression, the coefficients and
       /// the constant component are initialized to zero.
@@ -483,7 +449,7 @@
 
       ///Iterator over the expression
-
-      ///The iterator iterates over the terms of the expression.
-      ///
+      
+      ///The iterator iterates over the terms of the expression. 
+      /// 
       ///\code
       ///double s=0;
@@ -499,5 +465,5 @@
 
         /// Sets the iterator to the first term
-
+        
         /// Sets the iterator to the first term of the expression.
         ///
@@ -516,5 +482,5 @@
         const Value& operator*() const { return _it->second; }
         /// Next term
-
+        
         /// Assign the iterator to the next term.
         ///
@@ -528,7 +494,7 @@
 
       /// Const iterator over the expression
-
-      ///The iterator iterates over the terms of the expression.
-      ///
+      
+      ///The iterator iterates over the terms of the expression. 
+      /// 
       ///\code
       ///double s=0;
@@ -544,5 +510,5 @@
 
         /// Sets the iterator to the first term
-
+        
         /// Sets the iterator to the first term of the expression.
         ///
@@ -559,5 +525,5 @@
 
         /// Next term
-
+        
         /// Assign the iterator to the next term.
         ///
@@ -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
@@ -708,5 +674,5 @@
       typedef True SolverExpr;
       /// Default constructor
-
+      
       /// Construct an empty expression, the coefficients are
       /// initialized to zero.
@@ -743,5 +709,5 @@
       }
       /// \brief Removes the coefficients which's absolute value does
-      /// not exceed \c epsilon.
+      /// not exceed \c epsilon. 
       void simplify(Value epsilon = 0.0) {
         std::map<int, Value>::iterator it=comps.begin();
@@ -792,7 +758,7 @@
 
       ///Iterator over the expression
-
-      ///The iterator iterates over the terms of the expression.
-      ///
+      
+      ///The iterator iterates over the terms of the expression. 
+      /// 
       ///\code
       ///double s=0;
@@ -808,5 +774,5 @@
 
         /// Sets the iterator to the first term
-
+        
         /// Sets the iterator to the first term of the expression.
         ///
@@ -826,5 +792,5 @@
 
         /// Next term
-
+        
         /// Assign the iterator to the next term.
         ///
@@ -838,7 +804,7 @@
 
       ///Iterator over the expression
-
-      ///The iterator iterates over the terms of the expression.
-      ///
+      
+      ///The iterator iterates over the terms of the expression. 
+      /// 
       ///\code
       ///double s=0;
@@ -854,5 +820,5 @@
 
         /// Sets the iterator to the first term
-
+        
         /// Sets the iterator to the first term of the expression.
         ///
@@ -869,5 +835,5 @@
 
         /// Next term
-
+        
         /// Assign the iterator to the next term.
         ///
@@ -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,35 +1004,5 @@
     Value obj_const_comp;
 
-    LpBase() : _rows(), _cols(), obj_const_comp(0) {}
-
-  public:
-
-    ///Unsupported file format exception
-    class UnsupportedFormatError : public Exception
-    {
-      std::string _format;
-      mutable std::string _what;
-    public:
-      explicit UnsupportedFormatError(std::string format) throw()
-        : _format(format) { }
-      virtual ~UnsupportedFormatError() throw() {}
-      virtual const char* what() const throw() {
-        try {
-          _what.clear();
-          std::ostringstream oss;
-          oss << "lemon::UnsupportedFormatError: " << _format;
-          _what = oss.str();
-        }
-        catch (...) {}
-        if (!_what.empty()) return _what.c_str();
-        else return "lemon::UnsupportedFormatError";
-      }
-    };
-
-  protected:
-    virtual void _write(std::string, std::string format) const
-    {
-      throw UnsupportedFormatError(format);
-    }
+    LpBase() : rows(), cols(), obj_const_comp(0) {}
 
   public:
@@ -1150,6 +1086,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 +1096,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 +1125,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 +1131,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 +1183,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 +1205,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 +1218,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;
     }
@@ -1294,8 +1230,8 @@
       Row r;
       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),
-                                c.upperBounded()?c.upperBound()-*c.expr():INF));
+      r._id = _addRowId(_addRow(c.lowerBounded()?c.lowerBound():-INF, 
+                                ExprIterator(c.expr().comps.begin(), cols),
+                                ExprIterator(c.expr().comps.end(), cols),
+                                c.upperBounded()?c.upperBound():INF));
       return r;
     }
@@ -1304,6 +1240,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 +1247,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 +1257,5 @@
     std::string colName(Col c) const {
       std::string name;
-      _getColName(_cols(id(c)), name);
+      _getColName(cols(id(c)), name);
       return name;
     }
@@ -1330,5 +1266,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 +1275,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 +1284,5 @@
     std::string rowName(Row r) const {
       std::string name;
-      _getRowName(_rows(id(r)), name);
+      _getRowName(rows(id(r)), name);
       return name;
     }
@@ -1357,5 +1293,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 +1302,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 +1311,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 +1320,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 +1329,5 @@
     /// Value or -\ref INF.
     void colLowerBound(Col c, Value value) {
-      _setColLowerBound(_cols(id(c)),value);
+      _setColLowerBound(cols(id(c)),value);
     }
 
@@ -1402,5 +1338,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 +1384,5 @@
     /// Value or \ref INF.
     void colUpperBound(Col c, Value value) {
-      _setColUpperBound(_cols(id(c)),value);
+      _setColUpperBound(cols(id(c)),value);
     };
 
@@ -1457,5 +1393,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 +1440,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 +1486,5 @@
     /// Value or -\ref INF.
     void rowLowerBound(Row r, Value value) {
-      _setRowLowerBound(_rows(id(r)),value);
+      _setRowLowerBound(rows(id(r)),value);
     }
 
@@ -1559,5 +1495,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 +1504,5 @@
     /// Value or -\ref INF.
     void rowUpperBound(Row r, Value value) {
-      _setRowUpperBound(_rows(id(r)),value);
+      _setRowUpperBound(rows(id(r)),value);
     }
 
@@ -1577,12 +1513,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 +1527,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 +1538,5 @@
     Expr obj() const {
       Expr e;
-      _getObjCoeffs(InsertIterator(e.comps, _cols));
+      _getObjCoeffs(InsertIterator(e.comps, cols));
       *e = obj_const_comp;
       return e;
@@ -1620,24 +1556,9 @@
     void min() { _setSense(MIN); }
 
-    ///Clear the problem
-    void clear() { _clear(); _rows.clear(); _cols.clear(); }
-
-    /// Set the message level of the solver
+    ///Clears the problem
+    void clear() { _clear(); }
+
+    /// Sets the message level of the solver
     void messageLevel(MessageLevel level) { _messageLevel(level); }
-
-    /// Write the problem to a file in the given format
-
-    /// This function writes the problem to a file in the given format.
-    /// Different solver backends may support different formats.
-    /// Trying to write in an unsupported format will trigger
-    /// \ref UnsupportedFormatError. For the supported formats,
-    /// visit the documentation of the base class of the related backends
-    /// (\ref CplexBase, \ref GlpkBase etc.)
-    /// \param file The file path
-    /// \param format The output file format.
-    void write(std::string file, std::string format = "MPS") const
-    {
-      _write(file.c_str(),format.c_str());
-    }
 
     ///@}
@@ -1698,5 +1619,5 @@
   inline LpBase::Constr operator<=(const LpBase::Expr &e,
                                    const LpBase::Expr &f) {
-    return LpBase::Constr(0, f - e, LpBase::NaN);
+    return LpBase::Constr(0, f - e, LpBase::INF);
   }
 
@@ -1716,5 +1637,5 @@
   inline LpBase::Constr operator<=(const LpBase::Expr &e,
                                    const LpBase::Value &f) {
-    return LpBase::Constr(LpBase::NaN, e, f);
+    return LpBase::Constr(- LpBase::INF, e, f);
   }
 
@@ -1725,5 +1646,5 @@
   inline LpBase::Constr operator>=(const LpBase::Expr &e,
                                    const LpBase::Expr &f) {
-    return LpBase::Constr(0, e - f, LpBase::NaN);
+    return LpBase::Constr(0, e - f, LpBase::INF);
   }
 
@@ -1745,5 +1666,5 @@
   inline LpBase::Constr operator>=(const LpBase::Expr &e,
                                    const LpBase::Value &f) {
-    return LpBase::Constr(f, e, LpBase::NaN);
+    return LpBase::Constr(f, e, LpBase::INF);
   }
 
@@ -1897,8 +1818,8 @@
     enum VarStatus {
       /// The variable is in the basis
-      BASIC,
+      BASIC, 
       /// The variable is free, but not basic
       FREE,
-      /// The variable has active lower bound
+      /// The variable has active lower bound 
       LOWER,
       /// The variable has active upper bound
@@ -1964,5 +1885,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
@@ -1979,5 +1900,5 @@
     }
     /// Returns a component of the primal ray
-
+    
     /// The primal ray is solution of the modified primal problem,
     /// where we change each finite bound to 0, and we looking for a
@@ -1991,5 +1912,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 +1918,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
@@ -2013,5 +1934,5 @@
 
     /// Returns a component of the dual ray
-
+    
     /// The dual ray is solution of the modified primal problem, where
     /// we change each finite bound to 0 (i.e. the objective function
@@ -2025,15 +1946,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 +2036,5 @@
     ///
     void colType(Col c, ColTypes col_type) {
-      _setColType(_cols(id(c)),col_type);
+      _setColType(cols(id(c)),col_type);
     }
 
@@ -2123,5 +2044,5 @@
     ///
     ColTypes colType(Col c) const {
-      return _getColType(_cols(id(c)));
+      return _getColType(cols(id(c)));
     }
     ///@}
@@ -2140,5 +2061,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
@@ -2155,5 +2076,5 @@
     }
     ///The value of the objective function
-
+    
     ///\return
     ///- \ref INF or -\ref INF means either infeasibility or unboundedness
Index: lemon/lp_skeleton.cc
===================================================================
--- lemon/lp_skeleton.cc	(revision 1270)
+++ lemon/lp_skeleton.cc	(revision 793)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -92,6 +92,4 @@
   void SkeletonSolverBase::_messageLevel(MessageLevel) {}
 
-  void SkeletonSolverBase::_write(std::string, std::string) const {}
-
   LpSkeleton::SolveExitStatus LpSkeleton::_solve() { return SOLVED; }
 
Index: lemon/lp_skeleton.h
===================================================================
--- lemon/lp_skeleton.h	(revision 1270)
+++ lemon/lp_skeleton.h	(revision 793)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -24,5 +24,5 @@
 ///\file
 ///\brief Skeleton file to implement LP/MIP solver interfaces
-///
+///  
 ///The classes in this file do nothing, but they can serve as skeletons when
 ///implementing an interface to new solvers.
@@ -30,5 +30,5 @@
 
   ///A skeleton class to implement LP/MIP solver base interface
-
+  
   ///This class does nothing, but it can serve as a skeleton when
   ///implementing an interface to new solvers.
@@ -145,8 +145,4 @@
     ///\e
     virtual void _messageLevel(MessageLevel);
-
-    ///\e
-    virtual void _write(std::string file, std::string format) const;
-
   };
 
@@ -227,5 +223,4 @@
     ///\e
     virtual const char* _solverName() const;
-
   };
 
Index: lemon/maps.h
===================================================================
--- lemon/maps.h	(revision 1336)
+++ lemon/maps.h	(revision 839)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -26,5 +26,4 @@
 
 #include <lemon/core.h>
-#include <lemon/bits/stl_iterators.h>
 
 ///\file
@@ -235,5 +234,5 @@
   /// heap types and \c UnionFind, when the used items are small
   /// integers. This map conforms to the \ref concepts::ReferenceMap
-  /// "ReferenceMap" concept.
+  /// "ReferenceMap" concept. 
   ///
   /// The simplest way of using this map is through the rangeMap()
@@ -1918,9 +1917,9 @@
   /// \c InverseMap or \c operator()(), and the values of the map can be
   /// accessed with an STL compatible forward iterator (\c ValueIt).
-  ///
+  /// 
   /// This map is intended to be used when all associated values are
   /// different (the map is actually invertable) or there are only a few
   /// items with the same value.
-  /// Otherwise consider to use \c IterableValueMap, which is more
+  /// Otherwise consider to use \c IterableValueMap, which is more 
   /// suitable and more efficient for such cases. It provides iterators
   /// to traverse the items with the same associated value, but
@@ -2004,5 +2003,5 @@
       typename Container::const_iterator it;
     };
-
+    
     /// Alias for \c ValueIt
     typedef ValueIt ValueIterator;
@@ -2063,5 +2062,5 @@
       return it != _inv_map.end() ? it->second : INVALID;
     }
-
+    
     /// \brief Returns the number of items with the given value.
     ///
@@ -2380,5 +2379,5 @@
     return RangeIdMap<GR, K>(graph);
   }
-
+  
   /// \brief Dynamic iterable \c bool map.
   ///
@@ -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.
     ///
@@ -2632,14 +2621,4 @@
     };
 
-    /// \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.
     ///
@@ -2660,5 +2639,5 @@
       /// \param value The value.
       ItemIt(const IterableBoolMap& map, bool value)
-        : Parent(value ?
+        : Parent(value ? 
                  (map._sep > 0 ?
                   map._array[map._sep - 1] : INVALID) :
@@ -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,19 +3249,9 @@
     };
 
-    /// \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:
 
     virtual void add(const Key& key) {
       Parent::add(key);
-      lace(key);
+      unlace(key);
     }
 
@@ -3837,5 +3787,5 @@
     typedef typename To::Key Item;
     typedef typename ItemSetTraits<GR, Item>::ItemIt ItemIt;
-
+    
     for (ItemIt it(gr); it != INVALID; ++it) {
       to.set(it, from[it]);
@@ -3845,5 +3795,5 @@
   /// \brief Compare two graph maps.
   ///
-  /// This function compares the values of two graph maps. It returns
+  /// This function compares the values of two graph maps. It returns 
   /// \c true if the maps assign the same value for all items in the graph.
   /// The \c Key type of the maps (\c Node, \c Arc or \c Edge) must be equal
@@ -3857,5 +3807,5 @@
     typedef typename Map2::Key Item;
     typedef typename ItemSetTraits<GR, Item>::ItemIt ItemIt;
-
+    
     for (ItemIt it(gr); it != INVALID; ++it) {
       if (!(map1[it] == map2[it])) return false;
Index: lemon/matching.h
===================================================================
--- lemon/matching.h	(revision 1270)
+++ lemon/matching.h	(revision 698)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -17,6 +17,6 @@
  */
 
-#ifndef LEMON_MATCHING_H
-#define LEMON_MATCHING_H
+#ifndef LEMON_MAX_MATCHING_H
+#define LEMON_MAX_MATCHING_H
 
 #include <vector>
@@ -29,5 +29,4 @@
 #include <lemon/bin_heap.h>
 #include <lemon/maps.h>
-#include <lemon/fractional_matching.h>
 
 ///\ingroup matching
@@ -43,5 +42,5 @@
   /// This class implements Edmonds' alternating forest matching algorithm
   /// for finding a maximum cardinality matching in a general undirected graph.
-  /// It can be started from an arbitrary initial matching
+  /// It can be started from an arbitrary initial matching 
   /// (the default is the empty one).
   ///
@@ -71,9 +70,9 @@
     ///\brief Status constants for Gallai-Edmonds decomposition.
     ///
-    ///These constants are used for indicating the Gallai-Edmonds
+    ///These constants are used for indicating the Gallai-Edmonds 
     ///decomposition of a graph. The nodes with status \c EVEN (or \c D)
     ///induce a subgraph with factor-critical components, the nodes with
     ///status \c ODD (or \c A) form the canonical barrier, and the nodes
-    ///with status \c MATCHED (or \c C) induce a subgraph having a
+    ///with status \c MATCHED (or \c C) induce a subgraph having a 
     ///perfect matching.
     enum Status {
@@ -514,5 +513,5 @@
     }
 
-    /// \brief Start Edmonds' algorithm with a heuristic improvement
+    /// \brief Start Edmonds' algorithm with a heuristic improvement 
     /// for dense graphs
     ///
@@ -536,6 +535,6 @@
     /// \brief Run Edmonds' algorithm
     ///
-    /// This function runs Edmonds' algorithm. An additional heuristic of
-    /// postponing shrinks is used for relatively dense graphs
+    /// This function runs Edmonds' algorithm. An additional heuristic of 
+    /// postponing shrinks is used for relatively dense graphs 
     /// (for which <tt>m>=2*n</tt> holds).
     void run() {
@@ -558,5 +557,5 @@
     /// \brief Return the size (cardinality) of the matching.
     ///
-    /// This function returns the size (cardinality) of the current matching.
+    /// This function returns the size (cardinality) of the current matching. 
     /// After run() it returns the size of the maximum matching in the graph.
     int matchingSize() const {
@@ -572,5 +571,5 @@
     /// \brief Return \c true if the given edge is in the matching.
     ///
-    /// This function returns \c true if the given edge is in the current
+    /// This function returns \c true if the given edge is in the current 
     /// matching.
     bool matching(const Edge& edge) const {
@@ -581,5 +580,5 @@
     ///
     /// This function returns the matching arc (or edge) incident to the
-    /// given node in the current matching or \c INVALID if the node is
+    /// given node in the current matching or \c INVALID if the node is 
     /// not covered by the matching.
     Arc matching(const Node& n) const {
@@ -597,5 +596,5 @@
     /// \brief Return the mate of the given node.
     ///
-    /// This function returns the mate of the given node in the current
+    /// This function returns the mate of the given node in the current 
     /// matching or \c INVALID if the node is not covered by the matching.
     Node mate(const Node& n) const {
@@ -607,5 +606,5 @@
 
     /// \name Dual Solution
-    /// Functions to get the dual solution, i.e. the Gallai-Edmonds
+    /// Functions to get the dual solution, i.e. the Gallai-Edmonds 
     /// decomposition.
 
@@ -650,6 +649,6 @@
   /// \f$O(nm\log n)\f$ time complexity.
   ///
-  /// The maximum weighted matching problem is to find a subset of the
-  /// edges in an undirected graph with maximum overall weight for which
+  /// The maximum weighted matching problem is to find a subset of the 
+  /// edges in an undirected graph with maximum overall weight for which 
   /// each node has at most one incident edge.
   /// It can be formulated with the following linear program.
@@ -675,14 +674,14 @@
       \frac{\vert B \vert - 1}{2}z_B\f] */
   ///
-  /// The algorithm can be executed with the run() function.
+  /// The algorithm can be executed with the run() function. 
   /// After it the matching (the primal solution) and the dual solution
-  /// can be obtained using the query functions and the
-  /// \ref MaxWeightedMatching::BlossomIt "BlossomIt" nested class,
-  /// which is able to iterate on the nodes of a blossom.
+  /// can be obtained using the query functions and the 
+  /// \ref MaxWeightedMatching::BlossomIt "BlossomIt" nested class, 
+  /// which is able to iterate on the nodes of a blossom. 
   /// If the value type is integer, then the dual solution is multiplied
   /// by \ref MaxWeightedMatching::dualScale "4".
   ///
   /// \tparam GR The undirected graph type the algorithm runs on.
-  /// \tparam WM The type edge weight map. The default type is
+  /// \tparam WM The type edge weight map. The default type is 
   /// \ref concepts::Graph::EdgeMap "GR::EdgeMap<int>".
 #ifdef DOXYGEN
@@ -747,5 +746,5 @@
 
     enum Status {
-      EVEN = -1, MATCHED = 0, ODD = 1
+      EVEN = -1, MATCHED = 0, ODD = 1, UNMATCHED = -2
     };
 
@@ -799,8 +798,4 @@
 
     Value _delta_sum;
-    int _unmatched;
-
-    typedef MaxWeightedFractionalMatching<Graph, WeightMap> FractionalMatching;
-    FractionalMatching *_fractional;
 
     void createStructures() {
@@ -811,16 +806,11 @@
         _matching = new MatchingMap(_graph);
       }
-
       if (!_node_potential) {
         _node_potential = new NodePotential(_graph);
       }
-
       if (!_blossom_set) {
         _blossom_index = new IntNodeMap(_graph);
         _blossom_set = new BlossomSet(*_blossom_index);
         _blossom_data = new RangeMap<BlossomData>(_blossom_num);
-      } else if (_blossom_data->size() != _blossom_num) {
-        delete _blossom_data;
-        _blossom_data = new RangeMap<BlossomData>(_blossom_num);
       }
 
@@ -829,9 +819,5 @@
         _node_heap_index = new IntArcMap(_graph);
         _node_data = new RangeMap<NodeData>(_node_num,
-                                            NodeData(*_node_heap_index));
-      } else {
-        delete _node_data;
-        _node_data = new RangeMap<NodeData>(_node_num,
-                                            NodeData(*_node_heap_index));
+                                              NodeData(*_node_heap_index));
       }
 
@@ -839,34 +825,27 @@
         _tree_set_index = new IntIntMap(_blossom_num);
         _tree_set = new TreeSet(*_tree_set_index);
-      } else {
-        _tree_set_index->resize(_blossom_num);
-      }
-
+      }
       if (!_delta1) {
         _delta1_index = new IntNodeMap(_graph);
         _delta1 = new BinHeap<Value, IntNodeMap>(*_delta1_index);
       }
-
       if (!_delta2) {
         _delta2_index = new IntIntMap(_blossom_num);
         _delta2 = new BinHeap<Value, IntIntMap>(*_delta2_index);
-      } else {
-        _delta2_index->resize(_blossom_num);
-      }
-
+      }
       if (!_delta3) {
         _delta3_index = new IntEdgeMap(_graph);
         _delta3 = new BinHeap<Value, IntEdgeMap>(*_delta3_index);
       }
-
       if (!_delta4) {
         _delta4_index = new IntIntMap(_blossom_num);
         _delta4 = new BinHeap<Value, IntIntMap>(*_delta4_index);
-      } else {
-        _delta4_index->resize(_blossom_num);
       }
     }
 
     void destroyStructures() {
+      _node_num = countNodes(_graph);
+      _blossom_num = _node_num * 3 / 2;
+
       if (_matching) {
         delete _matching;
@@ -944,5 +923,205 @@
               _delta3->push(e, rw / 2);
             }
+          } else if ((*_blossom_data)[vb].status == UNMATCHED) {
+            if (_delta3->state(e) != _delta3->IN_HEAP) {
+              _delta3->push(e, rw);
+            }
           } else {
+            typename std::map<int, Arc>::iterator it =
+              (*_node_data)[vi].heap_index.find(tree);
+
+            if (it != (*_node_data)[vi].heap_index.end()) {
+              if ((*_node_data)[vi].heap[it->second] > rw) {
+                (*_node_data)[vi].heap.replace(it->second, e);
+                (*_node_data)[vi].heap.decrease(e, rw);
+                it->second = e;
+              }
+            } else {
+              (*_node_data)[vi].heap.push(e, rw);
+              (*_node_data)[vi].heap_index.insert(std::make_pair(tree, e));
+            }
+
+            if ((*_blossom_set)[v] > (*_node_data)[vi].heap.prio()) {
+              _blossom_set->decrease(v, (*_node_data)[vi].heap.prio());
+
+              if ((*_blossom_data)[vb].status == MATCHED) {
+                if (_delta2->state(vb) != _delta2->IN_HEAP) {
+                  _delta2->push(vb, _blossom_set->classPrio(vb) -
+                               (*_blossom_data)[vb].offset);
+                } else if ((*_delta2)[vb] > _blossom_set->classPrio(vb) -
+                           (*_blossom_data)[vb].offset){
+                  _delta2->decrease(vb, _blossom_set->classPrio(vb) -
+                                   (*_blossom_data)[vb].offset);
+                }
+              }
+            }
+          }
+        }
+      }
+      (*_blossom_data)[blossom].offset = 0;
+    }
+
+    void matchedToOdd(int blossom) {
+      if (_delta2->state(blossom) == _delta2->IN_HEAP) {
+        _delta2->erase(blossom);
+      }
+      (*_blossom_data)[blossom].offset += _delta_sum;
+      if (!_blossom_set->trivial(blossom)) {
+        _delta4->push(blossom, (*_blossom_data)[blossom].pot / 2 +
+                     (*_blossom_data)[blossom].offset);
+      }
+    }
+
+    void evenToMatched(int blossom, int tree) {
+      if (!_blossom_set->trivial(blossom)) {
+        (*_blossom_data)[blossom].pot += 2 * _delta_sum;
+      }
+
+      for (typename BlossomSet::ItemIt n(*_blossom_set, blossom);
+           n != INVALID; ++n) {
+        int ni = (*_node_index)[n];
+        (*_node_data)[ni].pot -= _delta_sum;
+
+        _delta1->erase(n);
+
+        for (InArcIt e(_graph, n); e != INVALID; ++e) {
+          Node v = _graph.source(e);
+          int vb = _blossom_set->find(v);
+          int vi = (*_node_index)[v];
+
+          Value rw = (*_node_data)[ni].pot + (*_node_data)[vi].pot -
+            dualScale * _weight[e];
+
+          if (vb == blossom) {
+            if (_delta3->state(e) == _delta3->IN_HEAP) {
+              _delta3->erase(e);
+            }
+          } else if ((*_blossom_data)[vb].status == EVEN) {
+
+            if (_delta3->state(e) == _delta3->IN_HEAP) {
+              _delta3->erase(e);
+            }
+
+            int vt = _tree_set->find(vb);
+
+            if (vt != tree) {
+
+              Arc r = _graph.oppositeArc(e);
+
+              typename std::map<int, Arc>::iterator it =
+                (*_node_data)[ni].heap_index.find(vt);
+
+              if (it != (*_node_data)[ni].heap_index.end()) {
+                if ((*_node_data)[ni].heap[it->second] > rw) {
+                  (*_node_data)[ni].heap.replace(it->second, r);
+                  (*_node_data)[ni].heap.decrease(r, rw);
+                  it->second = r;
+                }
+              } else {
+                (*_node_data)[ni].heap.push(r, rw);
+                (*_node_data)[ni].heap_index.insert(std::make_pair(vt, r));
+              }
+
+              if ((*_blossom_set)[n] > (*_node_data)[ni].heap.prio()) {
+                _blossom_set->decrease(n, (*_node_data)[ni].heap.prio());
+
+                if (_delta2->state(blossom) != _delta2->IN_HEAP) {
+                  _delta2->push(blossom, _blossom_set->classPrio(blossom) -
+                               (*_blossom_data)[blossom].offset);
+                } else if ((*_delta2)[blossom] >
+                           _blossom_set->classPrio(blossom) -
+                           (*_blossom_data)[blossom].offset){
+                  _delta2->decrease(blossom, _blossom_set->classPrio(blossom) -
+                                   (*_blossom_data)[blossom].offset);
+                }
+              }
+            }
+
+          } else if ((*_blossom_data)[vb].status == UNMATCHED) {
+            if (_delta3->state(e) == _delta3->IN_HEAP) {
+              _delta3->erase(e);
+            }
+          } else {
+
+            typename std::map<int, Arc>::iterator it =
+              (*_node_data)[vi].heap_index.find(tree);
+
+            if (it != (*_node_data)[vi].heap_index.end()) {
+              (*_node_data)[vi].heap.erase(it->second);
+              (*_node_data)[vi].heap_index.erase(it);
+              if ((*_node_data)[vi].heap.empty()) {
+                _blossom_set->increase(v, std::numeric_limits<Value>::max());
+              } else if ((*_blossom_set)[v] < (*_node_data)[vi].heap.prio()) {
+                _blossom_set->increase(v, (*_node_data)[vi].heap.prio());
+              }
+
+              if ((*_blossom_data)[vb].status == MATCHED) {
+                if (_blossom_set->classPrio(vb) ==
+                    std::numeric_limits<Value>::max()) {
+                  _delta2->erase(vb);
+                } else if ((*_delta2)[vb] < _blossom_set->classPrio(vb) -
+                           (*_blossom_data)[vb].offset) {
+                  _delta2->increase(vb, _blossom_set->classPrio(vb) -
+                                   (*_blossom_data)[vb].offset);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+
+    void oddToMatched(int blossom) {
+      (*_blossom_data)[blossom].offset -= _delta_sum;
+
+      if (_blossom_set->classPrio(blossom) !=
+          std::numeric_limits<Value>::max()) {
+        _delta2->push(blossom, _blossom_set->classPrio(blossom) -
+                       (*_blossom_data)[blossom].offset);
+      }
+
+      if (!_blossom_set->trivial(blossom)) {
+        _delta4->erase(blossom);
+      }
+    }
+
+    void oddToEven(int blossom, int tree) {
+      if (!_blossom_set->trivial(blossom)) {
+        _delta4->erase(blossom);
+        (*_blossom_data)[blossom].pot -=
+          2 * (2 * _delta_sum - (*_blossom_data)[blossom].offset);
+      }
+
+      for (typename BlossomSet::ItemIt n(*_blossom_set, blossom);
+           n != INVALID; ++n) {
+        int ni = (*_node_index)[n];
+
+        _blossom_set->increase(n, std::numeric_limits<Value>::max());
+
+        (*_node_data)[ni].heap.clear();
+        (*_node_data)[ni].heap_index.clear();
+        (*_node_data)[ni].pot +=
+          2 * _delta_sum - (*_blossom_data)[blossom].offset;
+
+        _delta1->push(n, (*_node_data)[ni].pot);
+
+        for (InArcIt e(_graph, n); e != INVALID; ++e) {
+          Node v = _graph.source(e);
+          int vb = _blossom_set->find(v);
+          int vi = (*_node_index)[v];
+
+          Value rw = (*_node_data)[ni].pot + (*_node_data)[vi].pot -
+            dualScale * _weight[e];
+
+          if ((*_blossom_data)[vb].status == EVEN) {
+            if (_delta3->state(e) != _delta3->IN_HEAP && blossom != vb) {
+              _delta3->push(e, rw / 2);
+            }
+          } else if ((*_blossom_data)[vb].status == UNMATCHED) {
+            if (_delta3->state(e) != _delta3->IN_HEAP) {
+              _delta3->push(e, rw);
+            }
+          } else {
+
             typename std::map<int, Arc>::iterator it =
               (*_node_data)[vi].heap_index.find(tree);
@@ -979,18 +1158,8 @@
     }
 
-    void matchedToOdd(int blossom) {
+
+    void matchedToUnmatched(int blossom) {
       if (_delta2->state(blossom) == _delta2->IN_HEAP) {
         _delta2->erase(blossom);
-      }
-      (*_blossom_data)[blossom].offset += _delta_sum;
-      if (!_blossom_set->trivial(blossom)) {
-        _delta4->push(blossom, (*_blossom_data)[blossom].pot / 2 +
-                      (*_blossom_data)[blossom].offset);
-      }
-    }
-
-    void evenToMatched(int blossom, int tree) {
-      if (!_blossom_set->trivial(blossom)) {
-        (*_blossom_data)[blossom].pot += 2 * _delta_sum;
       }
 
@@ -998,7 +1167,31 @@
            n != INVALID; ++n) {
         int ni = (*_node_index)[n];
-        (*_node_data)[ni].pot -= _delta_sum;
-
-        _delta1->erase(n);
+
+        _blossom_set->increase(n, std::numeric_limits<Value>::max());
+
+        (*_node_data)[ni].heap.clear();
+        (*_node_data)[ni].heap_index.clear();
+
+        for (OutArcIt e(_graph, n); e != INVALID; ++e) {
+          Node v = _graph.target(e);
+          int vb = _blossom_set->find(v);
+          int vi = (*_node_index)[v];
+
+          Value rw = (*_node_data)[ni].pot + (*_node_data)[vi].pot -
+            dualScale * _weight[e];
+
+          if ((*_blossom_data)[vb].status == EVEN) {
+            if (_delta3->state(e) != _delta3->IN_HEAP) {
+              _delta3->push(e, rw);
+            }
+          }
+        }
+      }
+    }
+
+    void unmatchedToMatched(int blossom) {
+      for (typename BlossomSet::ItemIt n(*_blossom_set, blossom);
+           n != INVALID; ++n) {
+        int ni = (*_node_index)[n];
 
         for (InArcIt e(_graph, n); e != INVALID; ++e) {
@@ -1022,146 +1215,40 @@
             int vt = _tree_set->find(vb);
 
-            if (vt != tree) {
-
-              Arc r = _graph.oppositeArc(e);
-
-              typename std::map<int, Arc>::iterator it =
-                (*_node_data)[ni].heap_index.find(vt);
-
-              if (it != (*_node_data)[ni].heap_index.end()) {
-                if ((*_node_data)[ni].heap[it->second] > rw) {
-                  (*_node_data)[ni].heap.replace(it->second, r);
-                  (*_node_data)[ni].heap.decrease(r, rw);
-                  it->second = r;
-                }
-              } else {
-                (*_node_data)[ni].heap.push(r, rw);
-                (*_node_data)[ni].heap_index.insert(std::make_pair(vt, r));
-              }
-
-              if ((*_blossom_set)[n] > (*_node_data)[ni].heap.prio()) {
-                _blossom_set->decrease(n, (*_node_data)[ni].heap.prio());
-
-                if (_delta2->state(blossom) != _delta2->IN_HEAP) {
-                  _delta2->push(blossom, _blossom_set->classPrio(blossom) -
-                               (*_blossom_data)[blossom].offset);
-                } else if ((*_delta2)[blossom] >
-                           _blossom_set->classPrio(blossom) -
-                           (*_blossom_data)[blossom].offset){
-                  _delta2->decrease(blossom, _blossom_set->classPrio(blossom) -
-                                   (*_blossom_data)[blossom].offset);
-                }
-              }
-            }
-          } else {
+            Arc r = _graph.oppositeArc(e);
 
             typename std::map<int, Arc>::iterator it =
-              (*_node_data)[vi].heap_index.find(tree);
-
-            if (it != (*_node_data)[vi].heap_index.end()) {
-              (*_node_data)[vi].heap.erase(it->second);
-              (*_node_data)[vi].heap_index.erase(it);
-              if ((*_node_data)[vi].heap.empty()) {
-                _blossom_set->increase(v, std::numeric_limits<Value>::max());
-              } else if ((*_blossom_set)[v] < (*_node_data)[vi].heap.prio()) {
-                _blossom_set->increase(v, (*_node_data)[vi].heap.prio());
-              }
-
-              if ((*_blossom_data)[vb].status == MATCHED) {
-                if (_blossom_set->classPrio(vb) ==
-                    std::numeric_limits<Value>::max()) {
-                  _delta2->erase(vb);
-                } else if ((*_delta2)[vb] < _blossom_set->classPrio(vb) -
-                           (*_blossom_data)[vb].offset) {
-                  _delta2->increase(vb, _blossom_set->classPrio(vb) -
-                                   (*_blossom_data)[vb].offset);
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-
-    void oddToMatched(int blossom) {
-      (*_blossom_data)[blossom].offset -= _delta_sum;
-
-      if (_blossom_set->classPrio(blossom) !=
-          std::numeric_limits<Value>::max()) {
-        _delta2->push(blossom, _blossom_set->classPrio(blossom) -
-                      (*_blossom_data)[blossom].offset);
-      }
-
-      if (!_blossom_set->trivial(blossom)) {
-        _delta4->erase(blossom);
-      }
-    }
-
-    void oddToEven(int blossom, int tree) {
-      if (!_blossom_set->trivial(blossom)) {
-        _delta4->erase(blossom);
-        (*_blossom_data)[blossom].pot -=
-          2 * (2 * _delta_sum - (*_blossom_data)[blossom].offset);
-      }
-
-      for (typename BlossomSet::ItemIt n(*_blossom_set, blossom);
-           n != INVALID; ++n) {
-        int ni = (*_node_index)[n];
-
-        _blossom_set->increase(n, std::numeric_limits<Value>::max());
-
-        (*_node_data)[ni].heap.clear();
-        (*_node_data)[ni].heap_index.clear();
-        (*_node_data)[ni].pot +=
-          2 * _delta_sum - (*_blossom_data)[blossom].offset;
-
-        _delta1->push(n, (*_node_data)[ni].pot);
-
-        for (InArcIt e(_graph, n); e != INVALID; ++e) {
-          Node v = _graph.source(e);
-          int vb = _blossom_set->find(v);
-          int vi = (*_node_index)[v];
-
-          Value rw = (*_node_data)[ni].pot + (*_node_data)[vi].pot -
-            dualScale * _weight[e];
-
-          if ((*_blossom_data)[vb].status == EVEN) {
-            if (_delta3->state(e) != _delta3->IN_HEAP && blossom != vb) {
-              _delta3->push(e, rw / 2);
-            }
-          } else {
-
-            typename std::map<int, Arc>::iterator it =
-              (*_node_data)[vi].heap_index.find(tree);
-
-            if (it != (*_node_data)[vi].heap_index.end()) {
-              if ((*_node_data)[vi].heap[it->second] > rw) {
-                (*_node_data)[vi].heap.replace(it->second, e);
-                (*_node_data)[vi].heap.decrease(e, rw);
-                it->second = e;
+              (*_node_data)[ni].heap_index.find(vt);
+
+            if (it != (*_node_data)[ni].heap_index.end()) {
+              if ((*_node_data)[ni].heap[it->second] > rw) {
+                (*_node_data)[ni].heap.replace(it->second, r);
+                (*_node_data)[ni].heap.decrease(r, rw);
+                it->second = r;
               }
             } else {
-              (*_node_data)[vi].heap.push(e, rw);
-              (*_node_data)[vi].heap_index.insert(std::make_pair(tree, e));
-            }
-
-            if ((*_blossom_set)[v] > (*_node_data)[vi].heap.prio()) {
-              _blossom_set->decrease(v, (*_node_data)[vi].heap.prio());
-
-              if ((*_blossom_data)[vb].status == MATCHED) {
-                if (_delta2->state(vb) != _delta2->IN_HEAP) {
-                  _delta2->push(vb, _blossom_set->classPrio(vb) -
-                               (*_blossom_data)[vb].offset);
-                } else if ((*_delta2)[vb] > _blossom_set->classPrio(vb) -
-                           (*_blossom_data)[vb].offset) {
-                  _delta2->decrease(vb, _blossom_set->classPrio(vb) -
-                                   (*_blossom_data)[vb].offset);
-                }
+              (*_node_data)[ni].heap.push(r, rw);
+              (*_node_data)[ni].heap_index.insert(std::make_pair(vt, r));
+            }
+
+            if ((*_blossom_set)[n] > (*_node_data)[ni].heap.prio()) {
+              _blossom_set->decrease(n, (*_node_data)[ni].heap.prio());
+
+              if (_delta2->state(blossom) != _delta2->IN_HEAP) {
+                _delta2->push(blossom, _blossom_set->classPrio(blossom) -
+                             (*_blossom_data)[blossom].offset);
+              } else if ((*_delta2)[blossom] > _blossom_set->classPrio(blossom)-
+                         (*_blossom_data)[blossom].offset){
+                _delta2->decrease(blossom, _blossom_set->classPrio(blossom) -
+                                 (*_blossom_data)[blossom].offset);
               }
             }
+
+          } else if ((*_blossom_data)[vb].status == UNMATCHED) {
+            if (_delta3->state(e) == _delta3->IN_HEAP) {
+              _delta3->erase(e);
+            }
           }
         }
       }
-      (*_blossom_data)[blossom].offset = 0;
     }
 
@@ -1208,7 +1295,9 @@
       destroyTree(tree);
 
+      (*_blossom_data)[blossom].status = UNMATCHED;
       (*_blossom_data)[blossom].base = node;
-      (*_blossom_data)[blossom].next = INVALID;
-    }
+      matchedToUnmatched(blossom);
+    }
+
 
     void augmentOnEdge(const Edge& edge) {
@@ -1217,29 +1306,24 @@
       int right = _blossom_set->find(_graph.v(edge));
 
-      int left_tree = _tree_set->find(left);
-      alternatePath(left, left_tree);
-      destroyTree(left_tree);
-
-      int right_tree = _tree_set->find(right);
-      alternatePath(right, right_tree);
-      destroyTree(right_tree);
+      if ((*_blossom_data)[left].status == EVEN) {
+        int left_tree = _tree_set->find(left);
+        alternatePath(left, left_tree);
+        destroyTree(left_tree);
+      } else {
+        (*_blossom_data)[left].status = MATCHED;
+        unmatchedToMatched(left);
+      }
+
+      if ((*_blossom_data)[right].status == EVEN) {
+        int right_tree = _tree_set->find(right);
+        alternatePath(right, right_tree);
+        destroyTree(right_tree);
+      } else {
+        (*_blossom_data)[right].status = MATCHED;
+        unmatchedToMatched(right);
+      }
 
       (*_blossom_data)[left].next = _graph.direct(edge, true);
       (*_blossom_data)[right].next = _graph.direct(edge, false);
-    }
-
-    void augmentOnArc(const Arc& arc) {
-
-      int left = _blossom_set->find(_graph.source(arc));
-      int right = _blossom_set->find(_graph.target(arc));
-
-      (*_blossom_data)[left].status = MATCHED;
-
-      int right_tree = _tree_set->find(right);
-      alternatePath(right, right_tree);
-      destroyTree(right_tree);
-
-      (*_blossom_data)[left].next = arc;
-      (*_blossom_data)[right].next = _graph.oppositeArc(arc);
     }
 
@@ -1446,5 +1530,5 @@
           (*_blossom_data)[sb].pred = pred;
           (*_blossom_data)[sb].next =
-            _graph.oppositeArc((*_blossom_data)[tb].next);
+                           _graph.oppositeArc((*_blossom_data)[tb].next);
 
           pred = (*_blossom_data)[ub].next;
@@ -1546,5 +1630,5 @@
 
       for (int i = 0; i < int(blossoms.size()); ++i) {
-        if ((*_blossom_data)[blossoms[i]].next != INVALID) {
+        if ((*_blossom_data)[blossoms[i]].status == MATCHED) {
 
           Value offset = (*_blossom_data)[blossoms[i]].offset;
@@ -1584,14 +1668,8 @@
         _delta4_index(0), _delta4(0),
 
-        _delta_sum(), _unmatched(0),
-
-        _fractional(0)
-    {}
+        _delta_sum() {}
 
     ~MaxWeightedMatching() {
       destroyStructures();
-      if (_fractional) {
-        delete _fractional;
-      }
     }
 
@@ -1608,7 +1686,4 @@
       createStructures();
 
-      _blossom_node_list.clear();
-      _blossom_potential.clear();
-
       for (ArcIt e(_graph); e != INVALID; ++e) {
         (*_node_heap_index)[e] = BinHeap<Value, IntArcMap>::PRE_HEAP;
@@ -1624,13 +1699,4 @@
         (*_delta4_index)[i] = _delta4->PRE_HEAP;
       }
-
-      _unmatched = _node_num;
-
-      _delta1->clear();
-      _delta2->clear();
-      _delta3->clear();
-      _delta4->clear();
-      _blossom_set->clear();
-      _tree_set->clear();
 
       int index = 0;
@@ -1644,6 +1710,4 @@
         }
         (*_node_index)[n] = index;
-        (*_node_data)[index].heap_index.clear();
-        (*_node_data)[index].heap.clear();
         (*_node_data)[index].pot = max;
         _delta1->push(n, max);
@@ -1670,159 +1734,9 @@
     }
 
-    /// \brief Initialize the algorithm with fractional matching
-    ///
-    /// This function initializes the algorithm with a fractional
-    /// matching. This initialization is also called jumpstart heuristic.
-    void fractionalInit() {
-      createStructures();
-
-      _blossom_node_list.clear();
-      _blossom_potential.clear();
-
-      if (_fractional == 0) {
-        _fractional = new FractionalMatching(_graph, _weight, false);
-      }
-      _fractional->run();
-
-      for (ArcIt e(_graph); e != INVALID; ++e) {
-        (*_node_heap_index)[e] = BinHeap<Value, IntArcMap>::PRE_HEAP;
-      }
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        (*_delta1_index)[n] = _delta1->PRE_HEAP;
-      }
-      for (EdgeIt e(_graph); e != INVALID; ++e) {
-        (*_delta3_index)[e] = _delta3->PRE_HEAP;
-      }
-      for (int i = 0; i < _blossom_num; ++i) {
-        (*_delta2_index)[i] = _delta2->PRE_HEAP;
-        (*_delta4_index)[i] = _delta4->PRE_HEAP;
-      }
-
-      _unmatched = 0;
-
-      _delta1->clear();
-      _delta2->clear();
-      _delta3->clear();
-      _delta4->clear();
-      _blossom_set->clear();
-      _tree_set->clear();
-
-      int index = 0;
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        Value pot = _fractional->nodeValue(n);
-        (*_node_index)[n] = index;
-        (*_node_data)[index].pot = pot;
-        (*_node_data)[index].heap_index.clear();
-        (*_node_data)[index].heap.clear();
-        int blossom =
-          _blossom_set->insert(n, std::numeric_limits<Value>::max());
-
-        (*_blossom_data)[blossom].status = MATCHED;
-        (*_blossom_data)[blossom].pred = INVALID;
-        (*_blossom_data)[blossom].next = _fractional->matching(n);
-        if (_fractional->matching(n) == INVALID) {
-          (*_blossom_data)[blossom].base = n;
-        }
-        (*_blossom_data)[blossom].pot = 0;
-        (*_blossom_data)[blossom].offset = 0;
-        ++index;
-      }
-
-      typename Graph::template NodeMap<bool> processed(_graph, false);
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        if (processed[n]) continue;
-        processed[n] = true;
-        if (_fractional->matching(n) == INVALID) continue;
-        int num = 1;
-        Node v = _graph.target(_fractional->matching(n));
-        while (n != v) {
-          processed[v] = true;
-          v = _graph.target(_fractional->matching(v));
-          ++num;
-        }
-
-        if (num % 2 == 1) {
-          std::vector<int> subblossoms(num);
-
-          subblossoms[--num] = _blossom_set->find(n);
-          _delta1->push(n, _fractional->nodeValue(n));
-          v = _graph.target(_fractional->matching(n));
-          while (n != v) {
-            subblossoms[--num] = _blossom_set->find(v);
-            _delta1->push(v, _fractional->nodeValue(v));
-            v = _graph.target(_fractional->matching(v));
-          }
-
-          int surface =
-            _blossom_set->join(subblossoms.begin(), subblossoms.end());
-          (*_blossom_data)[surface].status = EVEN;
-          (*_blossom_data)[surface].pred = INVALID;
-          (*_blossom_data)[surface].next = INVALID;
-          (*_blossom_data)[surface].pot = 0;
-          (*_blossom_data)[surface].offset = 0;
-
-          _tree_set->insert(surface);
-          ++_unmatched;
-        }
-      }
-
-      for (EdgeIt e(_graph); e != INVALID; ++e) {
-        int si = (*_node_index)[_graph.u(e)];
-        int sb = _blossom_set->find(_graph.u(e));
-        int ti = (*_node_index)[_graph.v(e)];
-        int tb = _blossom_set->find(_graph.v(e));
-        if ((*_blossom_data)[sb].status == EVEN &&
-            (*_blossom_data)[tb].status == EVEN && sb != tb) {
-          _delta3->push(e, ((*_node_data)[si].pot + (*_node_data)[ti].pot -
-                            dualScale * _weight[e]) / 2);
-        }
-      }
-
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        int nb = _blossom_set->find(n);
-        if ((*_blossom_data)[nb].status != MATCHED) continue;
-        int ni = (*_node_index)[n];
-
-        for (OutArcIt e(_graph, n); e != INVALID; ++e) {
-          Node v = _graph.target(e);
-          int vb = _blossom_set->find(v);
-          int vi = (*_node_index)[v];
-
-          Value rw = (*_node_data)[ni].pot + (*_node_data)[vi].pot -
-            dualScale * _weight[e];
-
-          if ((*_blossom_data)[vb].status == EVEN) {
-
-            int vt = _tree_set->find(vb);
-
-            typename std::map<int, Arc>::iterator it =
-              (*_node_data)[ni].heap_index.find(vt);
-
-            if (it != (*_node_data)[ni].heap_index.end()) {
-              if ((*_node_data)[ni].heap[it->second] > rw) {
-                (*_node_data)[ni].heap.replace(it->second, e);
-                (*_node_data)[ni].heap.decrease(e, rw);
-                it->second = e;
-              }
-            } else {
-              (*_node_data)[ni].heap.push(e, rw);
-              (*_node_data)[ni].heap_index.insert(std::make_pair(vt, e));
-            }
-          }
-        }
-
-        if (!(*_node_data)[ni].heap.empty()) {
-          _blossom_set->decrease(n, (*_node_data)[ni].heap.prio());
-          _delta2->push(nb, _blossom_set->classPrio(nb));
-        }
-      }
-    }
-
     /// \brief Start the algorithm
     ///
     /// This function starts the algorithm.
     ///
-    /// \pre \ref init() or \ref fractionalInit() must be called
-    /// before using this function.
+    /// \pre \ref init() must be called before using this function.
     void start() {
       enum OpType {
@@ -1830,5 +1744,6 @@
       };
 
-      while (_unmatched > 0) {
+      int unmatched = _node_num;
+      while (unmatched > 0) {
         Value d1 = !_delta1->empty() ?
           _delta1->prio() : std::numeric_limits<Value>::max();
@@ -1843,8 +1758,9 @@
           _delta4->prio() : std::numeric_limits<Value>::max();
 
-        _delta_sum = d3; OpType ot = D3;
-        if (d1 < _delta_sum) { _delta_sum = d1; ot = D1; }
+        _delta_sum = d1; OpType ot = D1;
         if (d2 < _delta_sum) { _delta_sum = d2; ot = D2; }
+        if (d3 < _delta_sum) { _delta_sum = d3; ot = D3; }
         if (d4 < _delta_sum) { _delta_sum = d4; ot = D4; }
+
 
         switch (ot) {
@@ -1853,5 +1769,5 @@
             Node n = _delta1->top();
             unmatchNode(n);
-            --_unmatched;
+            --unmatched;
           }
           break;
@@ -1860,11 +1776,6 @@
             int blossom = _delta2->top();
             Node n = _blossom_set->classTop(blossom);
-            Arc a = (*_node_data)[(*_node_index)[n]].heap.top();
-            if ((*_blossom_data)[blossom].next == INVALID) {
-              augmentOnArc(a);
-              --_unmatched;
-            } else {
-              extendOnArc(a);
-            }
+            Arc e = (*_node_data)[(*_node_index)[n]].heap.top();
+            extendOnArc(e);
           }
           break;
@@ -1879,6 +1790,18 @@
               _delta3->pop();
             } else {
-              int left_tree = _tree_set->find(left_blossom);
-              int right_tree = _tree_set->find(right_blossom);
+              int left_tree;
+              if ((*_blossom_data)[left_blossom].status == EVEN) {
+                left_tree = _tree_set->find(left_blossom);
+              } else {
+                left_tree = -1;
+                ++unmatched;
+              }
+              int right_tree;
+              if ((*_blossom_data)[right_blossom].status == EVEN) {
+                right_tree = _tree_set->find(right_blossom);
+              } else {
+                right_tree = -1;
+                ++unmatched;
+              }
 
               if (left_tree == right_tree) {
@@ -1886,5 +1809,5 @@
               } else {
                 augmentOnEdge(e);
-                _unmatched -= 2;
+                unmatched -= 2;
               }
             }
@@ -1904,9 +1827,9 @@
     /// \note mwm.run() is just a shortcut of the following code.
     /// \code
-    ///   mwm.fractionalInit();
+    ///   mwm.init();
     ///   mwm.start();
     /// \endcode
     void run() {
-      fractionalInit();
+      init();
       start();
     }
@@ -1915,5 +1838,5 @@
 
     /// \name Primal Solution
-    /// Functions to get the primal solution, i.e. the maximum weighted
+    /// Functions to get the primal solution, i.e. the maximum weighted 
     /// matching.\n
     /// Either \ref run() or \ref start() function should be called before
@@ -1934,5 +1857,5 @@
         }
       }
-      return sum / 2;
+      return sum /= 2;
     }
 
@@ -1954,5 +1877,5 @@
     /// \brief Return \c true if the given edge is in the matching.
     ///
-    /// This function returns \c true if the given edge is in the found
+    /// This function returns \c true if the given edge is in the found 
     /// matching.
     ///
@@ -1965,5 +1888,5 @@
     ///
     /// This function returns the matching arc (or edge) incident to the
-    /// given node in the found matching or \c INVALID if the node is
+    /// given node in the found matching or \c INVALID if the node is 
     /// not covered by the matching.
     ///
@@ -1983,5 +1906,5 @@
     /// \brief Return the mate of the given node.
     ///
-    /// This function returns the mate of the given node in the found
+    /// This function returns the mate of the given node in the found 
     /// matching or \c INVALID if the node is not covered by the matching.
     ///
@@ -2003,6 +1926,6 @@
     /// \brief Return the value of the dual solution.
     ///
-    /// This function returns the value of the dual solution.
-    /// It should be equal to the primal value scaled by \ref dualScale
+    /// This function returns the value of the dual solution. 
+    /// It should be equal to the primal value scaled by \ref dualScale 
     /// "dual scale".
     ///
@@ -2059,7 +1982,7 @@
     /// \brief Iterator for obtaining the nodes of a blossom.
     ///
-    /// This class provides an iterator for obtaining the nodes of the
+    /// This class provides an iterator for obtaining the nodes of the 
     /// given blossom. It lists a subset of the nodes.
-    /// Before using this iterator, you must allocate a
+    /// Before using this iterator, you must allocate a 
     /// MaxWeightedMatching class and execute it.
     class BlossomIt {
@@ -2070,6 +1993,6 @@
       /// Constructor to get the nodes of the given variable.
       ///
-      /// \pre Either \ref MaxWeightedMatching::run() "algorithm.run()" or
-      /// \ref MaxWeightedMatching::start() "algorithm.start()" must be
+      /// \pre Either \ref MaxWeightedMatching::run() "algorithm.run()" or 
+      /// \ref MaxWeightedMatching::start() "algorithm.start()" must be 
       /// called before initializing this iterator.
       BlossomIt(const MaxWeightedMatching& algorithm, int variable)
@@ -2124,6 +2047,6 @@
   /// \f$O(nm\log n)\f$ time complexity.
   ///
-  /// The maximum weighted perfect matching problem is to find a subset of
-  /// the edges in an undirected graph with maximum overall weight for which
+  /// The maximum weighted perfect matching problem is to find a subset of 
+  /// the edges in an undirected graph with maximum overall weight for which 
   /// each node has exactly one incident edge.
   /// It can be formulated with the following linear program.
@@ -2148,14 +2071,14 @@
       \frac{\vert B \vert - 1}{2}z_B\f] */
   ///
-  /// The algorithm can be executed with the run() function.
+  /// The algorithm can be executed with the run() function. 
   /// After it the matching (the primal solution) and the dual solution
-  /// can be obtained using the query functions and the
-  /// \ref MaxWeightedPerfectMatching::BlossomIt "BlossomIt" nested class,
-  /// which is able to iterate on the nodes of a blossom.
+  /// can be obtained using the query functions and the 
+  /// \ref MaxWeightedPerfectMatching::BlossomIt "BlossomIt" nested class, 
+  /// which is able to iterate on the nodes of a blossom. 
   /// If the value type is integer, then the dual solution is multiplied
   /// by \ref MaxWeightedMatching::dualScale "4".
   ///
   /// \tparam GR The undirected graph type the algorithm runs on.
-  /// \tparam WM The type edge weight map. The default type is
+  /// \tparam WM The type edge weight map. The default type is 
   /// \ref concepts::Graph::EdgeMap "GR::EdgeMap<int>".
 #ifdef DOXYGEN
@@ -2268,9 +2191,4 @@
 
     Value _delta_sum;
-    int _unmatched;
-
-    typedef MaxWeightedPerfectFractionalMatching<Graph, WeightMap>
-    FractionalMatching;
-    FractionalMatching *_fractional;
 
     void createStructures() {
@@ -2281,15 +2199,10 @@
         _matching = new MatchingMap(_graph);
       }
-
       if (!_node_potential) {
         _node_potential = new NodePotential(_graph);
       }
-
       if (!_blossom_set) {
         _blossom_index = new IntNodeMap(_graph);
         _blossom_set = new BlossomSet(*_blossom_index);
-        _blossom_data = new RangeMap<BlossomData>(_blossom_num);
-      } else if (_blossom_data->size() != _blossom_num) {
-        delete _blossom_data;
         _blossom_data = new RangeMap<BlossomData>(_blossom_num);
       }
@@ -2300,8 +2213,4 @@
         _node_data = new RangeMap<NodeData>(_node_num,
                                             NodeData(*_node_heap_index));
-      } else if (_node_data->size() != _node_num) {
-        delete _node_data;
-        _node_data = new RangeMap<NodeData>(_node_num,
-                                            NodeData(*_node_heap_index));
       }
 
@@ -2309,29 +2218,23 @@
         _tree_set_index = new IntIntMap(_blossom_num);
         _tree_set = new TreeSet(*_tree_set_index);
-      } else {
-        _tree_set_index->resize(_blossom_num);
-      }
-
+      }
       if (!_delta2) {
         _delta2_index = new IntIntMap(_blossom_num);
         _delta2 = new BinHeap<Value, IntIntMap>(*_delta2_index);
-      } else {
-        _delta2_index->resize(_blossom_num);
-      }
-
+      }
       if (!_delta3) {
         _delta3_index = new IntEdgeMap(_graph);
         _delta3 = new BinHeap<Value, IntEdgeMap>(*_delta3_index);
       }
-
       if (!_delta4) {
         _delta4_index = new IntIntMap(_blossom_num);
         _delta4 = new BinHeap<Value, IntIntMap>(*_delta4_index);
-      } else {
-        _delta4_index->resize(_blossom_num);
       }
     }
 
     void destroyStructures() {
+      _node_num = countNodes(_graph);
+      _blossom_num = _node_num * 3 / 2;
+
       if (_matching) {
         delete _matching;
@@ -3006,14 +2909,8 @@
         _delta4_index(0), _delta4(0),
 
-        _delta_sum(), _unmatched(0),
-
-        _fractional(0)
-    {}
+        _delta_sum() {}
 
     ~MaxWeightedPerfectMatching() {
       destroyStructures();
-      if (_fractional) {
-        delete _fractional;
-      }
     }
 
@@ -3030,7 +2927,4 @@
       createStructures();
 
-      _blossom_node_list.clear();
-      _blossom_potential.clear();
-
       for (ArcIt e(_graph); e != INVALID; ++e) {
         (*_node_heap_index)[e] = BinHeap<Value, IntArcMap>::PRE_HEAP;
@@ -3043,12 +2937,4 @@
         (*_delta4_index)[i] = _delta4->PRE_HEAP;
       }
-
-      _unmatched = _node_num;
-
-      _delta2->clear();
-      _delta3->clear();
-      _delta4->clear();
-      _blossom_set->clear();
-      _tree_set->clear();
 
       int index = 0;
@@ -3062,6 +2948,4 @@
         }
         (*_node_index)[n] = index;
-        (*_node_data)[index].heap_index.clear();
-        (*_node_data)[index].heap.clear();
         (*_node_data)[index].pot = max;
         int blossom =
@@ -3087,153 +2971,9 @@
     }
 
-    /// \brief Initialize the algorithm with fractional matching
-    ///
-    /// This function initializes the algorithm with a fractional
-    /// matching. This initialization is also called jumpstart heuristic.
-    void fractionalInit() {
-      createStructures();
-
-      _blossom_node_list.clear();
-      _blossom_potential.clear();
-
-      if (_fractional == 0) {
-        _fractional = new FractionalMatching(_graph, _weight, false);
-      }
-      if (!_fractional->run()) {
-        _unmatched = -1;
-        return;
-      }
-
-      for (ArcIt e(_graph); e != INVALID; ++e) {
-        (*_node_heap_index)[e] = BinHeap<Value, IntArcMap>::PRE_HEAP;
-      }
-      for (EdgeIt e(_graph); e != INVALID; ++e) {
-        (*_delta3_index)[e] = _delta3->PRE_HEAP;
-      }
-      for (int i = 0; i < _blossom_num; ++i) {
-        (*_delta2_index)[i] = _delta2->PRE_HEAP;
-        (*_delta4_index)[i] = _delta4->PRE_HEAP;
-      }
-
-      _unmatched = 0;
-
-      _delta2->clear();
-      _delta3->clear();
-      _delta4->clear();
-      _blossom_set->clear();
-      _tree_set->clear();
-
-      int index = 0;
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        Value pot = _fractional->nodeValue(n);
-        (*_node_index)[n] = index;
-        (*_node_data)[index].pot = pot;
-        (*_node_data)[index].heap_index.clear();
-        (*_node_data)[index].heap.clear();
-        int blossom =
-          _blossom_set->insert(n, std::numeric_limits<Value>::max());
-
-        (*_blossom_data)[blossom].status = MATCHED;
-        (*_blossom_data)[blossom].pred = INVALID;
-        (*_blossom_data)[blossom].next = _fractional->matching(n);
-        (*_blossom_data)[blossom].pot = 0;
-        (*_blossom_data)[blossom].offset = 0;
-        ++index;
-      }
-
-      typename Graph::template NodeMap<bool> processed(_graph, false);
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        if (processed[n]) continue;
-        processed[n] = true;
-        if (_fractional->matching(n) == INVALID) continue;
-        int num = 1;
-        Node v = _graph.target(_fractional->matching(n));
-        while (n != v) {
-          processed[v] = true;
-          v = _graph.target(_fractional->matching(v));
-          ++num;
-        }
-
-        if (num % 2 == 1) {
-          std::vector<int> subblossoms(num);
-
-          subblossoms[--num] = _blossom_set->find(n);
-          v = _graph.target(_fractional->matching(n));
-          while (n != v) {
-            subblossoms[--num] = _blossom_set->find(v);
-            v = _graph.target(_fractional->matching(v));
-          }
-
-          int surface =
-            _blossom_set->join(subblossoms.begin(), subblossoms.end());
-          (*_blossom_data)[surface].status = EVEN;
-          (*_blossom_data)[surface].pred = INVALID;
-          (*_blossom_data)[surface].next = INVALID;
-          (*_blossom_data)[surface].pot = 0;
-          (*_blossom_data)[surface].offset = 0;
-
-          _tree_set->insert(surface);
-          ++_unmatched;
-        }
-      }
-
-      for (EdgeIt e(_graph); e != INVALID; ++e) {
-        int si = (*_node_index)[_graph.u(e)];
-        int sb = _blossom_set->find(_graph.u(e));
-        int ti = (*_node_index)[_graph.v(e)];
-        int tb = _blossom_set->find(_graph.v(e));
-        if ((*_blossom_data)[sb].status == EVEN &&
-            (*_blossom_data)[tb].status == EVEN && sb != tb) {
-          _delta3->push(e, ((*_node_data)[si].pot + (*_node_data)[ti].pot -
-                            dualScale * _weight[e]) / 2);
-        }
-      }
-
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        int nb = _blossom_set->find(n);
-        if ((*_blossom_data)[nb].status != MATCHED) continue;
-        int ni = (*_node_index)[n];
-
-        for (OutArcIt e(_graph, n); e != INVALID; ++e) {
-          Node v = _graph.target(e);
-          int vb = _blossom_set->find(v);
-          int vi = (*_node_index)[v];
-
-          Value rw = (*_node_data)[ni].pot + (*_node_data)[vi].pot -
-            dualScale * _weight[e];
-
-          if ((*_blossom_data)[vb].status == EVEN) {
-
-            int vt = _tree_set->find(vb);
-
-            typename std::map<int, Arc>::iterator it =
-              (*_node_data)[ni].heap_index.find(vt);
-
-            if (it != (*_node_data)[ni].heap_index.end()) {
-              if ((*_node_data)[ni].heap[it->second] > rw) {
-                (*_node_data)[ni].heap.replace(it->second, e);
-                (*_node_data)[ni].heap.decrease(e, rw);
-                it->second = e;
-              }
-            } else {
-              (*_node_data)[ni].heap.push(e, rw);
-              (*_node_data)[ni].heap_index.insert(std::make_pair(vt, e));
-            }
-          }
-        }
-
-        if (!(*_node_data)[ni].heap.empty()) {
-          _blossom_set->decrease(n, (*_node_data)[ni].heap.prio());
-          _delta2->push(nb, _blossom_set->classPrio(nb));
-        }
-      }
-    }
-
     /// \brief Start the algorithm
     ///
     /// This function starts the algorithm.
     ///
-    /// \pre \ref init() or \ref fractionalInit() must be called before
-    /// using this function.
+    /// \pre \ref init() must be called before using this function.
     bool start() {
       enum OpType {
@@ -3241,7 +2981,6 @@
       };
 
-      if (_unmatched == -1) return false;
-
-      while (_unmatched > 0) {
+      int unmatched = _node_num;
+      while (unmatched > 0) {
         Value d2 = !_delta2->empty() ?
           _delta2->prio() : std::numeric_limits<Value>::max();
@@ -3253,6 +2992,6 @@
           _delta4->prio() : std::numeric_limits<Value>::max();
 
-        _delta_sum = d3; OpType ot = D3;
-        if (d2 < _delta_sum) { _delta_sum = d2; ot = D2; }
+        _delta_sum = d2; OpType ot = D2;
+        if (d3 < _delta_sum) { _delta_sum = d3; ot = D3; }
         if (d4 < _delta_sum) { _delta_sum = d4; ot = D4; }
 
@@ -3287,5 +3026,5 @@
               } else {
                 augmentOnEdge(e);
-                _unmatched -= 2;
+                unmatched -= 2;
               }
             }
@@ -3306,9 +3045,9 @@
     /// \note mwpm.run() is just a shortcut of the following code.
     /// \code
-    ///   mwpm.fractionalInit();
+    ///   mwpm.init();
     ///   mwpm.start();
     /// \endcode
     bool run() {
-      fractionalInit();
+      init();
       return start();
     }
@@ -3317,5 +3056,5 @@
 
     /// \name Primal Solution
-    /// Functions to get the primal solution, i.e. the maximum weighted
+    /// Functions to get the primal solution, i.e. the maximum weighted 
     /// perfect matching.\n
     /// Either \ref run() or \ref start() function should be called before
@@ -3336,10 +3075,10 @@
         }
       }
-      return sum / 2;
+      return sum /= 2;
     }
 
     /// \brief Return \c true if the given edge is in the matching.
     ///
-    /// This function returns \c true if the given edge is in the found
+    /// This function returns \c true if the given edge is in the found 
     /// matching.
     ///
@@ -3352,5 +3091,5 @@
     ///
     /// This function returns the matching arc (or edge) incident to the
-    /// given node in the found matching or \c INVALID if the node is
+    /// given node in the found matching or \c INVALID if the node is 
     /// not covered by the matching.
     ///
@@ -3370,5 +3109,5 @@
     /// \brief Return the mate of the given node.
     ///
-    /// This function returns the mate of the given node in the found
+    /// This function returns the mate of the given node in the found 
     /// matching or \c INVALID if the node is not covered by the matching.
     ///
@@ -3389,6 +3128,6 @@
     /// \brief Return the value of the dual solution.
     ///
-    /// This function returns the value of the dual solution.
-    /// It should be equal to the primal value scaled by \ref dualScale
+    /// This function returns the value of the dual solution. 
+    /// It should be equal to the primal value scaled by \ref dualScale 
     /// "dual scale".
     ///
@@ -3445,7 +3184,7 @@
     /// \brief Iterator for obtaining the nodes of a blossom.
     ///
-    /// This class provides an iterator for obtaining the nodes of the
+    /// This class provides an iterator for obtaining the nodes of the 
     /// given blossom. It lists a subset of the nodes.
-    /// Before using this iterator, you must allocate a
+    /// Before using this iterator, you must allocate a 
     /// MaxWeightedPerfectMatching class and execute it.
     class BlossomIt {
@@ -3456,6 +3195,6 @@
       /// Constructor to get the nodes of the given variable.
       ///
-      /// \pre Either \ref MaxWeightedPerfectMatching::run() "algorithm.run()"
-      /// or \ref MaxWeightedPerfectMatching::start() "algorithm.start()"
+      /// \pre Either \ref MaxWeightedPerfectMatching::run() "algorithm.run()" 
+      /// or \ref MaxWeightedPerfectMatching::start() "algorithm.start()" 
       /// must be called before initializing this iterator.
       BlossomIt(const MaxWeightedPerfectMatching& algorithm, int variable)
@@ -3503,3 +3242,3 @@
 } //END OF NAMESPACE LEMON
 
-#endif //LEMON_MATCHING_H
+#endif //LEMON_MAX_MATCHING_H
Index: lemon/math.h
===================================================================
--- lemon/math.h	(revision 1311)
+++ lemon/math.h	(revision 558)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -57,5 +57,5 @@
 
   ///Check whether the parameter is NaN or not
-
+  
   ///This function checks whether the parameter is NaN or not.
   ///Is should be equivalent with std::isnan(), but it is not
@@ -66,12 +66,7 @@
     }
 
-  ///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);
-  }
-
   /// @}
 
 } //namespace lemon
 
-#endif //LEMON_MATH_H
+#endif //LEMON_TOLERANCE_H
Index: mon/max_cardinality_search.h
===================================================================
--- lemon/max_cardinality_search.h	(revision 1271)
+++ 	(revision )
@@ -1,794 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2013
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * 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_MAX_CARDINALITY_SEARCH_H
-#define LEMON_MAX_CARDINALITY_SEARCH_H
-
-
-/// \ingroup search
-/// \file
-/// \brief Maximum cardinality search in undirected digraphs.
-
-#include <lemon/bin_heap.h>
-#include <lemon/bucket_heap.h>
-
-#include <lemon/error.h>
-#include <lemon/maps.h>
-
-#include <functional>
-
-namespace lemon {
-
-  /// \brief Default traits class of MaxCardinalitySearch class.
-  ///
-  /// Default traits class of MaxCardinalitySearch class.
-  /// \param Digraph Digraph type.
-  /// \param CapacityMap Type of capacity map.
-  template <typename GR, typename CAP>
-  struct MaxCardinalitySearchDefaultTraits {
-    /// The digraph type the algorithm runs on.
-    typedef GR Digraph;
-
-    template <typename CM>
-    struct CapMapSelector {
-
-      typedef CM CapacityMap;
-
-      static CapacityMap *createCapacityMap(const Digraph& g) {
-        return new CapacityMap(g);
-      }
-    };
-
-    template <typename CM>
-    struct CapMapSelector<ConstMap<CM, Const<int, 1> > > {
-
-      typedef ConstMap<CM, Const<int, 1> > CapacityMap;
-
-      static CapacityMap *createCapacityMap(const Digraph&) {
-        return new CapacityMap;
-      }
-    };
-
-    /// \brief The type of the map that stores the arc capacities.
-    ///
-    /// The type of the map that stores the arc capacities.
-    /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
-    typedef typename CapMapSelector<CAP>::CapacityMap CapacityMap;
-
-    /// \brief The type of the capacity of the arcs.
-    typedef typename CapacityMap::Value Value;
-
-    /// \brief Instantiates a CapacityMap.
-    ///
-    /// This function instantiates a \ref CapacityMap.
-    /// \param digraph is the digraph, to which we would like to define
-    /// the CapacityMap.
-    static CapacityMap *createCapacityMap(const Digraph& digraph) {
-      return CapMapSelector<CapacityMap>::createCapacityMap(digraph);
-    }
-
-    /// \brief The cross reference type used by heap.
-    ///
-    /// The cross reference type used by heap.
-    /// Usually it is \c Digraph::NodeMap<int>.
-    typedef typename Digraph::template NodeMap<int> HeapCrossRef;
-
-    /// \brief Instantiates a HeapCrossRef.
-    ///
-    /// This function instantiates a \ref HeapCrossRef.
-    /// \param digraph is the digraph, to which we would like to define the
-    /// HeapCrossRef.
-    static HeapCrossRef *createHeapCrossRef(const Digraph &digraph) {
-      return new HeapCrossRef(digraph);
-    }
-
-    template <typename CapacityMap>
-    struct HeapSelector {
-      template <typename Value, typename Ref>
-      struct Selector {
-        typedef BinHeap<Value, Ref, std::greater<Value> > Heap;
-      };
-    };
-
-    template <typename CapacityKey>
-    struct HeapSelector<ConstMap<CapacityKey, Const<int, 1> > > {
-      template <typename Value, typename Ref>
-      struct Selector {
-        typedef BucketHeap<Ref, false > Heap;
-      };
-    };
-
-    /// \brief The heap type used by MaxCardinalitySearch algorithm.
-    ///
-    /// The heap type used by MaxCardinalitySearch algorithm. It should
-    /// maximalize the priorities. The default heap type is
-    /// the \ref BinHeap, but it is specialized when the
-    /// CapacityMap is ConstMap<Digraph::Node, Const<int, 1> >
-    /// to BucketHeap.
-    ///
-    /// \sa MaxCardinalitySearch
-    typedef typename HeapSelector<CapacityMap>
-    ::template Selector<Value, HeapCrossRef>
-    ::Heap Heap;
-
-    /// \brief Instantiates a Heap.
-    ///
-    /// This function instantiates a \ref Heap.
-    /// \param crossref The cross reference of the heap.
-    static Heap *createHeap(HeapCrossRef& crossref) {
-      return new Heap(crossref);
-    }
-
-    /// \brief The type of the map that stores whether a node is processed.
-    ///
-    /// The type of the map that stores whether a node is processed.
-    /// It must meet the \ref concepts::WriteMap "WriteMap" concept.
-    /// By default it is a NullMap.
-    typedef NullMap<typename Digraph::Node, bool> ProcessedMap;
-
-    /// \brief Instantiates a ProcessedMap.
-    ///
-    /// This function instantiates a \ref ProcessedMap.
-    /// \param digraph is the digraph, to which
-    /// we would like to define the \ref ProcessedMap
-#ifdef DOXYGEN
-    static ProcessedMap *createProcessedMap(const Digraph &digraph)
-#else
-    static ProcessedMap *createProcessedMap(const Digraph &)
-#endif
-    {
-      return new ProcessedMap();
-    }
-
-    /// \brief The type of the map that stores the cardinalities of the nodes.
-    ///
-    /// The type of the map that stores the cardinalities of the nodes.
-    /// It must meet the \ref concepts::WriteMap "WriteMap" concept.
-    typedef typename Digraph::template NodeMap<Value> CardinalityMap;
-
-    /// \brief Instantiates a CardinalityMap.
-    ///
-    /// This function instantiates a \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);
-    }
-
-
-  };
-
-  /// \ingroup search
-  ///
-  /// \brief Maximum Cardinality Search algorithm class.
-  ///
-  /// This class provides an efficient implementation of Maximum Cardinality
-  /// 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
-  /// which were previusly processed.
-  /// If there is a cut in the digraph the algorithm should choose
-  /// again any unprocessed node of the digraph.
-
-  /// The arc capacities are passed to the algorithm using a
-  /// \ref concepts::ReadMap "ReadMap", so it is easy to change it to any
-  /// kind of capacity.
-  ///
-  /// The type of the capacity is determined by the \ref
-  /// concepts::ReadMap::Value "Value" of the capacity map.
-  ///
-  /// It is also possible to change the underlying priority heap.
-  ///
-  ///
-  /// \param GR The digraph type the algorithm runs on. The value of
-  /// Digraph is not used directly by the search algorithm, it
-  /// is only passed to \ref MaxCardinalitySearchDefaultTraits.
-  /// \param CAP This read-only ArcMap determines the capacities of
-  /// the arcs. It is read once for each arc, so the map may involve in
-  /// relatively time consuming process to compute the arc capacity if
-  /// it is necessary. The default map type is \ref
-  /// ConstMap "ConstMap<concepts::Digraph::Arc, Const<int,1> >". The value
-  /// of CapacityMap is not used directly by search algorithm, it is only
-  /// passed to \ref MaxCardinalitySearchDefaultTraits.
-  /// \param TR Traits class to set various data types used by the
-  /// algorithm.  The default traits class is
-  /// \ref MaxCardinalitySearchDefaultTraits
-  /// "MaxCardinalitySearchDefaultTraits<GR, CAP>".
-  /// See \ref MaxCardinalitySearchDefaultTraits
-  /// for the documentation of a MaxCardinalitySearch traits class.
-
-#ifdef DOXYGEN
-  template <typename GR, typename CAP, typename TR>
-#else
-  template <typename GR, typename CAP =
-            ConstMap<typename GR::Arc, Const<int,1> >,
-            typename TR =
-            MaxCardinalitySearchDefaultTraits<GR, CAP> >
-#endif
-  class MaxCardinalitySearch {
-  public:
-
-    typedef TR Traits;
-    ///The type of the underlying digraph.
-    typedef typename Traits::Digraph Digraph;
-
-    ///The type of the capacity of the arcs.
-    typedef typename Traits::CapacityMap::Value Value;
-    ///The type of the map that stores the arc capacities.
-    typedef typename Traits::CapacityMap CapacityMap;
-    ///The type of the map indicating if a node is processed.
-    typedef typename Traits::ProcessedMap ProcessedMap;
-    ///The type of the map that stores the cardinalities of the nodes.
-    typedef typename Traits::CardinalityMap CardinalityMap;
-    ///The cross reference type used for the current heap.
-    typedef typename Traits::HeapCrossRef HeapCrossRef;
-    ///The heap type used by the algorithm. It maximizes the priorities.
-    typedef typename Traits::Heap Heap;
-  private:
-    // Pointer to the underlying digraph.
-    const Digraph *_graph;
-    // Pointer to the capacity map
-    const CapacityMap *_capacity;
-    // Indicates if \ref _capacity is locally allocated (\c true) or not.
-    bool local_capacity;
-    // Pointer to the map of cardinality.
-    CardinalityMap *_cardinality;
-    // Indicates if \ref _cardinality is locally allocated (\c true) or not.
-    bool local_cardinality;
-    // Pointer to the map of processed status of the nodes.
-    ProcessedMap *_processed;
-    // Indicates if \ref _processed is locally allocated (\c true) or not.
-    bool local_processed;
-    // Pointer to the heap cross references.
-    HeapCrossRef *_heap_cross_ref;
-    // Indicates if \ref _heap_cross_ref is locally allocated (\c true) or not.
-    bool local_heap_cross_ref;
-    // Pointer to the heap.
-    Heap *_heap;
-    // Indicates if \ref _heap is locally allocated (\c true) or not.
-    bool local_heap;
-
-  public :
-
-    typedef MaxCardinalitySearch Create;
-
-    ///\name Named template parameters
-
-    ///@{
-
-    template <class T>
-    struct DefCapacityMapTraits : public Traits {
-      typedef T CapacityMap;
-      static CapacityMap *createCapacityMap(const Digraph &) {
-               LEMON_ASSERT(false,"Uninitialized parameter.");
-        return 0;
-      }
-    };
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// CapacityMap type
-    ///
-    /// \ref named-templ-param "Named parameter" for setting CapacityMap type
-    /// for the algorithm.
-    template <class T>
-    struct SetCapacityMap
-      : public MaxCardinalitySearch<Digraph, CapacityMap,
-                                    DefCapacityMapTraits<T> > {
-      typedef MaxCardinalitySearch<Digraph, CapacityMap,
-                                   DefCapacityMapTraits<T> > Create;
-    };
-
-    template <class T>
-    struct DefCardinalityMapTraits : public Traits {
-      typedef T CardinalityMap;
-      static CardinalityMap *createCardinalityMap(const Digraph &)
-      {
-        LEMON_ASSERT(false,"Uninitialized parameter.");
-        return 0;
-      }
-    };
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// CardinalityMap type
-    ///
-    /// \ref named-templ-param "Named parameter" for setting CardinalityMap
-    /// type for the algorithm.
-    template <class T>
-    struct SetCardinalityMap
-      : public MaxCardinalitySearch<Digraph, CapacityMap,
-                                    DefCardinalityMapTraits<T> > {
-      typedef MaxCardinalitySearch<Digraph, CapacityMap,
-                                   DefCardinalityMapTraits<T> > Create;
-    };
-
-    template <class T>
-    struct DefProcessedMapTraits : public Traits {
-      typedef T ProcessedMap;
-      static ProcessedMap *createProcessedMap(const Digraph &) {
-               LEMON_ASSERT(false,"Uninitialized parameter.");
-        return 0;
-      }
-    };
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// ProcessedMap type
-    ///
-    /// \ref named-templ-param "Named parameter" for setting ProcessedMap type
-    /// for the algorithm.
-    template <class T>
-    struct SetProcessedMap
-      : public MaxCardinalitySearch<Digraph, CapacityMap,
-                                    DefProcessedMapTraits<T> > {
-      typedef MaxCardinalitySearch<Digraph, CapacityMap,
-                                   DefProcessedMapTraits<T> > Create;
-    };
-
-    template <class H, class CR>
-    struct DefHeapTraits : public Traits {
-      typedef CR HeapCrossRef;
-      typedef H Heap;
-      static HeapCrossRef *createHeapCrossRef(const Digraph &) {
-             LEMON_ASSERT(false,"Uninitialized parameter.");
-        return 0;
-      }
-      static Heap *createHeap(HeapCrossRef &) {
-               LEMON_ASSERT(false,"Uninitialized parameter.");
-        return 0;
-      }
-    };
-    /// \brief \ref named-templ-param "Named parameter" for setting heap
-    /// and cross reference type
-    ///
-    /// \ref named-templ-param "Named parameter" for setting heap and cross
-    /// reference type for the algorithm.
-    template <class H, class CR = typename Digraph::template NodeMap<int> >
-    struct SetHeap
-      : public MaxCardinalitySearch<Digraph, CapacityMap,
-                                    DefHeapTraits<H, CR> > {
-      typedef MaxCardinalitySearch< Digraph, CapacityMap,
-                                    DefHeapTraits<H, CR> > Create;
-    };
-
-    template <class H, class CR>
-    struct DefStandardHeapTraits : public Traits {
-      typedef CR HeapCrossRef;
-      typedef H Heap;
-      static HeapCrossRef *createHeapCrossRef(const Digraph &digraph) {
-        return new HeapCrossRef(digraph);
-      }
-      static Heap *createHeap(HeapCrossRef &crossref) {
-        return new Heap(crossref);
-      }
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting heap and
-    /// cross reference type with automatic allocation
-    ///
-    /// \ref named-templ-param "Named parameter" for setting heap and cross
-    /// reference type. It can allocate the heap and the cross reference
-    /// object if the cross reference's constructor waits for the digraph as
-    /// parameter and the heap's constructor waits for the cross reference.
-    template <class H, class CR = typename Digraph::template NodeMap<int> >
-    struct SetStandardHeap
-      : public MaxCardinalitySearch<Digraph, CapacityMap,
-                                    DefStandardHeapTraits<H, CR> > {
-      typedef MaxCardinalitySearch<Digraph, CapacityMap,
-                                   DefStandardHeapTraits<H, CR> >
-      Create;
-    };
-
-    ///@}
-
-
-  protected:
-
-    MaxCardinalitySearch() {}
-
-  public:
-
-    /// \brief Constructor.
-    ///
-    ///\param digraph the digraph the algorithm will run on.
-    ///\param capacity the capacity map used by the algorithm.
-    MaxCardinalitySearch(const Digraph& digraph,
-                         const CapacityMap& capacity) :
-      _graph(&digraph),
-      _capacity(&capacity), local_capacity(false),
-      _cardinality(0), local_cardinality(false),
-      _processed(0), local_processed(false),
-      _heap_cross_ref(0), local_heap_cross_ref(false),
-      _heap(0), local_heap(false)
-    { }
-
-    /// \brief Constructor.
-    ///
-    ///\param digraph the digraph the algorithm will run on.
-    ///
-    ///A constant 1 capacity map will be allocated.
-    MaxCardinalitySearch(const Digraph& digraph) :
-      _graph(&digraph),
-      _capacity(0), local_capacity(false),
-      _cardinality(0), local_cardinality(false),
-      _processed(0), local_processed(false),
-      _heap_cross_ref(0), local_heap_cross_ref(false),
-      _heap(0), local_heap(false)
-    { }
-
-    /// \brief Destructor.
-    ~MaxCardinalitySearch() {
-      if(local_capacity) delete _capacity;
-      if(local_cardinality) delete _cardinality;
-      if(local_processed) delete _processed;
-      if(local_heap_cross_ref) delete _heap_cross_ref;
-      if(local_heap) delete _heap;
-    }
-
-    /// \brief Sets the capacity map.
-    ///
-    /// Sets the capacity map.
-    /// \return <tt> (*this) </tt>
-    MaxCardinalitySearch &capacityMap(const CapacityMap &m) {
-      if (local_capacity) {
-        delete _capacity;
-        local_capacity=false;
-      }
-      _capacity=&m;
-      return *this;
-    }
-
-    /// \brief Returns a const reference to the capacity map.
-    ///
-    /// Returns a const reference to the capacity map used by
-    /// the algorithm.
-    const CapacityMap &capacityMap() const {
-      return *_capacity;
-    }
-
-    /// \brief Sets the map storing the cardinalities calculated by the
-    /// algorithm.
-    ///
-    /// Sets the map storing the cardinalities calculated by the algorithm.
-    /// If you don't use this function before calling \ref run(),
-    /// it will allocate one. The destuctor deallocates this
-    /// automatically allocated map, of course.
-    /// \return <tt> (*this) </tt>
-    MaxCardinalitySearch &cardinalityMap(CardinalityMap &m) {
-      if(local_cardinality) {
-        delete _cardinality;
-        local_cardinality=false;
-      }
-      _cardinality = &m;
-      return *this;
-    }
-
-    /// \brief Sets the map storing the processed nodes.
-    ///
-    /// Sets the map storing the processed nodes.
-    /// If you don't use this function before calling \ref run(),
-    /// it will allocate one. The destuctor deallocates this
-    /// automatically allocated map, of course.
-    /// \return <tt> (*this) </tt>
-    MaxCardinalitySearch &processedMap(ProcessedMap &m)
-    {
-      if(local_processed) {
-        delete _processed;
-        local_processed=false;
-      }
-      _processed = &m;
-      return *this;
-    }
-
-    /// \brief Returns a const reference to the cardinality map.
-    ///
-    /// Returns a const reference to the cardinality map used by
-    /// the algorithm.
-    const ProcessedMap &processedMap() const {
-      return *_processed;
-    }
-
-    /// \brief Sets the heap and the cross reference used by algorithm.
-    ///
-    /// Sets the heap and the cross reference used by algorithm.
-    /// If you don't use this function before calling \ref run(),
-    /// it will allocate one. The destuctor deallocates this
-    /// automatically allocated map, of course.
-    /// \return <tt> (*this) </tt>
-    MaxCardinalitySearch &heap(Heap& hp, HeapCrossRef &cr) {
-      if(local_heap_cross_ref) {
-        delete _heap_cross_ref;
-        local_heap_cross_ref = false;
-      }
-      _heap_cross_ref = &cr;
-      if(local_heap) {
-        delete _heap;
-        local_heap = false;
-      }
-      _heap = &hp;
-      return *this;
-    }
-
-    /// \brief Returns a const reference to the heap.
-    ///
-    /// Returns a const reference to the heap used by
-    /// the algorithm.
-    const Heap &heap() const {
-      return *_heap;
-    }
-
-    /// \brief Returns a const reference to the cross reference.
-    ///
-    /// Returns a const reference to the cross reference
-    /// of the heap.
-    const HeapCrossRef &heapCrossRef() const {
-      return *_heap_cross_ref;
-    }
-
-  private:
-
-    typedef typename Digraph::Node Node;
-    typedef typename Digraph::NodeIt NodeIt;
-    typedef typename Digraph::Arc Arc;
-    typedef typename Digraph::InArcIt InArcIt;
-
-    void create_maps() {
-      if(!_capacity) {
-        local_capacity = true;
-        _capacity = Traits::createCapacityMap(*_graph);
-      }
-      if(!_cardinality) {
-        local_cardinality = true;
-        _cardinality = Traits::createCardinalityMap(*_graph);
-      }
-      if(!_processed) {
-        local_processed = true;
-        _processed = Traits::createProcessedMap(*_graph);
-      }
-      if (!_heap_cross_ref) {
-        local_heap_cross_ref = true;
-        _heap_cross_ref = Traits::createHeapCrossRef(*_graph);
-      }
-      if (!_heap) {
-        local_heap = true;
-        _heap = Traits::createHeap(*_heap_cross_ref);
-      }
-    }
-
-    void finalizeNodeData(Node node, Value capacity) {
-      _processed->set(node, true);
-      _cardinality->set(node, capacity);
-    }
-
-  public:
-    /// \name Execution control
-    /// The simplest way to execute the algorithm is to use
-    /// one of the member functions called \ref run().
-    /// \n
-    /// If you need more control on the execution,
-    /// first you must call \ref init(), then you can add several source nodes
-    /// with \ref addSource().
-    /// Finally \ref start() will perform the computation.
-
-    ///@{
-
-    /// \brief Initializes the internal data structures.
-    ///
-    /// Initializes the internal data structures, and clears the heap.
-    void init() {
-      create_maps();
-      _heap->clear();
-      for (NodeIt it(*_graph) ; it != INVALID ; ++it) {
-        _processed->set(it, false);
-        _heap_cross_ref->set(it, Heap::PRE_HEAP);
-      }
-    }
-
-    /// \brief Adds a new source node.
-    ///
-    /// Adds a new source node to the priority heap.
-    ///
-    /// It checks if the node has not yet been added to the heap.
-    void addSource(Node source, Value capacity = 0) {
-      if(_heap->state(source) == Heap::PRE_HEAP) {
-        _heap->push(source, capacity);
-      }
-    }
-
-    /// \brief Processes the next node in the priority heap
-    ///
-    /// Processes the next node in the priority heap.
-    ///
-    /// \return The processed node.
-    ///
-    /// \warning The priority heap must not be empty!
-    Node processNextNode() {
-      Node node = _heap->top();
-      finalizeNodeData(node, _heap->prio());
-      _heap->pop();
-
-      for (InArcIt it(*_graph, node); it != INVALID; ++it) {
-        Node source = _graph->source(it);
-        switch (_heap->state(source)) {
-        case Heap::PRE_HEAP:
-          _heap->push(source, (*_capacity)[it]);
-          break;
-        case Heap::IN_HEAP:
-          _heap->decrease(source, (*_heap)[source] + (*_capacity)[it]);
-          break;
-        case Heap::POST_HEAP:
-          break;
-        }
-      }
-      return node;
-    }
-
-    /// \brief Next node to be processed.
-    ///
-    /// Next node to be processed.
-    ///
-    /// \return The next node to be processed or INVALID if the
-    /// priority heap is empty.
-    Node nextNode() {
-      return !_heap->empty() ? _heap->top() : INVALID;
-    }
-
-    /// \brief Returns \c false if there are nodes
-    /// to be processed in the priority heap
-    ///
-    /// Returns \c false if there are nodes
-    /// to be processed in the priority heap
-    bool emptyQueue() { return _heap->empty(); }
-    /// \brief Returns the number of the nodes to be processed
-    /// in the priority heap
-    ///
-    /// Returns the number of the nodes to be processed in the priority heap
-    int emptySize() { return _heap->size(); }
-
-    /// \brief Executes the algorithm.
-    ///
-    /// Executes the algorithm.
-    ///
-    ///\pre init() must be called and at least one node should be added
-    /// with addSource() before using this function.
-    ///
-    /// This method runs the Maximum Cardinality Search algorithm from the
-    /// source node(s).
-    void start() {
-      while ( !_heap->empty() ) processNextNode();
-    }
-
-    /// \brief Executes the algorithm until \c dest is reached.
-    ///
-    /// Executes the algorithm until \c dest is reached.
-    ///
-    /// \pre init() must be called and at least one node should be added
-    /// with addSource() before using this function.
-    ///
-    /// This method runs the %MaxCardinalitySearch algorithm from the source
-    /// nodes.
-    void start(Node dest) {
-      while ( !_heap->empty() && _heap->top()!=dest ) processNextNode();
-      if ( !_heap->empty() ) finalizeNodeData(_heap->top(), _heap->prio());
-    }
-
-    /// \brief Executes the algorithm until a condition is met.
-    ///
-    /// Executes the algorithm until a condition is met.
-    ///
-    /// \pre init() must be called and at least one node should be added
-    /// with addSource() before using this function.
-    ///
-    /// \param nm must be a bool (or convertible) node map. The algorithm
-    /// will stop when it reaches a node \c v with <tt>nm[v]==true</tt>.
-    template <typename NodeBoolMap>
-    void start(const NodeBoolMap &nm) {
-      while ( !_heap->empty() && !nm[_heap->top()] ) processNextNode();
-      if ( !_heap->empty() ) finalizeNodeData(_heap->top(),_heap->prio());
-    }
-
-    /// \brief Runs the maximum cardinality search algorithm from node \c s.
-    ///
-    /// This method runs the %MaxCardinalitySearch algorithm from a root
-    /// node \c s.
-    ///
-    ///\note d.run(s) is just a shortcut of the following code.
-    ///\code
-    ///  d.init();
-    ///  d.addSource(s);
-    ///  d.start();
-    ///\endcode
-    void run(Node s) {
-      init();
-      addSource(s);
-      start();
-    }
-
-    /// \brief Runs the maximum cardinality search algorithm for the
-    /// whole digraph.
-    ///
-    /// This method runs the %MaxCardinalitySearch algorithm from all
-    /// unprocessed node of the digraph.
-    ///
-    ///\note d.run(s) is just a shortcut of the following code.
-    ///\code
-    ///  d.init();
-    ///  for (NodeIt it(digraph); it != INVALID; ++it) {
-    ///    if (!d.reached(it)) {
-    ///      d.addSource(s);
-    ///      d.start();
-    ///    }
-    ///  }
-    ///\endcode
-    void run() {
-      init();
-      for (NodeIt it(*_graph); it != INVALID; ++it) {
-        if (!reached(it)) {
-          addSource(it);
-          start();
-        }
-      }
-    }
-
-    ///@}
-
-    /// \name Query Functions
-    /// The results of the maximum cardinality search algorithm can be
-    /// obtained using these functions.
-    /// \n
-    /// Before the use of these functions, either run() or start() must be
-    /// called.
-
-    ///@{
-
-    /// \brief The cardinality of a node.
-    ///
-    /// Returns the cardinality of a node.
-    /// \pre \ref run() must be called before using this function.
-    /// \warning If node \c v in unreachable from the root the return value
-    /// of this funcion is undefined.
-    Value cardinality(Node node) const { return (*_cardinality)[node]; }
-
-    /// \brief The current cardinality of a node.
-    ///
-    /// Returns the current cardinality of a node.
-    /// \pre the given node should be reached but not processed
-    Value currentCardinality(Node node) const { return (*_heap)[node]; }
-
-    /// \brief Returns a reference to the NodeMap of cardinalities.
-    ///
-    /// Returns a reference to the NodeMap of cardinalities. \pre \ref run()
-    /// must be called before using this function.
-    const CardinalityMap &cardinalityMap() const { return *_cardinality;}
-
-    /// \brief Checks if a node is reachable from the root.
-    ///
-    /// Returns \c true if \c v is reachable from the root.
-    /// \warning The source nodes are initated as unreached.
-    /// \pre \ref run() must be called before using this function.
-    bool reached(Node v) { return (*_heap_cross_ref)[v] != Heap::PRE_HEAP; }
-
-    /// \brief Checks if a node is processed.
-    ///
-    /// Returns \c true if \c v is processed, i.e. the shortest
-    /// path to \c v has already found.
-    /// \pre \ref run() must be called before using this function.
-    bool processed(Node v) { return (*_heap_cross_ref)[v] == Heap::POST_HEAP; }
-
-    ///@}
-  };
-
-}
-
-#endif
Index: lemon/min_cost_arborescence.h
===================================================================
--- lemon/min_cost_arborescence.h	(revision 1270)
+++ lemon/min_cost_arborescence.h	(revision 760)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -102,5 +102,5 @@
   /// the minimum cost subgraph that is the union of arborescences with the
   /// given sources and spans all the nodes which are reachable from the
-  /// sources. The time complexity of the algorithm is O(n<sup>2</sup>+m).
+  /// sources. The time complexity of the algorithm is O(n<sup>2</sup>+e).
   ///
   /// The algorithm also provides an optimal dual solution, therefore
@@ -113,9 +113,8 @@
   /// it is necessary. The default map type is \ref
   /// concepts::Digraph::ArcMap "Digraph::ArcMap<int>".
-  /// \tparam TR The traits class that defines various types used by the
-  /// algorithm. By default, it is \ref MinCostArborescenceDefaultTraits
+  /// \param TR Traits class to set various data types used
+  /// by the algorithm. The default traits class is
+  /// \ref MinCostArborescenceDefaultTraits
   /// "MinCostArborescenceDefaultTraits<GR, CM>".
-  /// In most cases, this parameter should not be set directly,
-  /// consider to use the named template parameters instead.
 #ifndef DOXYGEN
   template <typename GR,
@@ -124,11 +123,11 @@
               MinCostArborescenceDefaultTraits<GR, CM> >
 #else
-  template <typename GR, typename CM, typename TR>
+  template <typename GR, typename CM, typedef TR>
 #endif
   class MinCostArborescence {
   public:
 
-    /// \brief The \ref lemon::MinCostArborescenceDefaultTraits "traits class"
-    /// of the algorithm.
+    /// \brief The \ref MinCostArborescenceDefaultTraits "traits class" 
+    /// of the algorithm. 
     typedef TR Traits;
     /// The type of the underlying digraph.
@@ -437,5 +436,5 @@
     /// \ref named-templ-param "Named parameter" for setting
     /// \c PredMap type.
-    /// It must meet the \ref concepts::WriteMap "WriteMap" concept,
+    /// It must meet the \ref concepts::WriteMap "WriteMap" concept, 
     /// and its value type must be the \c Arc type of the digraph.
     template <class T>
Index: mon/nagamochi_ibaraki.h
===================================================================
--- lemon/nagamochi_ibaraki.h	(revision 1270)
+++ 	(revision )
@@ -1,702 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2013
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * 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_NAGAMOCHI_IBARAKI_H
-#define LEMON_NAGAMOCHI_IBARAKI_H
-
-
-/// \ingroup min_cut
-/// \file
-/// \brief Implementation of the Nagamochi-Ibaraki algorithm.
-
-#include <lemon/core.h>
-#include <lemon/bin_heap.h>
-#include <lemon/bucket_heap.h>
-#include <lemon/maps.h>
-#include <lemon/radix_sort.h>
-#include <lemon/unionfind.h>
-
-#include <cassert>
-
-namespace lemon {
-
-  /// \brief Default traits class for NagamochiIbaraki class.
-  ///
-  /// Default traits class for NagamochiIbaraki class.
-  /// \param GR The undirected graph type.
-  /// \param CM Type of capacity map.
-  template <typename GR, typename CM>
-  struct NagamochiIbarakiDefaultTraits {
-    /// The type of the capacity map.
-    typedef typename CM::Value Value;
-
-    /// The undirected graph type the algorithm runs on.
-    typedef GR Graph;
-
-    /// \brief The type of the map that stores the edge capacities.
-    ///
-    /// The type of the map that stores the edge capacities.
-    /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
-    typedef CM CapacityMap;
-
-    /// \brief Instantiates a CapacityMap.
-    ///
-    /// This function instantiates a \ref CapacityMap.
-#ifdef DOXYGEN
-    static CapacityMap *createCapacityMap(const Graph& graph)
-#else
-    static CapacityMap *createCapacityMap(const Graph&)
-#endif
-    {
-        LEMON_ASSERT(false, "CapacityMap is not initialized");
-        return 0; // ignore warnings
-    }
-
-    /// \brief The cross reference type used by heap.
-    ///
-    /// The cross reference type used by heap.
-    /// Usually \c Graph::NodeMap<int>.
-    typedef typename Graph::template NodeMap<int> HeapCrossRef;
-
-    /// \brief Instantiates a HeapCrossRef.
-    ///
-    /// This function instantiates a \ref HeapCrossRef.
-    /// \param g is the graph, to which we would like to define the
-    /// \ref HeapCrossRef.
-    static HeapCrossRef *createHeapCrossRef(const Graph& g) {
-      return new HeapCrossRef(g);
-    }
-
-    /// \brief The heap type used by NagamochiIbaraki algorithm.
-    ///
-    /// The heap type used by NagamochiIbaraki algorithm. It has to
-    /// maximize the priorities.
-    ///
-    /// \sa BinHeap
-    /// \sa NagamochiIbaraki
-    typedef BinHeap<Value, HeapCrossRef, std::greater<Value> > Heap;
-
-    /// \brief Instantiates a Heap.
-    ///
-    /// This function instantiates a \ref Heap.
-    /// \param r is the cross reference of the heap.
-    static Heap *createHeap(HeapCrossRef& r) {
-      return new Heap(r);
-    }
-  };
-
-  /// \ingroup min_cut
-  ///
-  /// \brief Calculates the minimum cut in an undirected graph.
-  ///
-  /// Calculates the minimum cut in an undirected graph with the
-  /// Nagamochi-Ibaraki algorithm. The algorithm separates the graph's
-  /// nodes into two partitions with the minimum sum of edge capacities
-  /// between the two partitions. The algorithm can be used to test
-  /// the network reliability, especially to test how many links have
-  /// to be destroyed in the network to split it to at least two
-  /// distinict subnetworks.
-  ///
-  /// The complexity of the algorithm is \f$ O(nm\log(n)) \f$ but with
-  /// \ref FibHeap "Fibonacci heap" it can be decreased to
-  /// \f$ O(nm+n^2\log(n)) \f$.  When the edges have unit capacities,
-  /// \c BucketHeap can be used which yields \f$ O(nm) \f$ time
-  /// complexity.
-  ///
-  /// \warning The value type of the capacity map should be able to
-  /// hold any cut value of the graph, otherwise the result can
-  /// overflow.
-  /// \note This capacity is supposed to be integer type.
-#ifdef DOXYGEN
-  template <typename GR, typename CM, typename TR>
-#else
-  template <typename GR,
-            typename CM = typename GR::template EdgeMap<int>,
-            typename TR = NagamochiIbarakiDefaultTraits<GR, CM> >
-#endif
-  class NagamochiIbaraki {
-  public:
-
-    typedef TR Traits;
-    /// The type of the underlying graph.
-    typedef typename Traits::Graph Graph;
-
-    /// The type of the capacity map.
-    typedef typename Traits::CapacityMap CapacityMap;
-    /// The value type of the capacity map.
-    typedef typename Traits::CapacityMap::Value Value;
-
-    /// The heap type used by the algorithm.
-    typedef typename Traits::Heap Heap;
-    /// The cross reference type used for the heap.
-    typedef typename Traits::HeapCrossRef HeapCrossRef;
-
-    ///\name Named template parameters
-
-    ///@{
-
-    struct SetUnitCapacityTraits : public Traits {
-      typedef ConstMap<typename Graph::Edge, Const<int, 1> > CapacityMap;
-      static CapacityMap *createCapacityMap(const Graph&) {
-        return new CapacityMap();
-      }
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// the capacity map to a constMap<Edge, int, 1>() instance
-    ///
-    /// \ref named-templ-param "Named parameter" for setting
-    /// the capacity map to a constMap<Edge, int, 1>() instance
-    struct SetUnitCapacity
-      : public NagamochiIbaraki<Graph, CapacityMap,
-                                SetUnitCapacityTraits> {
-      typedef NagamochiIbaraki<Graph, CapacityMap,
-                               SetUnitCapacityTraits> Create;
-    };
-
-
-    template <class H, class CR>
-    struct SetHeapTraits : public Traits {
-      typedef CR HeapCrossRef;
-      typedef H Heap;
-      static HeapCrossRef *createHeapCrossRef(int num) {
-        LEMON_ASSERT(false, "HeapCrossRef is not initialized");
-        return 0; // ignore warnings
-      }
-      static Heap *createHeap(HeapCrossRef &) {
-        LEMON_ASSERT(false, "Heap is not initialized");
-        return 0; // ignore warnings
-      }
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// heap and cross reference type
-    ///
-    /// \ref named-templ-param "Named parameter" for setting heap and
-    /// cross reference type. The heap has to maximize the priorities.
-    template <class H, class CR = RangeMap<int> >
-    struct SetHeap
-      : public NagamochiIbaraki<Graph, CapacityMap, SetHeapTraits<H, CR> > {
-      typedef NagamochiIbaraki< Graph, CapacityMap, SetHeapTraits<H, CR> >
-      Create;
-    };
-
-    template <class H, class CR>
-    struct SetStandardHeapTraits : public Traits {
-      typedef CR HeapCrossRef;
-      typedef H Heap;
-      static HeapCrossRef *createHeapCrossRef(int size) {
-        return new HeapCrossRef(size);
-      }
-      static Heap *createHeap(HeapCrossRef &crossref) {
-        return new Heap(crossref);
-      }
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// heap and cross reference type with automatic allocation
-    ///
-    /// \ref named-templ-param "Named parameter" for setting heap and
-    /// cross reference type with automatic allocation. They should
-    /// have standard constructor interfaces to be able to
-    /// automatically created by the algorithm (i.e. the graph should
-    /// be passed to the constructor of the cross reference and the
-    /// cross reference should be passed to the constructor of the
-    /// heap). However, external heap and cross reference objects
-    /// could also be passed to the algorithm using the \ref heap()
-    /// function before calling \ref run() or \ref init(). The heap
-    /// has to maximize the priorities.
-    /// \sa SetHeap
-    template <class H, class CR = RangeMap<int> >
-    struct SetStandardHeap
-      : public NagamochiIbaraki<Graph, CapacityMap,
-                                SetStandardHeapTraits<H, CR> > {
-      typedef NagamochiIbaraki<Graph, CapacityMap,
-                               SetStandardHeapTraits<H, CR> > Create;
-    };
-
-    ///@}
-
-
-  private:
-
-    const Graph &_graph;
-    const CapacityMap *_capacity;
-    bool _local_capacity; // unit capacity
-
-    struct ArcData {
-      typename Graph::Node target;
-      int prev, next;
-    };
-    struct EdgeData {
-      Value capacity;
-      Value cut;
-    };
-
-    struct NodeData {
-      int first_arc;
-      typename Graph::Node prev, next;
-      int curr_arc;
-      typename Graph::Node last_rep;
-      Value sum;
-    };
-
-    typename Graph::template NodeMap<NodeData> *_nodes;
-    std::vector<ArcData> _arcs;
-    std::vector<EdgeData> _edges;
-
-    typename Graph::Node _first_node;
-    int _node_num;
-
-    Value _min_cut;
-
-    HeapCrossRef *_heap_cross_ref;
-    bool _local_heap_cross_ref;
-    Heap *_heap;
-    bool _local_heap;
-
-    typedef typename Graph::template NodeMap<typename Graph::Node> NodeList;
-    NodeList *_next_rep;
-
-    typedef typename Graph::template NodeMap<bool> MinCutMap;
-    MinCutMap *_cut_map;
-
-    void createStructures() {
-      if (!_nodes) {
-        _nodes = new (typename Graph::template NodeMap<NodeData>)(_graph);
-      }
-      if (!_capacity) {
-        _local_capacity = true;
-        _capacity = Traits::createCapacityMap(_graph);
-      }
-      if (!_heap_cross_ref) {
-        _local_heap_cross_ref = true;
-        _heap_cross_ref = Traits::createHeapCrossRef(_graph);
-      }
-      if (!_heap) {
-        _local_heap = true;
-        _heap = Traits::createHeap(*_heap_cross_ref);
-      }
-      if (!_next_rep) {
-        _next_rep = new NodeList(_graph);
-      }
-      if (!_cut_map) {
-        _cut_map = new MinCutMap(_graph);
-      }
-    }
-
-  protected:
-    //This is here to avoid a gcc-3.3 compilation error.
-    //It should never be called.
-    NagamochiIbaraki() {}
-
-  public:
-
-    typedef NagamochiIbaraki Create;
-
-
-    /// \brief Constructor.
-    ///
-    /// \param graph The graph the algorithm runs on.
-    /// \param capacity The capacity map used by the algorithm.
-    NagamochiIbaraki(const Graph& graph, const CapacityMap& capacity)
-      : _graph(graph), _capacity(&capacity), _local_capacity(false),
-        _nodes(0), _arcs(), _edges(), _min_cut(),
-        _heap_cross_ref(0), _local_heap_cross_ref(false),
-        _heap(0), _local_heap(false),
-        _next_rep(0), _cut_map(0) {}
-
-    /// \brief Constructor.
-    ///
-    /// This constructor can be used only when the Traits class
-    /// defines how can the local capacity map be instantiated.
-    /// If the SetUnitCapacity used the algorithm automatically
-    /// constructs the capacity map.
-    ///
-    ///\param graph The graph the algorithm runs on.
-    NagamochiIbaraki(const Graph& graph)
-      : _graph(graph), _capacity(0), _local_capacity(false),
-        _nodes(0), _arcs(), _edges(), _min_cut(),
-        _heap_cross_ref(0), _local_heap_cross_ref(false),
-        _heap(0), _local_heap(false),
-        _next_rep(0), _cut_map(0) {}
-
-    /// \brief Destructor.
-    ///
-    /// Destructor.
-    ~NagamochiIbaraki() {
-      if (_local_capacity) delete _capacity;
-      if (_nodes) delete _nodes;
-      if (_local_heap) delete _heap;
-      if (_local_heap_cross_ref) delete _heap_cross_ref;
-      if (_next_rep) delete _next_rep;
-      if (_cut_map) delete _cut_map;
-    }
-
-    /// \brief Sets the heap and the cross reference used by algorithm.
-    ///
-    /// Sets the heap and the cross reference used by algorithm.
-    /// If you don't use this function before calling \ref run(),
-    /// it will allocate one. The destuctor deallocates this
-    /// automatically allocated heap and cross reference, of course.
-    /// \return <tt> (*this) </tt>
-    NagamochiIbaraki &heap(Heap& hp, HeapCrossRef &cr)
-    {
-      if (_local_heap_cross_ref) {
-        delete _heap_cross_ref;
-        _local_heap_cross_ref = false;
-      }
-      _heap_cross_ref = &cr;
-      if (_local_heap) {
-        delete _heap;
-        _local_heap = false;
-      }
-      _heap = &hp;
-      return *this;
-    }
-
-    /// \name Execution control
-    /// The simplest way to execute the algorithm is to use
-    /// one of the member functions called \c run().
-    /// \n
-    /// If you need more control on the execution,
-    /// first you must call \ref init() and then call the start()
-    /// or proper times the processNextPhase() member functions.
-
-    ///@{
-
-    /// \brief Initializes the internal data structures.
-    ///
-    /// Initializes the internal data structures.
-    void init() {
-      createStructures();
-
-      int edge_num = countEdges(_graph);
-      _edges.resize(edge_num);
-      _arcs.resize(2 * edge_num);
-
-      typename Graph::Node prev = INVALID;
-      _node_num = 0;
-      for (typename Graph::NodeIt n(_graph); n != INVALID; ++n) {
-        (*_cut_map)[n] = false;
-        (*_next_rep)[n] = INVALID;
-        (*_nodes)[n].last_rep = n;
-        (*_nodes)[n].first_arc = -1;
-        (*_nodes)[n].curr_arc = -1;
-        (*_nodes)[n].prev = prev;
-        if (prev != INVALID) {
-          (*_nodes)[prev].next = n;
-        }
-        (*_nodes)[n].next = INVALID;
-        (*_nodes)[n].sum = 0;
-        prev = n;
-        ++_node_num;
-      }
-
-      _first_node = typename Graph::NodeIt(_graph);
-
-      int index = 0;
-      for (typename Graph::NodeIt n(_graph); n != INVALID; ++n) {
-        for (typename Graph::OutArcIt a(_graph, n); a != INVALID; ++a) {
-          typename Graph::Node m = _graph.target(a);
-
-          if (!(n < m)) continue;
-
-          (*_nodes)[n].sum += (*_capacity)[a];
-          (*_nodes)[m].sum += (*_capacity)[a];
-
-          int c = (*_nodes)[m].curr_arc;
-          if (c != -1 && _arcs[c ^ 1].target == n) {
-            _edges[c >> 1].capacity += (*_capacity)[a];
-          } else {
-            _edges[index].capacity = (*_capacity)[a];
-
-            _arcs[index << 1].prev = -1;
-            if ((*_nodes)[n].first_arc != -1) {
-              _arcs[(*_nodes)[n].first_arc].prev = (index << 1);
-            }
-            _arcs[index << 1].next = (*_nodes)[n].first_arc;
-            (*_nodes)[n].first_arc = (index << 1);
-            _arcs[index << 1].target = m;
-
-            (*_nodes)[m].curr_arc = (index << 1);
-
-            _arcs[(index << 1) | 1].prev = -1;
-            if ((*_nodes)[m].first_arc != -1) {
-              _arcs[(*_nodes)[m].first_arc].prev = ((index << 1) | 1);
-            }
-            _arcs[(index << 1) | 1].next = (*_nodes)[m].first_arc;
-            (*_nodes)[m].first_arc = ((index << 1) | 1);
-            _arcs[(index << 1) | 1].target = n;
-
-            ++index;
-          }
-        }
-      }
-
-      typename Graph::Node cut_node = INVALID;
-      _min_cut = std::numeric_limits<Value>::max();
-
-      for (typename Graph::Node n = _first_node;
-           n != INVALID; n = (*_nodes)[n].next) {
-        if ((*_nodes)[n].sum < _min_cut) {
-          cut_node = n;
-          _min_cut = (*_nodes)[n].sum;
-        }
-      }
-      (*_cut_map)[cut_node] = true;
-      if (_min_cut == 0) {
-        _first_node = INVALID;
-      }
-    }
-
-  public:
-
-    /// \brief Processes the next phase
-    ///
-    /// Processes the next phase in the algorithm. It must be called
-    /// at most one less the number of the nodes in the graph.
-    ///
-    ///\return %True when the algorithm finished.
-    bool processNextPhase() {
-      if (_first_node == INVALID) return true;
-
-      _heap->clear();
-      for (typename Graph::Node n = _first_node;
-           n != INVALID; n = (*_nodes)[n].next) {
-        (*_heap_cross_ref)[n] = Heap::PRE_HEAP;
-      }
-
-      std::vector<typename Graph::Node> order;
-      order.reserve(_node_num);
-      int sep = 0;
-
-      Value alpha = 0;
-      Value pmc = std::numeric_limits<Value>::max();
-
-      _heap->push(_first_node, static_cast<Value>(0));
-      while (!_heap->empty()) {
-        typename Graph::Node n = _heap->top();
-        Value v = _heap->prio();
-
-        _heap->pop();
-        for (int a = (*_nodes)[n].first_arc; a != -1; a = _arcs[a].next) {
-          switch (_heap->state(_arcs[a].target)) {
-          case Heap::PRE_HEAP:
-            {
-              Value nv = _edges[a >> 1].capacity;
-              _heap->push(_arcs[a].target, nv);
-              _edges[a >> 1].cut = nv;
-            } break;
-          case Heap::IN_HEAP:
-            {
-              Value nv = _edges[a >> 1].capacity + (*_heap)[_arcs[a].target];
-              _heap->decrease(_arcs[a].target, nv);
-              _edges[a >> 1].cut = nv;
-            } break;
-          case Heap::POST_HEAP:
-            break;
-          }
-        }
-
-        alpha += (*_nodes)[n].sum;
-        alpha -= 2 * v;
-
-        order.push_back(n);
-        if (!_heap->empty()) {
-          if (alpha < pmc) {
-            pmc = alpha;
-            sep = order.size();
-          }
-        }
-      }
-
-      if (static_cast<int>(order.size()) < _node_num) {
-        _first_node = INVALID;
-        for (typename Graph::NodeIt n(_graph); n != INVALID; ++n) {
-          (*_cut_map)[n] = false;
-        }
-        for (int i = 0; i < static_cast<int>(order.size()); ++i) {
-          typename Graph::Node n = order[i];
-          while (n != INVALID) {
-            (*_cut_map)[n] = true;
-            n = (*_next_rep)[n];
-          }
-        }
-        _min_cut = 0;
-        return true;
-      }
-
-      if (pmc < _min_cut) {
-        for (typename Graph::NodeIt n(_graph); n != INVALID; ++n) {
-          (*_cut_map)[n] = false;
-        }
-        for (int i = 0; i < sep; ++i) {
-          typename Graph::Node n = order[i];
-          while (n != INVALID) {
-            (*_cut_map)[n] = true;
-            n = (*_next_rep)[n];
-          }
-        }
-        _min_cut = pmc;
-      }
-
-      for (typename Graph::Node n = _first_node;
-           n != INVALID; n = (*_nodes)[n].next) {
-        bool merged = false;
-        for (int a = (*_nodes)[n].first_arc; a != -1; a = _arcs[a].next) {
-          if (!(_edges[a >> 1].cut < pmc)) {
-            if (!merged) {
-              for (int b = (*_nodes)[n].first_arc; b != -1; b = _arcs[b].next) {
-                (*_nodes)[_arcs[b].target].curr_arc = b;
-              }
-              merged = true;
-            }
-            typename Graph::Node m = _arcs[a].target;
-            int nb = 0;
-            for (int b = (*_nodes)[m].first_arc; b != -1; b = nb) {
-              nb = _arcs[b].next;
-              if ((b ^ a) == 1) continue;
-              typename Graph::Node o = _arcs[b].target;
-              int c = (*_nodes)[o].curr_arc;
-              if (c != -1 && _arcs[c ^ 1].target == n) {
-                _edges[c >> 1].capacity += _edges[b >> 1].capacity;
-                (*_nodes)[n].sum += _edges[b >> 1].capacity;
-                if (_edges[b >> 1].cut < _edges[c >> 1].cut) {
-                  _edges[b >> 1].cut = _edges[c >> 1].cut;
-                }
-                if (_arcs[b ^ 1].prev != -1) {
-                  _arcs[_arcs[b ^ 1].prev].next = _arcs[b ^ 1].next;
-                } else {
-                  (*_nodes)[o].first_arc = _arcs[b ^ 1].next;
-                }
-                if (_arcs[b ^ 1].next != -1) {
-                  _arcs[_arcs[b ^ 1].next].prev = _arcs[b ^ 1].prev;
-                }
-              } else {
-                if (_arcs[a].next != -1) {
-                  _arcs[_arcs[a].next].prev = b;
-                }
-                _arcs[b].next = _arcs[a].next;
-                _arcs[b].prev = a;
-                _arcs[a].next = b;
-                _arcs[b ^ 1].target = n;
-
-                (*_nodes)[n].sum += _edges[b >> 1].capacity;
-                (*_nodes)[o].curr_arc = b;
-              }
-            }
-
-            if (_arcs[a].prev != -1) {
-              _arcs[_arcs[a].prev].next = _arcs[a].next;
-            } else {
-              (*_nodes)[n].first_arc = _arcs[a].next;
-            }
-            if (_arcs[a].next != -1) {
-              _arcs[_arcs[a].next].prev = _arcs[a].prev;
-            }
-
-            (*_nodes)[n].sum -= _edges[a >> 1].capacity;
-            (*_next_rep)[(*_nodes)[n].last_rep] = m;
-            (*_nodes)[n].last_rep = (*_nodes)[m].last_rep;
-
-            if ((*_nodes)[m].prev != INVALID) {
-              (*_nodes)[(*_nodes)[m].prev].next = (*_nodes)[m].next;
-            } else{
-              _first_node = (*_nodes)[m].next;
-            }
-            if ((*_nodes)[m].next != INVALID) {
-              (*_nodes)[(*_nodes)[m].next].prev = (*_nodes)[m].prev;
-            }
-            --_node_num;
-          }
-        }
-      }
-
-      if (_node_num == 1) {
-        _first_node = INVALID;
-        return true;
-      }
-
-      return false;
-    }
-
-    /// \brief Executes the algorithm.
-    ///
-    /// Executes the algorithm.
-    ///
-    /// \pre init() must be called
-    void start() {
-      while (!processNextPhase()) {}
-    }
-
-
-    /// \brief Runs %NagamochiIbaraki algorithm.
-    ///
-    /// This method runs the %Min cut algorithm
-    ///
-    /// \note mc.run(s) is just a shortcut of the following code.
-    ///\code
-    ///  mc.init();
-    ///  mc.start();
-    ///\endcode
-    void run() {
-      init();
-      start();
-    }
-
-    ///@}
-
-    /// \name Query Functions
-    ///
-    /// The result of the %NagamochiIbaraki
-    /// algorithm can be obtained using these functions.\n
-    /// Before the use of these functions, either run() or start()
-    /// must be called.
-
-    ///@{
-
-    /// \brief Returns the min cut value.
-    ///
-    /// Returns the min cut value if the algorithm finished.
-    /// After the first processNextPhase() it is a value of a
-    /// valid cut in the graph.
-    Value minCutValue() const {
-      return _min_cut;
-    }
-
-    /// \brief Returns a min cut in a NodeMap.
-    ///
-    /// It sets the nodes of one of the two partitions to true and
-    /// the other partition to false.
-    /// \param cutMap A \ref concepts::WriteMap "writable" node map with
-    /// \c bool (or convertible) value type.
-    template <typename CutMap>
-    Value minCutMap(CutMap& cutMap) const {
-      for (typename Graph::NodeIt n(_graph); n != INVALID; ++n) {
-        cutMap.set(n, (*_cut_map)[n]);
-      }
-      return minCutValue();
-    }
-
-    ///@}
-
-  };
-}
-
-#endif
Index: mon/nearest_neighbor_tsp.h
===================================================================
--- lemon/nearest_neighbor_tsp.h	(revision 1294)
+++ 	(revision )
@@ -1,238 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2013
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * 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_NEAREST_NEIGHBOUR_TSP_H
-#define LEMON_NEAREST_NEIGHBOUR_TSP_H
-
-/// \ingroup tsp
-/// \file
-/// \brief Nearest neighbor algorithm for symmetric TSP
-
-#include <deque>
-#include <vector>
-#include <limits>
-#include <lemon/full_graph.h>
-#include <lemon/maps.h>
-
-namespace lemon {
-
-  /// \ingroup tsp
-  ///
-  /// \brief Nearest neighbor algorithm for symmetric TSP.
-  ///
-  /// NearestNeighborTsp implements the nearest neighbor heuristic for solving
-  /// symmetric \ref tsp "TSP".
-  ///
-  /// This is probably the simplest TSP heuristic.
-  /// It starts with a minimum cost edge and at each step, it connects the
-  /// nearest unvisited node to the current path.
-  /// Finally, it connects the two end points of the path to form a tour.
-  ///
-  /// This method runs in O(n<sup>2</sup>) time.
-  /// It quickly finds a relatively short tour for most TSP instances,
-  /// but it could also yield a really bad (or even the worst) solution
-  /// in special cases.
-  ///
-  /// \tparam CM Type of the cost map.
-  template <typename CM>
-  class NearestNeighborTsp
-  {
-    public:
-
-      /// Type of the cost map
-      typedef CM CostMap;
-      /// Type of the edge costs
-      typedef typename CM::Value Cost;
-
-    private:
-
-      GRAPH_TYPEDEFS(FullGraph);
-
-      const FullGraph &_gr;
-      const CostMap &_cost;
-      Cost _sum;
-      std::vector<Node> _path;
-
-    public:
-
-      /// \brief Constructor
-      ///
-      /// Constructor.
-      /// \param gr The \ref FullGraph "full graph" the algorithm runs on.
-      /// \param cost The cost map.
-      NearestNeighborTsp(const FullGraph &gr, const CostMap &cost)
-        : _gr(gr), _cost(cost) {}
-
-      /// \name Execution Control
-      /// @{
-
-      /// \brief Runs the algorithm.
-      ///
-      /// This function runs the algorithm.
-      ///
-      /// \return The total cost of the found tour.
-      Cost run() {
-        _path.clear();
-        if (_gr.nodeNum() == 0) {
-          return _sum = 0;
-        }
-        else if (_gr.nodeNum() == 1) {
-          _path.push_back(_gr(0));
-          return _sum = 0;
-        }
-
-        std::deque<Node> path_dq;
-        Edge min_edge1 = INVALID,
-             min_edge2 = INVALID;
-
-        min_edge1 = mapMin(_gr, _cost);
-        Node n1 = _gr.u(min_edge1),
-             n2 = _gr.v(min_edge1);
-        path_dq.push_back(n1);
-        path_dq.push_back(n2);
-
-        FullGraph::NodeMap<bool> used(_gr, false);
-        used[n1] = true;
-        used[n2] = true;
-
-        min_edge1 = INVALID;
-        while (int(path_dq.size()) != _gr.nodeNum()) {
-          if (min_edge1 == INVALID) {
-            for (IncEdgeIt e(_gr, n1); e != INVALID; ++e) {
-              if (!used[_gr.runningNode(e)] &&
-                  (min_edge1 == INVALID || _cost[e] < _cost[min_edge1])) {
-                min_edge1 = e;
-              }
-            }
-          }
-
-          if (min_edge2 == INVALID) {
-            for (IncEdgeIt e(_gr, n2); e != INVALID; ++e) {
-              if (!used[_gr.runningNode(e)] &&
-                  (min_edge2 == INVALID||_cost[e] < _cost[min_edge2])) {
-                min_edge2 = e;
-              }
-            }
-          }
-
-          if (_cost[min_edge1] < _cost[min_edge2]) {
-            n1 = _gr.oppositeNode(n1, min_edge1);
-            path_dq.push_front(n1);
-
-            used[n1] = true;
-            min_edge1 = INVALID;
-
-            if (_gr.u(min_edge2) == n1 || _gr.v(min_edge2) == n1)
-              min_edge2 = INVALID;
-          } else {
-            n2 = _gr.oppositeNode(n2, min_edge2);
-            path_dq.push_back(n2);
-
-            used[n2] = true;
-            min_edge2 = INVALID;
-
-            if (_gr.u(min_edge1) == n2 || _gr.v(min_edge1) == n2)
-              min_edge1 = INVALID;
-          }
-        }
-
-        n1 = path_dq.back();
-        n2 = path_dq.front();
-        _path.push_back(n2);
-        _sum = _cost[_gr.edge(n1, n2)];
-        for (int i = 1; i < int(path_dq.size()); ++i) {
-          n1 = n2;
-          n2 = path_dq[i];
-          _path.push_back(n2);
-          _sum += _cost[_gr.edge(n1, n2)];
-        }
-
-        return _sum;
-      }
-
-      /// @}
-
-      /// \name Query Functions
-      /// @{
-
-      /// \brief The total cost of the found tour.
-      ///
-      /// This function returns the total cost of the found tour.
-      ///
-      /// \pre run() must be called before using this function.
-      Cost tourCost() const {
-        return _sum;
-      }
-
-      /// \brief Returns a const reference to the node sequence of the
-      /// found tour.
-      ///
-      /// This function returns a const reference to a vector
-      /// that stores the node sequence of the found tour.
-      ///
-      /// \pre run() must be called before using this function.
-      const std::vector<Node>& tourNodes() const {
-        return _path;
-      }
-
-      /// \brief Gives back the node sequence of the found tour.
-      ///
-      /// This function copies the node sequence of the found tour into
-      /// an STL container through the given output iterator. The
-      /// <tt>value_type</tt> of the container must be <tt>FullGraph::Node</tt>.
-      /// For example,
-      /// \code
-      /// std::vector<FullGraph::Node> nodes(countNodes(graph));
-      /// tsp.tourNodes(nodes.begin());
-      /// \endcode
-      /// or
-      /// \code
-      /// std::list<FullGraph::Node> nodes;
-      /// tsp.tourNodes(std::back_inserter(nodes));
-      /// \endcode
-      ///
-      /// \pre run() must be called before using this function.
-      template <typename Iterator>
-      void tourNodes(Iterator out) const {
-        std::copy(_path.begin(), _path.end(), out);
-      }
-
-      /// \brief Gives back the found tour as a path.
-      ///
-      /// This function copies the found tour as a list of arcs/edges into
-      /// the given \ref lemon::concepts::Path "path structure".
-      ///
-      /// \pre run() must be called before using this function.
-      template <typename Path>
-      void tour(Path &path) const {
-        path.clear();
-        for (int i = 0; i < int(_path.size()) - 1; ++i) {
-          path.addBack(_gr.arc(_path[i], _path[i+1]));
-        }
-        if (int(_path.size()) >= 2) {
-          path.addBack(_gr.arc(_path.back(), _path.front()));
-        }
-      }
-
-      /// @}
-
-  };
-
-}; // namespace lemon
-
-#endif
Index: lemon/network_simplex.h
===================================================================
--- lemon/network_simplex.h	(revision 1318)
+++ lemon/network_simplex.h	(revision 878)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -42,15 +42,14 @@
   /// \ref NetworkSimplex implements the primal Network Simplex algorithm
   /// for finding a \ref min_cost_flow "minimum cost flow"
-  /// \cite amo93networkflows, \cite dantzig63linearprog,
-  /// \cite kellyoneill91netsimplex.
+  /// \ref amo93networkflows, \ref dantzig63linearprog,
+  /// \ref kellyoneill91netsimplex.
   /// This algorithm is a highly efficient specialized version of the
   /// linear programming simplex method directly for the minimum cost
   /// flow problem.
   ///
-  /// In general, \ref NetworkSimplex and \ref CostScaling are the fastest
-  /// implementations available in LEMON for solving this problem.
-  /// (For more information, see \ref min_cost_flow_algs "the module page".)
-  /// Furthermore, this class supports both directions of the supply/demand
-  /// inequality constraints. For more information, see \ref SupplyType.
+  /// In general, %NetworkSimplex is the fastest implementation available
+  /// in LEMON for this problem.
+  /// Moreover, it supports both directions of the supply/demand inequality
+  /// constraints. For more information, see \ref SupplyType.
   ///
   /// Most of the parameters of the problem (except for the digraph)
@@ -65,6 +64,5 @@
   /// algorithm. By default, it is the same as \c V.
   ///
-  /// \warning Both \c V and \c C must be signed number types.
-  /// \warning All input data (capacities, supply values, and costs) must
+  /// \warning Both number types must be signed and all input data must
   /// be integer.
   ///
@@ -100,5 +98,5 @@
       UNBOUNDED
     };
-
+    
     /// \brief Constants for selecting the type of the supply constraints.
     ///
@@ -118,5 +116,5 @@
       LEQ
     };
-
+    
     /// \brief Constants for selecting the pivot rule.
     ///
@@ -124,15 +122,12 @@
     /// the \ref run() function.
     ///
-    /// \ref NetworkSimplex provides five different implementations for
-    /// the pivot strategy that significantly affects the running time
+    /// \ref NetworkSimplex provides five different pivot rule
+    /// implementations that significantly affect the running time
     /// of the algorithm.
-    /// According to experimental tests conducted on various problem
-    /// instances, \ref BLOCK_SEARCH "Block Search" and
-    /// \ref ALTERING_LIST "Altering Candidate List" rules turned out
-    /// to be the most efficient.
-    /// Since \ref BLOCK_SEARCH "Block Search" is a simpler strategy that
-    /// seemed to be slightly more robust, it is used by default.
-    /// However, another pivot rule can easily be selected using the
-    /// \ref run() function with the proper parameter.
+    /// By default, \ref BLOCK_SEARCH "Block Search" is used, which
+    /// proved to be the most efficient and the most robust on various
+    /// test inputs.
+    /// However, another pivot rule can be selected using the \ref run()
+    /// function with the proper parameter.
     enum PivotRule {
 
@@ -160,9 +155,9 @@
       /// The \e Altering \e Candidate \e List pivot rule.
       /// It is a modified version of the Candidate List method.
-      /// It keeps only a few of the best eligible arcs from the former
+      /// It keeps only the several best eligible arcs from the former
       /// candidate list and extends this list in every iteration.
       ALTERING_LIST
     };
-
+    
   private:
 
@@ -170,21 +165,13 @@
 
     typedef std::vector<int> IntVector;
+    typedef std::vector<char> CharVector;
     typedef std::vector<Value> ValueVector;
     typedef std::vector<Cost> CostVector;
-    typedef std::vector<signed char> CharVector;
-    // Note: vector<signed char> is used instead of vector<ArcState> and
-    // vector<ArcDirection> for efficiency reasons
 
     // State constants for arcs
-    enum ArcState {
+    enum ArcStateEnum {
       STATE_UPPER = -1,
       STATE_TREE  =  0,
       STATE_LOWER =  1
-    };
-
-    // Direction constants for tree arcs
-    enum ArcDirection {
-      DIR_DOWN = -1,
-      DIR_UP   =  1
     };
 
@@ -199,5 +186,5 @@
 
     // Parameters of the problem
-    bool _has_lower;
+    bool _have_lower;
     SupplyType _stype;
     Value _sum_supply;
@@ -208,5 +195,4 @@
     IntVector _source;
     IntVector _target;
-    bool _arc_mixing;
 
     // Node and arc data
@@ -226,17 +212,19 @@
     IntVector _succ_num;
     IntVector _last_succ;
-    CharVector _pred_dir;
+    IntVector _dirty_revs;
+    CharVector _forward;
     CharVector _state;
-    IntVector _dirty_revs;
     int _root;
 
     // Temporary data used in the current pivot iteration
     int in_arc, join, u_in, v_in, u_out, v_out;
+    int first, second, right, last;
+    int stem, par_stem, new_stem;
     Value delta;
-
+    
     const Value MAX;
 
   public:
-
+  
     /// \brief Constant for infinite upper bounds (capacities).
     ///
@@ -278,5 +266,5 @@
       bool findEnteringArc() {
         Cost c;
-        for (int e = _next_arc; e != _search_arc_num; ++e) {
+        for (int e = _next_arc; e < _search_arc_num; ++e) {
           c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
           if (c < 0) {
@@ -286,5 +274,5 @@
           }
         }
-        for (int e = 0; e != _next_arc; ++e) {
+        for (int e = 0; e < _next_arc; ++e) {
           c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
           if (c < 0) {
@@ -326,5 +314,5 @@
       bool findEnteringArc() {
         Cost c, min = 0;
-        for (int e = 0; e != _search_arc_num; ++e) {
+        for (int e = 0; e < _search_arc_num; ++e) {
           c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
           if (c < min) {
@@ -367,5 +355,5 @@
       {
         // The main parameters of the pivot rule
-        const double BLOCK_SIZE_FACTOR = 1.0;
+        const double BLOCK_SIZE_FACTOR = 0.5;
         const int MIN_BLOCK_SIZE = 10;
 
@@ -380,5 +368,5 @@
         int cnt = _block_size;
         int e;
-        for (e = _next_arc; e != _search_arc_num; ++e) {
+        for (e = _next_arc; e < _search_arc_num; ++e) {
           c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
           if (c < min) {
@@ -391,5 +379,5 @@
           }
         }
-        for (e = 0; e != _next_arc; ++e) {
+        for (e = 0; e < _next_arc; ++e) {
           c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
           if (c < min) {
@@ -482,5 +470,5 @@
         min = 0;
         _curr_length = 0;
-        for (e = _next_arc; e != _search_arc_num; ++e) {
+        for (e = _next_arc; e < _search_arc_num; ++e) {
           c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
           if (c < 0) {
@@ -493,5 +481,5 @@
           }
         }
-        for (e = 0; e != _next_arc; ++e) {
+        for (e = 0; e < _next_arc; ++e) {
           c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
           if (c < 0) {
@@ -505,6 +493,6 @@
         }
         if (_curr_length == 0) return false;
-
-      search_end:
+      
+      search_end:        
         _minor_count = 1;
         _next_arc = e;
@@ -543,5 +531,5 @@
         SortFunc(const CostVector &map) : _map(map) {}
         bool operator()(int left, int right) {
-          return _map[left] < _map[right];
+          return _map[left] > _map[right];
         }
       };
@@ -561,5 +549,5 @@
         const double BLOCK_SIZE_FACTOR = 1.0;
         const int MIN_BLOCK_SIZE = 10;
-        const double HEAD_LENGTH_FACTOR = 0.01;
+        const double HEAD_LENGTH_FACTOR = 0.1;
         const int MIN_HEAD_LENGTH = 3;
 
@@ -577,11 +565,9 @@
         // Check the current candidate list
         int e;
-        Cost c;
-        for (int i = 0; i != _curr_length; ++i) {
+        for (int i = 0; i < _curr_length; ++i) {
           e = _candidates[i];
-          c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
-          if (c < 0) {
-            _cand_cost[e] = c;
-          } else {
+          _cand_cost[e] = _state[e] *
+            (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
+          if (_cand_cost[e] >= 0) {
             _candidates[i--] = _candidates[--_curr_length];
           }
@@ -592,8 +578,8 @@
         int limit = _head_length;
 
-        for (e = _next_arc; e != _search_arc_num; ++e) {
-          c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
-          if (c < 0) {
-            _cand_cost[e] = c;
+        for (e = _next_arc; e < _search_arc_num; ++e) {
+          _cand_cost[e] = _state[e] *
+            (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
+          if (_cand_cost[e] < 0) {
             _candidates[_curr_length++] = e;
           }
@@ -604,8 +590,8 @@
           }
         }
-        for (e = 0; e != _next_arc; ++e) {
-          c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
-          if (c < 0) {
-            _cand_cost[e] = c;
+        for (e = 0; e < _next_arc; ++e) {
+          _cand_cost[e] = _state[e] *
+            (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
+          if (_cand_cost[e] < 0) {
             _candidates[_curr_length++] = e;
           }
@@ -617,17 +603,17 @@
         }
         if (_curr_length == 0) return false;
-
+        
       search_end:
 
-        // Perform partial sort operation on the candidate list
-        int new_length = std::min(_head_length + 1, _curr_length);
-        std::partial_sort(_candidates.begin(), _candidates.begin() + new_length,
-                          _candidates.begin() + _curr_length, _sort_func);
-
-        // Select the entering arc and remove it from the list
+        // Make heap of the candidate list (approximating a partial sort)
+        make_heap( _candidates.begin(), _candidates.begin() + _curr_length,
+                   _sort_func );
+
+        // Pop the first element of the heap
         _in_arc = _candidates[0];
         _next_arc = e;
-        _candidates[0] = _candidates[new_length - 1];
-        _curr_length = new_length - 1;
+        pop_heap( _candidates.begin(), _candidates.begin() + _curr_length,
+                  _sort_func );
+        _curr_length = std::min(_head_length, _curr_length - 1);
         return true;
       }
@@ -642,12 +628,10 @@
     ///
     /// \param graph The digraph the algorithm runs on.
-    /// \param arc_mixing Indicate if the arcs will be stored in a
-    /// mixed order in the internal data structure.
-    /// In general, it leads to similar performance as using the original
-    /// arc order, but it makes the algorithm more robust and in special
-    /// cases, even significantly faster. Therefore, it is enabled by default.
-    NetworkSimplex(const GR& graph, bool arc_mixing = true) :
+    /// \param arc_mixing Indicate if the arcs have to be stored in a
+    /// mixed order in the internal data structure. 
+    /// In special cases, it could lead to better overall performance,
+    /// but it is usually slower. Therefore it is disabled by default.
+    NetworkSimplex(const GR& graph, bool arc_mixing = false) :
       _graph(graph), _node_id(graph), _arc_id(graph),
-      _arc_mixing(arc_mixing),
       MAX(std::numeric_limits<Value>::max()),
       INF(std::numeric_limits<Value>::has_infinity ?
@@ -659,6 +643,57 @@
       LEMON_ASSERT(std::numeric_limits<Cost>::is_signed,
         "The cost type of NetworkSimplex must be signed");
-
-      // Reset data structures
+        
+      // Resize vectors
+      _node_num = countNodes(_graph);
+      _arc_num = countArcs(_graph);
+      int all_node_num = _node_num + 1;
+      int max_arc_num = _arc_num + 2 * _node_num;
+
+      _source.resize(max_arc_num);
+      _target.resize(max_arc_num);
+
+      _lower.resize(_arc_num);
+      _upper.resize(_arc_num);
+      _cap.resize(max_arc_num);
+      _cost.resize(max_arc_num);
+      _supply.resize(all_node_num);
+      _flow.resize(max_arc_num);
+      _pi.resize(all_node_num);
+
+      _parent.resize(all_node_num);
+      _pred.resize(all_node_num);
+      _forward.resize(all_node_num);
+      _thread.resize(all_node_num);
+      _rev_thread.resize(all_node_num);
+      _succ_num.resize(all_node_num);
+      _last_succ.resize(all_node_num);
+      _state.resize(max_arc_num);
+
+      // Copy the graph
+      int i = 0;
+      for (NodeIt n(_graph); n != INVALID; ++n, ++i) {
+        _node_id[n] = i;
+      }
+      if (arc_mixing) {
+        // Store the arcs in a mixed order
+        int k = std::max(int(std::sqrt(double(_arc_num))), 10);
+        int i = 0, j = 0;
+        for (ArcIt a(_graph); a != INVALID; ++a) {
+          _arc_id[a] = i;
+          _source[i] = _node_id[_graph.source(a)];
+          _target[i] = _node_id[_graph.target(a)];
+          if ((i += k) >= _arc_num) i = ++j;
+        }
+      } else {
+        // Store the arcs in the original order
+        int i = 0;
+        for (ArcIt a(_graph); a != INVALID; ++a, ++i) {
+          _arc_id[a] = i;
+          _source[i] = _node_id[_graph.source(a)];
+          _target[i] = _node_id[_graph.target(a)];
+        }
+      }
+      
+      // Reset parameters
       reset();
     }
@@ -683,5 +718,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];
@@ -740,6 +775,4 @@
     ///
     /// \return <tt>(*this)</tt>
-    ///
-    /// \sa supplyType()
     template<typename SupplyMap>
     NetworkSimplex& supplyMap(const SupplyMap& map) {
@@ -758,5 +791,5 @@
     ///
     /// Using this function has the same effect as using \ref supplyMap()
-    /// with a map in which \c k is assigned to \c s, \c -k is
+    /// with such a map in which \c k is assigned to \c s, \c -k is
     /// assigned to \c t and all other nodes have zero supply value.
     ///
@@ -775,5 +808,5 @@
       return *this;
     }
-
+    
     /// \brief Set the type of the supply constraints.
     ///
@@ -801,5 +834,5 @@
     /// This function runs the algorithm.
     /// The paramters can be specified using functions \ref lowerMap(),
-    /// \ref upperMap(), \ref costMap(), \ref supplyMap(), \ref stSupply(),
+    /// \ref upperMap(), \ref costMap(), \ref supplyMap(), \ref stSupply(), 
     /// \ref supplyType().
     /// For example,
@@ -810,10 +843,10 @@
     /// \endcode
     ///
-    /// This function can be called more than once. All the given parameters
-    /// are kept for the next call, unless \ref resetParams() or \ref reset()
-    /// is used, thus only the modified parameters have to be set again.
-    /// If the underlying digraph was also modified after the construction
-    /// of the class (or the last \ref reset() call), then the \ref reset()
-    /// function must be called.
+    /// This function can be called more than once. All the parameters
+    /// that have been given are kept for the next call, unless
+    /// \ref reset() is called, thus only the modified parameters
+    /// have to be set again. See \ref reset() for examples.
+    /// However, the underlying digraph must not be modified after this
+    /// class have been constructed, since it copies and extends the graph.
     ///
     /// \param pivot_rule The pivot rule that will be used during the
@@ -829,5 +862,4 @@
     ///
     /// \see ProblemType, PivotRule
-    /// \see resetParams(), reset()
     ProblemType run(PivotRule pivot_rule = BLOCK_SEARCH) {
       if (!init()) return INFEASIBLE;
@@ -841,10 +873,9 @@
     /// \ref costMap(), \ref supplyMap(), \ref stSupply(), \ref supplyType().
     ///
-    /// It is useful for multiple \ref run() calls. Basically, all the given
-    /// parameters are kept for the next \ref run() call, unless
-    /// \ref resetParams() or \ref reset() is used.
-    /// If the underlying digraph was also modified after the construction
-    /// of the class or the last \ref reset() call, then the \ref reset()
-    /// function must be used, otherwise \ref resetParams() is sufficient.
+    /// It is useful for multiple run() calls. If this function is not
+    /// used, all the parameters given before are kept for the next
+    /// \ref run() call.
+    /// However, the underlying digraph must not be modified after this
+    /// class have been constructed, since it copies and extends the graph.
     ///
     /// For example,
@@ -856,12 +887,12 @@
     ///     .supplyMap(sup).run();
     ///
-    ///   // Run again with modified cost map (resetParams() is not called,
+    ///   // Run again with modified cost map (reset() is not called,
     ///   // so only the cost map have to be set again)
     ///   cost[e] += 100;
     ///   ns.costMap(cost).run();
     ///
-    ///   // Run again from scratch using resetParams()
+    ///   // Run again from scratch using reset()
     ///   // (the lower bounds will be set to zero on all arcs)
-    ///   ns.resetParams();
+    ///   ns.reset();
     ///   ns.upperMap(capacity).costMap(cost)
     ///     .supplyMap(sup).run();
@@ -869,7 +900,5 @@
     ///
     /// \return <tt>(*this)</tt>
-    ///
-    /// \see reset(), run()
-    NetworkSimplex& resetParams() {
+    NetworkSimplex& reset() {
       for (int i = 0; i != _node_num; ++i) {
         _supply[i] = 0;
@@ -880,83 +909,6 @@
         _cost[i] = 1;
       }
-      _has_lower = false;
+      _have_lower = false;
       _stype = GEQ;
-      return *this;
-    }
-
-    /// \brief Reset the internal data structures and all the parameters
-    /// that have been given before.
-    ///
-    /// This function resets the internal data structures and all the
-    /// paramaters that have been given before using functions \ref lowerMap(),
-    /// \ref upperMap(), \ref costMap(), \ref supplyMap(), \ref stSupply(),
-    /// \ref supplyType().
-    ///
-    /// It is useful for multiple \ref run() calls. Basically, all the given
-    /// parameters are kept for the next \ref run() call, unless
-    /// \ref resetParams() or \ref reset() is used.
-    /// If the underlying digraph was also modified after the construction
-    /// of the class or the last \ref reset() call, then the \ref reset()
-    /// function must be used, otherwise \ref resetParams() is sufficient.
-    ///
-    /// See \ref resetParams() for examples.
-    ///
-    /// \return <tt>(*this)</tt>
-    ///
-    /// \see resetParams(), run()
-    NetworkSimplex& reset() {
-      // Resize vectors
-      _node_num = countNodes(_graph);
-      _arc_num = countArcs(_graph);
-      int all_node_num = _node_num + 1;
-      int max_arc_num = _arc_num + 2 * _node_num;
-
-      _source.resize(max_arc_num);
-      _target.resize(max_arc_num);
-
-      _lower.resize(_arc_num);
-      _upper.resize(_arc_num);
-      _cap.resize(max_arc_num);
-      _cost.resize(max_arc_num);
-      _supply.resize(all_node_num);
-      _flow.resize(max_arc_num);
-      _pi.resize(all_node_num);
-
-      _parent.resize(all_node_num);
-      _pred.resize(all_node_num);
-      _pred_dir.resize(all_node_num);
-      _thread.resize(all_node_num);
-      _rev_thread.resize(all_node_num);
-      _succ_num.resize(all_node_num);
-      _last_succ.resize(all_node_num);
-      _state.resize(max_arc_num);
-
-      // Copy the graph
-      int i = 0;
-      for (NodeIt n(_graph); n != INVALID; ++n, ++i) {
-        _node_id[n] = i;
-      }
-      if (_arc_mixing && _node_num > 1) {
-        // Store the arcs in a mixed order
-        const int skip = std::max(_arc_num / _node_num, 3);
-        int i = 0, j = 0;
-        for (ArcIt a(_graph); a != INVALID; ++a) {
-          _arc_id[a] = i;
-          _source[i] = _node_id[_graph.source(a)];
-          _target[i] = _node_id[_graph.target(a)];
-          if ((i += skip) >= _arc_num) i = ++j;
-        }
-      } else {
-        // Store the arcs in the original order
-        int i = 0;
-        for (ArcIt a(_graph); a != INVALID; ++a, ++i) {
-          _arc_id[a] = i;
-          _source[i] = _node_id[_graph.source(a)];
-          _target[i] = _node_id[_graph.target(a)];
-        }
-      }
-
-      // Reset parameters
-      resetParams();
       return *this;
     }
@@ -974,5 +926,5 @@
     ///
     /// This function returns the total cost of the found flow.
-    /// Its complexity is O(m).
+    /// Its complexity is O(e).
     ///
     /// \note The return type of the function can be specified as a
@@ -1011,6 +963,5 @@
     }
 
-    /// \brief Copy the flow values (the primal solution) into the
-    /// given map.
+    /// \brief Return the flow map (the primal solution).
     ///
     /// This function copies the flow value on each arc into the given
@@ -1036,6 +987,5 @@
     }
 
-    /// \brief Copy the potential values (the dual solution) into the
-    /// given map.
+    /// \brief Return the potential map (the dual solution).
     ///
     /// This function copies the potential (dual value) of each node
@@ -1068,10 +1018,6 @@
              (_stype == LEQ && _sum_supply >= 0)) ) return false;
 
-      // Check lower and upper bounds
-      LEMON_DEBUG(checkBoundMaps(),
-          "Upper bounds must be greater or equal to the lower bounds");
-
       // Remove non-zero lower bounds
-      if (_has_lower) {
+      if (_have_lower) {
         for (int i = 0; i != _arc_num; ++i) {
           Value c = _lower[i];
@@ -1095,5 +1041,5 @@
         ART_COST = std::numeric_limits<Cost>::max() / 2 + 1;
       } else {
-        ART_COST = 0;
+        ART_COST = std::numeric_limits<Cost>::min();
         for (int i = 0; i != _arc_num; ++i) {
           if (_cost[i] > ART_COST) ART_COST = _cost[i];
@@ -1107,5 +1053,5 @@
         _state[i] = STATE_LOWER;
       }
-
+      
       // Set data for the artificial root node
       _root = _node_num;
@@ -1134,5 +1080,5 @@
           _state[e] = STATE_TREE;
           if (_supply[u] >= 0) {
-            _pred_dir[u] = DIR_UP;
+            _forward[u] = true;
             _pi[u] = 0;
             _source[e] = u;
@@ -1141,5 +1087,5 @@
             _cost[e] = 0;
           } else {
-            _pred_dir[u] = DIR_DOWN;
+            _forward[u] = false;
             _pi[u] = ART_COST;
             _source[e] = _root;
@@ -1161,5 +1107,5 @@
           _last_succ[u] = u;
           if (_supply[u] >= 0) {
-            _pred_dir[u] = DIR_UP;
+            _forward[u] = true;
             _pi[u] = 0;
             _pred[u] = e;
@@ -1171,5 +1117,5 @@
             _state[e] = STATE_TREE;
           } else {
-            _pred_dir[u] = DIR_DOWN;
+            _forward[u] = false;
             _pi[u] = ART_COST;
             _pred[u] = f;
@@ -1202,5 +1148,5 @@
           _last_succ[u] = u;
           if (_supply[u] <= 0) {
-            _pred_dir[u] = DIR_DOWN;
+            _forward[u] = false;
             _pi[u] = 0;
             _pred[u] = e;
@@ -1212,5 +1158,5 @@
             _state[e] = STATE_TREE;
           } else {
-            _pred_dir[u] = DIR_UP;
+            _forward[u] = true;
             _pi[u] = -ART_COST;
             _pred[u] = f;
@@ -1236,13 +1182,4 @@
     }
 
-    // Check if the upper bound is greater than or equal to the lower bound
-    // on each arc.
-    bool checkBoundMaps() {
-      for (int j = 0; j != _arc_num; ++j) {
-        if (_upper[j] < _lower[j]) return false;
-      }
-      return true;
-    }
-
     // Find the join node
     void findJoinNode() {
@@ -1264,5 +1201,4 @@
       // Initialize first and second nodes according to the direction
       // of the cycle
-      int first, second;
       if (_state[in_arc] == STATE_LOWER) {
         first  = _source[in_arc];
@@ -1274,15 +1210,12 @@
       delta = _cap[in_arc];
       int result = 0;
-      Value c, d;
+      Value d;
       int e;
 
-      // Search the cycle form the first node to the join node
+      // Search the cycle along the path form the first node to the root
       for (int u = first; u != join; u = _parent[u]) {
         e = _pred[u];
-        d = _flow[e];
-        if (_pred_dir[u] == DIR_DOWN) {
-          c = _cap[e];
-          d = c >= MAX ? INF : c - d;
-        }
+        d = _forward[u] ?
+          _flow[e] : (_cap[e] >= MAX ? INF : _cap[e] - _flow[e]);
         if (d < delta) {
           delta = d;
@@ -1291,13 +1224,9 @@
         }
       }
-
-      // Search the cycle form the second node to the join node
+      // Search the cycle along the path form the second node to the root
       for (int u = second; u != join; u = _parent[u]) {
         e = _pred[u];
-        d = _flow[e];
-        if (_pred_dir[u] == DIR_UP) {
-          c = _cap[e];
-          d = c >= MAX ? INF : c - d;
-        }
+        d = _forward[u] ? 
+          (_cap[e] >= MAX ? INF : _cap[e] - _flow[e]) : _flow[e];
         if (d <= delta) {
           delta = d;
@@ -1324,8 +1253,8 @@
         _flow[in_arc] += val;
         for (int u = _source[in_arc]; u != join; u = _parent[u]) {
-          _flow[_pred[u]] -= _pred_dir[u] * val;
+          _flow[_pred[u]] += _forward[u] ? -val : val;
         }
         for (int u = _target[in_arc]; u != join; u = _parent[u]) {
-          _flow[_pred[u]] += _pred_dir[u] * val;
+          _flow[_pred[u]] += _forward[u] ? val : -val;
         }
       }
@@ -1342,4 +1271,5 @@
     // Update the tree structure
     void updateTreeStructure() {
+      int u, w;
       int old_rev_thread = _rev_thread[u_out];
       int old_succ_num = _succ_num[u_out];
@@ -1347,225 +1277,126 @@
       v_out = _parent[u_out];
 
-      // Check if u_in and u_out coincide
-      if (u_in == u_out) {
-        // Update _parent, _pred, _pred_dir
-        _parent[u_in] = v_in;
-        _pred[u_in] = in_arc;
-        _pred_dir[u_in] = u_in == _source[in_arc] ? DIR_UP : DIR_DOWN;
-
-        // Update _thread and _rev_thread
-        if (_thread[v_in] != u_out) {
-          int after = _thread[old_last_succ];
-          _thread[old_rev_thread] = after;
-          _rev_thread[after] = old_rev_thread;
-          after = _thread[v_in];
-          _thread[v_in] = u_out;
-          _rev_thread[u_out] = v_in;
-          _thread[old_last_succ] = after;
-          _rev_thread[after] = old_last_succ;
-        }
+      u = _last_succ[u_in];  // the last successor of u_in
+      right = _thread[u];    // the node after it
+
+      // Handle the case when old_rev_thread equals to v_in
+      // (it also means that join and v_out coincide)
+      if (old_rev_thread == v_in) {
+        last = _thread[_last_succ[u_out]];
       } else {
-        // Handle the case when old_rev_thread equals to v_in
-        // (it also means that join and v_out coincide)
-        int thread_continue = old_rev_thread == v_in ?
-          _thread[old_last_succ] : _thread[v_in];
-
-        // Update _thread and _parent along the stem nodes (i.e. the nodes
-        // between u_in and u_out, whose parent have to be changed)
-        int stem = u_in;              // the current stem node
-        int par_stem = v_in;          // the new parent of stem
-        int next_stem;                // the next stem node
-        int last = _last_succ[u_in];  // the last successor of stem
-        int before, after = _thread[last];
-        _thread[v_in] = u_in;
-        _dirty_revs.clear();
-        _dirty_revs.push_back(v_in);
-        while (stem != u_out) {
-          // Insert the next stem node into the thread list
-          next_stem = _parent[stem];
-          _thread[last] = next_stem;
-          _dirty_revs.push_back(last);
-
-          // Remove the subtree of stem from the thread list
-          before = _rev_thread[stem];
-          _thread[before] = after;
-          _rev_thread[after] = before;
-
-          // Change the parent node and shift stem nodes
-          _parent[stem] = par_stem;
-          par_stem = stem;
-          stem = next_stem;
-
-          // Update last and after
-          last = _last_succ[stem] == _last_succ[par_stem] ?
-            _rev_thread[par_stem] : _last_succ[stem];
-          after = _thread[last];
-        }
-        _parent[u_out] = par_stem;
-        _thread[last] = thread_continue;
-        _rev_thread[thread_continue] = last;
-        _last_succ[u_out] = last;
-
-        // Remove the subtree of u_out from the thread list except for
-        // the case when old_rev_thread equals to v_in
-        if (old_rev_thread != v_in) {
-          _thread[old_rev_thread] = after;
-          _rev_thread[after] = old_rev_thread;
-        }
-
-        // Update _rev_thread using the new _thread values
-        for (int i = 0; i != int(_dirty_revs.size()); ++i) {
-          int u = _dirty_revs[i];
-          _rev_thread[_thread[u]] = u;
-        }
-
-        // Update _pred, _pred_dir, _last_succ and _succ_num for the
-        // stem nodes from u_out to u_in
-        int tmp_sc = 0, tmp_ls = _last_succ[u_out];
-        for (int u = u_out, p = _parent[u]; u != u_in; u = p, p = _parent[u]) {
-          _pred[u] = _pred[p];
-          _pred_dir[u] = -_pred_dir[p];
-          tmp_sc += _succ_num[u] - _succ_num[p];
-          _succ_num[u] = tmp_sc;
-          _last_succ[p] = tmp_ls;
-        }
-        _pred[u_in] = in_arc;
-        _pred_dir[u_in] = u_in == _source[in_arc] ? DIR_UP : DIR_DOWN;
-        _succ_num[u_in] = old_succ_num;
+        last = _thread[v_in];
+      }
+
+      // Update _thread and _parent along the stem nodes (i.e. the nodes
+      // between u_in and u_out, whose parent have to be changed)
+      _thread[v_in] = stem = u_in;
+      _dirty_revs.clear();
+      _dirty_revs.push_back(v_in);
+      par_stem = v_in;
+      while (stem != u_out) {
+        // Insert the next stem node into the thread list
+        new_stem = _parent[stem];
+        _thread[u] = new_stem;
+        _dirty_revs.push_back(u);
+
+        // Remove the subtree of stem from the thread list
+        w = _rev_thread[stem];
+        _thread[w] = right;
+        _rev_thread[right] = w;
+
+        // Change the parent node and shift stem nodes
+        _parent[stem] = par_stem;
+        par_stem = stem;
+        stem = new_stem;
+
+        // Update u and right
+        u = _last_succ[stem] == _last_succ[par_stem] ?
+          _rev_thread[par_stem] : _last_succ[stem];
+        right = _thread[u];
+      }
+      _parent[u_out] = par_stem;
+      _thread[u] = last;
+      _rev_thread[last] = u;
+      _last_succ[u_out] = u;
+
+      // Remove the subtree of u_out from the thread list except for
+      // the case when old_rev_thread equals to v_in
+      // (it also means that join and v_out coincide)
+      if (old_rev_thread != v_in) {
+        _thread[old_rev_thread] = right;
+        _rev_thread[right] = old_rev_thread;
+      }
+
+      // Update _rev_thread using the new _thread values
+      for (int i = 0; i < int(_dirty_revs.size()); ++i) {
+        u = _dirty_revs[i];
+        _rev_thread[_thread[u]] = u;
+      }
+
+      // Update _pred, _forward, _last_succ and _succ_num for the
+      // stem nodes from u_out to u_in
+      int tmp_sc = 0, tmp_ls = _last_succ[u_out];
+      u = u_out;
+      while (u != u_in) {
+        w = _parent[u];
+        _pred[u] = _pred[w];
+        _forward[u] = !_forward[w];
+        tmp_sc += _succ_num[u] - _succ_num[w];
+        _succ_num[u] = tmp_sc;
+        _last_succ[w] = tmp_ls;
+        u = w;
+      }
+      _pred[u_in] = in_arc;
+      _forward[u_in] = (u_in == _source[in_arc]);
+      _succ_num[u_in] = old_succ_num;
+
+      // Set limits for updating _last_succ form v_in and v_out
+      // towards the root
+      int up_limit_in = -1;
+      int up_limit_out = -1;
+      if (_last_succ[join] == v_in) {
+        up_limit_out = join;
+      } else {
+        up_limit_in = join;
       }
 
       // Update _last_succ from v_in towards the root
-      int up_limit_out = _last_succ[join] == v_in ? join : -1;
-      int last_succ_out = _last_succ[u_out];
-      for (int u = v_in; u != -1 && _last_succ[u] == v_in; u = _parent[u]) {
-        _last_succ[u] = last_succ_out;
-      }
-
+      for (u = v_in; u != up_limit_in && _last_succ[u] == v_in;
+           u = _parent[u]) {
+        _last_succ[u] = _last_succ[u_out];
+      }
       // Update _last_succ from v_out towards the root
       if (join != old_rev_thread && v_in != old_rev_thread) {
-        for (int u = v_out; u != up_limit_out && _last_succ[u] == old_last_succ;
+        for (u = v_out; u != up_limit_out && _last_succ[u] == old_last_succ;
              u = _parent[u]) {
           _last_succ[u] = old_rev_thread;
         }
-      }
-      else if (last_succ_out != old_last_succ) {
-        for (int u = v_out; u != up_limit_out && _last_succ[u] == old_last_succ;
+      } else {
+        for (u = v_out; u != up_limit_out && _last_succ[u] == old_last_succ;
              u = _parent[u]) {
-          _last_succ[u] = last_succ_out;
+          _last_succ[u] = _last_succ[u_out];
         }
       }
 
       // Update _succ_num from v_in to join
-      for (int u = v_in; u != join; u = _parent[u]) {
+      for (u = v_in; u != join; u = _parent[u]) {
         _succ_num[u] += old_succ_num;
       }
       // Update _succ_num from v_out to join
-      for (int u = v_out; u != join; u = _parent[u]) {
+      for (u = v_out; u != join; u = _parent[u]) {
         _succ_num[u] -= old_succ_num;
       }
     }
 
-    // Update potentials in the subtree that has been moved
+    // Update potentials
     void updatePotential() {
-      Cost sigma = _pi[v_in] - _pi[u_in] -
-                   _pred_dir[u_in] * _cost[in_arc];
+      Cost sigma = _forward[u_in] ?
+        _pi[v_in] - _pi[u_in] - _cost[_pred[u_in]] :
+        _pi[v_in] - _pi[u_in] + _cost[_pred[u_in]];
+      // Update potentials in the subtree, which has been moved
       int end = _thread[_last_succ[u_in]];
       for (int u = u_in; u != end; u = _thread[u]) {
         _pi[u] += sigma;
       }
-    }
-
-    // Heuristic initial pivots
-    bool initialPivots() {
-      Value curr, total = 0;
-      std::vector<Node> supply_nodes, demand_nodes;
-      for (NodeIt u(_graph); u != INVALID; ++u) {
-        curr = _supply[_node_id[u]];
-        if (curr > 0) {
-          total += curr;
-          supply_nodes.push_back(u);
-        }
-        else if (curr < 0) {
-          demand_nodes.push_back(u);
-        }
-      }
-      if (_sum_supply > 0) total -= _sum_supply;
-      if (total <= 0) return true;
-
-      IntVector arc_vector;
-      if (_sum_supply >= 0) {
-        if (supply_nodes.size() == 1 && demand_nodes.size() == 1) {
-          // Perform a reverse graph search from the sink to the source
-          typename GR::template NodeMap<bool> reached(_graph, false);
-          Node s = supply_nodes[0], t = demand_nodes[0];
-          std::vector<Node> stack;
-          reached[t] = true;
-          stack.push_back(t);
-          while (!stack.empty()) {
-            Node u, v = stack.back();
-            stack.pop_back();
-            if (v == s) break;
-            for (InArcIt a(_graph, v); a != INVALID; ++a) {
-              if (reached[u = _graph.source(a)]) continue;
-              int j = _arc_id[a];
-              if (_cap[j] >= total) {
-                arc_vector.push_back(j);
-                reached[u] = true;
-                stack.push_back(u);
-              }
-            }
-          }
-        } else {
-          // Find the min. cost incoming arc for each demand node
-          for (int i = 0; i != int(demand_nodes.size()); ++i) {
-            Node v = demand_nodes[i];
-            Cost c, min_cost = std::numeric_limits<Cost>::max();
-            Arc min_arc = INVALID;
-            for (InArcIt a(_graph, v); a != INVALID; ++a) {
-              c = _cost[_arc_id[a]];
-              if (c < min_cost) {
-                min_cost = c;
-                min_arc = a;
-              }
-            }
-            if (min_arc != INVALID) {
-              arc_vector.push_back(_arc_id[min_arc]);
-            }
-          }
-        }
-      } else {
-        // Find the min. cost outgoing arc for each supply node
-        for (int i = 0; i != int(supply_nodes.size()); ++i) {
-          Node u = supply_nodes[i];
-          Cost c, min_cost = std::numeric_limits<Cost>::max();
-          Arc min_arc = INVALID;
-          for (OutArcIt a(_graph, u); a != INVALID; ++a) {
-            c = _cost[_arc_id[a]];
-            if (c < min_cost) {
-              min_cost = c;
-              min_arc = a;
-            }
-          }
-          if (min_arc != INVALID) {
-            arc_vector.push_back(_arc_id[min_arc]);
-          }
-        }
-      }
-
-      // Perform heuristic initial pivots
-      for (int i = 0; i != int(arc_vector.size()); ++i) {
-        in_arc = arc_vector[i];
-        if (_state[in_arc] * (_cost[in_arc] + _pi[_source[in_arc]] -
-            _pi[_target[in_arc]]) >= 0) continue;
-        findJoinNode();
-        bool change = findLeavingArc();
-        if (delta >= MAX) return false;
-        changeFlow(change);
-        if (change) {
-          updateTreeStructure();
-          updatePotential();
-        }
-      }
-      return true;
     }
 
@@ -1592,7 +1423,4 @@
       PivotRuleImpl pivot(*this);
 
-      // Perform heuristic initial pivots
-      if (!initialPivots()) return UNBOUNDED;
-
       // Execute the Network Simplex algorithm
       while (pivot.findEnteringArc()) {
@@ -1606,5 +1434,5 @@
         }
       }
-
+      
       // Check feasibility
       for (int e = _search_arc_num; e != _all_arc_num; ++e) {
@@ -1613,5 +1441,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];
@@ -1623,10 +1451,10 @@
         }
       }
-
+      
       // Shift potentials to meet the requirements of the GEQ/LEQ type
       // optimality conditions
       if (_sum_supply == 0) {
         if (_stype == GEQ) {
-          Cost max_pot = -std::numeric_limits<Cost>::max();
+          Cost max_pot = std::numeric_limits<Cost>::min();
           for (int i = 0; i != _node_num; ++i) {
             if (_pi[i] > max_pot) max_pot = _pi[i];
Index: mon/opt2_tsp.h
===================================================================
--- lemon/opt2_tsp.h	(revision 1270)
+++ 	(revision )
@@ -1,367 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2013
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * 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_OPT2_TSP_H
-#define LEMON_OPT2_TSP_H
-
-/// \ingroup tsp
-/// \file
-/// \brief 2-opt algorithm for symmetric TSP.
-
-#include <vector>
-#include <lemon/full_graph.h>
-
-namespace lemon {
-
-  /// \ingroup tsp
-  ///
-  /// \brief 2-opt algorithm for symmetric TSP.
-  ///
-  /// Opt2Tsp implements the 2-opt heuristic for solving
-  /// symmetric \ref tsp "TSP".
-  ///
-  /// This algorithm starts with an initial tour and iteratively improves it.
-  /// At each step, it removes two edges and the reconnects the created two
-  /// paths in the other way if the resulting tour is shorter.
-  /// The algorithm finishes when no such 2-opt move can be applied, and so
-  /// the tour is 2-optimal.
-  ///
-  /// If no starting tour is given to the \ref run() function, then the
-  /// algorithm uses the node sequence determined by the node IDs.
-  /// Oherwise, it starts with the given tour.
-  ///
-  /// This is a rather slow but effective method.
-  /// Its typical usage is the improvement of the result of a fast tour
-  /// construction heuristic (e.g. the InsertionTsp algorithm).
-  ///
-  /// \tparam CM Type of the cost map.
-  template <typename CM>
-  class Opt2Tsp
-  {
-    public:
-
-      /// Type of the cost map
-      typedef CM CostMap;
-      /// Type of the edge costs
-      typedef typename CM::Value Cost;
-
-    private:
-
-      GRAPH_TYPEDEFS(FullGraph);
-
-      const FullGraph &_gr;
-      const CostMap &_cost;
-      Cost _sum;
-      std::vector<int> _plist;
-      std::vector<Node> _path;
-
-    public:
-
-      /// \brief Constructor
-      ///
-      /// Constructor.
-      /// \param gr The \ref FullGraph "full graph" the algorithm runs on.
-      /// \param cost The cost map.
-      Opt2Tsp(const FullGraph &gr, const CostMap &cost)
-        : _gr(gr), _cost(cost) {}
-
-      /// \name Execution Control
-      /// @{
-
-      /// \brief Runs the algorithm from scratch.
-      ///
-      /// This function runs the algorithm starting from the tour that is
-      /// determined by the node ID sequence.
-      ///
-      /// \return The total cost of the found tour.
-      Cost run() {
-        _path.clear();
-
-        if (_gr.nodeNum() == 0) return _sum = 0;
-        else if (_gr.nodeNum() == 1) {
-          _path.push_back(_gr(0));
-          return _sum = 0;
-        }
-        else if (_gr.nodeNum() == 2) {
-          _path.push_back(_gr(0));
-          _path.push_back(_gr(1));
-          return _sum = 2 * _cost[_gr.edge(_gr(0), _gr(1))];
-        }
-
-        _plist.resize(2*_gr.nodeNum());
-        for (int i = 1; i < _gr.nodeNum()-1; ++i) {
-          _plist[2*i] = i-1;
-          _plist[2*i+1] = i+1;
-        }
-        _plist[0] = _gr.nodeNum()-1;
-        _plist[1] = 1;
-        _plist[2*_gr.nodeNum()-2] = _gr.nodeNum()-2;
-        _plist[2*_gr.nodeNum()-1] = 0;
-
-        return start();
-      }
-
-      /// \brief Runs the algorithm starting from the given tour.
-      ///
-      /// This function runs the algorithm starting from the given tour.
-      ///
-      /// \param tour The tour as a path structure. It must be a
-      /// \ref checkPath() "valid path" containing excactly n arcs.
-      ///
-      /// \return The total cost of the found tour.
-      template <typename Path>
-      Cost run(const Path& tour) {
-        _path.clear();
-
-        if (_gr.nodeNum() == 0) return _sum = 0;
-        else if (_gr.nodeNum() == 1) {
-          _path.push_back(_gr(0));
-          return _sum = 0;
-        }
-        else if (_gr.nodeNum() == 2) {
-          _path.push_back(_gr(0));
-          _path.push_back(_gr(1));
-          return _sum = 2 * _cost[_gr.edge(_gr(0), _gr(1))];
-        }
-
-        _plist.resize(2*_gr.nodeNum());
-        typename Path::ArcIt it(tour);
-        int first = _gr.id(_gr.source(it)),
-            prev = first,
-            curr = _gr.id(_gr.target(it)),
-            next = -1;
-        _plist[2*first+1] = curr;
-        for (++it; it != INVALID; ++it) {
-          next = _gr.id(_gr.target(it));
-          _plist[2*curr] = prev;
-          _plist[2*curr+1] = next;
-          prev = curr;
-          curr = next;
-        }
-        _plist[2*first] = prev;
-
-        return start();
-      }
-
-      /// \brief Runs the algorithm starting from the given tour.
-      ///
-      /// This function runs the algorithm starting from the given tour
-      /// (node sequence).
-      ///
-      /// \param tour A vector that stores all <tt>Node</tt>s of the graph
-      /// in the desired order.
-      ///
-      /// \return The total cost of the found tour.
-      Cost run(const std::vector<Node>& tour) {
-        _path.clear();
-
-        if (_gr.nodeNum() == 0) return _sum = 0;
-        else if (_gr.nodeNum() == 1) {
-          _path.push_back(_gr(0));
-          return _sum = 0;
-        }
-        else if (_gr.nodeNum() == 2) {
-          _path.push_back(_gr(0));
-          _path.push_back(_gr(1));
-          return _sum = 2 * _cost[_gr.edge(_gr(0), _gr(1))];
-        }
-
-        _plist.resize(2*_gr.nodeNum());
-        typename std::vector<Node>::const_iterator it = tour.begin();
-        int first = _gr.id(*it),
-            prev = first,
-            curr = _gr.id(*(++it)),
-            next = -1;
-        _plist[2*first+1] = curr;
-        for (++it; it != tour.end(); ++it) {
-          next = _gr.id(*it);
-          _plist[2*curr] = prev;
-          _plist[2*curr+1] = next;
-          prev = curr;
-          curr = next;
-        }
-        _plist[2*first] = curr;
-        _plist[2*curr] = prev;
-        _plist[2*curr+1] = first;
-
-        return start();
-      }
-
-      /// @}
-
-      /// \name Query Functions
-      /// @{
-
-      /// \brief The total cost of the found tour.
-      ///
-      /// This function returns the total cost of the found tour.
-      ///
-      /// \pre run() must be called before using this function.
-      Cost tourCost() const {
-        return _sum;
-      }
-
-      /// \brief Returns a const reference to the node sequence of the
-      /// found tour.
-      ///
-      /// This function returns a const reference to a vector
-      /// that stores the node sequence of the found tour.
-      ///
-      /// \pre run() must be called before using this function.
-      const std::vector<Node>& tourNodes() const {
-        return _path;
-      }
-
-      /// \brief Gives back the node sequence of the found tour.
-      ///
-      /// This function copies the node sequence of the found tour into
-      /// an STL container through the given output iterator. The
-      /// <tt>value_type</tt> of the container must be <tt>FullGraph::Node</tt>.
-      /// For example,
-      /// \code
-      /// std::vector<FullGraph::Node> nodes(countNodes(graph));
-      /// tsp.tourNodes(nodes.begin());
-      /// \endcode
-      /// or
-      /// \code
-      /// std::list<FullGraph::Node> nodes;
-      /// tsp.tourNodes(std::back_inserter(nodes));
-      /// \endcode
-      ///
-      /// \pre run() must be called before using this function.
-      template <typename Iterator>
-      void tourNodes(Iterator out) const {
-        std::copy(_path.begin(), _path.end(), out);
-      }
-
-      /// \brief Gives back the found tour as a path.
-      ///
-      /// This function copies the found tour as a list of arcs/edges into
-      /// the given \ref lemon::concepts::Path "path structure".
-      ///
-      /// \pre run() must be called before using this function.
-      template <typename Path>
-      void tour(Path &path) const {
-        path.clear();
-        for (int i = 0; i < int(_path.size()) - 1; ++i) {
-          path.addBack(_gr.arc(_path[i], _path[i+1]));
-        }
-        if (int(_path.size()) >= 2) {
-          path.addBack(_gr.arc(_path.back(), _path.front()));
-        }
-      }
-
-      /// @}
-
-    private:
-
-      // Iterator class for the linked list storage of the tour
-      class PathListIt {
-        public:
-          PathListIt(const std::vector<int> &pl, int i=0)
-            : plist(&pl), act(i), last(pl[2*act]) {}
-          PathListIt(const std::vector<int> &pl, int i, int l)
-            : plist(&pl), act(i), last(l) {}
-
-          int nextIndex() const {
-            return (*plist)[2*act] == last ? 2*act+1 : 2*act;
-          }
-
-          int prevIndex() const {
-            return (*plist)[2*act] == last ? 2*act : 2*act+1;
-          }
-
-          int next() const {
-            int x = (*plist)[2*act];
-            return x == last ? (*plist)[2*act+1] : x;
-          }
-
-          int prev() const {
-            return last;
-          }
-
-          PathListIt& operator++() {
-            int tmp = act;
-            act = next();
-            last = tmp;
-            return *this;
-          }
-
-          operator int() const {
-            return act;
-          }
-
-        private:
-          const std::vector<int> *plist;
-          int act;
-          int last;
-      };
-
-      // Checks and applies 2-opt move (if it improves the tour)
-      bool checkOpt2(const PathListIt& i, const PathListIt& j) {
-        Node u  = _gr.nodeFromId(i),
-             un = _gr.nodeFromId(i.next()),
-             v  = _gr.nodeFromId(j),
-             vn = _gr.nodeFromId(j.next());
-
-        if (_cost[_gr.edge(u, un)] + _cost[_gr.edge(v, vn)] >
-            _cost[_gr.edge(u, v)] + _cost[_gr.edge(un, vn)])
-        {
-          _plist[PathListIt(_plist, i.next(), i).prevIndex()] = j.next();
-          _plist[PathListIt(_plist, j.next(), j).prevIndex()] = i.next();
-
-          _plist[i.nextIndex()] = j;
-          _plist[j.nextIndex()] = i;
-
-          return true;
-        }
-
-        return false;
-     }
-
-      // Executes the algorithm from the initial tour
-      Cost start() {
-
-      restart_search:
-        for (PathListIt i(_plist); true; ++i) {
-          PathListIt j = i;
-          if (++j == 0 || ++j == 0) break;
-          for (; j != 0 && j != i.prev(); ++j) {
-            if (checkOpt2(i, j))
-              goto restart_search;
-          }
-        }
-
-        PathListIt i(_plist);
-        _path.push_back(_gr.nodeFromId(i));
-        for (++i; i != 0; ++i)
-          _path.push_back(_gr.nodeFromId(i));
-
-        _sum = _cost[_gr.edge(_path.back(), _path.front())];
-        for (int i = 0; i < int(_path.size())-1; ++i) {
-          _sum += _cost[_gr.edge(_path[i], _path[i+1])];
-        }
-
-        return _sum;
-      }
-
-  };
-
-}; // namespace lemon
-
-#endif
Index: lemon/path.h
===================================================================
--- lemon/path.h	(revision 1336)
+++ lemon/path.h	(revision 868)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -31,5 +31,4 @@
 #include <lemon/core.h>
 #include <lemon/concepts/path.h>
-#include <lemon/bits/stl_iterators.h>
 
 namespace lemon {
@@ -45,5 +44,5 @@
   ///
   /// In a sense, the path can be treated as a list of arcs. The
-  /// LEMON path type stores just this list. As a consequence, it
+  /// lemon path type stores just this list. As a consequence, it
   /// cannot enumerate the nodes of the path and the source node of
   /// a zero length path is undefined.
@@ -66,10 +65,4 @@
     Path() {}
 
-    /// \brief Copy constructor
-    ///
-    Path(const Path& cpath) {
-      pathCopy(cpath, *this);
-    }
-
     /// \brief Template copy constructor
     ///
@@ -79,11 +72,4 @@
     Path(const CPath& cpath) {
       pathCopy(cpath, *this);
-    }
-
-    /// \brief Copy assignment
-    ///
-    Path& operator=(const Path& cpath) {
-      pathCopy(cpath, *this);
-      return *this;
     }
 
@@ -142,21 +128,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);
-    }
-
-
     /// \brief Length of the path.
     int length() const { return head.size() + tail.size(); }
@@ -167,5 +136,5 @@
     void clear() { head.clear(); tail.clear(); }
 
-    /// \brief The n-th arc.
+    /// \brief The nth arc.
     ///
     /// \pre \c n is in the <tt>[0..length() - 1]</tt> range.
@@ -175,5 +144,5 @@
     }
 
-    /// \brief Initialize arc iterator to point to the n-th arc
+    /// \brief Initialize arc iterator to point to the nth arc
     ///
     /// \pre \c n is in the <tt>[0..length() - 1]</tt> range.
@@ -263,5 +232,5 @@
   ///
   /// In a sense, the path can be treated as a list of arcs. The
-  /// LEMON path type stores just this list. As a consequence it
+  /// lemon path type stores just this list. As a consequence it
   /// cannot enumerate the nodes in the path and the zero length paths
   /// cannot store the source.
@@ -284,10 +253,4 @@
     SimplePath() {}
 
-    /// \brief Copy constructor
-    ///
-    SimplePath(const SimplePath& cpath) {
-      pathCopy(cpath, *this);
-    }
-
     /// \brief Template copy constructor
     ///
@@ -297,11 +260,4 @@
     SimplePath(const CPath& cpath) {
       pathCopy(cpath, *this);
-    }
-
-    /// \brief Copy assignment
-    ///
-    SimplePath& operator=(const SimplePath& cpath) {
-      pathCopy(cpath, *this);
-      return *this;
     }
 
@@ -336,5 +292,5 @@
       /// Constructor with starting point
       ArcIt(const SimplePath &_path, int _idx)
-        : path(&_path), idx(_idx) {}
+        : idx(_idx), path(&_path) {}
 
     public:
@@ -364,21 +320,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(); }
@@ -389,5 +328,5 @@
     void clear() { data.clear(); }
 
-    /// \brief The n-th arc.
+    /// \brief The nth arc.
     ///
     /// \pre \c n is in the <tt>[0..length() - 1]</tt> range.
@@ -396,5 +335,5 @@
     }
 
-    /// \brief  Initializes arc iterator to point to the n-th arc.
+    /// \brief  Initializes arc iterator to point to the nth arc.
     ArcIt nthIt(int n) const {
       return ArcIt(*this, n);
@@ -457,5 +396,5 @@
   ///
   /// In a sense, the path can be treated as a list of arcs. The
-  /// LEMON path type stores just this list. As a consequence it
+  /// lemon path type stores just this list. As a consequence it
   /// cannot enumerate the nodes in the path and the zero length paths
   /// cannot store the source.
@@ -493,10 +432,4 @@
     ListPath() : first(0), last(0) {}
 
-    /// \brief Copy constructor
-    ///
-    ListPath(const ListPath& cpath) : first(0), last(0) {
-      pathCopy(cpath, *this);
-    }
-
     /// \brief Template copy constructor
     ///
@@ -513,11 +446,4 @@
     ~ListPath() {
       clear();
-    }
-
-    /// \brief Copy assignment
-    ///
-    ListPath& operator=(const ListPath& cpath) {
-      pathCopy(cpath, *this);
-      return *this;
     }
 
@@ -579,24 +505,7 @@
     };
 
-    /// \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.
-    ///
-    /// This function looks for the n-th arc in O(n) time.
+    /// \brief The nth arc.
+    ///
+    /// This function looks for the nth arc in O(n) time.
     /// \pre \c n is in the <tt>[0..length() - 1]</tt> range.
     const Arc& nth(int n) const {
@@ -608,5 +517,5 @@
     }
 
-    /// \brief Initializes arc iterator to point to the n-th arc.
+    /// \brief Initializes arc iterator to point to the nth arc.
     ArcIt nthIt(int n) const {
       Node *node = first;
@@ -827,5 +736,5 @@
   ///
   /// In a sense, the path can be treated as a list of arcs. The
-  /// LEMON path type stores just this list. As a consequence it
+  /// lemon path type stores just this list. As a consequence it
   /// cannot enumerate the nodes in the path and the source node of
   /// a zero length path is undefined.
@@ -848,11 +757,5 @@
     ///
     /// Default constructor
-    StaticPath() : len(0), _arcs(0) {}
-
-    /// \brief Copy constructor
-    ///
-    StaticPath(const StaticPath& cpath) : _arcs(0) {
-      pathCopy(cpath, *this);
-    }
+    StaticPath() : len(0), arcs(0) {}
 
     /// \brief Template copy constructor
@@ -860,5 +763,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,12 +771,5 @@
     /// Destructor of the path
     ~StaticPath() {
-      if (_arcs) delete[] _arcs;
-    }
-
-    /// \brief Copy assignment
-    ///
-    StaticPath& operator=(const StaticPath& cpath) {
-      pathCopy(cpath, *this);
-      return *this;
+      if (arcs) delete[] arcs;
     }
 
@@ -935,30 +831,13 @@
       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.
+
+    /// \brief The nth arc.
     ///
     /// \pre \c n is in the <tt>[0..length() - 1]</tt> range.
     const Arc& nth(int n) const {
-      return _arcs[n];
-    }
-
-    /// \brief The arc iterator pointing to the n-th arc.
+      return arcs[n];
+    }
+
+    /// \brief The arc iterator pointing to the nth arc.
     ArcIt nthIt(int n) const {
       return ArcIt(*this, n);
@@ -974,16 +853,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 +873,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 +884,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 +894,5 @@
   private:
     int len;
-    Arc* _arcs;
+    Arc* arcs;
   };
 
@@ -1088,5 +967,5 @@
     };
 
-
+    
     template <typename From, typename To,
               bool revEnable = RevPathTagIndicator<From>::value>
@@ -1094,5 +973,5 @@
       static void copy(const From& from, To& to) {
         PathCopySelectorForward<From, To>::copy(from, to);
-      }
+      }      
     };
 
@@ -1101,5 +980,5 @@
       static void copy(const From& from, To& to) {
         PathCopySelectorBackward<From, To>::copy(from, to);
-      }
+      }      
     };
 
@@ -1164,5 +1043,5 @@
   ///
   /// In a sense, the path can be treated as a list of arcs. The
-  /// LEMON path type stores only this list. As a consequence, it
+  /// lemon path type stores only this list. As a consequence, it
   /// cannot enumerate the nodes in the path and the zero length paths
   /// cannot have a source node.
@@ -1227,23 +1106,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/planarity.h
===================================================================
--- lemon/planarity.h	(revision 1270)
+++ lemon/planarity.h	(revision 862)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -73,4 +73,5 @@
 
       void discover(const Arc& arc) {
+        Node source = _graph.source(arc);
         Node target = _graph.target(arc);
 
@@ -140,5 +141,5 @@
     class PlanarityChecking {
     private:
-
+      
       TEMPLATE_GRAPH_TYPEDEFS(Graph);
 
@@ -146,9 +147,9 @@
 
     private:
-
+      
       typedef typename Graph::template NodeMap<Arc> PredMap;
-
+      
       typedef typename Graph::template EdgeMap<bool> TreeMap;
-
+      
       typedef typename Graph::template NodeMap<int> OrderMap;
       typedef std::vector<Node> OrderList;
@@ -221,5 +222,5 @@
 
           for (typename MergeRoots::Value::iterator it =
-                 merge_roots[node].begin();
+                 merge_roots[node].begin(); 
                it != merge_roots[node].end(); ++it) {
             int rn = *it;
@@ -432,5 +433,5 @@
 
               bool rd;
-              if (!external(xnode, rorder, child_lists,
+              if (!external(xnode, rorder, child_lists, 
                             ancestor_map, low_map)) {
                 rd = true;
@@ -518,7 +519,7 @@
   ///
   /// This function implements the Boyer-Myrvold algorithm for
-  /// planarity checking of an undirected simple graph. It is a simplified
+  /// planarity checking of an undirected graph. It is a simplified
   /// version of the PlanarEmbedding algorithm class because neither
-  /// the embedding nor the Kuratowski subdivisons are computed.
+  /// the embedding nor the kuratowski subdivisons are not computed.
   template <typename GR>
   bool checkPlanarity(const GR& graph) {
@@ -532,15 +533,14 @@
   ///
   /// This class implements the Boyer-Myrvold algorithm for planar
-  /// embedding of an undirected simple graph. The planar embedding is an
+  /// embedding of an undirected graph. The planar embedding is an
   /// ordering of the outgoing edges of the nodes, which is a possible
   /// configuration to draw the graph in the plane. If there is not
-  /// such ordering then the graph contains a K<sub>5</sub> (full graph
-  /// with 5 nodes) or a K<sub>3,3</sub> (complete bipartite graph on
-  /// 3 Red and 3 Blue nodes) subdivision.
+  /// such ordering then the graph contains a \f$ K_5 \f$ (full graph
+  /// with 5 nodes) or a \f$ K_{3,3} \f$ (complete bipartite graph on
+  /// 3 ANode and 3 BNode) subdivision.
   ///
   /// The current implementation calculates either an embedding or a
-  /// Kuratowski subdivision. The running time of the algorithm is O(n).
-  ///
-  /// \see PlanarDrawing, checkPlanarity()
+  /// Kuratowski subdivision. The running time of the algorithm is 
+  /// \f$ O(n) \f$.
   template <typename Graph>
   class PlanarEmbedding {
@@ -592,24 +592,20 @@
   public:
 
-    /// \brief The map type for storing the embedding
-    ///
-    /// The map type for storing the embedding.
-    /// \see embeddingMap()
+    /// \brief The map for store of embedding
     typedef typename Graph::template ArcMap<Arc> EmbeddingMap;
 
     /// \brief Constructor
     ///
-    /// Constructor.
-    /// \pre The graph must be simple, i.e. it should not
-    /// contain parallel or loop arcs.
+    /// \note The graph should be simple, i.e. parallel and loop arc
+    /// free.
     PlanarEmbedding(const Graph& graph)
       : _graph(graph), _embedding(_graph), _kuratowski(graph, false) {}
 
-    /// \brief Run the algorithm.
+    /// \brief Runs the algorithm.
     ///
-    /// This function runs the algorithm.
-    /// \param kuratowski If this parameter is set to \c false, then the
+    /// Runs the algorithm.
+    /// \param kuratowski If the parameter is false, then the
     /// algorithm does not compute a Kuratowski subdivision.
-    /// \return \c true if the graph is planar.
+    ///\return %True when the graph is planar.
     bool run(bool kuratowski = true) {
       typedef _planarity_bits::PlanarityVisitor<Graph> Visitor;
@@ -704,7 +700,7 @@
     }
 
-    /// \brief Give back the successor of an arc
+    /// \brief Gives back the successor of an arc
     ///
-    /// This function gives back the successor of an arc. It makes
+    /// Gives back the successor of an arc. This function makes
     /// possible to query the cyclic order of the outgoing arcs from
     /// a node.
@@ -713,21 +709,19 @@
     }
 
-    /// \brief Give back the calculated embedding map
+    /// \brief Gives back the calculated embedding map
     ///
-    /// This function gives back the calculated embedding map, which
-    /// contains the successor of each arc in the cyclic order of the
-    /// outgoing arcs of its source node.
+    /// The returned map contains the successor of each arc in the
+    /// graph.
     const EmbeddingMap& embeddingMap() const {
       return _embedding;
     }
 
-    /// \brief Give back \c true if the given edge is in the Kuratowski
+    /// \brief Gives back true if the undirected arc is in the
+    /// kuratowski subdivision
+    ///
+    /// Gives back true if the undirected arc is in the kuratowski
     /// subdivision
-    ///
-    /// This function gives back \c true if the given edge is in the found
-    /// Kuratowski subdivision.
-    /// \pre The \c run() function must be called with \c true parameter
-    /// before using this function.
-    bool kuratowski(const Edge& edge) const {
+    /// \note The \c run() had to be called with true value.
+    bool kuratowski(const Edge& edge) {
       return _kuratowski[edge];
     }
@@ -2066,13 +2060,11 @@
   ///
   /// The planar drawing algorithm calculates positions for the nodes
-  /// in the plane. These coordinates satisfy that if the edges are
-  /// represented with straight lines, then they will not intersect
+  /// in the plane which coordinates satisfy that if the arcs are
+  /// represented with straight lines then they will not intersect
   /// each other.
   ///
-  /// Scnyder's algorithm embeds the graph on an \c (n-2)x(n-2) size grid,
-  /// i.e. each node will be located in the \c [0..n-2]x[0..n-2] square.
+  /// Scnyder's algorithm embeds the graph on \c (n-2,n-2) size grid,
+  /// i.e. each node will be located in the \c [0,n-2]x[0,n-2] square.
   /// The time complexity of the algorithm is O(n).
-  ///
-  /// \see PlanarEmbedding
   template <typename Graph>
   class PlanarDrawing {
@@ -2081,7 +2073,7 @@
     TEMPLATE_GRAPH_TYPEDEFS(Graph);
 
-    /// \brief The point type for storing coordinates
+    /// \brief The point type for store coordinates
     typedef dim2::Point<int> Point;
-    /// \brief The map type for storing the coordinates of the nodes
+    /// \brief The map type for store coordinates
     typedef typename Graph::template NodeMap<Point> PointMap;
 
@@ -2090,6 +2082,5 @@
     ///
     /// Constructor
-    /// \pre The graph must be simple, i.e. it should not
-    /// contain parallel or loop arcs.
+    /// \pre The graph should be simple, i.e. loop and parallel arc free.
     PlanarDrawing(const Graph& graph)
       : _graph(graph), _point_map(graph) {}
@@ -2376,8 +2367,8 @@
   public:
 
-    /// \brief Calculate the node positions
+    /// \brief Calculates the node positions
     ///
-    /// This function calculates the node positions on the plane.
-    /// \return \c true if the graph is planar.
+    /// This function calculates the node positions.
+    /// \return %True if the graph is planar.
     bool run() {
       PlanarEmbedding<Graph> pe(_graph);
@@ -2388,11 +2379,10 @@
     }
 
-    /// \brief Calculate the node positions according to a
+    /// \brief Calculates the node positions according to a
     /// combinatorical embedding
     ///
-    /// This function calculates the node positions on the plane.
-    /// The given \c embedding map should contain a valid combinatorical
-    /// embedding, i.e. a valid cyclic order of the arcs.
-    /// It can be computed using PlanarEmbedding.
+    /// This function calculates the node locations. The \c embedding
+    /// parameter should contain a valid combinatorical embedding, i.e.
+    /// a valid cyclic order of the arcs.
     template <typename EmbeddingMap>
     void run(const EmbeddingMap& embedding) {
@@ -2434,13 +2424,12 @@
     /// \brief The coordinate of the given node
     ///
-    /// This function returns the coordinate of the given node.
+    /// The coordinate of the given node.
     Point operator[](const Node& node) const {
       return _point_map[node];
     }
 
-    /// \brief Return the grid embedding in a node map
+    /// \brief Returns the grid embedding in a \e NodeMap.
     ///
-    /// This function returns the grid embedding in a node map of
-    /// \c dim2::Point<int> coordinates.
+    /// Returns the grid embedding in a \e NodeMap of \c dim2::Point<int> .
     const PointMap& coords() const {
       return _point_map;
@@ -2482,20 +2471,21 @@
   ///
   /// The graph coloring problem is the coloring of the graph nodes
-  /// so that there are no adjacent nodes with the same color. The
-  /// planar graphs can always be colored with four colors, which is
-  /// proved by Appel and Haken. Their proofs provide a quadratic
+  /// that there are not adjacent nodes with the same color. The
+  /// planar graphs can be always colored with four colors, it is
+  /// proved by Appel and Haken and their proofs provide a quadratic
   /// time algorithm for four coloring, but it could not be used to
-  /// implement an efficient algorithm. The five and six coloring can be
-  /// made in linear time, but in this class, the five coloring has
+  /// implement efficient algorithm. The five and six coloring can be
+  /// made in linear time, but in this class the five coloring has
   /// quadratic worst case time complexity. The two coloring (if
   /// possible) is solvable with a graph search algorithm and it is
   /// implemented in \ref bipartitePartitions() function in LEMON. To
-  /// decide whether a planar graph is three colorable is NP-complete.
+  /// decide whether the planar graph is three colorable is
+  /// NP-complete.
   ///
   /// This class contains member functions for calculate colorings
   /// with five and six colors. The six coloring algorithm is a simple
   /// greedy coloring on the backward minimum outgoing order of nodes.
-  /// This order can be computed by selecting the node with least
-  /// outgoing arcs to unprocessed nodes in each phase. This order
+  /// This order can be computed as in each phase the node with least
+  /// outgoing arcs to unprocessed nodes is chosen. This order
   /// guarantees that when a node is chosen for coloring it has at
   /// most five already colored adjacents. The five coloring algorithm
@@ -2510,17 +2500,13 @@
     TEMPLATE_GRAPH_TYPEDEFS(Graph);
 
-    /// \brief The map type for storing color indices
+    /// \brief The map type for store color indexes
     typedef typename Graph::template NodeMap<int> IndexMap;
-    /// \brief The map type for storing colors
-    ///
-    /// The map type for storing colors.
-    /// \see Palette, Color
+    /// \brief The map type for store colors
     typedef ComposeMap<Palette, IndexMap> ColorMap;
 
     /// \brief Constructor
     ///
-    /// Constructor.
-    /// \pre The graph must be simple, i.e. it should not
-    /// contain parallel or loop arcs.
+    /// Constructor
+    /// \pre The graph should be simple, i.e. loop and parallel arc free.
     PlanarColoring(const Graph& graph)
       : _graph(graph), _color_map(graph), _palette(0) {
@@ -2533,32 +2519,32 @@
     }
 
-    /// \brief Return the node map of color indices
+    /// \brief Returns the \e NodeMap of color indexes
     ///
-    /// This function returns the node map of color indices. The values are
-    /// in the range \c [0..4] or \c [0..5] according to the coloring method.
+    /// Returns the \e NodeMap of color indexes. The values are in the
+    /// range \c [0..4] or \c [0..5] according to the coloring method.
     IndexMap colorIndexMap() const {
       return _color_map;
     }
 
-    /// \brief Return the node map of colors
+    /// \brief Returns the \e NodeMap of colors
     ///
-    /// This function returns the node map of colors. The values are among
-    /// five or six distinct \ref lemon::Color "colors".
+    /// Returns the \e NodeMap of colors. The values are five or six
+    /// distinct \ref lemon::Color "colors".
     ColorMap colorMap() const {
       return composeMap(_palette, _color_map);
     }
 
-    /// \brief Return the color index of the node
+    /// \brief Returns the color index of the node
     ///
-    /// This function returns the color index of the given node. The value is
-    /// in the range \c [0..4] or \c [0..5] according to the coloring method.
+    /// Returns the color index of the node. The values are in the
+    /// range \c [0..4] or \c [0..5] according to the coloring method.
     int colorIndex(const Node& node) const {
       return _color_map[node];
     }
 
-    /// \brief Return the color of the node
+    /// \brief Returns the color of the node
     ///
-    /// This function returns the color of the given node. The value is among
-    /// five or six distinct \ref lemon::Color "colors".
+    /// Returns the color of the node. The values are five or six
+    /// distinct \ref lemon::Color "colors".
     Color color(const Node& node) const {
       return _palette[_color_map[node]];
@@ -2566,12 +2552,12 @@
 
 
-    /// \brief Calculate a coloring with at most six colors
+    /// \brief Calculates a coloring with at most six colors
     ///
     /// This function calculates a coloring with at most six colors. The time
     /// complexity of this variant is linear in the size of the graph.
-    /// \return \c true if the algorithm could color the graph with six colors.
-    /// If the algorithm fails, then the graph is not planar.
-    /// \note This function can return \c true if the graph is not
-    /// planar, but it can be colored with at most six colors.
+    /// \return %True when the algorithm could color the graph with six color.
+    /// If the algorithm fails, then the graph could not be planar.
+    /// \note This function can return true if the graph is not
+    /// planar but it can be colored with 6 colors.
     bool runSixColoring() {
 
@@ -2675,12 +2661,9 @@
   public:
 
-    /// \brief Calculate a coloring with at most five colors
+    /// \brief Calculates a coloring with at most five colors
     ///
     /// This function calculates a coloring with at most five
     /// colors. The worst case time complexity of this variant is
     /// quadratic in the size of the graph.
-    /// \param embedding This map should contain a valid combinatorical
-    /// embedding, i.e. a valid cyclic order of the arcs.
-    /// It can be computed using PlanarEmbedding.
     template <typename EmbeddingMap>
     void runFiveColoring(const EmbeddingMap& embedding) {
@@ -2729,10 +2712,10 @@
     }
 
-    /// \brief Calculate a coloring with at most five colors
+    /// \brief Calculates a coloring with at most five colors
     ///
     /// This function calculates a coloring with at most five
     /// colors. The worst case time complexity of this variant is
     /// quadratic in the size of the graph.
-    /// \return \c true if the graph is planar.
+    /// \return %True when the graph is planar.
     bool runFiveColoring() {
       PlanarEmbedding<Graph> pe(_graph);
Index: lemon/preflow.h
===================================================================
--- lemon/preflow.h	(revision 1270)
+++ lemon/preflow.h	(revision 835)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -103,10 +103,10 @@
   /// This class provides an implementation of Goldberg-Tarjan's \e preflow
   /// \e push-relabel algorithm producing a \ref max_flow
-  /// "flow of maximum value" in a digraph \cite clrs01algorithms,
-  /// \cite amo93networkflows, \cite goldberg88newapproach.
+  /// "flow of maximum value" in a digraph \ref clrs01algorithms,
+  /// \ref amo93networkflows, \ref goldberg88newapproach.
   /// The preflow algorithms are the fastest known maximum
   /// flow algorithms. The current implementation uses a mixture of the
   /// \e "highest label" and the \e "bound decrease" heuristics.
-  /// The worst case time complexity of the algorithm is \f$O(n^2\sqrt{m})\f$.
+  /// The worst case time complexity of the algorithm is \f$O(n^2\sqrt{e})\f$.
   ///
   /// The algorithm consists of two phases. After the first phase
@@ -114,15 +114,7 @@
   /// second phase constructs a feasible maximum flow on each arc.
   ///
-  /// \warning This implementation cannot handle infinite or very large
-  /// capacities (e.g. the maximum value of \c CAP::Value).
-  ///
   /// \tparam GR The type of the digraph the algorithm runs on.
   /// \tparam CAP The type of the capacity map. The default map
   /// type is \ref concepts::Digraph::ArcMap "GR::ArcMap<int>".
-  /// \tparam TR The traits class that defines various types used by the
-  /// algorithm. By default, it is \ref PreflowDefaultTraits
-  /// "PreflowDefaultTraits<GR, CAP>".
-  /// In most cases, this parameter should not be set directly,
-  /// consider to use the named template parameters instead.
 #ifdef DOXYGEN
   template <typename GR, typename CAP, typename TR>
@@ -135,5 +127,5 @@
   public:
 
-    ///The \ref lemon::PreflowDefaultTraits "traits class" of the algorithm.
+    ///The \ref PreflowDefaultTraits "traits class" of the algorithm.
     typedef TR Traits;
     ///The type of the digraph the algorithm runs on.
@@ -544,4 +536,7 @@
           _flow->set(e, (*_capacity)[e]);
           (*_excess)[u] += rem;
+          if (u != _target && !_level->active(u)) {
+            _level->activate(u);
+          }
         }
       }
@@ -553,10 +548,9 @@
           _flow->set(e, 0);
           (*_excess)[v] += rem;
-        }
-      }
-      for (NodeIt n(_graph); n != INVALID; ++n)
-        if(n!=_source && n!=_target && _tolerance.positive((*_excess)[n]))
-          _level->activate(n);
-
+          if (v != _target && !_level->active(v)) {
+            _level->activate(v);
+          }
+        }
+      }
       return true;
     }
@@ -575,16 +569,10 @@
       _phase = true;
 
-      while (true) {
+      Node n = _level->highestActive();
+      int level = _level->highestActiveLevel();
+      while (n != INVALID) {
         int num = _node_num;
 
-        Node n = INVALID;
-        int level = -1;
-
-        while (num > 0) {
-          n = _level->highestActive();
-          if (n == INVALID) goto first_phase_done;
-          level = _level->highestActiveLevel();
-          --num;
-
+        while (num > 0 && n != INVALID) {
           Value excess = (*_excess)[n];
           int new_level = _level->maxLevel();
@@ -652,20 +640,12 @@
             _level->deactivate(n);
           }
+
+          n = _level->highestActive();
+          level = _level->highestActiveLevel();
+          --num;
         }
 
         num = _node_num * 20;
-        while (num > 0) {
-          while (level >= 0 && _level->activeFree(level)) {
-            --level;
-          }
-          if (level == -1) {
-            n = _level->highestActive();
-            level = _level->highestActiveLevel();
-            if (n == INVALID) goto first_phase_done;
-          } else {
-            n = _level->activeOn(level);
-          }
-          --num;
-
+        while (num > 0 && n != INVALID) {
           Value excess = (*_excess)[n];
           int new_level = _level->maxLevel();
@@ -733,7 +713,17 @@
             _level->deactivate(n);
           }
-        }
-      }
-    first_phase_done:;
+
+          while (level >= 0 && _level->activeFree(level)) {
+            --level;
+          }
+          if (level == -1) {
+            n = _level->highestActive();
+            level = _level->highestActiveLevel();
+          } else {
+            n = _level->activeOn(level);
+          }
+          --num;
+        }
+      }
     }
 
Index: mon/quad_heap.h
===================================================================
--- lemon/quad_heap.h	(revision 929)
+++ 	(revision )
@@ -1,343 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2009
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * 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_QUAD_HEAP_H
-#define LEMON_QUAD_HEAP_H
-
-///\ingroup heaps
-///\file
-///\brief Fourary (quaternary) heap implementation.
-
-#include <vector>
-#include <utility>
-#include <functional>
-
-namespace lemon {
-
-  /// \ingroup heaps
-  ///
-  ///\brief Fourary (quaternary) heap data structure.
-  ///
-  /// This class implements the \e Fourary (\e quaternary) \e heap
-  /// data structure.
-  /// It fully conforms to the \ref concepts::Heap "heap concept".
-  ///
-  /// The fourary heap is a specialization of the \ref DHeap "D-ary heap"
-  /// for <tt>D=4</tt>. It is similar to the \ref BinHeap "binary heap",
-  /// but its nodes have at most four children, instead of two.
-  ///
-  /// \tparam PR Type of the priorities of the items.
-  /// \tparam IM A read-writable item map with \c int values, used
-  /// internally to handle the cross references.
-  /// \tparam CMP A functor class for comparing the priorities.
-  /// The default is \c std::less<PR>.
-  ///
-  ///\sa BinHeap
-  ///\sa DHeap
-#ifdef DOXYGEN
-  template <typename PR, typename IM, typename CMP>
-#else
-  template <typename PR, typename IM, typename CMP = std::less<PR> >
-#endif
-  class QuadHeap {
-  public:
-    /// Type of the item-int map.
-    typedef IM ItemIntMap;
-    /// Type of the priorities.
-    typedef PR Prio;
-    /// Type of the items stored in the heap.
-    typedef typename ItemIntMap::Key Item;
-    /// Type of the item-priority pairs.
-    typedef std::pair<Item,Prio> Pair;
-    /// Functor type for comparing the priorities.
-    typedef CMP Compare;
-
-    /// \brief Type to represent the states of the items.
-    ///
-    /// Each item has a state associated to it. It can be "in heap",
-    /// "pre-heap" or "post-heap". The latter two are indifferent from the
-    /// heap's point of view, but may be useful to the user.
-    ///
-    /// The item-int map must be initialized in such way that it assigns
-    /// \c PRE_HEAP (<tt>-1</tt>) to any element to be put in the heap.
-    enum State {
-      IN_HEAP = 0,    ///< = 0.
-      PRE_HEAP = -1,  ///< = -1.
-      POST_HEAP = -2  ///< = -2.
-    };
-
-  private:
-    std::vector<Pair> _data;
-    Compare _comp;
-    ItemIntMap &_iim;
-
-  public:
-    /// \brief Constructor.
-    ///
-    /// Constructor.
-    /// \param map A map that assigns \c int values to the items.
-    /// It is used internally to handle the cross references.
-    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
-    explicit QuadHeap(ItemIntMap &map) : _iim(map) {}
-
-    /// \brief Constructor.
-    ///
-    /// Constructor.
-    /// \param map A map that assigns \c int values to the items.
-    /// It is used internally to handle the cross references.
-    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
-    /// \param comp The function object used for comparing the priorities.
-    QuadHeap(ItemIntMap &map, const Compare &comp)
-      : _iim(map), _comp(comp) {}
-
-    /// \brief The number of items stored in the heap.
-    ///
-    /// This function returns the number of items stored in the heap.
-    int size() const { return _data.size(); }
-
-    /// \brief Check if the heap is empty.
-    ///
-    /// This function returns \c true if the heap is empty.
-    bool empty() const { return _data.empty(); }
-
-    /// \brief Make the heap empty.
-    ///
-    /// This functon makes the heap empty.
-    /// It does not change the cross reference map. If you want to reuse
-    /// a heap that is not surely empty, you should first clear it and
-    /// then you should set the cross reference map to \c PRE_HEAP
-    /// for each item.
-    void clear() { _data.clear(); }
-
-  private:
-    static int parent(int i) { return (i-1)/4; }
-    static int firstChild(int i) { return 4*i+1; }
-
-    bool less(const Pair &p1, const Pair &p2) const {
-      return _comp(p1.second, p2.second);
-    }
-
-    void bubbleUp(int hole, Pair p) {
-      int par = parent(hole);
-      while( hole>0 && less(p,_data[par]) ) {
-        move(_data[par],hole);
-        hole = par;
-        par = parent(hole);
-      }
-      move(p, hole);
-    }
-
-    void bubbleDown(int hole, Pair p, int length) {
-      if( length>1 ) {
-        int child = firstChild(hole);
-        while( child+3<length ) {
-          int min=child;
-          if( less(_data[++child], _data[min]) ) min=child;
-          if( less(_data[++child], _data[min]) ) min=child;
-          if( less(_data[++child], _data[min]) ) min=child;
-          if( !less(_data[min], p) )
-            goto ok;
-          move(_data[min], hole);
-          hole = min;
-          child = firstChild(hole);
-        }
-        if ( child<length ) {
-          int min = child;
-          if( ++child<length && less(_data[child], _data[min]) ) min=child;
-          if( ++child<length && less(_data[child], _data[min]) ) min=child;
-          if( less(_data[min], p) ) {
-            move(_data[min], hole);
-            hole = min;
-          }
-        }
-      }
-    ok:
-      move(p, hole);
-    }
-
-    void move(const Pair &p, int i) {
-      _data[i] = p;
-      _iim.set(p.first, i);
-    }
-
-  public:
-    /// \brief Insert a pair of item and priority into the heap.
-    ///
-    /// This function inserts \c p.first to the heap with priority
-    /// \c p.second.
-    /// \param p The pair to insert.
-    /// \pre \c p.first must not be stored in the heap.
-    void push(const Pair &p) {
-      int n = _data.size();
-      _data.resize(n+1);
-      bubbleUp(n, p);
-    }
-
-    /// \brief Insert an item into the heap with the given priority.
-    ///
-    /// This function inserts the given item into the heap with the
-    /// given priority.
-    /// \param i The item to insert.
-    /// \param p The priority of the item.
-    /// \pre \e i must not be stored in the heap.
-    void push(const Item &i, const Prio &p) { push(Pair(i,p)); }
-
-    /// \brief Return the item having minimum priority.
-    ///
-    /// This function returns the item having minimum priority.
-    /// \pre The heap must be non-empty.
-    Item top() const { return _data[0].first; }
-
-    /// \brief The minimum priority.
-    ///
-    /// This function returns the minimum priority.
-    /// \pre The heap must be non-empty.
-    Prio prio() const { return _data[0].second; }
-
-    /// \brief Remove the item having minimum priority.
-    ///
-    /// This function removes the item having minimum priority.
-    /// \pre The heap must be non-empty.
-    void pop() {
-      int n = _data.size()-1;
-      _iim.set(_data[0].first, POST_HEAP);
-      if (n>0) bubbleDown(0, _data[n], n);
-      _data.pop_back();
-    }
-
-    /// \brief Remove the given item from the heap.
-    ///
-    /// This function removes the given item from the heap if it is
-    /// already stored.
-    /// \param i The item to delete.
-    /// \pre \e i must be in the heap.
-    void erase(const Item &i) {
-      int h = _iim[i];
-      int n = _data.size()-1;
-      _iim.set(_data[h].first, POST_HEAP);
-      if( h<n ) {
-        if( less(_data[parent(h)], _data[n]) )
-          bubbleDown(h, _data[n], n);
-        else
-          bubbleUp(h, _data[n]);
-      }
-      _data.pop_back();
-    }
-
-    /// \brief The priority of the given item.
-    ///
-    /// This function returns the priority of the given item.
-    /// \param i The item.
-    /// \pre \e i must be in the heap.
-    Prio operator[](const Item &i) const {
-      int idx = _iim[i];
-      return _data[idx].second;
-    }
-
-    /// \brief Set the priority of an item or insert it, if it is
-    /// not stored in the heap.
-    ///
-    /// This method sets the priority of the given item if it is
-    /// already stored in the heap. Otherwise it inserts the given
-    /// item into the heap with the given priority.
-    /// \param i The item.
-    /// \param p The priority.
-    void set(const Item &i, const Prio &p) {
-      int idx = _iim[i];
-      if( idx < 0 )
-        push(i,p);
-      else if( _comp(p, _data[idx].second) )
-        bubbleUp(idx, Pair(i,p));
-      else
-        bubbleDown(idx, Pair(i,p), _data.size());
-    }
-
-    /// \brief Decrease the priority of an item to the given value.
-    ///
-    /// This function decreases the priority of an item to the given value.
-    /// \param i The item.
-    /// \param p The priority.
-    /// \pre \e i must be stored in the heap with priority at least \e p.
-    void decrease(const Item &i, const Prio &p) {
-      int idx = _iim[i];
-      bubbleUp(idx, Pair(i,p));
-    }
-
-    /// \brief Increase the priority of an item to the given value.
-    ///
-    /// This function increases the priority of an item to the given value.
-    /// \param i The item.
-    /// \param p The priority.
-    /// \pre \e i must be stored in the heap with priority at most \e p.
-    void increase(const Item &i, const Prio &p) {
-      int idx = _iim[i];
-      bubbleDown(idx, Pair(i,p), _data.size());
-    }
-
-    /// \brief Return the state of an item.
-    ///
-    /// This method returns \c PRE_HEAP if the given item has never
-    /// been in the heap, \c IN_HEAP if it is in the heap at the moment,
-    /// and \c POST_HEAP otherwise.
-    /// In the latter case it is possible that the item will get back
-    /// to the heap again.
-    /// \param i The item.
-    State state(const Item &i) const {
-      int s = _iim[i];
-      if (s>=0) s=0;
-      return State(s);
-    }
-
-    /// \brief Set the state of an item in the heap.
-    ///
-    /// This function sets the state of the given item in the heap.
-    /// It can be used to manually clear the heap when it is important
-    /// to achive better time complexity.
-    /// \param i The item.
-    /// \param st The state. It should not be \c IN_HEAP.
-    void state(const Item& i, State st) {
-      switch (st) {
-        case POST_HEAP:
-        case PRE_HEAP:
-          if (state(i) == IN_HEAP) erase(i);
-          _iim[i] = st;
-          break;
-        case IN_HEAP:
-          break;
-      }
-    }
-
-    /// \brief Replace an item in the heap.
-    ///
-    /// This function replaces item \c i with item \c j.
-    /// Item \c i must be in the heap, while \c j must be out of the heap.
-    /// After calling this method, item \c i will be out of the
-    /// heap and \c j will be in the heap with the same prioriority
-    /// as item \c i had before.
-    void replace(const Item& i, const Item& j) {
-      int idx = _iim[i];
-      _iim.set(i, _iim[j]);
-      _iim.set(j, idx);
-      _data[idx].first = j;
-    }
-
-  }; // class QuadHeap
-
-} // namespace lemon
-
-#endif // LEMON_FOURARY_HEAP_H
Index: lemon/radix_sort.h
===================================================================
--- lemon/radix_sort.h	(revision 1328)
+++ lemon/radix_sort.h	(revision 606)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -35,10 +35,4 @@
   namespace _radix_sort_bits {
 
-    template <typename Iterator>
-    bool unitRange(Iterator first, Iterator last) {
-      ++first;
-      return first == last;
-    }
-
     template <typename Value>
     struct Identity {
@@ -67,4 +61,7 @@
       std::iter_swap(first, last);
       ++first;
+      if (!(first < last)) {
+        return first;
+      }
       while (true) {
         while (!(functor(*first) & mask)) {
@@ -75,5 +72,5 @@
           --last;
         }
-        if (unitRange(last, first)) {
+        if (!(first < last)) {
           return first;
         }
@@ -101,4 +98,7 @@
       std::iter_swap(first, last);
       ++first;
+      if (!(first < last)) {
+        return first;
+      }
       while (true) {
         while (functor(*first) < 0) {
@@ -109,5 +109,5 @@
           --last;
         }
-        if (unitRange(last, first)) {
+        if (!(first < last)) {
           return first;
         }
@@ -120,5 +120,5 @@
     void radixIntroSort(Iterator first, Iterator last,
                         Functor functor, Value mask) {
-      while (mask != 0 && first != last && !unitRange(first, last)) {
+      while (mask != 0 && last - first > 1) {
         Iterator cut = radixSortPartition(first, last, functor, mask);
         mask >>= 1;
@@ -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 1343)
+++ 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>
@@ -202,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))
@@ -216,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))
@@ -252,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;
@@ -608,5 +606,5 @@
     /// \return Currently always \c true.
     bool seed() {
-#ifndef LEMON_WIN32
+#ifndef WIN32
       if (seedFromFile("/dev/urandom", 0)) return true;
 #endif
@@ -628,5 +626,5 @@
     /// \param offset The offset, from the file read.
     /// \return \c true when the seeding successes.
-#ifndef LEMON_WIN32
+#ifndef WIN32
     bool seedFromFile(const std::string& file = "/dev/urandom", int offset = 0)
 #else
@@ -650,5 +648,5 @@
     /// \return Currently always \c true.
     bool seedFromTime() {
-#ifndef LEMON_WIN32
+#ifndef WIN32
       timeval tv;
       gettimeofday(&tv, 0);
Index: lemon/smart_graph.h
===================================================================
--- lemon/smart_graph.h	(revision 1336)
+++ lemon/smart_graph.h	(revision 834)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -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;
     }
 
@@ -187,5 +187,5 @@
   ///\ref SmartDigraph is a simple and fast digraph implementation.
   ///It is also quite memory efficient but at the price
-  ///that it does not support node and arc deletion
+  ///that it does not support node and arc deletion 
   ///(except for the Snapshot feature).
   ///
@@ -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();
       }
     }
@@ -336,5 +336,5 @@
     ///arcs from a SmartDigraph structure.
     ///
-    ///\note After a state is restored, you cannot restore a later state,
+    ///\note After a state is restored, you cannot restore a later state, 
     ///i.e. you cannot add the removed nodes and arcs again using
     ///another Snapshot instance.
@@ -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,8 @@
     };
 
-    std::vector<NodeT> _nodes;
-    std::vector<ArcT> _arcs;
+    std::vector<NodeT> nodes;
+    std::vector<ArcT> arcs;
+
+    int first_free_arc;
 
   public:
@@ -466,5 +468,5 @@
 
     SmartGraphBase()
-      : _nodes(), _arcs() {}
+      : nodes(), arcs() {}
 
     typedef True NodeNumTag;
@@ -472,17 +474,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 +497,5 @@
 
     void first(Node& node) const {
-      node._id = _nodes.size() - 1;
+      node._id = nodes.size() - 1;
     }
 
@@ -503,5 +505,5 @@
 
     void first(Arc& arc) const {
-      arc._id = _arcs.size() - 1;
+      arc._id = arcs.size() - 1;
     }
 
@@ -511,5 +513,5 @@
 
     void first(Edge& arc) const {
-      arc._id = _arcs.size() / 2 - 1;
+      arc._id = arcs.size() / 2 - 1;
     }
 
@@ -519,21 +521,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 +547,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 +566,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 +584,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 +601,6 @@
 
     void clear() {
-      _arcs.clear();
-      _nodes.clear();
+      arcs.clear();
+      nodes.clear();
     }
 
@@ -613,5 +615,5 @@
   /// \ref SmartGraph is a simple and fast graph implementation.
   /// It is also quite memory efficient but at the price
-  /// that it does not support node and edge deletion
+  /// that it does not support node and edge deletion 
   /// (except for the Snapshot feature).
   ///
@@ -702,5 +704,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 +714,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 +725,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 +739,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();
       }
     }
@@ -760,5 +762,5 @@
     ///edges from a SmartGraph structure.
     ///
-    ///\note After a state is restored, you cannot restore a later state,
+    ///\note After a state is restored, you cannot restore a later state, 
     ///i.e. you cannot add the removed nodes and edges again using
     ///another Snapshot instance.
@@ -810,533 +812,4 @@
   };
 
-  class SmartBpGraphBase {
-
-  protected:
-
-    struct NodeT {
-      int first_out;
-      int partition_next;
-      int partition_index;
-      bool red;
-    };
-
-    struct ArcT {
-      int target;
-      int next_out;
-    };
-
-    std::vector<NodeT> _nodes;
-    std::vector<ArcT> _arcs;
-
-    int first_red, first_blue;
-    int max_red, max_blue;
-
-  public:
-
-    typedef SmartBpGraphBase Graph;
-
-    class Node;
-    class Arc;
-    class Edge;
-
-    class Node {
-      friend class SmartBpGraphBase;
-    protected:
-
-      int _id;
-      explicit Node(int id) { _id = id;}
-
-    public:
-      Node() {}
-      Node (Invalid) { _id = -1; }
-      bool operator==(const Node& node) const {return _id == node._id;}
-      bool operator!=(const Node& node) const {return _id != node._id;}
-      bool operator<(const Node& node) const {return _id < node._id;}
-    };
-
-    class RedNode : public Node {
-      friend class SmartBpGraphBase;
-    protected:
-
-      explicit RedNode(int pid) : Node(pid) {}
-
-    public:
-      RedNode() {}
-      RedNode(const RedNode& node) : Node(node) {}
-      RedNode(Invalid) : Node(INVALID){}
-    };
-
-    class BlueNode : public Node {
-      friend class SmartBpGraphBase;
-    protected:
-
-      explicit BlueNode(int pid) : Node(pid) {}
-
-    public:
-      BlueNode() {}
-      BlueNode(const BlueNode& node) : Node(node) {}
-      BlueNode(Invalid) : Node(INVALID){}
-    };
-
-    class Edge {
-      friend class SmartBpGraphBase;
-    protected:
-
-      int _id;
-      explicit Edge(int id) { _id = id;}
-
-    public:
-      Edge() {}
-      Edge (Invalid) { _id = -1; }
-      bool operator==(const Edge& arc) const {return _id == arc._id;}
-      bool operator!=(const Edge& arc) const {return _id != arc._id;}
-      bool operator<(const Edge& arc) const {return _id < arc._id;}
-    };
-
-    class Arc {
-      friend class SmartBpGraphBase;
-    protected:
-
-      int _id;
-      explicit Arc(int id) { _id = id;}
-
-    public:
-      operator Edge() const {
-        return _id != -1 ? edgeFromId(_id / 2) : INVALID;
-      }
-
-      Arc() {}
-      Arc (Invalid) { _id = -1; }
-      bool operator==(const Arc& arc) const {return _id == arc._id;}
-      bool operator!=(const Arc& arc) const {return _id != arc._id;}
-      bool operator<(const Arc& arc) const {return _id < arc._id;}
-    };
-
-
-
-    SmartBpGraphBase()
-      : _nodes(), _arcs(), first_red(-1), first_blue(-1),
-        max_red(-1), max_blue(-1) {}
-
-    typedef True NodeNumTag;
-    typedef True EdgeNumTag;
-    typedef True ArcNumTag;
-
-    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 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; }
-
-    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); }
-
-    RedNode redNode(Edge e) const {
-      return RedNode(_arcs[2 * e._id].target);
-    }
-    BlueNode blueNode(Edge e) const {
-      return BlueNode(_arcs[2 * e._id + 1].target);
-    }
-
-    static bool direction(Arc a) {
-      return (a._id & 1) == 1;
-    }
-
-    static Arc direct(Edge e, bool d) {
-      return Arc(e._id * 2 + (d ? 1 : 0));
-    }
-
-    void first(Node& node) const {
-      node._id = _nodes.size() - 1;
-    }
-
-    static void next(Node& node) {
-      --node._id;
-    }
-
-    void first(RedNode& node) const {
-      node._id = first_red;
-    }
-
-    void next(RedNode& node) const {
-      node._id = _nodes[node._id].partition_next;
-    }
-
-    void first(BlueNode& node) const {
-      node._id = first_blue;
-    }
-
-    void next(BlueNode& node) const {
-      node._id = _nodes[node._id].partition_next;
-    }
-
-    void first(Arc& arc) const {
-      arc._id = _arcs.size() - 1;
-    }
-
-    static void next(Arc& arc) {
-      --arc._id;
-    }
-
-    void first(Edge& arc) const {
-      arc._id = _arcs.size() / 2 - 1;
-    }
-
-    static void next(Edge& arc) {
-      --arc._id;
-    }
-
-    void firstOut(Arc &arc, const Node& v) const {
-      arc._id = _nodes[v._id].first_out;
-    }
-    void nextOut(Arc &arc) const {
-      arc._id = _arcs[arc._id].next_out;
-    }
-
-    void firstIn(Arc &arc, const Node& v) const {
-      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);
-      if (arc._id == -2) arc._id = -1;
-    }
-
-    void firstInc(Edge &arc, bool& d, const Node& v) const {
-      int de = _nodes[v._id].first_out;
-      if (de != -1) {
-        arc._id = de / 2;
-        d = ((de & 1) == 1);
-      } else {
-        arc._id = -1;
-        d = true;
-      }
-    }
-    void nextInc(Edge &arc, bool& d) const {
-      int de = (_arcs[(arc._id * 2) | (d ? 1 : 0)].next_out);
-      if (de != -1) {
-        arc._id = de / 2;
-        d = ((de & 1) == 1);
-      } else {
-        arc._id = -1;
-        d = true;
-      }
-    }
-
-    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; }
-    static int id(Arc e) { return e._id; }
-    static int id(Edge e) { return e._id; }
-
-    static Node nodeFromId(int id) { return Node(id);}
-    static Arc arcFromId(int id) { return Arc(id);}
-    static Edge edgeFromId(int id) { return Edge(id);}
-
-    bool valid(Node n) const {
-      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());
-    }
-    bool valid(Edge e) const {
-      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;
-      first_red = n;
-
-      return RedNode(n);
-    }
-
-    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;
-      first_blue = n;
-
-      return BlueNode(n);
-    }
-
-    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);
-
-      return Edge(n / 2);
-    }
-
-    void clear() {
-      _arcs.clear();
-      _nodes.clear();
-      first_red = -1;
-      first_blue = -1;
-      max_blue = -1;
-      max_red = -1;
-    }
-
-  };
-
-  typedef BpGraphExtender<SmartBpGraphBase> ExtendedSmartBpGraphBase;
-
-  /// \ingroup graphs
-  ///
-  /// \brief A smart undirected bipartite graph class.
-  ///
-  /// \ref SmartBpGraph is a simple and fast bipartite graph implementation.
-  /// It is also quite memory efficient but at the price
-  /// that it does not support node and edge deletion
-  /// (except for the Snapshot feature).
-  ///
-  /// This type fully conforms to the \ref concepts::BpGraph "BpGraph concept"
-  /// and it also provides some additional functionalities.
-  /// Most of its member functions and nested classes are documented
-  /// only in the concept class.
-  ///
-  /// This class provides constant time counting for nodes, edges and arcs.
-  ///
-  /// \sa concepts::BpGraph
-  /// \sa SmartGraph
-  class SmartBpGraph : public ExtendedSmartBpGraphBase {
-    typedef ExtendedSmartBpGraphBase Parent;
-
-  private:
-    /// Graphs are \e not copy constructible. Use GraphCopy instead.
-    SmartBpGraph(const SmartBpGraph &) : ExtendedSmartBpGraphBase() {};
-    /// \brief Assignment of a graph to another one is \e not allowed.
-    /// Use GraphCopy instead.
-    void operator=(const SmartBpGraph &) {}
-
-  public:
-
-    /// Constructor
-
-    /// Constructor.
-    ///
-    SmartBpGraph() {}
-
-    /// \brief Add a new red node to the graph.
-    ///
-    /// This function adds a red new node to the graph.
-    /// \return The new node.
-    RedNode addRedNode() { return Parent::addRedNode(); }
-
-    /// \brief Add a new blue node to the graph.
-    ///
-    /// This function adds a blue new node to the graph.
-    /// \return The new node.
-    BlueNode addBlueNode() { return Parent::addBlueNode(); }
-
-    /// \brief Add a new edge to the graph.
-    ///
-    /// This function adds a new edge to the graph between nodes
-    /// \c u and \c v with inherent orientation from node \c u to
-    /// node \c v.
-    /// \return The new edge.
-    Edge addEdge(RedNode u, BlueNode v) {
-      return Parent::addEdge(u, v);
-    }
-    Edge addEdge(BlueNode v, RedNode u) {
-      return Parent::addEdge(u, v);
-    }
-
-    /// \brief Node validity check
-    ///
-    /// This function gives back \c true if the given node is valid,
-    /// i.e. it is a real node of the graph.
-    ///
-    /// \warning A removed node (using Snapshot) could become valid again
-    /// if new nodes are added to the graph.
-    bool valid(Node n) const { return Parent::valid(n); }
-
-    /// \brief Edge validity check
-    ///
-    /// This function gives back \c true if the given edge is valid,
-    /// i.e. it is a real edge of the graph.
-    ///
-    /// \warning A removed edge (using Snapshot) could become valid again
-    /// if new edges are added to the graph.
-    bool valid(Edge e) const { return Parent::valid(e); }
-
-    /// \brief Arc validity check
-    ///
-    /// This function gives back \c true if the given arc is valid,
-    /// i.e. it is a real arc of the graph.
-    ///
-    /// \warning A removed arc (using Snapshot) could become valid again
-    /// if new edges are added to the graph.
-    bool valid(Arc a) const { return Parent::valid(a); }
-
-    ///Clear the graph.
-
-    ///This function erases all nodes and arcs from the graph.
-    ///
-    void clear() {
-      Parent::clear();
-    }
-
-    /// Reserve memory for nodes.
-
-    /// Using this function, it is possible to avoid superfluous memory
-    /// allocation: if you know that the graph you want to build will
-    /// be large (e.g. it will contain millions of nodes and/or edges),
-    /// then it is worth reserving space for this amount before starting
-    /// to build the graph.
-    /// \sa reserveEdge()
-    void reserveNode(int n) { _nodes.reserve(n); };
-
-    /// Reserve memory for edges.
-
-    /// Using this function, it is possible to avoid superfluous memory
-    /// allocation: if you know that the graph you want to build will
-    /// be large (e.g. it will contain millions of nodes and/or edges),
-    /// then it is worth reserving space for this amount before starting
-    /// to build the graph.
-    /// \sa reserveNode()
-    void reserveEdge(int m) { _arcs.reserve(2 * m); };
-
-  public:
-
-    class Snapshot;
-
-  protected:
-
-    void saveSnapshot(Snapshot &s)
-    {
-      s._graph = this;
-      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;
-        Edge arc=edgeFromId(n/2);
-        Parent::notifier(Edge()).erase(arc);
-        std::vector<Arc> dir;
-        dir.push_back(arcFromId(n));
-        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;
-        Node node = nodeFromId(n);
-        if (Parent::red(node)) {
-          first_red = _nodes[n].partition_next;
-          if (first_red != -1) {
-            max_red = _nodes[first_red].partition_index;
-          } else {
-            max_red = -1;
-          }
-          Parent::notifier(RedNode()).erase(asRedNodeUnsafe(node));
-        } else {
-          first_blue = _nodes[n].partition_next;
-          if (first_blue != -1) {
-            max_blue = _nodes[first_blue].partition_index;
-          } else {
-            max_blue = -1;
-          }
-          Parent::notifier(BlueNode()).erase(asBlueNodeUnsafe(node));
-        }
-        Parent::notifier(Node()).erase(node);
-        _nodes.pop_back();
-      }
-    }
-
-  public:
-
-    ///Class to make a snapshot of the graph and to restore it later.
-
-    ///Class to make a snapshot of the graph and to restore it later.
-    ///
-    ///The newly added nodes and edges can be removed using the
-    ///restore() function. This is the only way for deleting nodes and/or
-    ///edges from a SmartBpGraph structure.
-    ///
-    ///\note After a state is restored, you cannot restore a later state,
-    ///i.e. you cannot add the removed nodes and edges again using
-    ///another Snapshot instance.
-    ///
-    ///\warning The validity of the snapshot is not stored due to
-    ///performance reasons. If you do not use the snapshot correctly,
-    ///it can cause broken program, invalid or not restored state of
-    ///the graph or no change.
-    class Snapshot
-    {
-      SmartBpGraph *_graph;
-    protected:
-      friend class SmartBpGraph;
-      unsigned int node_num;
-      unsigned int arc_num;
-    public:
-      ///Default constructor.
-
-      ///Default constructor.
-      ///You have to call save() to actually make a snapshot.
-      Snapshot() : _graph(0) {}
-      ///Constructor that immediately makes a snapshot
-
-      /// This constructor immediately makes a snapshot of the given graph.
-      ///
-      Snapshot(SmartBpGraph &gr) {
-        gr.saveSnapshot(*this);
-      }
-
-      ///Make a snapshot.
-
-      ///This function makes a snapshot of the given graph.
-      ///It can be called more than once. In case of a repeated
-      ///call, the previous snapshot gets lost.
-      void save(SmartBpGraph &gr)
-      {
-        gr.saveSnapshot(*this);
-      }
-
-      ///Undo the changes until the last snapshot.
-
-      ///This function undos the changes until the last snapshot
-      ///created by save() or Snapshot(SmartBpGraph&).
-      void restore()
-      {
-        _graph->restoreSnapshot(*this);
-      }
-    };
-  };
-
 } //namespace lemon
 
Index: lemon/soplex.cc
===================================================================
--- lemon/soplex.cc	(revision 1336)
+++ lemon/soplex.cc	(revision 793)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -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());
   }
 
@@ -288,5 +288,5 @@
 
     _clear_temporals();
-
+    
     _applyMessageLevel();
 
@@ -433,6 +433,6 @@
     _row_names.clear();
     _row_names_ref.clear();
-    _cols.clear();
-    _rows.clear();
+    cols.clear();
+    rows.clear();
     _clear_temporals();
   }
Index: lemon/soplex.h
===================================================================
--- lemon/soplex.h	(revision 1270)
+++ lemon/soplex.h	(revision 793)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/static_graph.h
===================================================================
--- lemon/static_graph.h	(revision 1328)
+++ lemon/static_graph.h	(revision 834)
@@ -1,7 +1,7 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
+/* -*- C++ -*-
  *
- * This file is a part of LEMON, a generic C++ optimization library.
+ * This file is a part of LEMON, a generic C++ optimization library
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -32,10 +32,10 @@
   public:
 
-    StaticDigraphBase()
-      : built(false), node_num(0), arc_num(0),
+    StaticDigraphBase() 
+      : built(false), node_num(0), arc_num(0), 
         node_first_out(NULL), node_first_in(NULL),
-        arc_source(NULL), arc_target(NULL),
+        arc_source(NULL), arc_target(NULL), 
         arc_next_in(NULL), arc_next_out(NULL) {}
-
+    
     ~StaticDigraphBase() {
       if (built) {
@@ -63,5 +63,5 @@
 
     class Arc {
-      friend class StaticDigraphBase;
+      friend class StaticDigraphBase;      
     protected:
       int id;
@@ -84,6 +84,6 @@
     static void next(Arc& e) { --e.id; }
 
-    void firstOut(Arc& e, const Node& n) const {
-      e.id = node_first_out[n.id] != node_first_out[n.id + 1] ?
+    void firstOut(Arc& e, const Node& n) const { 
+      e.id = node_first_out[n.id] != node_first_out[n.id + 1] ? 
         node_first_out[n.id] : -1;
     }
@@ -114,9 +114,9 @@
       typedef typename Digraph::Arc Arc;
 
-      ArcLess(const Digraph &_graph, const NodeRefMap& _nodeRef)
+      ArcLess(const Digraph &_graph, const NodeRefMap& _nodeRef) 
         : digraph(_graph), nodeRef(_nodeRef) {}
-
+      
       bool operator()(const Arc& left, const Arc& right) const {
-        return nodeRef[digraph.target(left)] < nodeRef[digraph.target(right)];
+	return nodeRef[digraph.target(left)] < nodeRef[digraph.target(right)];
       }
     private:
@@ -124,9 +124,9 @@
       const NodeRefMap& nodeRef;
     };
-
+    
   public:
 
     typedef True BuildTag;
-
+    
     void clear() {
       if (built) {
@@ -142,5 +142,5 @@
       arc_num = 0;
     }
-
+    
     template <typename Digraph, typename NodeRefMap, typename ArcRefMap>
     void build(const Digraph& digraph, NodeRefMap& nodeRef, ArcRefMap& arcRef) {
@@ -184,5 +184,5 @@
             int target = nodeRef[digraph.target(*it)].id;
             arcRef[*it] = Arc(arc_index);
-            arc_source[arc_index] = source;
+            arc_source[arc_index] = source; 
             arc_target[arc_index] = target;
             arc_next_in[arc_index] = node_first_in[target];
@@ -198,5 +198,5 @@
       node_first_out[node_num] = arc_num;
     }
-
+    
     template <typename ArcListIterator>
     void build(int n, ArcListIterator first, ArcListIterator last) {
@@ -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];
@@ -213,9 +213,9 @@
       arc_next_out = new int[arc_num];
       arc_next_in = new int[arc_num];
-
+      
       for (int i = 0; i != node_num; ++i) {
         node_first_in[i] = -1;
-      }
-
+      }      
+      
       int arc_index = 0;
       for (int i = 0; i != node_num; ++i) {
@@ -283,5 +283,5 @@
   /// Since this digraph structure is completely static, its nodes and arcs
   /// can be indexed with integers from the ranges <tt>[0..nodeNum()-1]</tt>
-  /// and <tt>[0..arcNum()-1]</tt>, respectively.
+  /// and <tt>[0..arcNum()-1]</tt>, respectively. 
   /// The index of an item is the same as its ID, it can be obtained
   /// using the corresponding \ref index() or \ref concepts::Digraph::id()
@@ -300,7 +300,7 @@
 
     typedef ExtendedStaticDigraphBase Parent;
-
+  
   public:
-
+  
     /// \brief Constructor
     ///
@@ -350,5 +350,5 @@
     /// This method also makes possible to copy a digraph to a StaticDigraph
     /// structure using \ref DigraphCopy.
-    ///
+    /// 
     /// \param digraph An existing digraph to be copied.
     /// \param nodeRef The node references will be copied into this map.
@@ -371,5 +371,5 @@
       Parent::build(digraph, nodeRef, arcRef);
     }
-
+  
     /// \brief Build the digraph from an arc list.
     ///
@@ -422,5 +422,5 @@
     using Parent::fastNextOut;
     using Parent::fastLastOut;
-
+    
   public:
 
@@ -433,6 +433,6 @@
 
       OutArcIt(const StaticDigraph& digraph, const Node& node) {
-        digraph.fastFirstOut(*this, node);
-        digraph.fastLastOut(last, node);
+	digraph.fastFirstOut(*this, node);
+	digraph.fastLastOut(last, node);
         if (last == *this) *this = INVALID;
       }
@@ -444,8 +444,8 @@
       }
 
-      OutArcIt& operator++() {
+      OutArcIt& operator++() { 
         StaticDigraph::fastNextOut(*this);
         if (last == *this) *this = INVALID;
-        return *this;
+        return *this; 
       }
 
Index: lemon/suurballe.h
===================================================================
--- lemon/suurballe.h	(revision 1270)
+++ lemon/suurballe.h	(revision 670)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -30,51 +30,7 @@
 #include <lemon/path.h>
 #include <lemon/list_graph.h>
-#include <lemon/dijkstra.h>
 #include <lemon/maps.h>
 
 namespace lemon {
-
-  /// \brief Default traits class of Suurballe algorithm.
-  ///
-  /// Default traits class of Suurballe algorithm.
-  /// \tparam GR The digraph type the algorithm runs on.
-  /// \tparam LEN The type of the length map.
-  /// The default value is <tt>GR::ArcMap<int></tt>.
-#ifdef DOXYGEN
-  template <typename GR, typename LEN>
-#else
-  template < typename GR,
-             typename LEN = typename GR::template ArcMap<int> >
-#endif
-  struct SuurballeDefaultTraits
-  {
-    /// The type of the digraph.
-    typedef GR Digraph;
-    /// The type of the length map.
-    typedef LEN LengthMap;
-    /// The type of the lengths.
-    typedef typename LEN::Value Length;
-    /// The type of the flow map.
-    typedef typename GR::template ArcMap<int> FlowMap;
-    /// The type of the potential map.
-    typedef typename GR::template NodeMap<Length> PotentialMap;
-
-    /// \brief The path type
-    ///
-    /// The type used for storing the found arc-disjoint paths.
-    /// It must conform to the \ref lemon::concepts::Path "Path" concept
-    /// and it must have an \c addBack() function.
-    typedef lemon::Path<Digraph> Path;
-
-    /// The cross reference type used for the heap.
-    typedef typename GR::template NodeMap<int> HeapCrossRef;
-
-    /// \brief The heap type used for internal Dijkstra computations.
-    ///
-    /// The type of the heap used for internal Dijkstra computations.
-    /// It must conform to the \ref lemon::concepts::Heap "Heap" concept
-    /// and its priority type must be \c Length.
-    typedef BinHeap<Length, HeapCrossRef> Heap;
-  };
 
   /// \addtogroup shortest_path
@@ -91,5 +47,5 @@
   /// "minimum cost flow problem". This implementation is actually an
   /// efficient specialized version of the \ref CapacityScaling
-  /// "successive shortest path" algorithm directly for this problem.
+  /// "Successive Shortest Path" algorithm directly for this problem.
   /// Therefore this class provides query functions for flow values and
   /// node potentials (the dual solution) just like the minimum cost flow
@@ -100,14 +56,13 @@
   /// The default value is <tt>GR::ArcMap<int></tt>.
   ///
-  /// \warning Length values should be \e non-negative.
+  /// \warning Length values should be \e non-negative \e integers.
   ///
-  /// \note For finding \e node-disjoint paths, this algorithm can be used
+  /// \note For finding node-disjoint paths this algorithm can be used
   /// along with the \ref SplitNodes adaptor.
 #ifdef DOXYGEN
-  template <typename GR, typename LEN, typename TR>
+  template <typename GR, typename LEN>
 #else
   template < typename GR,
-             typename LEN = typename GR::template ArcMap<int>,
-             typename TR = SuurballeDefaultTraits<GR, LEN> >
+             typename LEN = typename GR::template ArcMap<int> >
 #endif
   class Suurballe
@@ -120,24 +75,24 @@
   public:
 
-    /// The type of the digraph.
-    typedef typename TR::Digraph Digraph;
+    /// The type of the digraph the algorithm runs on.
+    typedef GR Digraph;
     /// The type of the length map.
-    typedef typename TR::LengthMap LengthMap;
+    typedef LEN LengthMap;
     /// The type of the lengths.
-    typedef typename TR::Length Length;
-
+    typedef typename LengthMap::Value Length;
+#ifdef DOXYGEN
     /// The type of the flow map.
-    typedef typename TR::FlowMap FlowMap;
+    typedef GR::ArcMap<int> FlowMap;
     /// The type of the potential map.
-    typedef typename TR::PotentialMap PotentialMap;
+    typedef GR::NodeMap<Length> PotentialMap;
+#else
+    /// The type of the flow map.
+    typedef typename Digraph::template ArcMap<int> FlowMap;
+    /// The type of the potential map.
+    typedef typename Digraph::template NodeMap<Length> PotentialMap;
+#endif
+
     /// The type of the path structures.
-    typedef typename TR::Path Path;
-    /// The cross reference type used for the heap.
-    typedef typename TR::HeapCrossRef HeapCrossRef;
-    /// The heap type used for internal Dijkstra computations.
-    typedef typename TR::Heap Heap;
-
-    /// The \ref lemon::SuurballeDefaultTraits "traits class" of the algorithm.
-    typedef TR Traits;
+    typedef SimplePath<GR> Path;
 
   private:
@@ -150,36 +105,42 @@
     class ResidualDijkstra
     {
+      typedef typename Digraph::template NodeMap<int> HeapCrossRef;
+      typedef BinHeap<Length, HeapCrossRef> Heap;
+
     private:
 
+      // The digraph the algorithm runs on
       const Digraph &_graph;
+
+      // The main maps
+      const FlowMap &_flow;
       const LengthMap &_length;
-      const FlowMap &_flow;
-      PotentialMap &_pi;
+      PotentialMap &_potential;
+
+      // The distance map
+      PotentialMap _dist;
+      // The pred arc map
       PredMap &_pred;
+      // The processed (i.e. permanently labeled) nodes
+      std::vector<Node> _proc_nodes;
+
       Node _s;
       Node _t;
 
-      PotentialMap _dist;
-      std::vector<Node> _proc_nodes;
-
     public:
 
-      // Constructor
-      ResidualDijkstra(Suurballe &srb) :
-        _graph(srb._graph), _length(srb._length),
-        _flow(*srb._flow), _pi(*srb._potential), _pred(srb._pred),
-        _s(srb._s), _t(srb._t), _dist(_graph) {}
-
-      // Run the algorithm and return true if a path is found
-      // from the source node to the target node.
-      bool run(int cnt) {
-        return cnt == 0 ? startFirst() : start();
-      }
-
-    private:
-
-      // Execute the algorithm for the first time (the flow and potential
-      // functions have to be identically zero).
-      bool startFirst() {
+      /// Constructor.
+      ResidualDijkstra( const Digraph &graph,
+                        const FlowMap &flow,
+                        const LengthMap &length,
+                        PotentialMap &potential,
+                        PredMap &pred,
+                        Node s, Node t ) :
+        _graph(graph), _flow(flow), _length(length), _potential(potential),
+        _dist(graph), _pred(pred), _s(s), _t(t) {}
+
+      /// \brief Run the algorithm. It returns \c true if a path is found
+      /// from the source node to the target node.
+      bool run() {
         HeapCrossRef heap_cross_ref(_graph, Heap::PRE_HEAP);
         Heap heap(heap_cross_ref);
@@ -191,21 +152,22 @@
         while (!heap.empty() && heap.top() != _t) {
           Node u = heap.top(), v;
-          Length d = heap.prio(), dn;
+          Length d = heap.prio() + _potential[u], nd;
           _dist[u] = heap.prio();
+          heap.pop();
           _proc_nodes.push_back(u);
-          heap.pop();
 
           // Traverse outgoing arcs
           for (OutArcIt e(_graph, u); e != INVALID; ++e) {
-            v = _graph.target(e);
-            switch(heap.state(v)) {
+            if (_flow[e] == 0) {
+              v = _graph.target(e);
+              switch(heap.state(v)) {
               case Heap::PRE_HEAP:
-                heap.push(v, d + _length[e]);
+                heap.push(v, d + _length[e] - _potential[v]);
                 _pred[v] = e;
                 break;
               case Heap::IN_HEAP:
-                dn = d + _length[e];
-                if (dn < heap[v]) {
-                  heap.decrease(v, dn);
+                nd = d + _length[e] - _potential[v];
+                if (nd < heap[v]) {
+                  heap.decrease(v, nd);
                   _pred[v] = e;
                 }
@@ -213,50 +175,4 @@
               case Heap::POST_HEAP:
                 break;
-            }
-          }
-        }
-        if (heap.empty()) return false;
-
-        // Update potentials of processed nodes
-        Length t_dist = heap.prio();
-        for (int i = 0; i < int(_proc_nodes.size()); ++i)
-          _pi[_proc_nodes[i]] = _dist[_proc_nodes[i]] - t_dist;
-        return true;
-      }
-
-      // Execute the algorithm.
-      bool start() {
-        HeapCrossRef heap_cross_ref(_graph, Heap::PRE_HEAP);
-        Heap heap(heap_cross_ref);
-        heap.push(_s, 0);
-        _pred[_s] = INVALID;
-        _proc_nodes.clear();
-
-        // Process nodes
-        while (!heap.empty() && heap.top() != _t) {
-          Node u = heap.top(), v;
-          Length d = heap.prio() + _pi[u], dn;
-          _dist[u] = heap.prio();
-          _proc_nodes.push_back(u);
-          heap.pop();
-
-          // Traverse outgoing arcs
-          for (OutArcIt e(_graph, u); e != INVALID; ++e) {
-            if (_flow[e] == 0) {
-              v = _graph.target(e);
-              switch(heap.state(v)) {
-                case Heap::PRE_HEAP:
-                  heap.push(v, d + _length[e] - _pi[v]);
-                  _pred[v] = e;
-                  break;
-                case Heap::IN_HEAP:
-                  dn = d + _length[e] - _pi[v];
-                  if (dn < heap[v]) {
-                    heap.decrease(v, dn);
-                    _pred[v] = e;
-                  }
-                  break;
-                case Heap::POST_HEAP:
-                  break;
               }
             }
@@ -268,17 +184,17 @@
               v = _graph.source(e);
               switch(heap.state(v)) {
-                case Heap::PRE_HEAP:
-                  heap.push(v, d - _length[e] - _pi[v]);
+              case Heap::PRE_HEAP:
+                heap.push(v, d - _length[e] - _potential[v]);
+                _pred[v] = e;
+                break;
+              case Heap::IN_HEAP:
+                nd = d - _length[e] - _potential[v];
+                if (nd < heap[v]) {
+                  heap.decrease(v, nd);
                   _pred[v] = e;
-                  break;
-                case Heap::IN_HEAP:
-                  dn = d - _length[e] - _pi[v];
-                  if (dn < heap[v]) {
-                    heap.decrease(v, dn);
-                    _pred[v] = e;
-                  }
-                  break;
-                case Heap::POST_HEAP:
-                  break;
+                }
+                break;
+              case Heap::POST_HEAP:
+                break;
               }
             }
@@ -290,86 +206,9 @@
         Length t_dist = heap.prio();
         for (int i = 0; i < int(_proc_nodes.size()); ++i)
-          _pi[_proc_nodes[i]] += _dist[_proc_nodes[i]] - t_dist;
+          _potential[_proc_nodes[i]] += _dist[_proc_nodes[i]] - t_dist;
         return true;
       }
 
     }; //class ResidualDijkstra
-
-  public:
-
-    /// \name Named Template Parameters
-    /// @{
-
-    template <typename T>
-    struct SetFlowMapTraits : public Traits {
-      typedef T FlowMap;
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// \c FlowMap type.
-    ///
-    /// \ref named-templ-param "Named parameter" for setting
-    /// \c FlowMap type.
-    template <typename T>
-    struct SetFlowMap
-      : public Suurballe<GR, LEN, SetFlowMapTraits<T> > {
-      typedef Suurballe<GR, LEN, SetFlowMapTraits<T> > Create;
-    };
-
-    template <typename T>
-    struct SetPotentialMapTraits : public Traits {
-      typedef T PotentialMap;
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// \c PotentialMap type.
-    ///
-    /// \ref named-templ-param "Named parameter" for setting
-    /// \c PotentialMap type.
-    template <typename T>
-    struct SetPotentialMap
-      : public Suurballe<GR, LEN, SetPotentialMapTraits<T> > {
-      typedef Suurballe<GR, LEN, SetPotentialMapTraits<T> > Create;
-    };
-
-    template <typename T>
-    struct SetPathTraits : public Traits {
-      typedef T Path;
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// \c %Path type.
-    ///
-    /// \ref named-templ-param "Named parameter" for setting \c %Path type.
-    /// It must conform to the \ref lemon::concepts::Path "Path" concept
-    /// and it must have an \c addBack() function.
-    template <typename T>
-    struct SetPath
-      : public Suurballe<GR, LEN, SetPathTraits<T> > {
-      typedef Suurballe<GR, LEN, SetPathTraits<T> > Create;
-    };
-
-    template <typename H, typename CR>
-    struct SetHeapTraits : public Traits {
-      typedef H Heap;
-      typedef CR HeapCrossRef;
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// \c Heap and \c HeapCrossRef types.
-    ///
-    /// \ref named-templ-param "Named parameter" for setting \c Heap
-    /// and \c HeapCrossRef types with automatic allocation.
-    /// They will be used for internal Dijkstra computations.
-    /// The heap type must conform to the \ref lemon::concepts::Heap "Heap"
-    /// concept and its priority type must be \c Length.
-    template <typename H,
-              typename CR = typename Digraph::template NodeMap<int> >
-    struct SetHeap
-      : public Suurballe<GR, LEN, SetHeapTraits<H, CR> > {
-      typedef Suurballe<GR, LEN, SetHeapTraits<H, CR> > Create;
-    };
-
-    /// @}
 
   private:
@@ -388,23 +227,17 @@
 
     // The source node
-    Node _s;
+    Node _source;
     // The target node
-    Node _t;
+    Node _target;
 
     // Container to store the found paths
-    std::vector<Path> _paths;
+    std::vector< SimplePath<Digraph> > paths;
     int _path_num;
 
     // The pred arc map
     PredMap _pred;
-
-    // Data for full init
-    PotentialMap *_init_dist;
-    PredMap *_init_pred;
-    bool _full_init;
-
-  protected:
-
-    Suurballe() {}
+    // Implementation of the Dijkstra algorithm for finding augmenting
+    // shortest paths in the residual network
+    ResidualDijkstra *_dijkstra;
 
   public:
@@ -419,7 +252,9 @@
                const LengthMap &length ) :
       _graph(graph), _length(length), _flow(0), _local_flow(false),
-      _potential(0), _local_potential(false), _pred(graph),
-      _init_dist(0), _init_pred(0)
-    {}
+      _potential(0), _local_potential(false), _pred(graph)
+    {
+      LEMON_ASSERT(std::numeric_limits<Length>::is_integer,
+        "The length type of Suurballe must be integer");
+    }
 
     /// Destructor.
@@ -427,6 +262,5 @@
       if (_local_flow) delete _flow;
       if (_local_potential) delete _potential;
-      delete _init_dist;
-      delete _init_pred;
+      delete _dijkstra;
     }
 
@@ -473,11 +307,8 @@
     /// \name Execution Control
     /// The simplest way to execute the algorithm is to call the run()
-    /// function.\n
-    /// If you need to execute the algorithm many times using the same
-    /// source node, then you may call fullInit() once and start()
-    /// for each target node.\n
+    /// function.
+    /// \n
     /// If you only need the flow that is the union of the found
-    /// arc-disjoint paths, then you may call findFlow() instead of
-    /// start().
+    /// arc-disjoint paths, you may call init() and findFlow().
 
     /// @{
@@ -499,9 +330,11 @@
     /// \code
     ///   s.init(s);
-    ///   s.start(t, k);
+    ///   s.findFlow(t, k);
+    ///   s.findPaths();
     /// \endcode
     int run(const Node& s, const Node& t, int k = 2) {
       init(s);
-      start(t, k);
+      findFlow(t, k);
+      findPaths();
       return _path_num;
     }
@@ -509,9 +342,9 @@
     /// \brief Initialize the algorithm.
     ///
-    /// This function initializes the algorithm with the given source node.
+    /// This function initializes the algorithm.
     ///
     /// \param s The source node.
     void init(const Node& s) {
-      _s = s;
+      _source = s;
 
       // Initialize maps
@@ -524,61 +357,6 @@
         _local_potential = true;
       }
-      _full_init = false;
-    }
-
-    /// \brief Initialize the algorithm and perform Dijkstra.
-    ///
-    /// This function initializes the algorithm and performs a full
-    /// Dijkstra search from the given source node. It makes consecutive
-    /// executions of \ref start() "start(t, k)" faster, since they
-    /// have to perform %Dijkstra only k-1 times.
-    ///
-    /// This initialization is usually worth using instead of \ref init()
-    /// if the algorithm is executed many times using the same source node.
-    ///
-    /// \param s The source node.
-    void fullInit(const Node& s) {
-      // Initialize maps
-      init(s);
-      if (!_init_dist) {
-        _init_dist = new PotentialMap(_graph);
-      }
-      if (!_init_pred) {
-        _init_pred = new PredMap(_graph);
-      }
-
-      // Run a full Dijkstra
-      typename Dijkstra<Digraph, LengthMap>
-        ::template SetStandardHeap<Heap>
-        ::template SetDistMap<PotentialMap>
-        ::template SetPredMap<PredMap>
-        ::Create dijk(_graph, _length);
-      dijk.distMap(*_init_dist).predMap(*_init_pred);
-      dijk.run(s);
-
-      _full_init = true;
-    }
-
-    /// \brief Execute the algorithm.
-    ///
-    /// This function executes the algorithm.
-    ///
-    /// \param t The target node.
-    /// \param k The number of paths to be found.
-    ///
-    /// \return \c k if there are at least \c k arc-disjoint paths from
-    /// \c s to \c t in the digraph. Otherwise it returns the number of
-    /// arc-disjoint paths found.
-    ///
-    /// \note Apart from the return value, <tt>s.start(t, k)</tt> is
-    /// just a shortcut of the following code.
-    /// \code
-    ///   s.findFlow(t, k);
-    ///   s.findPaths();
-    /// \endcode
-    int start(const Node& t, int k = 2) {
-      findFlow(t, k);
-      findPaths();
-      return _path_num;
+      for (ArcIt e(_graph); e != INVALID; ++e) (*_flow)[e] = 0;
+      for (NodeIt n(_graph); n != INVALID; ++n) (*_potential)[n] = 0;
     }
 
@@ -598,37 +376,18 @@
     /// \pre \ref init() must be called before using this function.
     int findFlow(const Node& t, int k = 2) {
-      _t = t;
-      ResidualDijkstra dijkstra(*this);
-
-      // Initialization
-      for (ArcIt e(_graph); e != INVALID; ++e) {
-        (*_flow)[e] = 0;
-      }
-      if (_full_init) {
-        for (NodeIt n(_graph); n != INVALID; ++n) {
-          (*_potential)[n] = (*_init_dist)[n];
-        }
-        Node u = _t;
-        Arc e;
-        while ((e = (*_init_pred)[u]) != INVALID) {
-          (*_flow)[e] = 1;
-          u = _graph.source(e);
-        }
-        _path_num = 1;
-      } else {
-        for (NodeIt n(_graph); n != INVALID; ++n) {
-          (*_potential)[n] = 0;
-        }
-        _path_num = 0;
-      }
+      _target = t;
+      _dijkstra =
+        new ResidualDijkstra( _graph, *_flow, _length, *_potential, _pred,
+                              _source, _target );
 
       // Find shortest paths
+      _path_num = 0;
       while (_path_num < k) {
         // Run Dijkstra
-        if (!dijkstra.run(_path_num)) break;
+        if (!_dijkstra->run()) break;
         ++_path_num;
 
         // Set the flow along the found shortest path
-        Node u = _t;
+        Node u = _target;
         Arc e;
         while ((e = _pred[u]) != INVALID) {
@@ -647,6 +406,6 @@
     /// \brief Compute the paths from the flow.
     ///
-    /// This function computes arc-disjoint paths from the found minimum
-    /// cost flow, which is the union of them.
+    /// This function computes the paths from the found minimum cost flow,
+    /// which is the union of some arc-disjoint paths.
     ///
     /// \pre \ref init() and \ref findFlow() must be called before using
@@ -656,13 +415,13 @@
       for(ArcIt a(_graph); a != INVALID; ++a) res_flow[a] = (*_flow)[a];
 
-      _paths.clear();
-      _paths.resize(_path_num);
+      paths.clear();
+      paths.resize(_path_num);
       for (int i = 0; i < _path_num; ++i) {
-        Node n = _s;
-        while (n != _t) {
+        Node n = _source;
+        while (n != _target) {
           OutArcIt e(_graph, n);
           for ( ; res_flow[e] == 0; ++e) ;
           n = _graph.target(e);
-          _paths[i].addBack(e);
+          paths[i].addBack(e);
           res_flow[e] = 0;
         }
@@ -683,5 +442,5 @@
     /// This function returns the total length of the found paths, i.e.
     /// the total cost of the found flow.
-    /// The complexity of the function is O(m).
+    /// The complexity of the function is O(e).
     ///
     /// \pre \ref run() or \ref findFlow() must be called before using
@@ -762,6 +521,6 @@
     /// \pre \ref run() or \ref findPaths() must be called before using
     /// this function.
-    const Path& path(int i) const {
-      return _paths[i];
+    Path path(int i) const {
+      return paths[i];
     }
 
Index: lemon/time_measure.h
===================================================================
--- lemon/time_measure.h	(revision 1340)
+++ lemon/time_measure.h	(revision 833)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -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
@@ -37,5 +35,4 @@
 #include <fstream>
 #include <iostream>
-#include <lemon/math.h>
 
 namespace lemon {
@@ -67,19 +64,4 @@
     double rtime;
 
-  public:
-    ///Display format specifier
-
-    ///\e
-    ///
-    enum Format {
-      /// Reports all measured values
-      NORMAL = 0,
-      /// Only real time and an error indicator is displayed
-      SHORT = 1
-    };
-
-  private:
-    static Format _format;
-
     void _reset() {
       utime = stime = cutime = cstime = rtime = 0;
@@ -88,22 +70,8 @@
   public:
 
-    ///Set output format
-
-    ///Set output format.
-    ///
-    ///The output format is global for all timestamp instances.
-    static void format(Format f) { _format = f; }
-    ///Retrieve the current output format
-
-    ///Retrieve the current output format
-    ///
-    ///The output format is global for all timestamp instances.
-    static Format format() { return _format; }
-
-
     ///Read the current time values of the process
     void stamp()
     {
-#ifndef LEMON_WIN32
+#ifndef WIN32
       timeval tv;
       gettimeofday(&tv, 0);
@@ -257,22 +225,9 @@
   inline std::ostream& operator<<(std::ostream& os,const TimeStamp &t)
   {
-    switch(t._format)
-      {
-      case TimeStamp::NORMAL:
-        os << "u: " << t.userTime() <<
-          "s, s: " << t.systemTime() <<
-          "s, cu: " << t.cUserTime() <<
-          "s, cs: " << t.cSystemTime() <<
-          "s, real: " << t.realTime() << "s";
-        break;
-      case TimeStamp::SHORT:
-        double total = t.userTime()+t.systemTime()+
-          t.cUserTime()+t.cSystemTime();
-        os << t.realTime()
-           << "s (err: " << round((t.realTime()-total)/
-                                  t.realTime()*10000)/100
-           << "%)";
-        break;
-      }
+    os << "u: " << t.userTime() <<
+      "s, s: " << t.systemTime() <<
+      "s, cu: " << t.cUserTime() <<
+      "s, cs: " << t.cSystemTime() <<
+      "s, real: " << t.realTime() << "s";
     return os;
   }
@@ -514,5 +469,4 @@
     std::string _title;
     std::ostream &_os;
-    bool _active;
   public:
     ///Constructor
@@ -522,25 +476,11 @@
     ///\param os The stream to print the report to.
     ///\param run Sets whether the timer should start immediately.
-    ///\param active Sets whether the report should actually be printed
-    ///       on destruction.
-    TimeReport(std::string title,std::ostream &os=std::cerr,bool run=true,
-               bool active=true)
-      : Timer(run), _title(title), _os(os), _active(active) {}
+    TimeReport(std::string title,std::ostream &os=std::cerr,bool run=true)
+      : Timer(run), _title(title), _os(os){}
     ///Destructor that prints the ellapsed time
     ~TimeReport()
     {
-      if(_active) _os << _title << *this << std::endl;
-    }
-
-    ///Retrieve the activity status
-
-    ///\e
-    ///
-    bool active() const { return _active; }
-    ///Set the activity status
-
-    /// This function set whether the time report should actually be printed
-    /// on destruction.
-    void active(bool a) { _active=a; }
+      _os << _title << *this << std::endl;
+    }
   };
 
Index: lemon/unionfind.h
===================================================================
--- lemon/unionfind.h	(revision 1270)
+++ lemon/unionfind.h	(revision 864)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -1289,13 +1289,4 @@
         first_free_class(-1), first_free_node(-1) {}
 
-    /// \brief Clears the union-find data structure
-    ///
-    /// Erase each item from the data structure.
-    void clear() {
-      nodes.clear();
-      classes.clear();
-      first_free_node = first_free_class = first_class = -1;
-    }
-
     /// \brief Insert a new node into a new component.
     ///
Index: mon/vf2.h
===================================================================
--- lemon/vf2.h	(revision 1353)
+++ 	(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; }
-
-    ///Find 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: m4/lx_check_coin.m4
===================================================================
--- m4/lx_check_coin.m4	(revision 796)
+++ m4/lx_check_coin.m4	(revision 796)
@@ -0,0 +1,136 @@
+AC_DEFUN([LX_CHECK_COIN],
+[
+  AC_ARG_WITH([coin],
+AS_HELP_STRING([--with-coin@<:@=PREFIX@:>@], [search for CLP under PREFIX or under the default search paths if PREFIX is not given @<:@default@:>@])
+AS_HELP_STRING([--without-coin], [disable checking for CLP]),
+              [], [with_coin=yes])
+
+  AC_ARG_WITH([coin-includedir],
+AS_HELP_STRING([--with-coin-includedir=DIR], [search for CLP headers in DIR]),
+              [], [with_coin_includedir=no])
+
+  AC_ARG_WITH([coin-libdir],
+AS_HELP_STRING([--with-coin-libdir=DIR], [search for CLP libraries in DIR]),
+              [], [with_coin_libdir=no])
+
+  lx_clp_found=no
+  if test x"$with_coin" != x"no"; then
+    AC_MSG_CHECKING([for CLP])
+
+    if test x"$with_coin_includedir" != x"no"; then
+      CLP_CXXFLAGS="-I$with_coin_includedir"
+    elif test x"$with_coin" != x"yes"; then
+      CLP_CXXFLAGS="-I$with_coin/include"
+    fi
+
+    if test x"$with_coin_libdir" != x"no"; then
+      CLP_LDFLAGS="-L$with_coin_libdir"
+    elif test x"$with_coin" != x"yes"; then
+      CLP_LDFLAGS="-L$with_coin/lib"
+    fi
+    CLP_LIBS="-lClp -lCoinUtils -lm"
+
+    lx_save_cxxflags="$CXXFLAGS"
+    lx_save_ldflags="$LDFLAGS"
+    lx_save_libs="$LIBS"
+    CXXFLAGS="$CLP_CXXFLAGS"
+    LDFLAGS="$CLP_LDFLAGS"
+    LIBS="$CLP_LIBS"
+
+    lx_clp_test_prog='
+      #include <coin/ClpModel.hpp>
+
+      int main(int argc, char** argv)
+      {
+        ClpModel clp;
+        return 0;
+      }'
+
+    AC_LANG_PUSH(C++)
+    AC_LINK_IFELSE([$lx_clp_test_prog], [lx_clp_found=yes], [lx_clp_found=no])
+    AC_LANG_POP(C++)
+
+    CXXFLAGS="$lx_save_cxxflags"
+    LDFLAGS="$lx_save_ldflags"
+    LIBS="$lx_save_libs"
+
+    if test x"$lx_clp_found" = x"yes"; then
+      AC_DEFINE([LEMON_HAVE_CLP], [1], [Define to 1 if you have CLP.])
+      lx_lp_found=yes
+      AC_DEFINE([LEMON_HAVE_LP], [1], [Define to 1 if you have any LP solver.])
+      AC_MSG_RESULT([yes])
+    else
+      CLP_CXXFLAGS=""
+      CLP_LDFLAGS=""
+      CLP_LIBS=""
+      AC_MSG_RESULT([no])
+    fi
+  fi
+  CLP_LIBS="$CLP_LDFLAGS $CLP_LIBS"
+  AC_SUBST(CLP_CXXFLAGS)
+  AC_SUBST(CLP_LIBS)
+  AM_CONDITIONAL([HAVE_CLP], [test x"$lx_clp_found" = x"yes"])
+
+
+  lx_cbc_found=no
+  if test x"$lx_clp_found" = x"yes"; then
+    if test x"$with_coin" != x"no"; then
+      AC_MSG_CHECKING([for CBC])
+
+      if test x"$with_coin_includedir" != x"no"; then
+        CBC_CXXFLAGS="-I$with_coin_includedir"
+      elif test x"$with_coin" != x"yes"; then
+        CBC_CXXFLAGS="-I$with_coin/include"
+      fi
+
+      if test x"$with_coin_libdir" != x"no"; then
+        CBC_LDFLAGS="-L$with_coin_libdir"
+      elif test x"$with_coin" != x"yes"; then
+        CBC_LDFLAGS="-L$with_coin/lib"
+      fi
+      CBC_LIBS="-lOsi -lCbc -lCbcSolver -lClp -lOsiClp -lCoinUtils -lVol -lOsiVol -lCgl -lm -llapack -lblas"
+
+      lx_save_cxxflags="$CXXFLAGS"
+      lx_save_ldflags="$LDFLAGS"
+      lx_save_libs="$LIBS"
+      CXXFLAGS="$CBC_CXXFLAGS"
+      LDFLAGS="$CBC_LDFLAGS"
+      LIBS="$CBC_LIBS"
+
+      lx_cbc_test_prog='
+        #include <coin/CbcModel.hpp>
+
+        int main(int argc, char** argv)
+        {
+          CbcModel cbc;
+          return 0;
+        }'
+
+      AC_LANG_PUSH(C++)
+      AC_LINK_IFELSE([$lx_cbc_test_prog], [lx_cbc_found=yes], [lx_cbc_found=no])
+      AC_LANG_POP(C++)
+
+      CXXFLAGS="$lx_save_cxxflags"
+      LDFLAGS="$lx_save_ldflags"
+      LIBS="$lx_save_libs"
+
+      if test x"$lx_cbc_found" = x"yes"; then
+        AC_DEFINE([LEMON_HAVE_CBC], [1], [Define to 1 if you have CBC.])
+        lx_lp_found=yes
+        AC_DEFINE([LEMON_HAVE_LP], [1], [Define to 1 if you have any LP solver.])
+        lx_mip_found=yes
+        AC_DEFINE([LEMON_HAVE_MIP], [1], [Define to 1 if you have any MIP solver.])
+        AC_MSG_RESULT([yes])
+      else
+        CBC_CXXFLAGS=""
+        CBC_LDFLAGS=""
+        CBC_LIBS=""
+        AC_MSG_RESULT([no])
+      fi
+    fi
+  fi
+  CBC_LIBS="$CBC_LDFLAGS $CBC_LIBS"
+  AC_SUBST(CBC_CXXFLAGS)
+  AC_SUBST(CBC_LIBS)
+  AM_CONDITIONAL([HAVE_CBC], [test x"$lx_cbc_found" = x"yes"])
+])
Index: m4/lx_check_cplex.m4
===================================================================
--- m4/lx_check_cplex.m4	(revision 674)
+++ m4/lx_check_cplex.m4	(revision 674)
@@ -0,0 +1,81 @@
+AC_DEFUN([LX_CHECK_CPLEX],
+[
+  AC_ARG_WITH([cplex],
+AS_HELP_STRING([--with-cplex@<:@=PREFIX@:>@], [search for CPLEX under PREFIX or under the default search paths if PREFIX is not given @<:@default@:>@])
+AS_HELP_STRING([--without-cplex], [disable checking for CPLEX]),
+              [], [with_cplex=yes])
+
+  AC_ARG_WITH([cplex-includedir],
+AS_HELP_STRING([--with-cplex-includedir=DIR], [search for CPLEX headers in DIR]),
+              [], [with_cplex_includedir=no])
+
+  AC_ARG_WITH([cplex-libdir],
+AS_HELP_STRING([--with-cplex-libdir=DIR], [search for CPLEX libraries in DIR]),
+              [], [with_cplex_libdir=no])
+
+  lx_cplex_found=no
+  if test x"$with_cplex" != x"no"; then
+    AC_MSG_CHECKING([for CPLEX])
+
+    if test x"$with_cplex_includedir" != x"no"; then
+      CPLEX_CFLAGS="-I$with_cplex_includedir"
+    elif test x"$with_cplex" != x"yes"; then
+      CPLEX_CFLAGS="-I$with_cplex/include"
+    elif test x"$CPLEX_INCLUDEDIR" != x; then
+      CPLEX_CFLAGS="-I$CPLEX_INCLUDEDIR"
+    fi
+
+    if test x"$with_cplex_libdir" != x"no"; then
+      CPLEX_LDFLAGS="-L$with_cplex_libdir"
+    elif test x"$with_cplex" != x"yes"; then
+      CPLEX_LDFLAGS="-L$with_cplex/lib"
+    elif test x"$CPLEX_LIBDIR" != x; then
+      CPLEX_LDFLAGS="-L$CPLEX_LIBDIR"
+    fi
+    CPLEX_LIBS="-lcplex -lm -lpthread"
+
+    lx_save_cxxflags="$CXXFLAGS"
+    lx_save_ldflags="$LDFLAGS"
+    lx_save_libs="$LIBS"
+    CXXFLAGS="$CPLEX_CFLAGS"
+    LDFLAGS="$CPLEX_LDFLAGS"
+    LIBS="$CPLEX_LIBS"
+
+    lx_cplex_test_prog='
+      extern "C" {
+      #include <ilcplex/cplex.h>
+      }
+
+      int main(int argc, char** argv)
+      {
+        CPXENVptr env = NULL;
+        return 0;
+      }'
+
+    AC_LANG_PUSH(C++)
+    AC_LINK_IFELSE([$lx_cplex_test_prog], [lx_cplex_found=yes], [lx_cplex_found=no])
+    AC_LANG_POP(C++)
+
+    CXXFLAGS="$lx_save_cxxflags"
+    LDFLAGS="$lx_save_ldflags"
+    LIBS="$lx_save_libs"
+
+    if test x"$lx_cplex_found" = x"yes"; then
+      AC_DEFINE([LEMON_HAVE_CPLEX], [1], [Define to 1 if you have CPLEX.])
+      lx_lp_found=yes
+      AC_DEFINE([LEMON_HAVE_LP], [1], [Define to 1 if you have any LP solver.])
+      lx_mip_found=yes
+      AC_DEFINE([LEMON_HAVE_MIP], [1], [Define to 1 if you have any MIP solver.])
+      AC_MSG_RESULT([yes])
+    else
+      CPLEX_CFLAGS=""
+      CPLEX_LDFLAGS=""
+      CPLEX_LIBS=""
+      AC_MSG_RESULT([no])
+    fi
+  fi
+  CPLEX_LIBS="$CPLEX_LDFLAGS $CPLEX_LIBS"
+  AC_SUBST(CPLEX_CFLAGS)
+  AC_SUBST(CPLEX_LIBS)
+  AM_CONDITIONAL([HAVE_CPLEX], [test x"$lx_cplex_found" = x"yes"])
+])
Index: m4/lx_check_glpk.m4
===================================================================
--- m4/lx_check_glpk.m4	(revision 674)
+++ m4/lx_check_glpk.m4	(revision 674)
@@ -0,0 +1,84 @@
+AC_DEFUN([LX_CHECK_GLPK],
+[
+  AC_ARG_WITH([glpk],
+AS_HELP_STRING([--with-glpk@<:@=PREFIX@:>@], [search for GLPK under PREFIX or under the default search paths if PREFIX is not given @<:@default@:>@])
+AS_HELP_STRING([--without-glpk], [disable checking for GLPK]),
+              [], [with_glpk=yes])
+
+  AC_ARG_WITH([glpk-includedir],
+AS_HELP_STRING([--with-glpk-includedir=DIR], [search for GLPK headers in DIR]),
+              [], [with_glpk_includedir=no])
+
+  AC_ARG_WITH([glpk-libdir],
+AS_HELP_STRING([--with-glpk-libdir=DIR], [search for GLPK libraries in DIR]),
+              [], [with_glpk_libdir=no])
+
+  lx_glpk_found=no
+  if test x"$with_glpk" != x"no"; then
+    AC_MSG_CHECKING([for GLPK])
+
+    if test x"$with_glpk_includedir" != x"no"; then
+      GLPK_CFLAGS="-I$with_glpk_includedir"
+    elif test x"$with_glpk" != x"yes"; then
+      GLPK_CFLAGS="-I$with_glpk/include"
+    fi
+
+    if test x"$with_glpk_libdir" != x"no"; then
+      GLPK_LDFLAGS="-L$with_glpk_libdir"
+    elif test x"$with_glpk" != x"yes"; then
+      GLPK_LDFLAGS="-L$with_glpk/lib"
+    fi
+    GLPK_LIBS="-lglpk"
+
+    lx_save_cxxflags="$CXXFLAGS"
+    lx_save_ldflags="$LDFLAGS"
+    lx_save_libs="$LIBS"
+    CXXFLAGS="$GLPK_CFLAGS"
+    LDFLAGS="$GLPK_LDFLAGS"
+    LIBS="$GLPK_LIBS"
+
+    lx_glpk_test_prog='
+      extern "C" {
+      #include <glpk.h>
+      }
+
+      #if (GLP_MAJOR_VERSION < 4) \
+         || (GLP_MAJOR_VERSION == 4 && GLP_MINOR_VERSION < 33)
+      #error Supported GLPK versions: 4.33 or above
+      #endif
+
+      int main(int argc, char** argv)
+      {
+        LPX *lp;
+        lp = lpx_create_prob();
+        lpx_delete_prob(lp);
+        return 0;
+      }'
+
+    AC_LANG_PUSH(C++)
+    AC_LINK_IFELSE([$lx_glpk_test_prog], [lx_glpk_found=yes], [lx_glpk_found=no])
+    AC_LANG_POP(C++)
+
+    CXXFLAGS="$lx_save_cxxflags"
+    LDFLAGS="$lx_save_ldflags"
+    LIBS="$lx_save_libs"
+
+    if test x"$lx_glpk_found" = x"yes"; then
+      AC_DEFINE([LEMON_HAVE_GLPK], [1], [Define to 1 if you have GLPK.])
+      lx_lp_found=yes
+      AC_DEFINE([LEMON_HAVE_LP], [1], [Define to 1 if you have any LP solver.])
+      lx_mip_found=yes
+      AC_DEFINE([LEMON_HAVE_MIP], [1], [Define to 1 if you have any MIP solver.])
+      AC_MSG_RESULT([yes])
+    else
+      GLPK_CFLAGS=""
+      GLPK_LDFLAGS=""
+      GLPK_LIBS=""
+      AC_MSG_RESULT([no])
+    fi
+  fi
+  GLPK_LIBS="$GLPK_LDFLAGS $GLPK_LIBS"
+  AC_SUBST(GLPK_CFLAGS)
+  AC_SUBST(GLPK_LIBS)
+  AM_CONDITIONAL([HAVE_GLPK], [test x"$lx_glpk_found" = x"yes"])
+])
Index: m4/lx_check_soplex.m4
===================================================================
--- m4/lx_check_soplex.m4	(revision 674)
+++ m4/lx_check_soplex.m4	(revision 674)
@@ -0,0 +1,73 @@
+AC_DEFUN([LX_CHECK_SOPLEX],
+[
+  AC_ARG_WITH([soplex],
+AS_HELP_STRING([--with-soplex@<:@=PREFIX@:>@], [search for SOPLEX under PREFIX or under the default search paths if PREFIX is not given @<:@default@:>@])
+AS_HELP_STRING([--without-soplex], [disable checking for SOPLEX]),
+              [], [with_soplex=yes])
+
+  AC_ARG_WITH([soplex-includedir],
+AS_HELP_STRING([--with-soplex-includedir=DIR], [search for SOPLEX headers in DIR]),
+              [], [with_soplex_includedir=no])
+
+  AC_ARG_WITH([soplex-libdir],
+AS_HELP_STRING([--with-soplex-libdir=DIR], [search for SOPLEX libraries in DIR]),
+              [], [with_soplex_libdir=no])
+
+  lx_soplex_found=no
+  if test x"$with_soplex" != x"no"; then
+    AC_MSG_CHECKING([for SOPLEX])
+
+    if test x"$with_soplex_includedir" != x"no"; then
+      SOPLEX_CXXFLAGS="-I$with_soplex_includedir"
+    elif test x"$with_soplex" != x"yes"; then
+      SOPLEX_CXXFLAGS="-I$with_soplex/src"
+    fi
+
+    if test x"$with_soplex_libdir" != x"no"; then
+      SOPLEX_LDFLAGS="-L$with_soplex_libdir"
+    elif test x"$with_soplex" != x"yes"; then
+      SOPLEX_LDFLAGS="-L$with_soplex/lib"
+    fi
+    SOPLEX_LIBS="-lsoplex -lz"
+
+    lx_save_cxxflags="$CXXFLAGS"
+    lx_save_ldflags="$LDFLAGS"
+    lx_save_libs="$LIBS"
+    CXXFLAGS="$SOPLEX_CXXFLAGS"
+    LDFLAGS="$SOPLEX_LDFLAGS"
+    LIBS="$SOPLEX_LIBS"
+
+    lx_soplex_test_prog='
+      #include <soplex.h>
+
+      int main(int argc, char** argv)
+      {
+        soplex::SoPlex soplex;
+        return 0;
+      }'
+
+    AC_LANG_PUSH(C++)
+    AC_LINK_IFELSE([$lx_soplex_test_prog], [lx_soplex_found=yes], [lx_soplex_found=no])
+    AC_LANG_POP(C++)
+
+    CXXFLAGS="$lx_save_cxxflags"
+    LDFLAGS="$lx_save_ldflags"
+    LIBS="$lx_save_libs"
+
+    if test x"$lx_soplex_found" = x"yes"; then
+      AC_DEFINE([LEMON_HAVE_SOPLEX], [1], [Define to 1 if you have SOPLEX.])
+      lx_lp_found=yes
+      AC_DEFINE([LEMON_HAVE_LP], [1], [Define to 1 if you have any LP solver.])
+      AC_MSG_RESULT([yes])
+    else
+      SOPLEX_CXXFLAGS=""
+      SOPLEX_LDFLAGS=""
+      SOPLEX_LIBS=""
+      AC_MSG_RESULT([no])
+    fi
+  fi
+  SOPLEX_LIBS="$SOPLEX_LDFLAGS $SOPLEX_LIBS"
+  AC_SUBST(SOPLEX_CXXFLAGS)
+  AC_SUBST(SOPLEX_LIBS)
+  AM_CONDITIONAL([HAVE_SOPLEX], [test x"$lx_soplex_found" = x"yes"])
+])
Index: scripts/Makefile.am
===================================================================
--- scripts/Makefile.am	(revision 840)
+++ scripts/Makefile.am	(revision 840)
@@ -0,0 +1,7 @@
+EXTRA_DIST += \
+	scripts/bib2dox.py \
+	scripts/bootstrap.sh \
+	scripts/chg-len.py \
+	scripts/mk-release.sh \
+	scripts/unify-sources.sh \
+	scripts/valgrind-wrapper.sh
Index: scripts/bib2dox.py
===================================================================
--- scripts/bib2dox.py	(revision 801)
+++ scripts/bib2dox.py	(revision 801)
@@ -0,0 +1,811 @@
+#!/usr/bin/env /usr/local/Python/bin/python2.1
+"""
+  BibTeX to Doxygen converter
+  Usage: python bib2dox.py bibfile.bib > bibfile.dox
+
+  This code is the modification of the BibTeX to XML converter
+  by Vidar Bronken Gundersen et al. See the original copyright notices below. 
+
+  **********************************************************************
+
+  Decoder for bibliographic data, BibTeX
+  Usage: python bibtex2xml.py bibfile.bib > bibfile.xml
+
+  v.8
+  (c)2002-06-23 Vidar Bronken Gundersen
+  http://bibtexml.sf.net/
+  Reuse approved as long as this notification is kept.
+  Licence: GPL.
+
+  Contributions/thanks to:
+  Egon Willighagen, http://sf.net/projects/jreferences/
+  Richard Mahoney (for providing a test case)
+
+  Editted by Sara Sprenkle to be more robust and handle more bibtex features.
+  (c) 2003-01-15
+
+  1.  Changed bibtex: tags to bibxml: tags.
+  2.  Use xmlns:bibxml="http://bibtexml.sf.net/"
+  3.  Allow spaces between @type and first {
+  4.  "author" fields with multiple authors split by " and "
+      are put in separate xml "bibxml:author" tags.
+  5.  Option for Titles: words are capitalized
+      only if first letter in title or capitalized inside braces
+  6.  Removes braces from within field values
+  7.  Ignores comments in bibtex file (including @comment{ or % )
+  8.  Replaces some special latex tags, e.g., replaces ~ with '&#160;'
+  9.  Handles bibtex @string abbreviations
+        --> includes bibtex's default abbreviations for months
+        --> does concatenation of abbr # " more " and " more " # abbr
+  10. Handles @type( ... ) or @type{ ... }
+  11. The keywords field is split on , or ; and put into separate xml
+      "bibxml:keywords" tags
+  12. Ignores @preamble
+
+  Known Limitations
+  1.  Does not transform Latex encoding like math mode and special
+      latex symbols.
+  2.  Does not parse author fields into first and last names.
+      E.g., It does not do anything special to an author whose name is
+      in the form LAST_NAME, FIRST_NAME
+      In "author" tag, will show up as
+      <bibxml:author>LAST_NAME, FIRST_NAME</bibxml:author>
+  3.  Does not handle "crossref" fields other than to print
+      <bibxml:crossref>...</bibxml:crossref>
+  4.  Does not inform user of the input's format errors.  You just won't
+      be able to transform the file later with XSL
+
+  You will have to manually edit the XML output if you need to handle
+  these (and unknown) limitations.
+
+"""
+
+import string, re
+
+# set of valid name characters
+valid_name_chars = '[\w\-:]'
+
+#
+# define global regular expression variables
+#
+author_rex = re.compile('\s+and\s+')
+rembraces_rex = re.compile('[{}]')
+capitalize_rex = re.compile('({[^}]*})')
+
+# used by bibtexkeywords(data)
+keywords_rex = re.compile('[,;]')
+
+# used by concat_line(line)
+concatsplit_rex = re.compile('\s*#\s*')
+
+# split on {, }, or " in verify_out_of_braces
+delimiter_rex = re.compile('([{}"])',re.I)
+
+field_rex = re.compile('\s*(\w*)\s*=\s*(.*)')
+data_rex = re.compile('\s*(\w*)\s*=\s*([^,]*),?')
+
+url_rex = re.compile('\\\url\{([^}]*)\}')
+
+#
+# styles for html formatting
+#
+divstyle = 'margin-top: -4ex; margin-left: 8em;'
+
+#
+# return the string parameter without braces
+#
+def transformurls(str):
+    return url_rex.sub(r'<a href="\1">\1</a>', str)
+
+#
+# return the string parameter without braces
+#
+def removebraces(str):
+    return rembraces_rex.sub('', str)
+
+#
+# latex-specific replacements
+# (do this after braces were removed)
+#
+def latexreplacements(line):
+    line = string.replace(line, '~', '&nbsp;')
+    line = string.replace(line, '\\\'a', '&aacute;')
+    line = string.replace(line, '\\"a', '&auml;')
+    line = string.replace(line, '\\\'e', '&eacute;')
+    line = string.replace(line, '\\"e', '&euml;')
+    line = string.replace(line, '\\\'i', '&iacute;')
+    line = string.replace(line, '\\"i', '&iuml;')
+    line = string.replace(line, '\\\'o', '&oacute;')
+    line = string.replace(line, '\\"o', '&ouml;')
+    line = string.replace(line, '\\\'u', '&uacute;')
+    line = string.replace(line, '\\"u', '&uuml;')
+    line = string.replace(line, '\\H o', '&otilde;')
+    line = string.replace(line, '\\H u', '&uuml;')   # &utilde; does not exist
+    line = string.replace(line, '\\\'A', '&Aacute;')
+    line = string.replace(line, '\\"A', '&Auml;')
+    line = string.replace(line, '\\\'E', '&Eacute;')
+    line = string.replace(line, '\\"E', '&Euml;')
+    line = string.replace(line, '\\\'I', '&Iacute;')
+    line = string.replace(line, '\\"I', '&Iuml;')
+    line = string.replace(line, '\\\'O', '&Oacute;')
+    line = string.replace(line, '\\"O', '&Ouml;')
+    line = string.replace(line, '\\\'U', '&Uacute;')
+    line = string.replace(line, '\\"U', '&Uuml;')
+    line = string.replace(line, '\\H O', '&Otilde;')
+    line = string.replace(line, '\\H U', '&Uuml;')   # &Utilde; does not exist
+
+    return line
+
+#
+# copy characters form a string decoding html expressions (&xyz;)
+#
+def copychars(str, ifrom, count):
+    result = ''
+    i = ifrom
+    c = 0
+    html_spec = False
+    while (i < len(str)) and (c < count):
+        if str[i] == '&':
+            html_spec = True;
+            if i+1 < len(str):
+                result += str[i+1]
+            c += 1
+            i += 2
+        else:
+            if not html_spec:
+                if ((str[i] >= 'A') and (str[i] <= 'Z')) or \
+                   ((str[i] >= 'a') and (str[i] <= 'z')):
+                    result += str[i]
+                    c += 1
+            elif str[i] == ';':
+                html_spec = False;
+            i += 1
+    
+    return result
+
+
+# 
+# Handle a list of authors (separated by 'and').
+# It gives back an array of the follwing values:
+#  - num: the number of authors,
+#  - list: the list of the author names,
+#  - text: the bibtex text (separated by commas and/or 'and')
+#  - abbrev: abbreviation that can be used for indicate the
+#    bibliography entries
+#
+def bibtexauthor(data):
+    result = {}
+    bibtex = ''
+    result['list'] = author_rex.split(data)
+    result['num'] = len(result['list'])
+    for i, author in enumerate(result['list']):
+        # general transformations
+        author = latexreplacements(removebraces(author.strip()))
+        # transform "Xyz, A. B." to "A. B. Xyz"
+        pos = author.find(',')
+        if pos != -1:
+            author = author[pos+1:].strip() + ' ' + author[:pos].strip()
+        result['list'][i] = author
+        bibtex += author + '#'
+    bibtex = bibtex[:-1]
+    if result['num'] > 1:
+        ix = bibtex.rfind('#')
+        if result['num'] == 2:
+            bibtex = bibtex[:ix] + ' and ' + bibtex[ix+1:]
+        else:
+            bibtex = bibtex[:ix] + ', and ' + bibtex[ix+1:]
+    bibtex = bibtex.replace('#', ', ')
+    result['text'] = bibtex
+    
+    result['abbrev'] = ''
+    for author in result['list']:
+        pos = author.rfind(' ') + 1
+        count = 1
+        if result['num'] == 1:
+            count = 3
+        result['abbrev'] += copychars(author, pos, count)
+
+    return result
+
+
+#
+# data = title string
+# @return the capitalized title (first letter is capitalized), rest are capitalized
+# only if capitalized inside braces
+#
+def capitalizetitle(data):
+    title_list = capitalize_rex.split(data)
+    title = ''
+    count = 0
+    for phrase in title_list:
+         check = string.lstrip(phrase)
+
+         # keep phrase's capitalization the same
+         if check.find('{') == 0:
+              title += removebraces(phrase)
+         else:
+         # first word --> capitalize first letter (after spaces)
+              if count == 0:
+                  title += check.capitalize()
+              else:
+                  title += phrase.lower()
+         count = count + 1
+
+    return title
+
+
+#
+# @return the bibtex for the title
+# @param data --> title string
+# braces are removed from title
+#
+def bibtextitle(data, entrytype):
+    if entrytype in ('book', 'inbook'):
+        title = removebraces(data.strip())
+    else:
+        title = removebraces(capitalizetitle(data.strip()))
+    bibtex = title
+    return bibtex
+
+
+#
+# function to compare entry lists
+#
+def entry_cmp(x, y):
+    return cmp(x[0], y[0])
+
+
+#
+# print the XML for the transformed "filecont_source"
+#
+def bibtexdecoder(filecont_source):
+    filecont = []
+    file = []
+    
+    # want @<alphanumeric chars><spaces>{<spaces><any chars>,
+    pubtype_rex = re.compile('@(\w*)\s*{\s*(.*),')
+    endtype_rex = re.compile('}\s*$')
+    endtag_rex = re.compile('^\s*}\s*$')
+
+    bracefield_rex = re.compile('\s*(\w*)\s*=\s*(.*)')
+    bracedata_rex = re.compile('\s*(\w*)\s*=\s*{(.*)},?')
+
+    quotefield_rex = re.compile('\s*(\w*)\s*=\s*(.*)')
+    quotedata_rex = re.compile('\s*(\w*)\s*=\s*"(.*)",?')
+
+    for line in filecont_source:
+        line = line[:-1]
+
+        # encode character entities
+        line = string.replace(line, '&', '&amp;')
+        line = string.replace(line, '<', '&lt;')
+        line = string.replace(line, '>', '&gt;')
+
+        # start entry: publication type (store for later use)
+        if pubtype_rex.match(line):
+        # want @<alphanumeric chars><spaces>{<spaces><any chars>,
+            entrycont = {}
+            entry = []
+            entrytype = pubtype_rex.sub('\g<1>',line)
+            entrytype = string.lower(entrytype)
+            entryid   = pubtype_rex.sub('\g<2>', line)
+
+        # end entry if just a }
+        elif endtype_rex.match(line):
+            # generate doxygen code for the entry
+
+            # enty type related formattings
+            if entrytype in ('book', 'inbook'):
+                entrycont['title'] = '<em>' + entrycont['title'] + '</em>'
+                if not entrycont.has_key('author'):
+                    entrycont['author'] = entrycont['editor']
+                    entrycont['author']['text'] += ', editors'
+            elif entrytype == 'article':
+                entrycont['journal'] = '<em>' + entrycont['journal'] + '</em>'
+            elif entrytype in ('inproceedings', 'incollection', 'conference'):
+                entrycont['booktitle'] = '<em>' + entrycont['booktitle'] + '</em>'
+            elif entrytype == 'techreport':
+                if not entrycont.has_key('type'):
+                    entrycont['type'] = 'Technical report'
+            elif entrytype == 'mastersthesis':
+                entrycont['type'] = 'Master\'s thesis'
+            elif entrytype == 'phdthesis':
+                entrycont['type'] = 'PhD thesis'
+
+            for eline in entrycont:
+                if eline != '':
+                    eline = latexreplacements(eline)
+
+            if entrycont.has_key('pages') and (entrycont['pages'] != ''):
+                entrycont['pages'] = string.replace(entrycont['pages'], '--', '-')
+
+            if entrycont.has_key('author') and (entrycont['author'] != ''):
+                entry.append(entrycont['author']['text'] + '.')
+            if entrycont.has_key('title') and (entrycont['title'] != ''):
+                entry.append(entrycont['title'] + '.')
+            if entrycont.has_key('journal') and (entrycont['journal'] != ''):
+                entry.append(entrycont['journal'] + ',')
+            if entrycont.has_key('booktitle') and (entrycont['booktitle'] != ''):
+                entry.append('In ' + entrycont['booktitle'] + ',')
+            if entrycont.has_key('type') and (entrycont['type'] != ''):
+                eline = entrycont['type']
+                if entrycont.has_key('number') and (entrycont['number'] != ''):
+                    eline += ' ' + entrycont['number']
+                eline += ','
+                entry.append(eline)
+            if entrycont.has_key('institution') and (entrycont['institution'] != ''):
+                entry.append(entrycont['institution'] + ',')
+            if entrycont.has_key('publisher') and (entrycont['publisher'] != ''):
+                entry.append(entrycont['publisher'] + ',')
+            if entrycont.has_key('school') and (entrycont['school'] != ''):
+                entry.append(entrycont['school'] + ',')
+            if entrycont.has_key('address') and (entrycont['address'] != ''):
+                entry.append(entrycont['address'] + ',')
+            if entrycont.has_key('edition') and (entrycont['edition'] != ''):
+                entry.append(entrycont['edition'] + ' edition,')
+            if entrycont.has_key('howpublished') and (entrycont['howpublished'] != ''):
+                entry.append(entrycont['howpublished'] + ',')
+            if entrycont.has_key('volume') and (entrycont['volume'] != ''):
+                eline = entrycont['volume'];
+                if entrycont.has_key('number') and (entrycont['number'] != ''):
+                    eline += '(' + entrycont['number'] + ')'
+                if entrycont.has_key('pages') and (entrycont['pages'] != ''):
+                    eline += ':' + entrycont['pages']
+                eline += ','
+                entry.append(eline)
+            else:
+                if entrycont.has_key('pages') and (entrycont['pages'] != ''):
+                    entry.append('pages ' + entrycont['pages'] + ',')
+            if entrycont.has_key('year') and (entrycont['year'] != ''):
+                if entrycont.has_key('month') and (entrycont['month'] != ''):
+                    entry.append(entrycont['month'] + ' ' + entrycont['year'] + '.')
+                else:
+                    entry.append(entrycont['year'] + '.')
+            if entrycont.has_key('note') and (entrycont['note'] != ''):
+                entry.append(entrycont['note'] + '.')
+            if entrycont.has_key('url') and (entrycont['url'] != ''):
+                entry.append(entrycont['url'] + '.')
+
+            # generate keys for sorting and for the output
+            sortkey = ''
+            bibkey = ''
+            if entrycont.has_key('author'):
+                for author in entrycont['author']['list']:
+                    sortkey += copychars(author, author.rfind(' ')+1, len(author))
+                bibkey = entrycont['author']['abbrev']
+            else:
+                bibkey = 'x'
+            if entrycont.has_key('year'):
+                sortkey += entrycont['year']
+                bibkey += entrycont['year'][-2:]
+            if entrycont.has_key('title'):
+                sortkey += entrycont['title']
+            if entrycont.has_key('key'):
+                sortkey = entrycont['key'] + sortkey
+                bibkey = entrycont['key']
+            entry.insert(0, sortkey)
+            entry.insert(1, bibkey)
+            entry.insert(2, entryid)
+           
+            # add the entry to the file contents
+            filecont.append(entry)
+
+        else:
+            # field, publication info
+            field = ''
+            data = ''
+            
+            # field = {data} entries
+            if bracedata_rex.match(line):
+                field = bracefield_rex.sub('\g<1>', line)
+                field = string.lower(field)
+                data =  bracedata_rex.sub('\g<2>', line)
+
+            # field = "data" entries
+            elif quotedata_rex.match(line):
+                field = quotefield_rex.sub('\g<1>', line)
+                field = string.lower(field)
+                data =  quotedata_rex.sub('\g<2>', line)
+
+            # field = data entries
+            elif data_rex.match(line):
+                field = field_rex.sub('\g<1>', line)
+                field = string.lower(field)
+                data =  data_rex.sub('\g<2>', line)
+
+            if field == 'url':
+                data = '\\url{' + data.strip() + '}'
+            
+            if field in ('author', 'editor'):
+                entrycont[field] = bibtexauthor(data)
+                line = ''
+            elif field == 'title':
+                line = bibtextitle(data, entrytype)
+            elif field != '':
+                line = removebraces(transformurls(data.strip()))
+
+            if line != '':
+                line = latexreplacements(line)
+                entrycont[field] = line
+
+
+    # sort entries
+    filecont.sort(entry_cmp)
+    
+    # count the bibtex keys
+    keytable = {}
+    counttable = {}
+    for entry in filecont:
+        bibkey = entry[1]
+        if not keytable.has_key(bibkey):
+            keytable[bibkey] = 1
+        else:
+            keytable[bibkey] += 1
+
+    for bibkey in keytable.keys():
+        counttable[bibkey] = 0
+    
+    # generate output
+    for entry in filecont:
+        # generate output key form the bibtex key
+        bibkey = entry[1]
+        entryid = entry[2]
+        if keytable[bibkey] == 1:
+            outkey = bibkey
+        else:
+            outkey = bibkey + chr(97 + counttable[bibkey])
+        counttable[bibkey] += 1
+        
+        # append the entry code to the output
+        file.append('\\section ' + entryid + ' [' + outkey + ']')
+        file.append('<div style="' + divstyle + '">')
+        for line in entry[3:]:
+            file.append(line)
+        file.append('</div>')
+        file.append('')
+
+    return file
+
+
+#
+# return 1 iff abbr is in line but not inside braces or quotes
+# assumes that abbr appears only once on the line (out of braces and quotes)
+#
+def verify_out_of_braces(line, abbr):
+
+    phrase_split = delimiter_rex.split(line)
+
+    abbr_rex = re.compile( '\\b' + abbr + '\\b', re.I)
+
+    open_brace = 0
+    open_quote = 0
+
+    for phrase in phrase_split:
+        if phrase == "{":
+            open_brace = open_brace + 1
+        elif phrase == "}":
+            open_brace = open_brace - 1
+        elif phrase == '"':
+            if open_quote == 1:
+                open_quote = 0
+            else:
+                open_quote = 1
+        elif abbr_rex.search(phrase):
+            if open_brace == 0 and open_quote == 0:
+                return 1
+
+    return 0
+
+
+#
+# a line in the form phrase1 # phrase2 # ... # phrasen
+# is returned as phrase1 phrase2 ... phrasen
+# with the correct punctuation
+# Bug: Doesn't always work with multiple abbreviations plugged in
+#
+def concat_line(line):
+    # only look at part after equals
+    field = field_rex.sub('\g<1>',line)
+    rest = field_rex.sub('\g<2>',line)
+
+    concat_line = field + ' ='
+
+    pound_split = concatsplit_rex.split(rest)
+
+    phrase_count = 0
+    length = len(pound_split)
+
+    for phrase in pound_split:
+        phrase = phrase.strip()
+        if phrase_count != 0:
+            if phrase.startswith('"') or phrase.startswith('{'):
+                phrase = phrase[1:]
+        elif phrase.startswith('"'):
+            phrase = phrase.replace('"','{',1)
+
+        if phrase_count != length-1:
+            if phrase.endswith('"') or phrase.endswith('}'):
+                phrase = phrase[:-1]
+        else:
+            if phrase.endswith('"'):
+                phrase = phrase[:-1]
+                phrase = phrase + "}"
+            elif phrase.endswith('",'):
+                phrase = phrase[:-2]
+                phrase = phrase + "},"
+
+        # if phrase did have \#, add the \# back
+        if phrase.endswith('\\'):
+            phrase = phrase + "#"
+        concat_line = concat_line + ' ' + phrase
+
+        phrase_count = phrase_count + 1
+
+    return concat_line
+
+
+#
+# substitute abbreviations into filecont
+# @param filecont_source - string of data from file
+#
+def bibtex_replace_abbreviations(filecont_source):
+    filecont = filecont_source.splitlines()
+
+    #  These are defined in bibtex, so we'll define them too
+    abbr_list = ['jan','feb','mar','apr','may','jun',
+                 'jul','aug','sep','oct','nov','dec']
+    value_list = ['January','February','March','April',
+                  'May','June','July','August','September',
+                  'October','November','December']
+
+    abbr_rex = []
+    total_abbr_count = 0
+
+    front = '\\b'
+    back = '(,?)\\b'
+
+    for x in abbr_list:
+        abbr_rex.append( re.compile( front + abbr_list[total_abbr_count] + back, re.I ) )
+        total_abbr_count = total_abbr_count + 1
+
+
+    abbrdef_rex = re.compile('\s*@string\s*{\s*('+ valid_name_chars +'*)\s*=(.*)',
+                             re.I)
+
+    comment_rex = re.compile('@comment\s*{',re.I)
+    preamble_rex = re.compile('@preamble\s*{',re.I)
+
+    waiting_for_end_string = 0
+    i = 0
+    filecont2 = ''
+
+    for line in filecont:
+        if line == ' ' or line == '':
+            continue
+
+        if waiting_for_end_string:
+            if re.search('}',line):
+                waiting_for_end_string = 0
+                continue
+
+        if abbrdef_rex.search(line):
+            abbr = abbrdef_rex.sub('\g<1>', line)
+
+            if abbr_list.count(abbr) == 0:
+                val = abbrdef_rex.sub('\g<2>', line)
+                abbr_list.append(abbr)
+                value_list.append(string.strip(val))
+                abbr_rex.append( re.compile( front + abbr_list[total_abbr_count] + back, re.I ) )
+                total_abbr_count = total_abbr_count + 1
+            waiting_for_end_string = 1
+            continue
+
+        if comment_rex.search(line):
+            waiting_for_end_string = 1
+            continue
+
+        if preamble_rex.search(line):
+            waiting_for_end_string = 1
+            continue
+
+
+        # replace subsequent abbreviations with the value
+        abbr_count = 0
+
+        for x in abbr_list:
+
+            if abbr_rex[abbr_count].search(line):
+                if verify_out_of_braces(line,abbr_list[abbr_count]) == 1:
+                    line = abbr_rex[abbr_count].sub( value_list[abbr_count] + '\g<1>', line)
+                # Check for # concatenations
+                if concatsplit_rex.search(line):
+                    line = concat_line(line)
+            abbr_count = abbr_count + 1
+
+
+        filecont2 = filecont2 + line + '\n'
+        i = i+1
+
+
+    # Do one final pass over file
+
+    # make sure that didn't end up with {" or }" after the substitution
+    filecont2 = filecont2.replace('{"','{{')
+    filecont2 = filecont2.replace('"}','}}')
+
+    afterquotevalue_rex = re.compile('"\s*,\s*')
+    afterbrace_rex = re.compile('"\s*}')
+    afterbracevalue_rex = re.compile('(=\s*{[^=]*)},\s*')
+
+    # add new lines to data that changed because of abbreviation substitutions
+    filecont2 = afterquotevalue_rex.sub('",\n', filecont2)
+    filecont2 = afterbrace_rex.sub('"\n}', filecont2)
+    filecont2 = afterbracevalue_rex.sub('\g<1>},\n', filecont2)
+
+    return filecont2
+
+#
+# convert @type( ... ) to @type{ ... }
+#
+def no_outer_parens(filecont):
+
+    # do checking for open parens
+    # will convert to braces
+    paren_split = re.split('([(){}])',filecont)
+
+    open_paren_count = 0
+    open_type = 0
+    look_next = 0
+
+    # rebuild filecont
+    filecont = ''
+
+    at_rex = re.compile('@\w*')
+
+    for phrase in paren_split:
+        if look_next == 1:
+            if phrase == '(':
+                phrase = '{'
+                open_paren_count = open_paren_count + 1
+            else:
+                open_type = 0
+            look_next = 0
+
+        if phrase == '(':
+            open_paren_count = open_paren_count + 1
+
+        elif phrase == ')':
+            open_paren_count = open_paren_count - 1
+            if open_type == 1 and open_paren_count == 0:
+                phrase = '}'
+                open_type = 0
+
+        elif at_rex.search( phrase ):
+            open_type = 1
+            look_next = 1
+
+        filecont = filecont + phrase
+
+    return filecont
+
+
+#
+# make all whitespace into just one space
+# format the bibtex file into a usable form.
+#
+def bibtexwasher(filecont_source):
+
+    space_rex = re.compile('\s+')
+    comment_rex = re.compile('\s*%')
+
+    filecont = []
+
+    # remove trailing and excessive whitespace
+    # ignore comments
+    for line in filecont_source:
+        line = string.strip(line)
+        line = space_rex.sub(' ', line)
+        # ignore comments
+        if not comment_rex.match(line) and line != '':
+            filecont.append(' '+ line)
+
+    filecont = string.join(filecont, '')
+
+    # the file is in one long string
+
+    filecont = no_outer_parens(filecont)
+
+    #
+    # split lines according to preferred syntax scheme
+    #
+    filecont = re.sub('(=\s*{[^=]*)},', '\g<1>},\n', filecont)
+
+    # add new lines after commas that are after values
+    filecont = re.sub('"\s*,', '",\n', filecont)
+    filecont = re.sub('=\s*([\w\d]+)\s*,', '= \g<1>,\n', filecont)
+    filecont = re.sub('(@\w*)\s*({(\s*)[^,\s]*)\s*,',
+                          '\n\n\g<1>\g<2>,\n', filecont)
+
+    # add new lines after }
+    filecont = re.sub('"\s*}','"\n}\n', filecont)
+    filecont = re.sub('}\s*,','},\n', filecont)
+
+
+    filecont = re.sub('@(\w*)', '\n@\g<1>', filecont)
+
+    # character encoding, reserved latex characters
+    filecont = re.sub('{\\\&}', '&', filecont)
+    filecont = re.sub('\\\&', '&', filecont)
+
+    # do checking for open braces to get format correct
+    open_brace_count = 0
+    brace_split = re.split('([{}])',filecont)
+
+    # rebuild filecont
+    filecont = ''
+
+    for phrase in brace_split:
+        if phrase == '{':
+            open_brace_count = open_brace_count + 1
+        elif phrase == '}':
+            open_brace_count = open_brace_count - 1
+            if open_brace_count == 0:
+                filecont = filecont + '\n'
+
+        filecont = filecont + phrase
+
+    filecont2 = bibtex_replace_abbreviations(filecont)
+
+    # gather
+    filecont = filecont2.splitlines()
+    i=0
+    j=0         # count the number of blank lines
+    for line in filecont:
+        # ignore blank lines
+        if line == '' or line == ' ':
+            j = j+1
+            continue
+        filecont[i] = line + '\n'
+        i = i+1
+
+    # get rid of the extra stuff at the end of the array
+    # (The extra stuff are duplicates that are in the array because
+    # blank lines were removed.)
+    length = len( filecont)
+    filecont[length-j:length] = []
+
+    return filecont
+
+
+def filehandler(filepath):
+    try:
+        fd = open(filepath, 'r')
+        filecont_source = fd.readlines()
+        fd.close()
+    except:
+        print 'Could not open file:', filepath
+    washeddata = bibtexwasher(filecont_source)
+    outdata = bibtexdecoder(washeddata)
+    print '/**'
+    print '\page references References'
+    print
+    for line in outdata:
+        print line
+    print '*/'
+
+
+# main program
+
+def main():
+    import sys
+    if sys.argv[1:]:
+        filepath = sys.argv[1]
+    else:
+        print "No input file"
+        sys.exit()
+    filehandler(filepath)
+
+if __name__ == "__main__": main()
+
+
+# end python script
Index: scripts/bootstrap.sh
===================================================================
--- scripts/bootstrap.sh	(revision 841)
+++ scripts/bootstrap.sh	(revision 841)
@@ -0,0 +1,142 @@
+#!/bin/bash
+#
+# This file is a part of LEMON, a generic C++ optimization library.
+#
+# Copyright (C) 2003-2009
+# Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
+# (Egervary Research Group on Combinatorial Optimization, EGRES).
+#
+# 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.
+
+
+if [ ! -f ~/.lemon-bootstrap ]; then
+    echo 'Create ~/.lemon-bootstrap'.
+    cat >~/.lemon-bootstrap <<EOF
+#
+# Default settings for bootstraping the LEMON source code repository
+#
+EOF
+fi
+
+source ~/.lemon-bootstrap
+if [ -f ../../../.lemon-bootstrap ]; then source ../../../.lemon-bootstrap; fi
+if [ -f ../../.lemon-bootstrap ]; then source ../../.lemon-bootstrap; fi
+if [ -f ../.lemon-bootstrap ]; then source ../.lemon-bootstrap; fi
+if [ -f ./.lemon-bootstrap ]; then source ./.lemon-bootstrap; fi
+
+
+function augment_config() { 
+    if [ "x${!1}" == "x" ]; then
+        eval $1=$2
+        echo Add "'$1'" to '~/.lemon-bootstrap'.
+        echo >>~/.lemon-bootstrap
+        echo $3 >>~/.lemon-bootstrap
+        echo $1=$2 >>~/.lemon-bootstrap
+    fi
+}
+
+augment_config LEMON_INSTALL_PREFIX /usr/local \
+    "# LEMON installation prefix"
+
+augment_config COIN_OR_PREFIX /usr/local/coin-or \
+    "# COIN-OR installation root prefix (used for CLP/CBC)"
+
+augment_config SOPLEX_PREFIX /usr/local/soplex \
+    "# Soplex build prefix"
+
+
+function ask() {
+echo -n "$1 [$2]? "
+read _an
+if [ "x$_an" == "x" ]; then
+    ret="$2"
+else
+    ret=$_an
+fi
+}
+
+function yesorno() {
+    ret='rossz'
+    while [ "$ret" != "y" -a "$ret" != "n" -a "$ret" != "yes" -a "$ret" != "no" ]; do
+        ask "$1" "$2"
+    done
+    if [ "$ret" != "y" -a "$ret" != "yes" ]; then
+        return 1
+    else
+        return 0
+    fi
+}
+
+if yesorno "External build" "n"
+then
+    CONFIGURE_PATH=".."
+else
+    CONFIGURE_PATH="."
+    if yesorno "Autoreconf" "y"
+    then
+        AUTORE=yes
+    else
+        AUTORE=no
+    fi
+fi
+
+if yesorno "Optimize" "n" 
+then
+    opt_flags=' -O2'
+else
+    opt_flags=''
+fi
+
+if yesorno "Stop on warning" "y" 
+then
+    werror_flags=' -Werror'
+else
+    werror_flags=''
+fi
+
+cxx_flags="CXXFLAGS=-ggdb$opt_flags$werror_flags"
+
+if yesorno "Check with valgrind" "n" 
+then
+    valgrind_flags=' --enable-valgrind'
+else
+    valgrind_flags=''
+fi
+
+if [ -f ${COIN_OR_PREFIX}/include/coin/config_coinutils.h ]; then
+    if yesorno "Use COIN-OR (CBC/CLP)" "n"
+    then
+        coin_flag="--with-coin=$COIN_OR_PREFIX"
+    else
+        coin_flag=""
+    fi
+else
+    coin_flag=""        
+fi
+
+if [ -f ${SOPLEX_PREFIX}/src/soplex.h ]; then
+    if yesorno "Use Soplex" "n"
+    then
+        soplex_flag="--with-soplex=$SOPLEX_PREFIX"
+    else
+        soplex_flag=""
+    fi
+else
+    soplex_flag=""
+fi
+
+if [ "x$AUTORE" == "xyes" ]; then
+    autoreconf -vif;
+fi
+${CONFIGURE_PATH}/configure --prefix=$LEMON_INSTALL_PREFIX \
+$valgrind_flags \
+"$cxx_flags" \
+$coin_flag \
+$soplex_flag \
+$*
Index: scripts/chg-len.py
===================================================================
--- scripts/chg-len.py	(revision 780)
+++ scripts/chg-len.py	(revision 780)
@@ -0,0 +1,46 @@
+#! /usr/bin/env python
+#
+# This file is a part of LEMON, a generic C++ optimization library.
+#
+# Copyright (C) 2003-2009
+# Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
+# (Egervary Research Group on Combinatorial Optimization, EGRES).
+#
+# 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.
+
+import sys
+
+from mercurial import ui, hg
+from mercurial import util
+
+util.rcpath = lambda : []
+
+if len(sys.argv)>1 and sys.argv[1] in ["-h","--help"]:
+    print """
+This utility just prints the length of the longest path
+in the revision graph from revison 0 to the current one.
+"""
+    exit(0)
+
+u = ui.ui()
+r = hg.repository(u, ".")
+N = r.changectx(".").rev()
+lengths=[0]*(N+1)
+for i in range(N+1):
+    p=r.changectx(i).parents()
+    if p[0]:
+        p0=lengths[p[0].rev()]
+    else:
+        p0=-1
+    if len(p)>1 and p[1]:
+        p1=lengths[p[1].rev()]
+    else:
+        p1=-1
+    lengths[i]=max(p0,p1)+1
+print lengths[N]
Index: scripts/mk-release.sh
===================================================================
--- scripts/mk-release.sh	(revision 780)
+++ scripts/mk-release.sh	(revision 780)
@@ -0,0 +1,49 @@
+#!/bin/bash
+#
+# This file is a part of LEMON, a generic C++ optimization library.
+#
+# Copyright (C) 2003-2009
+# Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
+# (Egervary Research Group on Combinatorial Optimization, EGRES).
+#
+# 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.
+
+set -e
+
+if [ $# = 0 ]; then
+    echo "Usage: $0 release-id"
+    exit 1
+else
+    export LEMON_VERSION=$1
+fi
+
+echo '*****************************************************************'
+echo ' Start making release tarballs for version '${LEMON_VERSION}
+echo '*****************************************************************'
+
+autoreconf -vif
+./configure
+
+make
+make html
+make distcheck
+tar xf lemon-${LEMON_VERSION}.tar.gz
+zip -r lemon-${LEMON_VERSION}.zip lemon-${LEMON_VERSION}
+mv lemon-${LEMON_VERSION}/doc/html lemon-doc-${LEMON_VERSION}
+tar czf lemon-doc-${LEMON_VERSION}.tar.gz lemon-doc-${LEMON_VERSION}
+zip -r lemon-doc-${LEMON_VERSION}.zip lemon-doc-${LEMON_VERSION}
+tar czf lemon-nodoc-${LEMON_VERSION}.tar.gz lemon-${LEMON_VERSION}
+zip -r lemon-nodoc-${LEMON_VERSION}.zip lemon-${LEMON_VERSION}
+hg tag -m 'LEMON '${LEMON_VERSION}' released ('$(hg par --template="{node|short}")' tagged as r'${LEMON_VERSION}')' r${LEMON_VERSION}
+
+rm -rf lemon-${LEMON_VERSION} lemon-doc-${LEMON_VERSION}
+
+echo '*****************************************************************'
+echo '  Release '${LEMON_VERSION}' has been created' 
+echo '*****************************************************************'
Index: test/CMakeLists.txt
===================================================================
--- test/CMakeLists.txt	(revision 1350)
+++ test/CMakeLists.txt	(revision 863)
@@ -8,14 +8,8 @@
 )
 
-SET(TEST_WITH_VALGRIND "NO" CACHE STRING
-  "Run the test with valgrind (YES/NO).")
-SET(VALGRIND_FLAGS "" CACHE STRING "Valgrind flags used by the tests.")
-
 SET(TESTS
   adaptors_test
-  arc_look_up_test
   bellman_ford_test
   bfs_test
-  bpgraph_test
   circulation_test
   connectivity_test
@@ -28,5 +22,4 @@
   error_test
   euler_test
-  fractional_matching_test
   gomory_hu_test
   graph_copy_test
@@ -36,33 +29,21 @@
   heap_test
   kruskal_test
-  lgf_reader_writer_test
-  lgf_test
   maps_test
   matching_test
-  max_cardinality_search_test
-  max_clique_test
-  max_flow_test
   min_cost_arborescence_test
   min_cost_flow_test
   min_mean_cycle_test
-  nagamochi_ibaraki_test
   path_test
   planarity_test
+  preflow_test
   radix_sort_test
   random_test
   suurballe_test
   time_measure_test
-  tsp_test
   unionfind_test
-  vf2_test
 )
 
 IF(LEMON_HAVE_LP)
-  IF(${CMAKE_BUILD_TYPE} STREQUAL "Maintainer")
-    ADD_EXECUTABLE(lp_test lp_test.cc)
-  ELSE()
-    ADD_EXECUTABLE(lp_test EXCLUDE_FROM_ALL lp_test.cc)
-  ENDIF()
-
+  ADD_EXECUTABLE(lp_test lp_test.cc)
   SET(LP_TEST_LIBS lemon)
 
@@ -71,16 +52,12 @@
   ENDIF()
   IF(LEMON_HAVE_CPLEX)
-    SET(LP_TEST_LIBS ${LP_TEST_LIBS} ${ILOG_LIBRARIES})
+    SET(LP_TEST_LIBS ${LP_TEST_LIBS} ${CPLEX_LIBRARIES})
   ENDIF()
   IF(LEMON_HAVE_CLP)
     SET(LP_TEST_LIBS ${LP_TEST_LIBS} ${COIN_CLP_LIBRARIES})
   ENDIF()
-  IF(LEMON_HAVE_SOPLEX)
-    SET(LP_TEST_LIBS ${LP_TEST_LIBS} ${SOPLEX_LIBRARIES})
-  ENDIF()
 
   TARGET_LINK_LIBRARIES(lp_test ${LP_TEST_LIBS})
   ADD_TEST(lp_test lp_test)
-  ADD_DEPENDENCIES(check lp_test)
 
   IF(WIN32 AND LEMON_HAVE_GLPK)
@@ -98,5 +75,5 @@
     GET_FILENAME_COMPONENT(TARGET_PATH ${TARGET_LOC} PATH)
     ADD_CUSTOM_COMMAND(TARGET lp_test POST_BUILD
-      COMMAND ${CMAKE_COMMAND} -E copy ${ILOG_CPLEX_DLL} ${TARGET_PATH}
+      COMMAND ${CMAKE_COMMAND} -E copy ${CPLEX_BIN_DIR}/cplex91.dll ${TARGET_PATH}
     )
   ENDIF()
@@ -104,10 +81,5 @@
 
 IF(LEMON_HAVE_MIP)
-  IF(${CMAKE_BUILD_TYPE} STREQUAL "Maintainer")
-    ADD_EXECUTABLE(mip_test mip_test.cc)
-  ELSE()
-    ADD_EXECUTABLE(mip_test EXCLUDE_FROM_ALL mip_test.cc)
-  ENDIF()
-
+  ADD_EXECUTABLE(mip_test mip_test.cc)
   SET(MIP_TEST_LIBS lemon)
 
@@ -116,5 +88,5 @@
   ENDIF()
   IF(LEMON_HAVE_CPLEX)
-    SET(MIP_TEST_LIBS ${MIP_TEST_LIBS} ${ILOG_LIBRARIES})
+    SET(MIP_TEST_LIBS ${MIP_TEST_LIBS} ${CPLEX_LIBRARIES})
   ENDIF()
   IF(LEMON_HAVE_CBC)
@@ -124,5 +96,4 @@
   TARGET_LINK_LIBRARIES(mip_test ${MIP_TEST_LIBS})
   ADD_TEST(mip_test mip_test)
-  ADD_DEPENDENCIES(check mip_test)
 
   IF(WIN32 AND LEMON_HAVE_GLPK)
@@ -140,5 +111,5 @@
     GET_FILENAME_COMPONENT(TARGET_PATH ${TARGET_LOC} PATH)
     ADD_CUSTOM_COMMAND(TARGET mip_test POST_BUILD
-      COMMAND ${CMAKE_COMMAND} -E copy ${ILOG_CPLEX_DLL} ${TARGET_PATH}
+      COMMAND ${CMAKE_COMMAND} -E copy ${CPLEX_BIN_DIR}/cplex91.dll ${TARGET_PATH}
     )
   ENDIF()
@@ -146,17 +117,6 @@
 
 FOREACH(TEST_NAME ${TESTS})
-  IF(${CMAKE_BUILD_TYPE} STREQUAL "Maintainer")
-    ADD_EXECUTABLE(${TEST_NAME} ${TEST_NAME}.cc)
-  ELSE()
-    ADD_EXECUTABLE(${TEST_NAME} EXCLUDE_FROM_ALL ${TEST_NAME}.cc)
-  ENDIF()
+  ADD_EXECUTABLE(${TEST_NAME} ${TEST_NAME}.cc)
   TARGET_LINK_LIBRARIES(${TEST_NAME} lemon)
-    IF(TEST_WITH_VALGRIND)
-      ADD_TEST(${TEST_NAME}
-        valgrind --error-exitcode=1 ${VALGRIND_FLAGS}
-        ${CMAKE_CURRENT_BINARY_DIR}/${TEST_NAME} )
-    ELSE()
-      ADD_TEST(${TEST_NAME} ${TEST_NAME})
-    ENDIF()
-  ADD_DEPENDENCIES(check ${TEST_NAME})
+  ADD_TEST(${TEST_NAME} ${TEST_NAME})
 ENDFOREACH()
Index: test/Makefile.am
===================================================================
--- test/Makefile.am	(revision 863)
+++ test/Makefile.am	(revision 863)
@@ -0,0 +1,97 @@
+if USE_VALGRIND
+TESTS_ENVIRONMENT=$(top_srcdir)/scripts/valgrind-wrapper.sh
+endif
+
+EXTRA_DIST += \
+	test/CMakeLists.txt
+
+noinst_HEADERS += \
+	test/graph_test.h \
+	test/test_tools.h
+
+check_PROGRAMS += \
+	test/adaptors_test \
+	test/bellman_ford_test \
+	test/bfs_test \
+	test/circulation_test \
+	test/connectivity_test \
+	test/counter_test \
+	test/dfs_test \
+	test/digraph_test \
+	test/dijkstra_test \
+	test/dim_test \
+	test/edge_set_test \
+	test/error_test \
+	test/euler_test \
+	test/gomory_hu_test \
+	test/graph_copy_test \
+	test/graph_test \
+	test/graph_utils_test \
+	test/hao_orlin_test \
+	test/heap_test \
+	test/kruskal_test \
+	test/maps_test \
+	test/matching_test \
+	test/min_cost_arborescence_test \
+	test/min_cost_flow_test \
+	test/min_mean_cycle_test \
+	test/path_test \
+	test/planarity_test \
+	test/preflow_test \
+	test/radix_sort_test \
+	test/random_test \
+	test/suurballe_test \
+	test/test_tools_fail \
+	test/test_tools_pass \
+	test/time_measure_test \
+	test/unionfind_test
+
+test_test_tools_pass_DEPENDENCIES = demo
+
+if HAVE_LP
+check_PROGRAMS += test/lp_test
+endif HAVE_LP
+if HAVE_MIP
+check_PROGRAMS += test/mip_test
+endif HAVE_MIP
+
+TESTS += $(check_PROGRAMS)
+XFAIL_TESTS += test/test_tools_fail$(EXEEXT)
+
+test_adaptors_test_SOURCES = test/adaptors_test.cc
+test_bellman_ford_test_SOURCES = test/bellman_ford_test.cc
+test_bfs_test_SOURCES = test/bfs_test.cc
+test_circulation_test_SOURCES = test/circulation_test.cc
+test_counter_test_SOURCES = test/counter_test.cc
+test_connectivity_test_SOURCES = test/connectivity_test.cc
+test_dfs_test_SOURCES = test/dfs_test.cc
+test_digraph_test_SOURCES = test/digraph_test.cc
+test_dijkstra_test_SOURCES = test/dijkstra_test.cc
+test_dim_test_SOURCES = test/dim_test.cc
+test_edge_set_test_SOURCES = test/edge_set_test.cc
+test_error_test_SOURCES = test/error_test.cc
+test_euler_test_SOURCES = test/euler_test.cc
+test_gomory_hu_test_SOURCES = test/gomory_hu_test.cc
+test_graph_copy_test_SOURCES = test/graph_copy_test.cc
+test_graph_test_SOURCES = test/graph_test.cc
+test_graph_utils_test_SOURCES = test/graph_utils_test.cc
+test_heap_test_SOURCES = test/heap_test.cc
+test_kruskal_test_SOURCES = test/kruskal_test.cc
+test_hao_orlin_test_SOURCES = test/hao_orlin_test.cc
+test_lp_test_SOURCES = test/lp_test.cc
+test_maps_test_SOURCES = test/maps_test.cc
+test_mip_test_SOURCES = test/mip_test.cc
+test_matching_test_SOURCES = test/matching_test.cc
+test_min_cost_arborescence_test_SOURCES = test/min_cost_arborescence_test.cc
+test_min_cost_flow_test_SOURCES = test/min_cost_flow_test.cc
+test_min_mean_cycle_test_SOURCES = test/min_mean_cycle_test.cc
+test_path_test_SOURCES = test/path_test.cc
+test_planarity_test_SOURCES = test/planarity_test.cc
+test_preflow_test_SOURCES = test/preflow_test.cc
+test_radix_sort_test_SOURCES = test/radix_sort_test.cc
+test_suurballe_test_SOURCES = test/suurballe_test.cc
+test_random_test_SOURCES = test/random_test.cc
+test_test_tools_fail_SOURCES = test/test_tools_fail.cc
+test_test_tools_pass_SOURCES = test/test_tools_pass.cc
+test_time_measure_test_SOURCES = test/time_measure_test.cc
+test_unionfind_test_SOURCES = test/unionfind_test.cc
Index: test/adaptors_test.cc
===================================================================
--- test/adaptors_test.cc	(revision 1270)
+++ test/adaptors_test.cc	(revision 550)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -66,5 +66,4 @@
   Digraph::Arc a2 = digraph.addArc(n1, n3);
   Digraph::Arc a3 = digraph.addArc(n2, n3);
-  ::lemon::ignore_unused_variable_warning(a3);
 
   // Check the adaptor
@@ -101,5 +100,4 @@
   Adaptor::Arc a7 = adaptor.addArc(n1, n4);
   Adaptor::Arc a8 = adaptor.addArc(n1, n2);
-  ::lemon::ignore_unused_variable_warning(a6,a7,a8);
 
   adaptor.erase(a1);
@@ -761,5 +759,4 @@
   Digraph::Arc a2 = digraph.addArc(n1, n3);
   Digraph::Arc a3 = digraph.addArc(n2, n3);
-  ::lemon::ignore_unused_variable_warning(a1,a2,a3);
 
   checkGraphNodeList(adaptor, 6);
@@ -1381,13 +1378,11 @@
 
   // Apply several adaptors on the grid graph
-  typedef Orienter< const GridGraph, GridGraph::EdgeMap<bool> >
-    OrientedGridGraph;
-  typedef SplitNodes<OrientedGridGraph> SplitGridGraph;
+  typedef SplitNodes<Orienter< const GridGraph, GridGraph::EdgeMap<bool> > >
+    SplitGridGraph;
   typedef Undirector<const SplitGridGraph> USplitGridGraph;
   checkConcept<concepts::Digraph, SplitGridGraph>();
   checkConcept<concepts::Graph, USplitGridGraph>();
 
-  OrientedGridGraph oadaptor = orienter(graph, dir_map);
-  SplitGridGraph adaptor = splitNodes(oadaptor);
+  SplitGridGraph adaptor = splitNodes(orienter(graph, dir_map));
   USplitGridGraph uadaptor = undirector(adaptor);
 
Index: st/arc_look_up_test.cc
===================================================================
--- test/arc_look_up_test.cc	(revision 1312)
+++ 	(revision )
@@ -1,84 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2013
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * 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 <iostream>
-#include "lemon/list_graph.h"
-#include "lemon/lgf_reader.h"
-
-#include "test_tools.h"
-
-using namespace lemon;
-
-const std::string lgf =
-  "@nodes\n"
-"label\n"
-"0\n"
-"1\n"
-"2\n"
-"3\n"
-"4\n"
-"5\n"
-"6\n"
-"@arcs\n"
-"label\n"
-"5 6 0\n"
-"5 4 1\n"
-"4 6 2\n"
-"3 4 3\n"
-"3 4 4\n"
-"3 2 5\n"
-"3 5 6\n"
-"3 5 7\n"
-"3 5 8\n"
-"3 5 9\n"
-"2 4 10\n"
-"2 4 11\n"
-"2 4 12\n"
-"2 4 13\n"
-"1 2 14\n"
-"1 2 15\n"
-"1 0 16\n"
-"1 3 17\n"
-"1 3 18\n"
-"1 3 19\n"
-"1 3 20\n"
-"0 2 21\n"
-"0 2 22\n"
-"0 2 23\n"
-"0 2 24\n";
-
-
-int main() {
-  ListDigraph graph;
-  std::istringstream lgfs(lgf);
-  DigraphReader<ListDigraph>(graph, lgfs).run();
-
-  AllArcLookUp<ListDigraph> lookup(graph);
-
-  int numArcs = countArcs(graph);
-
-  int arcCnt = 0;
-  for(ListDigraph::NodeIt n1(graph); n1 != INVALID; ++n1)
-    for(ListDigraph::NodeIt n2(graph); n2 != INVALID; ++n2)
-      for(ListDigraph::Arc a = lookup(n1, n2); a != INVALID;
-          a = lookup(n1, n2, a))
-        ++arcCnt;
-  check(arcCnt==numArcs, "Wrong total number of arcs");
-
-  return 0;
-}
Index: test/bellman_ford_test.cc
===================================================================
--- test/bellman_ford_test.cc	(revision 1337)
+++ test/bellman_ford_test.cc	(revision 838)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -66,8 +66,6 @@
   Arc e;
   Value l;
-  ::lemon::ignore_unused_variable_warning(l);
   int k=3;
   bool b;
-  ::lemon::ignore_unused_variable_warning(b);
   BF::DistMap d(gr);
   BF::PredMap p(gr);
@@ -100,10 +98,6 @@
     pp = const_bf_test.path(t);
     pp = const_bf_test.negativeCycle();
-
+    
     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);
-    }
   }
   {
@@ -116,5 +110,5 @@
     concepts::ReadWriteMap<Node,Arc> pred_map;
     concepts::ReadWriteMap<Node,Value> dist_map;
-
+    
     bf_test
       .lengthMap(length_map)
@@ -154,6 +148,4 @@
   Digraph g;
   bool b;
-  ::lemon::ignore_unused_variable_warning(b);
-
   bellmanFord(g,LengthMap()).run(Node());
   b = bellmanFord(g,LengthMap()).run(Node(),Node());
@@ -197,7 +189,7 @@
   check(pathSource(gr, p) == s, "path() found a wrong path.");
   check(pathTarget(gr, p) == t, "path() found a wrong path.");
-
+  
   ListPath<Digraph> path;
-  Value dist = 0;
+  Value dist;
   bool reached = bellmanFord(gr,length).path(path).dist(dist).run(s,t);
 
@@ -236,16 +228,16 @@
   SmartDigraph gr;
   IntArcMap length(gr);
-
+  
   Node n1 = gr.addNode();
   Node n2 = gr.addNode();
   Node n3 = gr.addNode();
   Node n4 = gr.addNode();
-
+  
   Arc a1 = gr.addArc(n1, n2);
   Arc a2 = gr.addArc(n2, n2);
-
+  
   length[a1] = 2;
   length[a2] = -1;
-
+  
   {
     BellmanFord<SmartDigraph, IntArcMap> bf(gr, length);
@@ -255,7 +247,7 @@
           "Wrong negative cycle.");
   }
-
+ 
   length[a2] = 0;
-
+  
   {
     BellmanFord<SmartDigraph, IntArcMap> bf(gr, length);
@@ -264,10 +256,10 @@
           "Negative cycle should not be found.");
   }
-
+  
   length[gr.addArc(n1, n3)] = 5;
   length[gr.addArc(n4, n3)] = 1;
   length[gr.addArc(n2, n4)] = 2;
   length[gr.addArc(n3, n2)] = -4;
-
+  
   {
     BellmanFord<SmartDigraph, IntArcMap> bf(gr, length);
Index: test/bfs_test.cc
===================================================================
--- test/bfs_test.cc	(revision 1270)
+++ test/bfs_test.cc	(revision 632)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -62,5 +62,4 @@
   Arc e;
   int l, i;
-  ::lemon::ignore_unused_variable_warning(l,i);
   bool b;
   BType::DistMap d(G);
@@ -85,5 +84,5 @@
     b = const_bfs_test.emptyQueue();
     i = const_bfs_test.queueSize();
-
+    
     bfs_test.start();
     bfs_test.start(t);
@@ -106,10 +105,10 @@
       ::SetProcessedMap<concepts::WriteMap<Node,bool> >
       ::Create bfs_test(G);
-
+      
     concepts::ReadWriteMap<Node,Arc> pred_map;
     concepts::ReadWriteMap<Node,int> dist_map;
     concepts::ReadWriteMap<Node,bool> reached_map;
     concepts::WriteMap<Node,bool> processed_map;
-
+    
     bfs_test
       .predMap(pred_map)
@@ -121,5 +120,5 @@
     bfs_test.run(s,t);
     bfs_test.run();
-
+    
     bfs_test.init();
     bfs_test.addSource(s);
@@ -130,5 +129,5 @@
     b = bfs_test.emptyQueue();
     i = bfs_test.queueSize();
-
+    
     bfs_test.start();
     bfs_test.start(t);
@@ -152,6 +151,4 @@
   Digraph g;
   bool b;
-  ::lemon::ignore_unused_variable_warning(b);
-
   bfs(g).run(Node());
   b=bfs(g).run(Node(),Node());
Index: st/bpgraph_test.cc
===================================================================
--- test/bpgraph_test.cc	(revision 1292)
+++ 	(revision )
@@ -1,456 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2013
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * 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/concepts/bpgraph.h>
-#include <lemon/list_graph.h>
-#include <lemon/smart_graph.h>
-#include <lemon/full_graph.h>
-
-#include "test_tools.h"
-#include "graph_test.h"
-
-using namespace lemon;
-using namespace lemon::concepts;
-
-template <class BpGraph>
-void checkBpGraphBuild() {
-  TEMPLATE_BPGRAPH_TYPEDEFS(BpGraph);
-
-  BpGraph G;
-  checkGraphNodeList(G, 0);
-  checkGraphRedNodeList(G, 0);
-  checkGraphBlueNodeList(G, 0);
-  checkGraphEdgeList(G, 0);
-  checkGraphArcList(G, 0);
-
-  G.reserveNode(3);
-  G.reserveEdge(3);
-
-  RedNode
-    rn1 = G.addRedNode();
-  checkGraphNodeList(G, 1);
-  checkGraphRedNodeList(G, 1);
-  checkGraphBlueNodeList(G, 0);
-  checkGraphEdgeList(G, 0);
-  checkGraphArcList(G, 0);
-
-  BlueNode
-    bn1 = G.addBlueNode(),
-    bn2 = G.addBlueNode();
-  checkGraphNodeList(G, 3);
-  checkGraphRedNodeList(G, 1);
-  checkGraphBlueNodeList(G, 2);
-  checkGraphEdgeList(G, 0);
-  checkGraphArcList(G, 0);
-
-  Edge e1 = G.addEdge(rn1, bn2);
-  check(G.redNode(e1) == rn1 && G.blueNode(e1) == bn2, "Wrong edge");
-  check(G.u(e1) == rn1 && G.v(e1) == bn2, "Wrong edge");
-
-  checkGraphNodeList(G, 3);
-  checkGraphRedNodeList(G, 1);
-  checkGraphBlueNodeList(G, 2);
-  checkGraphEdgeList(G, 1);
-  checkGraphArcList(G, 2);
-
-  checkGraphIncEdgeArcLists(G, rn1, 1);
-  checkGraphIncEdgeArcLists(G, bn1, 0);
-  checkGraphIncEdgeArcLists(G, bn2, 1);
-
-  checkGraphConEdgeList(G, 1);
-  checkGraphConArcList(G, 2);
-
-  Edge
-    e2 = G.addEdge(bn1, rn1),
-    e3 = G.addEdge(rn1, bn2);
-  ::lemon::ignore_unused_variable_warning(e2,e3);
-
-  checkGraphNodeList(G, 3);
-  checkGraphRedNodeList(G, 1);
-  checkGraphBlueNodeList(G, 2);
-  checkGraphEdgeList(G, 3);
-  checkGraphArcList(G, 6);
-
-  checkGraphIncEdgeArcLists(G, rn1, 3);
-  checkGraphIncEdgeArcLists(G, bn1, 1);
-  checkGraphIncEdgeArcLists(G, bn2, 2);
-
-  checkGraphConEdgeList(G, 3);
-  checkGraphConArcList(G, 6);
-
-  checkArcDirections(G);
-
-  checkNodeIds(G);
-  checkRedNodeIds(G);
-  checkBlueNodeIds(G);
-  checkArcIds(G);
-  checkEdgeIds(G);
-
-  checkGraphNodeMap(G);
-  checkGraphRedNodeMap(G);
-  checkGraphBlueNodeMap(G);
-  checkGraphArcMap(G);
-  checkGraphEdgeMap(G);
-}
-
-template <class BpGraph>
-void checkBpGraphErase() {
-  TEMPLATE_BPGRAPH_TYPEDEFS(BpGraph);
-
-  BpGraph G;
-  RedNode
-    n1 = G.addRedNode(), n4 = G.addRedNode();
-  BlueNode
-    n2 = G.addBlueNode(), n3 = G.addBlueNode();
-  Edge
-    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
-  G.erase(e2);
-
-  checkGraphNodeList(G, 4);
-  checkGraphRedNodeList(G, 2);
-  checkGraphBlueNodeList(G, 2);
-  checkGraphEdgeList(G, 3);
-  checkGraphArcList(G, 6);
-
-  checkGraphIncEdgeArcLists(G, n1, 1);
-  checkGraphIncEdgeArcLists(G, n2, 2);
-  checkGraphIncEdgeArcLists(G, n3, 1);
-  checkGraphIncEdgeArcLists(G, n4, 2);
-
-  checkGraphConEdgeList(G, 3);
-  checkGraphConArcList(G, 6);
-
-  // Check node deletion
-  G.erase(n3);
-
-  checkGraphNodeList(G, 3);
-  checkGraphRedNodeList(G, 2);
-  checkGraphBlueNodeList(G, 1);
-  checkGraphEdgeList(G, 2);
-  checkGraphArcList(G, 4);
-
-  checkGraphIncEdgeArcLists(G, n1, 1);
-  checkGraphIncEdgeArcLists(G, n2, 2);
-  checkGraphIncEdgeArcLists(G, n4, 1);
-
-  checkGraphConEdgeList(G, 2);
-  checkGraphConArcList(G, 4);
-
-}
-
-template <class BpGraph>
-void checkBpGraphAlter() {
-  TEMPLATE_BPGRAPH_TYPEDEFS(BpGraph);
-
-  BpGraph G;
-  RedNode
-    n1 = G.addRedNode(), n4 = G.addRedNode();
-  BlueNode
-    n2 = G.addBlueNode(), n3 = G.addBlueNode();
-  Edge
-    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);
-  check(G.redNode(e2) == n4, "Wrong red node");
-  check(G.blueNode(e2) == n3, "Wrong blue node");
-
-  checkGraphNodeList(G, 4);
-  checkGraphRedNodeList(G, 2);
-  checkGraphBlueNodeList(G, 2);
-  checkGraphEdgeList(G, 4);
-  checkGraphArcList(G, 8);
-
-  checkGraphIncEdgeArcLists(G, n1, 1);
-  checkGraphIncEdgeArcLists(G, n2, 2);
-  checkGraphIncEdgeArcLists(G, n3, 2);
-  checkGraphIncEdgeArcLists(G, n4, 3);
-
-  checkGraphConEdgeList(G, 4);
-  checkGraphConArcList(G, 8);
-
-  G.changeBlue(e2, n2);
-  check(G.redNode(e2) == n4, "Wrong red node");
-  check(G.blueNode(e2) == n2, "Wrong blue node");
-
-  checkGraphNodeList(G, 4);
-  checkGraphRedNodeList(G, 2);
-  checkGraphBlueNodeList(G, 2);
-  checkGraphEdgeList(G, 4);
-  checkGraphArcList(G, 8);
-
-  checkGraphIncEdgeArcLists(G, n1, 1);
-  checkGraphIncEdgeArcLists(G, n2, 3);
-  checkGraphIncEdgeArcLists(G, n3, 1);
-  checkGraphIncEdgeArcLists(G, n4, 3);
-
-  checkGraphConEdgeList(G, 4);
-  checkGraphConArcList(G, 8);
-}
-
-
-template <class BpGraph>
-void checkBpGraphSnapshot() {
-  TEMPLATE_BPGRAPH_TYPEDEFS(BpGraph);
-
-  BpGraph G;
-  RedNode
-    n1 = G.addRedNode();
-  BlueNode
-    n2 = G.addBlueNode(),
-    n3 = G.addBlueNode();
-  Edge
-    e1 = G.addEdge(n1, n2),
-    e2 = G.addEdge(n1, n3);
-  ::lemon::ignore_unused_variable_warning(e1,e2);
-
-  checkGraphNodeList(G, 3);
-  checkGraphRedNodeList(G, 1);
-  checkGraphBlueNodeList(G, 2);
-  checkGraphEdgeList(G, 2);
-  checkGraphArcList(G, 4);
-
-  typename BpGraph::Snapshot snapshot(G);
-
-  RedNode n4 = G.addRedNode();
-  G.addEdge(n4, n2);
-  G.addEdge(n4, n3);
-
-  checkGraphNodeList(G, 4);
-  checkGraphRedNodeList(G, 2);
-  checkGraphBlueNodeList(G, 2);
-  checkGraphEdgeList(G, 4);
-  checkGraphArcList(G, 8);
-
-  snapshot.restore();
-
-  checkGraphNodeList(G, 3);
-  checkGraphRedNodeList(G, 1);
-  checkGraphBlueNodeList(G, 2);
-  checkGraphEdgeList(G, 2);
-  checkGraphArcList(G, 4);
-
-  checkGraphIncEdgeArcLists(G, n1, 2);
-  checkGraphIncEdgeArcLists(G, n2, 1);
-  checkGraphIncEdgeArcLists(G, n3, 1);
-
-  checkGraphConEdgeList(G, 2);
-  checkGraphConArcList(G, 4);
-
-  checkNodeIds(G);
-  checkRedNodeIds(G);
-  checkBlueNodeIds(G);
-  checkArcIds(G);
-  checkEdgeIds(G);
-
-  checkGraphNodeMap(G);
-  checkGraphRedNodeMap(G);
-  checkGraphBlueNodeMap(G);
-  checkGraphArcMap(G);
-  checkGraphEdgeMap(G);
-
-  G.addRedNode();
-  snapshot.save(G);
-
-  G.addEdge(G.addRedNode(), G.addBlueNode());
-
-  snapshot.restore();
-  snapshot.save(G);
-
-  checkGraphNodeList(G, 4);
-  checkGraphRedNodeList(G, 2);
-  checkGraphBlueNodeList(G, 2);
-  checkGraphEdgeList(G, 2);
-  checkGraphArcList(G, 4);
-
-  G.addEdge(G.addRedNode(), G.addBlueNode());
-
-  snapshot.restore();
-
-  checkGraphNodeList(G, 4);
-  checkGraphRedNodeList(G, 2);
-  checkGraphBlueNodeList(G, 2);
-  checkGraphEdgeList(G, 2);
-  checkGraphArcList(G, 4);
-}
-
-template <typename BpGraph>
-void checkBpGraphValidity() {
-  TEMPLATE_BPGRAPH_TYPEDEFS(BpGraph);
-  BpGraph g;
-
-  RedNode
-    n1 = g.addRedNode();
-  BlueNode
-    n2 = g.addBlueNode(),
-    n3 = g.addBlueNode();
-
-  Edge
-    e1 = g.addEdge(n1, n2),
-    e2 = g.addEdge(n1, n3);
-  ::lemon::ignore_unused_variable_warning(e2);
-
-  check(g.valid(n1), "Wrong validity check");
-  check(g.valid(e1), "Wrong validity check");
-  check(g.valid(g.direct(e1, true)), "Wrong validity check");
-
-  check(!g.valid(g.nodeFromId(-1)), "Wrong validity check");
-  check(!g.valid(g.edgeFromId(-1)), "Wrong validity check");
-  check(!g.valid(g.arcFromId(-1)), "Wrong validity check");
-}
-
-void checkConcepts() {
-  { // Checking graph components
-    checkConcept<BaseBpGraphComponent, BaseBpGraphComponent >();
-
-    checkConcept<IDableBpGraphComponent<>,
-      IDableBpGraphComponent<> >();
-
-    checkConcept<IterableBpGraphComponent<>,
-      IterableBpGraphComponent<> >();
-
-    checkConcept<AlterableBpGraphComponent<>,
-      AlterableBpGraphComponent<> >();
-
-    checkConcept<MappableBpGraphComponent<>,
-      MappableBpGraphComponent<> >();
-
-    checkConcept<ExtendableBpGraphComponent<>,
-      ExtendableBpGraphComponent<> >();
-
-    checkConcept<ErasableBpGraphComponent<>,
-      ErasableBpGraphComponent<> >();
-
-    checkConcept<ClearableBpGraphComponent<>,
-      ClearableBpGraphComponent<> >();
-
-  }
-  { // Checking skeleton graph
-    checkConcept<BpGraph, BpGraph>();
-  }
-  { // Checking SmartBpGraph
-    checkConcept<BpGraph, SmartBpGraph>();
-    checkConcept<AlterableBpGraphComponent<>, SmartBpGraph>();
-    checkConcept<ExtendableBpGraphComponent<>, SmartBpGraph>();
-    checkConcept<ClearableBpGraphComponent<>, SmartBpGraph>();
-  }
-}
-
-void checkFullBpGraph(int redNum, int blueNum) {
-  typedef FullBpGraph BpGraph;
-  BPGRAPH_TYPEDEFS(BpGraph);
-
-  BpGraph G(redNum, blueNum);
-  checkGraphNodeList(G, redNum + blueNum);
-  checkGraphRedNodeList(G, redNum);
-  checkGraphBlueNodeList(G, blueNum);
-  checkGraphEdgeList(G, redNum * blueNum);
-  checkGraphArcList(G, 2 * redNum * blueNum);
-
-  G.resize(redNum, blueNum);
-  checkGraphNodeList(G, redNum + blueNum);
-  checkGraphRedNodeList(G, redNum);
-  checkGraphBlueNodeList(G, blueNum);
-  checkGraphEdgeList(G, redNum * blueNum);
-  checkGraphArcList(G, 2 * redNum * blueNum);
-
-  for (RedNodeIt n(G); n != INVALID; ++n) {
-    checkGraphOutArcList(G, n, blueNum);
-    checkGraphInArcList(G, n, blueNum);
-    checkGraphIncEdgeList(G, n, blueNum);
-  }
-
-  for (BlueNodeIt n(G); n != INVALID; ++n) {
-    checkGraphOutArcList(G, n, redNum);
-    checkGraphInArcList(G, n, redNum);
-    checkGraphIncEdgeList(G, n, redNum);
-  }
-
-  checkGraphConArcList(G, 2 * redNum * blueNum);
-  checkGraphConEdgeList(G, redNum * blueNum);
-
-  checkArcDirections(G);
-
-  checkNodeIds(G);
-  checkRedNodeIds(G);
-  checkBlueNodeIds(G);
-  checkArcIds(G);
-  checkEdgeIds(G);
-
-  checkGraphNodeMap(G);
-  checkGraphRedNodeMap(G);
-  checkGraphBlueNodeMap(G);
-  checkGraphArcMap(G);
-  checkGraphEdgeMap(G);
-
-  for (int i = 0; i < G.redNum(); ++i) {
-    check(G.red(G.redNode(i)), "Wrong node");
-    check(G.index(G.redNode(i)) == i, "Wrong index");
-  }
-
-  for (int i = 0; i < G.blueNum(); ++i) {
-    check(G.blue(G.blueNode(i)), "Wrong node");
-    check(G.index(G.blueNode(i)) == i, "Wrong index");
-  }
-
-  for (NodeIt u(G); u != INVALID; ++u) {
-    for (NodeIt v(G); v != INVALID; ++v) {
-      Edge e = G.edge(u, v);
-      Arc a = G.arc(u, v);
-      if (G.red(u) == G.red(v)) {
-        check(e == INVALID, "Wrong edge lookup");
-        check(a == INVALID, "Wrong arc lookup");
-      } else {
-        check((G.u(e) == u && G.v(e) == v) ||
-              (G.u(e) == v && G.v(e) == u), "Wrong edge lookup");
-        check(G.source(a) == u && G.target(a) == v, "Wrong arc lookup");
-      }
-    }
-  }
-
-}
-
-void checkGraphs() {
-  { // Checking ListGraph
-    checkBpGraphBuild<ListBpGraph>();
-    checkBpGraphErase<ListBpGraph>();
-    checkBpGraphAlter<ListBpGraph>();
-    checkBpGraphSnapshot<ListBpGraph>();
-    checkBpGraphValidity<ListBpGraph>();
-  }
-  { // Checking SmartGraph
-    checkBpGraphBuild<SmartBpGraph>();
-    checkBpGraphSnapshot<SmartBpGraph>();
-    checkBpGraphValidity<SmartBpGraph>();
-  }
-  { // Checking FullBpGraph
-    checkFullBpGraph(6, 8);
-    checkFullBpGraph(7, 4);
-  }
-}
-
-int main() {
-  checkConcepts();
-  checkGraphs();
-  return 0;
-}
Index: test/circulation_test.cc
===================================================================
--- test/circulation_test.cc	(revision 1270)
+++ test/circulation_test.cc	(revision 736)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -74,5 +74,4 @@
   VType v;
   bool b;
-  ::lemon::ignore_unused_variable_warning(v,b);
 
   typedef Circulation<Digraph, CapMap, CapMap, SupplyMap>
@@ -83,5 +82,5 @@
   CirculationType circ_test(g, lcap, ucap, supply);
   const CirculationType& const_circ_test = circ_test;
-
+   
   circ_test
     .lowerMap(lcap)
@@ -89,5 +88,5 @@
     .supplyMap(supply)
     .flowMap(flow);
-
+  
   const CirculationType::Elevator& elev = const_circ_test.elevator();
   circ_test.elevator(const_cast<CirculationType::Elevator&>(elev));
@@ -104,6 +103,6 @@
   b = const_circ_test.barrier(n);
   const_circ_test.barrierMap(bar);
-
-  ::lemon::ignore_unused_variable_warning(fm);
+  
+  ignore_unused_variable_warning(fm);
 }
 
Index: test/connectivity_test.cc
===================================================================
--- test/connectivity_test.cc	(revision 1270)
+++ test/connectivity_test.cc	(revision 696)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -30,10 +30,10 @@
   typedef ListDigraph Digraph;
   typedef Undirector<Digraph> Graph;
-
-  {
-    Digraph d;
-    Digraph::NodeMap<int> order(d);
-    Graph g(d);
-
+  
+  {
+    Digraph d;
+    Digraph::NodeMap<int> order(d);
+    Graph g(d);
+    
     check(stronglyConnected(d), "The empty digraph is strongly connected");
     check(countStronglyConnectedComponents(d) == 0,
@@ -49,5 +49,5 @@
     check(countBiEdgeConnectedComponents(g) == 0,
           "The empty graph has 0 bi-edge-connected component");
-
+          
     check(dag(d), "The empty digraph is DAG.");
     check(checkedTopologicalSort(d, order), "The empty digraph is DAG.");
@@ -69,5 +69,4 @@
     Graph g(d);
     Digraph::Node n = d.addNode();
-    ::lemon::ignore_unused_variable_warning(n);
 
     check(stronglyConnected(d), "This digraph is strongly connected");
@@ -84,5 +83,5 @@
     check(countBiEdgeConnectedComponents(g) == 1,
           "This graph has 1 bi-edge-connected component");
-
+          
     check(dag(d), "This digraph is DAG.");
     check(checkedTopologicalSort(d, order), "This digraph is DAG.");
@@ -100,25 +99,8 @@
 
   {
-    ListGraph g;
-    ListGraph::NodeMap<bool> map(g);
-
-    ListGraph::Node n1 = g.addNode();
-    ListGraph::Node n2 = g.addNode();
-
-    ListGraph::Edge e1 = g.addEdge(n1, n2);
-    ::lemon::ignore_unused_variable_warning(e1);
-    check(biNodeConnected(g), "Graph is bi-node-connected");
-
-    ListGraph::Node n3 = g.addNode();
-    ::lemon::ignore_unused_variable_warning(n3);
-    check(!biNodeConnected(g), "Graph is not bi-node-connected");
-  }
-
-
-  {
-    Digraph d;
-    Digraph::NodeMap<int> order(d);
-    Graph g(d);
-
+    Digraph d;
+    Digraph::NodeMap<int> order(d);
+    Graph g(d);
+    
     Digraph::Node n1 = d.addNode();
     Digraph::Node n2 = d.addNode();
@@ -127,5 +109,5 @@
     Digraph::Node n5 = d.addNode();
     Digraph::Node n6 = d.addNode();
-
+    
     d.addArc(n1, n3);
     d.addArc(n3, n2);
@@ -155,21 +137,21 @@
     check(!parallelFree(g), "This graph is not parallel-free.");
     check(!simpleGraph(g), "This graph is not simple.");
-
+    
     d.addArc(n3, n3);
-
+    
     check(!loopFree(d), "This digraph is not loop-free.");
     check(!loopFree(g), "This graph is not loop-free.");
     check(!simpleGraph(d), "This digraph is not simple.");
-
+    
     d.addArc(n3, n2);
-
+    
     check(!parallelFree(d), "This digraph is not parallel-free.");
   }
-
+  
   {
     Digraph d;
     Digraph::ArcMap<bool> cutarcs(d, false);
     Graph g(d);
-
+    
     Digraph::Node n1 = d.addNode();
     Digraph::Node n2 = d.addNode();
@@ -191,5 +173,5 @@
     d.addArc(n6, n7);
     d.addArc(n7, n6);
-
+   
     check(!stronglyConnected(d), "This digraph is not strongly connected");
     check(countStronglyConnectedComponents(d) == 3,
@@ -254,5 +236,5 @@
     Digraph d;
     Digraph::NodeMap<int> order(d);
-
+    
     Digraph::Node belt = d.addNode();
     Digraph::Node trousers = d.addNode();
@@ -264,5 +246,4 @@
     Digraph::Node watch = d.addNode();
     Digraph::Node pants = d.addNode();
-    ::lemon::ignore_unused_variable_warning(watch);
 
     d.addArc(socks, shoe);
@@ -275,5 +256,5 @@
     d.addArc(shirt, necktie);
     d.addArc(necktie, coat);
-
+    
     check(dag(d), "This digraph is DAG.");
     topologicalSort(d, order);
@@ -287,5 +268,5 @@
     ListGraph g;
     ListGraph::NodeMap<bool> map(g);
-
+    
     ListGraph::Node n1 = g.addNode();
     ListGraph::Node n2 = g.addNode();
@@ -303,8 +284,8 @@
     g.addEdge(n4, n7);
     g.addEdge(n5, n7);
-
+   
     check(bipartite(g), "This graph is bipartite");
     check(bipartitePartitions(g, map), "This graph is bipartite");
-
+    
     check(map[n1] == map[n2] && map[n1] == map[n6] && map[n1] == map[n7],
           "Wrong bipartitePartitions()");
Index: test/dfs_test.cc
===================================================================
--- test/dfs_test.cc	(revision 1270)
+++ test/dfs_test.cc	(revision 632)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -51,8 +51,5 @@
   "@attributes\n"
   "source 0\n"
-  "target 5\n"
-  "source1 6\n"
-  "target1 3\n";
-
+  "target 5\n";
 
 void checkDfsCompile()
@@ -68,6 +65,4 @@
   int l, i;
   bool b;
-  ::lemon::ignore_unused_variable_warning(l,i,b);
-
   DType::DistMap d(G);
   DType::PredMap p(G);
@@ -89,5 +84,5 @@
     b = const_dfs_test.emptyQueue();
     i = const_dfs_test.queueSize();
-
+    
     dfs_test.start();
     dfs_test.start(t);
@@ -115,5 +110,5 @@
     concepts::ReadWriteMap<Node,bool> reached_map;
     concepts::WriteMap<Node,bool> processed_map;
-
+    
     dfs_test
       .predMap(pred_map)
@@ -132,5 +127,5 @@
     b = dfs_test.emptyQueue();
     i = dfs_test.queueSize();
-
+    
     dfs_test.start();
     dfs_test.start(t);
@@ -154,6 +149,4 @@
   Digraph g;
   bool b;
-  ::lemon::ignore_unused_variable_warning(b);
-
   dfs(g).run(Node());
   b=dfs(g).run(Node(),Node());
@@ -187,5 +180,4 @@
   Digraph G;
   Node s, t;
-  Node s1, t1;
 
   std::istringstream input(test_lgf);
@@ -193,6 +185,4 @@
     node("source", s).
     node("target", t).
-    node("source1", s1).
-    node("target1", t1).
     run();
 
@@ -221,9 +211,4 @@
 
   {
-  Dfs<Digraph> dfs(G);
-  check(dfs.run(s1,t1) && dfs.reached(t1),"Node 3 is reachable from Node 6.");
-  }
-
-  {
     NullMap<Node,Arc> myPredMap;
     dfs(G).predMap(myPredMap).run(s);
Index: test/digraph_test.cc
===================================================================
--- test/digraph_test.cc	(revision 1270)
+++ test/digraph_test.cc	(revision 827)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -65,5 +65,4 @@
       a3 = G.addArc(n2, n3),
       a4 = G.addArc(n2, n3);
-  ::lemon::ignore_unused_variable_warning(a2,a3,a4);
 
   checkGraphNodeList(G, 3);
@@ -94,5 +93,4 @@
   Arc a1 = G.addArc(n1, n2), a2 = G.addArc(n2, n1),
       a3 = G.addArc(n2, n3), a4 = G.addArc(n2, n3);
-  ::lemon::ignore_unused_variable_warning(a1,a2,a3,a4);
 
   Node n4 = G.split(n2);
@@ -128,5 +126,4 @@
       a3 = G.addArc(n4, n3), a4 = G.addArc(n4, n3),
       a5 = G.addArc(n2, n4);
-  ::lemon::ignore_unused_variable_warning(a1,a2,a3,a5);
 
   checkGraphNodeList(G, 4);
@@ -208,5 +205,4 @@
       a3 = G.addArc(n4, n3), a4 = G.addArc(n3, n1),
       a5 = G.addArc(n2, n4);
-  ::lemon::ignore_unused_variable_warning(a2,a3,a4,a5);
 
   // Check arc deletion
@@ -256,5 +252,4 @@
   Arc a1 = G.addArc(n1, n2), a2 = G.addArc(n2, n1),
       a3 = G.addArc(n2, n3), a4 = G.addArc(n2, n3);
-  ::lemon::ignore_unused_variable_warning(a1,a2,a3,a4);
 
   typename Digraph::Snapshot snapshot(G);
@@ -357,5 +352,4 @@
     e1 = g.addArc(n1, n2),
     e2 = g.addArc(n2, n3);
-  ::lemon::ignore_unused_variable_warning(e2);
 
   check(g.valid(n1), "Wrong validity check");
@@ -399,7 +393,7 @@
   SmartDigraph::NodeMap<StaticDigraph::Node> nref(g);
   SmartDigraph::ArcMap<StaticDigraph::Arc> aref(g);
-
+  
   StaticDigraph G;
-
+  
   checkGraphNodeList(G, 0);
   checkGraphArcList(G, 0);
@@ -443,5 +437,4 @@
     a3 = g.addArc(n2, n3),
     a4 = g.addArc(n2, n3);
-  ::lemon::ignore_unused_variable_warning(a2,a3,a4);
 
   digraphCopy(g, G).nodeRef(nref).run();
@@ -472,5 +465,5 @@
 
   G.build(6, arcs.begin(), arcs.end());
-
+  
   checkGraphNodeList(G, 6);
   checkGraphArcList(G, 9);
@@ -496,5 +489,5 @@
   checkGraphNodeMap(G);
   checkGraphArcMap(G);
-
+  
   int n = G.nodeNum();
   int m = G.arcNum();
Index: test/dijkstra_test.cc
===================================================================
--- test/dijkstra_test.cc	(revision 1270)
+++ test/dijkstra_test.cc	(revision 632)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -66,6 +66,4 @@
   int i;
   bool b;
-  ::lemon::ignore_unused_variable_warning(l,i,b);
-
   DType::DistMap d(G);
   DType::PredMap p(G);
@@ -88,5 +86,5 @@
     b = const_dijkstra_test.emptyQueue();
     i = const_dijkstra_test.queueSize();
-
+    
     dijkstra_test.start();
     dijkstra_test.start(t);
@@ -112,5 +110,5 @@
       ::SetHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> > >
       ::SetStandardHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> > >
-      ::SetHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> >,
+      ::SetHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> >, 
                 concepts::ReadWriteMap<Node,int> >
       ::Create dijkstra_test(G,length);
@@ -122,5 +120,5 @@
     concepts::ReadWriteMap<Node,int> heap_cross_ref;
     BinHeap<VType, concepts::ReadWriteMap<Node,int> > heap(heap_cross_ref);
-
+    
     dijkstra_test
       .lengthMap(length_map)
@@ -139,5 +137,5 @@
     b = dijkstra_test.emptyQueue();
     i = dijkstra_test.queueSize();
-
+    
     dijkstra_test.start();
     dijkstra_test.start(t);
@@ -165,6 +163,4 @@
   Digraph g;
   bool b;
-  ::lemon::ignore_unused_variable_warning(b);
-
   dijkstra(g,LengthMap()).run(Node());
   b=dijkstra(g,LengthMap()).run(Node(),Node());
Index: test/edge_set_test.cc
===================================================================
--- test/edge_set_test.cc	(revision 1270)
+++ test/edge_set_test.cc	(revision 559)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -45,10 +45,8 @@
 
   Digraph::Arc ga1 = digraph.addArc(n1, n2);
-  ::lemon::ignore_unused_variable_warning(ga1);
 
   ArcSet arc_set(digraph);
 
   Digraph::Arc ga2 = digraph.addArc(n2, n1);
-  ::lemon::ignore_unused_variable_warning(ga2);
 
   checkGraphNodeList(arc_set, 2);
@@ -78,6 +76,4 @@
     a3 = arc_set.addArc(n2, n3),
     a4 = arc_set.addArc(n2, n3);
-  ::lemon::ignore_unused_variable_warning(a2,a3,a4);
-
   checkGraphNodeList(arc_set, 3);
   checkGraphArcList(arc_set, 4);
@@ -115,10 +111,8 @@
 
   Digraph::Arc ga1 = digraph.addArc(n1, n2);
-  ::lemon::ignore_unused_variable_warning(ga1);
 
   ArcSet arc_set(digraph);
 
   Digraph::Arc ga2 = digraph.addArc(n2, n1);
-  ::lemon::ignore_unused_variable_warning(ga2);
 
   checkGraphNodeList(arc_set, 2);
@@ -148,6 +142,4 @@
     a3 = arc_set.addArc(n2, n3),
     a4 = arc_set.addArc(n2, n3);
-  ::lemon::ignore_unused_variable_warning(a2,a3,a4);
-
   checkGraphNodeList(arc_set, 3);
   checkGraphArcList(arc_set, 4);
@@ -199,10 +191,8 @@
 
   Digraph::Arc ga1 = digraph.addArc(n1, n2);
-  ::lemon::ignore_unused_variable_warning(ga1);
 
   EdgeSet edge_set(digraph);
 
   Digraph::Arc ga2 = digraph.addArc(n2, n1);
-  ::lemon::ignore_unused_variable_warning(ga2);
 
   checkGraphNodeList(edge_set, 2);
@@ -241,6 +231,4 @@
     e3 = edge_set.addEdge(n2, n3),
     e4 = edge_set.addEdge(n2, n3);
-  ::lemon::ignore_unused_variable_warning(e2,e3,e4);
-
   checkGraphNodeList(edge_set, 3);
   checkGraphEdgeList(edge_set, 4);
@@ -287,10 +275,8 @@
 
   Digraph::Arc ga1 = digraph.addArc(n1, n2);
-  ::lemon::ignore_unused_variable_warning(ga1);
 
   EdgeSet edge_set(digraph);
 
   Digraph::Arc ga2 = digraph.addArc(n2, n1);
-  ::lemon::ignore_unused_variable_warning(ga2);
 
   checkGraphNodeList(edge_set, 2);
@@ -329,6 +315,4 @@
     e3 = edge_set.addEdge(n2, n3),
     e4 = edge_set.addEdge(n2, n3);
-  ::lemon::ignore_unused_variable_warning(e2,e3,e4);
-
   checkGraphNodeList(edge_set, 3);
   checkGraphEdgeList(edge_set, 4);
Index: test/euler_test.cc
===================================================================
--- test/euler_test.cc	(revision 1270)
+++ test/euler_test.cc	(revision 639)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -86,9 +86,9 @@
   typedef ListDigraph Digraph;
   typedef Undirector<Digraph> Graph;
-
-  {
-    Digraph d;
-    Graph g(d);
-
+  
+  {
+    Digraph d;
+    Graph g(d);
+    
     checkDiEulerIt(d);
     checkDiEulerIt(g);
@@ -102,5 +102,4 @@
     Graph g(d);
     Digraph::Node n = d.addNode();
-    ::lemon::ignore_unused_variable_warning(n);
 
     checkDiEulerIt(d);
@@ -130,5 +129,5 @@
     Digraph::Node n2 = d.addNode();
     Digraph::Node n3 = d.addNode();
-
+    
     d.addArc(n1, n2);
     d.addArc(n2, n1);
@@ -155,5 +154,5 @@
     Digraph::Node n5 = d.addNode();
     Digraph::Node n6 = d.addNode();
-
+    
     d.addArc(n1, n2);
     d.addArc(n2, n4);
@@ -191,6 +190,5 @@
     Digraph::Node n4 = d.addNode();
     Digraph::Node n5 = d.addNode();
-    ::lemon::ignore_unused_variable_warning(n0,n4,n5);
-
+    
     d.addArc(n1, n2);
     d.addArc(n2, n3);
@@ -214,5 +212,5 @@
     Digraph::Node n2 = d.addNode();
     Digraph::Node n3 = d.addNode();
-
+    
     d.addArc(n1, n2);
     d.addArc(n2, n3);
Index: st/fractional_matching_test.cc
===================================================================
--- test/fractional_matching_test.cc	(revision 1270)
+++ 	(revision )
@@ -1,527 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2013
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * 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 <iostream>
-#include <sstream>
-#include <vector>
-#include <queue>
-#include <cstdlib>
-
-#include <lemon/fractional_matching.h>
-#include <lemon/smart_graph.h>
-#include <lemon/concepts/graph.h>
-#include <lemon/concepts/maps.h>
-#include <lemon/lgf_reader.h>
-#include <lemon/math.h>
-
-#include "test_tools.h"
-
-using namespace std;
-using namespace lemon;
-
-GRAPH_TYPEDEFS(SmartGraph);
-
-
-const int lgfn = 4;
-const std::string lgf[lgfn] = {
-  "@nodes\n"
-  "label\n"
-  "0\n"
-  "1\n"
-  "2\n"
-  "3\n"
-  "4\n"
-  "5\n"
-  "6\n"
-  "7\n"
-  "@edges\n"
-  "     label  weight\n"
-  "7 4  0      984\n"
-  "0 7  1      73\n"
-  "7 1  2      204\n"
-  "2 3  3      583\n"
-  "2 7  4      565\n"
-  "2 1  5      582\n"
-  "0 4  6      551\n"
-  "2 5  7      385\n"
-  "1 5  8      561\n"
-  "5 3  9      484\n"
-  "7 5  10     904\n"
-  "3 6  11     47\n"
-  "7 6  12     888\n"
-  "3 0  13     747\n"
-  "6 1  14     310\n",
-
-  "@nodes\n"
-  "label\n"
-  "0\n"
-  "1\n"
-  "2\n"
-  "3\n"
-  "4\n"
-  "5\n"
-  "6\n"
-  "7\n"
-  "@edges\n"
-  "     label  weight\n"
-  "2 5  0      710\n"
-  "0 5  1      241\n"
-  "2 4  2      856\n"
-  "2 6  3      762\n"
-  "4 1  4      747\n"
-  "6 1  5      962\n"
-  "4 7  6      723\n"
-  "1 7  7      661\n"
-  "2 3  8      376\n"
-  "1 0  9      416\n"
-  "6 7  10     391\n",
-
-  "@nodes\n"
-  "label\n"
-  "0\n"
-  "1\n"
-  "2\n"
-  "3\n"
-  "4\n"
-  "5\n"
-  "6\n"
-  "7\n"
-  "@edges\n"
-  "     label  weight\n"
-  "6 2  0      553\n"
-  "0 7  1      653\n"
-  "6 3  2      22\n"
-  "4 7  3      846\n"
-  "7 2  4      981\n"
-  "7 6  5      250\n"
-  "5 2  6      539\n",
-
-  "@nodes\n"
-  "label\n"
-  "0\n"
-  "@edges\n"
-  "     label  weight\n"
-  "0 0  0      100\n"
-};
-
-void checkMaxFractionalMatchingCompile()
-{
-  typedef concepts::Graph Graph;
-  typedef Graph::Node Node;
-  typedef Graph::Edge Edge;
-
-  Graph g;
-  Node n;
-  Edge e;
-
-  MaxFractionalMatching<Graph> mat_test(g);
-  const MaxFractionalMatching<Graph>&
-    const_mat_test = mat_test;
-
-  mat_test.init();
-  mat_test.start();
-  mat_test.start(true);
-  mat_test.startPerfect();
-  mat_test.startPerfect(true);
-  mat_test.run();
-  mat_test.run(true);
-  mat_test.runPerfect();
-  mat_test.runPerfect(true);
-
-  const_mat_test.matchingSize();
-  const_mat_test.matching(e);
-  const_mat_test.matching(n);
-  const MaxFractionalMatching<Graph>::MatchingMap& mmap =
-    const_mat_test.matchingMap();
-  e = mmap[n];
-
-  const_mat_test.barrier(n);
-}
-
-void checkMaxWeightedFractionalMatchingCompile()
-{
-  typedef concepts::Graph Graph;
-  typedef Graph::Node Node;
-  typedef Graph::Edge Edge;
-  typedef Graph::EdgeMap<int> WeightMap;
-
-  Graph g;
-  Node n;
-  Edge e;
-  WeightMap w(g);
-
-  MaxWeightedFractionalMatching<Graph> mat_test(g, w);
-  const MaxWeightedFractionalMatching<Graph>&
-    const_mat_test = mat_test;
-
-  mat_test.init();
-  mat_test.start();
-  mat_test.run();
-
-  const_mat_test.matchingWeight();
-  const_mat_test.matchingSize();
-  const_mat_test.matching(e);
-  const_mat_test.matching(n);
-  const MaxWeightedFractionalMatching<Graph>::MatchingMap& mmap =
-    const_mat_test.matchingMap();
-  e = mmap[n];
-
-  const_mat_test.dualValue();
-  const_mat_test.nodeValue(n);
-}
-
-void checkMaxWeightedPerfectFractionalMatchingCompile()
-{
-  typedef concepts::Graph Graph;
-  typedef Graph::Node Node;
-  typedef Graph::Edge Edge;
-  typedef Graph::EdgeMap<int> WeightMap;
-
-  Graph g;
-  Node n;
-  Edge e;
-  WeightMap w(g);
-
-  MaxWeightedPerfectFractionalMatching<Graph> mat_test(g, w);
-  const MaxWeightedPerfectFractionalMatching<Graph>&
-    const_mat_test = mat_test;
-
-  mat_test.init();
-  mat_test.start();
-  mat_test.run();
-
-  const_mat_test.matchingWeight();
-  const_mat_test.matching(e);
-  const_mat_test.matching(n);
-  const MaxWeightedPerfectFractionalMatching<Graph>::MatchingMap& mmap =
-    const_mat_test.matchingMap();
-  e = mmap[n];
-
-  const_mat_test.dualValue();
-  const_mat_test.nodeValue(n);
-}
-
-void checkFractionalMatching(const SmartGraph& graph,
-                             const MaxFractionalMatching<SmartGraph>& mfm,
-                             bool allow_loops = true) {
-  int pv = 0;
-  for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) {
-    int indeg = 0;
-    for (InArcIt a(graph, n); a != INVALID; ++a) {
-      if (mfm.matching(graph.source(a)) == a) {
-        ++indeg;
-      }
-    }
-    if (mfm.matching(n) != INVALID) {
-      check(indeg == 1, "Invalid matching");
-      ++pv;
-    } else {
-      check(indeg == 0, "Invalid matching");
-    }
-  }
-  check(pv == mfm.matchingSize(), "Wrong matching size");
-
-  for (SmartGraph::EdgeIt e(graph); e != INVALID; ++e) {
-    check((e == mfm.matching(graph.u(e)) ? 1 : 0) +
-          (e == mfm.matching(graph.v(e)) ? 1 : 0) ==
-          mfm.matching(e), "Invalid matching");
-  }
-
-  SmartGraph::NodeMap<bool> processed(graph, false);
-  for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) {
-    if (processed[n]) continue;
-    processed[n] = true;
-    if (mfm.matching(n) == INVALID) continue;
-    int num = 1;
-    Node v = graph.target(mfm.matching(n));
-    while (v != n) {
-      processed[v] = true;
-      ++num;
-      v = graph.target(mfm.matching(v));
-    }
-    check(num == 2 || num % 2 == 1, "Wrong cycle size");
-    check(allow_loops || num != 1, "Wrong cycle size");
-  }
-
-  int anum = 0, bnum = 0;
-  SmartGraph::NodeMap<bool> neighbours(graph, false);
-  for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) {
-    if (!mfm.barrier(n)) continue;
-    ++anum;
-    for (SmartGraph::InArcIt a(graph, n); a != INVALID; ++a) {
-      Node u = graph.source(a);
-      if (!allow_loops && u == n) continue;
-      if (!neighbours[u]) {
-        neighbours[u] = true;
-        ++bnum;
-      }
-    }
-  }
-  check(anum - bnum + mfm.matchingSize() == countNodes(graph),
-        "Wrong barrier");
-}
-
-void checkPerfectFractionalMatching(const SmartGraph& graph,
-                             const MaxFractionalMatching<SmartGraph>& mfm,
-                             bool perfect, bool allow_loops = true) {
-  if (perfect) {
-    for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) {
-      int indeg = 0;
-      for (InArcIt a(graph, n); a != INVALID; ++a) {
-        if (mfm.matching(graph.source(a)) == a) {
-          ++indeg;
-        }
-      }
-      check(mfm.matching(n) != INVALID, "Invalid matching");
-      check(indeg == 1, "Invalid matching");
-    }
-    for (SmartGraph::EdgeIt e(graph); e != INVALID; ++e) {
-      check((e == mfm.matching(graph.u(e)) ? 1 : 0) +
-            (e == mfm.matching(graph.v(e)) ? 1 : 0) ==
-            mfm.matching(e), "Invalid matching");
-    }
-  } else {
-    int anum = 0, bnum = 0;
-    SmartGraph::NodeMap<bool> neighbours(graph, false);
-    for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) {
-      if (!mfm.barrier(n)) continue;
-      ++anum;
-      for (SmartGraph::InArcIt a(graph, n); a != INVALID; ++a) {
-        Node u = graph.source(a);
-        if (!allow_loops && u == n) continue;
-        if (!neighbours[u]) {
-          neighbours[u] = true;
-          ++bnum;
-        }
-      }
-    }
-    check(anum - bnum > 0, "Wrong barrier");
-  }
-}
-
-void checkWeightedFractionalMatching(const SmartGraph& graph,
-                   const SmartGraph::EdgeMap<int>& weight,
-                   const MaxWeightedFractionalMatching<SmartGraph>& mwfm,
-                   bool allow_loops = true) {
-  for (SmartGraph::EdgeIt e(graph); e != INVALID; ++e) {
-    if (graph.u(e) == graph.v(e) && !allow_loops) continue;
-    int rw = mwfm.nodeValue(graph.u(e)) + mwfm.nodeValue(graph.v(e))
-      - weight[e] * mwfm.dualScale;
-
-    check(rw >= 0, "Negative reduced weight");
-    check(rw == 0 || !mwfm.matching(e),
-          "Non-zero reduced weight on matching edge");
-  }
-
-  int pv = 0;
-  for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) {
-    int indeg = 0;
-    for (InArcIt a(graph, n); a != INVALID; ++a) {
-      if (mwfm.matching(graph.source(a)) == a) {
-        ++indeg;
-      }
-    }
-    check(indeg <= 1, "Invalid matching");
-    if (mwfm.matching(n) != INVALID) {
-      check(mwfm.nodeValue(n) >= 0, "Invalid node value");
-      check(indeg == 1, "Invalid matching");
-      pv += weight[mwfm.matching(n)];
-      SmartGraph::Node o = graph.target(mwfm.matching(n));
-      ::lemon::ignore_unused_variable_warning(o);
-    } else {
-      check(mwfm.nodeValue(n) == 0, "Invalid matching");
-      check(indeg == 0, "Invalid matching");
-    }
-  }
-
-  for (SmartGraph::EdgeIt e(graph); e != INVALID; ++e) {
-    check((e == mwfm.matching(graph.u(e)) ? 1 : 0) +
-          (e == mwfm.matching(graph.v(e)) ? 1 : 0) ==
-          mwfm.matching(e), "Invalid matching");
-  }
-
-  int dv = 0;
-  for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) {
-    dv += mwfm.nodeValue(n);
-  }
-
-  check(pv * mwfm.dualScale == dv * 2, "Wrong duality");
-
-  SmartGraph::NodeMap<bool> processed(graph, false);
-  for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) {
-    if (processed[n]) continue;
-    processed[n] = true;
-    if (mwfm.matching(n) == INVALID) continue;
-    int num = 1;
-    Node v = graph.target(mwfm.matching(n));
-    while (v != n) {
-      processed[v] = true;
-      ++num;
-      v = graph.target(mwfm.matching(v));
-    }
-    check(num == 2 || num % 2 == 1, "Wrong cycle size");
-    check(allow_loops || num != 1, "Wrong cycle size");
-  }
-
-  return;
-}
-
-void checkWeightedPerfectFractionalMatching(const SmartGraph& graph,
-                const SmartGraph::EdgeMap<int>& weight,
-                const MaxWeightedPerfectFractionalMatching<SmartGraph>& mwpfm,
-                bool allow_loops = true) {
-  for (SmartGraph::EdgeIt e(graph); e != INVALID; ++e) {
-    if (graph.u(e) == graph.v(e) && !allow_loops) continue;
-    int rw = mwpfm.nodeValue(graph.u(e)) + mwpfm.nodeValue(graph.v(e))
-      - weight[e] * mwpfm.dualScale;
-
-    check(rw >= 0, "Negative reduced weight");
-    check(rw == 0 || !mwpfm.matching(e),
-          "Non-zero reduced weight on matching edge");
-  }
-
-  int pv = 0;
-  for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) {
-    int indeg = 0;
-    for (InArcIt a(graph, n); a != INVALID; ++a) {
-      if (mwpfm.matching(graph.source(a)) == a) {
-        ++indeg;
-      }
-    }
-    check(mwpfm.matching(n) != INVALID, "Invalid perfect matching");
-    check(indeg == 1, "Invalid perfect matching");
-    pv += weight[mwpfm.matching(n)];
-    SmartGraph::Node o = graph.target(mwpfm.matching(n));
-    ::lemon::ignore_unused_variable_warning(o);
-  }
-
-  for (SmartGraph::EdgeIt e(graph); e != INVALID; ++e) {
-    check((e == mwpfm.matching(graph.u(e)) ? 1 : 0) +
-          (e == mwpfm.matching(graph.v(e)) ? 1 : 0) ==
-          mwpfm.matching(e), "Invalid matching");
-  }
-
-  int dv = 0;
-  for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) {
-    dv += mwpfm.nodeValue(n);
-  }
-
-  check(pv * mwpfm.dualScale == dv * 2, "Wrong duality");
-
-  SmartGraph::NodeMap<bool> processed(graph, false);
-  for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) {
-    if (processed[n]) continue;
-    processed[n] = true;
-    if (mwpfm.matching(n) == INVALID) continue;
-    int num = 1;
-    Node v = graph.target(mwpfm.matching(n));
-    while (v != n) {
-      processed[v] = true;
-      ++num;
-      v = graph.target(mwpfm.matching(v));
-    }
-    check(num == 2 || num % 2 == 1, "Wrong cycle size");
-    check(allow_loops || num != 1, "Wrong cycle size");
-  }
-
-  return;
-}
-
-
-int main() {
-
-  for (int i = 0; i < lgfn; ++i) {
-    SmartGraph graph;
-    SmartGraph::EdgeMap<int> weight(graph);
-
-    istringstream lgfs(lgf[i]);
-    graphReader(graph, lgfs).
-      edgeMap("weight", weight).run();
-
-    bool perfect_with_loops;
-    {
-      MaxFractionalMatching<SmartGraph> mfm(graph, true);
-      mfm.run();
-      checkFractionalMatching(graph, mfm, true);
-      perfect_with_loops = mfm.matchingSize() == countNodes(graph);
-    }
-
-    bool perfect_without_loops;
-    {
-      MaxFractionalMatching<SmartGraph> mfm(graph, false);
-      mfm.run();
-      checkFractionalMatching(graph, mfm, false);
-      perfect_without_loops = mfm.matchingSize() == countNodes(graph);
-    }
-
-    {
-      MaxFractionalMatching<SmartGraph> mfm(graph, true);
-      bool result = mfm.runPerfect();
-      checkPerfectFractionalMatching(graph, mfm, result, true);
-      check(result == perfect_with_loops, "Wrong perfect matching");
-    }
-
-    {
-      MaxFractionalMatching<SmartGraph> mfm(graph, false);
-      bool result = mfm.runPerfect();
-      checkPerfectFractionalMatching(graph, mfm, result, false);
-      check(result == perfect_without_loops, "Wrong perfect matching");
-    }
-
-    {
-      MaxWeightedFractionalMatching<SmartGraph> mwfm(graph, weight, true);
-      mwfm.run();
-      checkWeightedFractionalMatching(graph, weight, mwfm, true);
-    }
-
-    {
-      MaxWeightedFractionalMatching<SmartGraph> mwfm(graph, weight, false);
-      mwfm.run();
-      checkWeightedFractionalMatching(graph, weight, mwfm, false);
-    }
-
-    {
-      MaxWeightedPerfectFractionalMatching<SmartGraph> mwpfm(graph, weight,
-                                                             true);
-      bool perfect = mwpfm.run();
-      check(perfect == (mwpfm.matchingSize() == countNodes(graph)),
-            "Perfect matching found");
-      check(perfect == perfect_with_loops, "Wrong perfect matching");
-
-      if (perfect) {
-        checkWeightedPerfectFractionalMatching(graph, weight, mwpfm, true);
-      }
-    }
-
-    {
-      MaxWeightedPerfectFractionalMatching<SmartGraph> mwpfm(graph, weight,
-                                                             false);
-      bool perfect = mwpfm.run();
-      check(perfect == (mwpfm.matchingSize() == countNodes(graph)),
-            "Perfect matching found");
-      check(perfect == perfect_without_loops, "Wrong perfect matching");
-
-      if (perfect) {
-        checkWeightedPerfectFractionalMatching(graph, weight, mwpfm, false);
-      }
-    }
-
-  }
-
-  return 0;
-}
Index: test/gomory_hu_test.cc
===================================================================
--- test/gomory_hu_test.cc	(revision 1270)
+++ test/gomory_hu_test.cc	(revision 643)
@@ -1,20 +1,2 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2013
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * 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 <iostream>
 
@@ -52,5 +34,5 @@
   "source 0\n"
   "target 3\n";
-
+  
 void checkGomoryHuCompile()
 {
@@ -69,5 +51,4 @@
   Value v;
   int d;
-  ::lemon::ignore_unused_variable_warning(v,d);
 
   GomoryHu<Graph, CapMap> gh_test(g, cap);
@@ -89,5 +70,5 @@
 
 int cutValue(const Graph& graph, const BoolNodeMap& cut,
-             const IntEdgeMap& capacity) {
+	     const IntEdgeMap& capacity) {
 
   int sum = 0;
@@ -127,5 +108,5 @@
       int sum=0;
       for(GomoryHu<Graph>::MinCutEdgeIt a(ght, u, v);a!=INVALID;++a)
-        sum+=capacity[a];
+        sum+=capacity[a]; 
       check(sum == ght.minCutValue(u, v), "Problem with MinCutEdgeIt");
 
@@ -138,5 +119,5 @@
     }
   }
-
+  
   return 0;
 }
Index: test/graph_copy_test.cc
===================================================================
--- test/graph_copy_test.cc	(revision 1270)
+++ test/graph_copy_test.cc	(revision 463)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -19,5 +19,4 @@
 #include <lemon/smart_graph.h>
 #include <lemon/list_graph.h>
-#include <lemon/static_graph.h>
 #include <lemon/lgf_reader.h>
 #include <lemon/error.h>
@@ -28,9 +27,7 @@
 using namespace lemon;
 
-template <typename GR>
 void digraph_copy_test() {
   const int nn = 10;
 
-  // Build a digraph
   SmartDigraph from;
   SmartDigraph::NodeMap<int> fnm(from);
@@ -55,16 +52,15 @@
   }
 
-  // Test digraph copy
-  GR to;
-  typename GR::template NodeMap<int> tnm(to);
-  typename GR::template ArcMap<int> tam(to);
-  typename GR::Node tn;
-  typename GR::Arc ta;
+  ListDigraph to;
+  ListDigraph::NodeMap<int> tnm(to);
+  ListDigraph::ArcMap<int> tam(to);
+  ListDigraph::Node tn;
+  ListDigraph::Arc ta;
 
-  SmartDigraph::NodeMap<typename GR::Node> nr(from);
-  SmartDigraph::ArcMap<typename GR::Arc> er(from);
+  SmartDigraph::NodeMap<ListDigraph::Node> nr(from);
+  SmartDigraph::ArcMap<ListDigraph::Arc> er(from);
 
-  typename GR::template NodeMap<SmartDigraph::Node> ncr(to);
-  typename GR::template ArcMap<SmartDigraph::Arc> ecr(to);
+  ListDigraph::NodeMap<SmartDigraph::Node> ncr(to);
+  ListDigraph::ArcMap<SmartDigraph::Arc> ecr(to);
 
   digraphCopy(from, to).
@@ -73,7 +69,4 @@
     nodeCrossRef(ncr).arcCrossRef(ecr).
     node(fn, tn).arc(fa, ta).run();
-
-  check(countNodes(from) == countNodes(to), "Wrong copy.");
-  check(countArcs(from) == countArcs(to), "Wrong copy.");
 
   for (SmartDigraph::NodeIt it(from); it != INVALID; ++it) {
@@ -89,26 +82,18 @@
   }
 
-  for (typename GR::NodeIt it(to); it != INVALID; ++it) {
+  for (ListDigraph::NodeIt it(to); it != INVALID; ++it) {
     check(nr[ncr[it]] == it, "Wrong copy.");
   }
 
-  for (typename GR::ArcIt it(to); it != INVALID; ++it) {
+  for (ListDigraph::ArcIt it(to); it != INVALID; ++it) {
     check(er[ecr[it]] == it, "Wrong copy.");
   }
   check(tn == nr[fn], "Wrong copy.");
   check(ta == er[fa], "Wrong copy.");
-
-  // Test repeated copy
-  digraphCopy(from, to).run();
-
-  check(countNodes(from) == countNodes(to), "Wrong copy.");
-  check(countArcs(from) == countArcs(to), "Wrong copy.");
 }
 
-template <typename GR>
 void graph_copy_test() {
   const int nn = 10;
 
-  // Build a graph
   SmartGraph from;
   SmartGraph::NodeMap<int> fnm(from);
@@ -138,20 +123,19 @@
   }
 
-  // Test graph copy
-  GR to;
-  typename GR::template NodeMap<int> tnm(to);
-  typename GR::template ArcMap<int> tam(to);
-  typename GR::template EdgeMap<int> tem(to);
-  typename GR::Node tn;
-  typename GR::Arc ta;
-  typename GR::Edge te;
+  ListGraph to;
+  ListGraph::NodeMap<int> tnm(to);
+  ListGraph::ArcMap<int> tam(to);
+  ListGraph::EdgeMap<int> tem(to);
+  ListGraph::Node tn;
+  ListGraph::Arc ta;
+  ListGraph::Edge te;
 
-  SmartGraph::NodeMap<typename GR::Node> nr(from);
-  SmartGraph::ArcMap<typename GR::Arc> ar(from);
-  SmartGraph::EdgeMap<typename GR::Edge> er(from);
+  SmartGraph::NodeMap<ListGraph::Node> nr(from);
+  SmartGraph::ArcMap<ListGraph::Arc> ar(from);
+  SmartGraph::EdgeMap<ListGraph::Edge> er(from);
 
-  typename GR::template NodeMap<SmartGraph::Node> ncr(to);
-  typename GR::template ArcMap<SmartGraph::Arc> acr(to);
-  typename GR::template EdgeMap<SmartGraph::Edge> ecr(to);
+  ListGraph::NodeMap<SmartGraph::Node> ncr(to);
+  ListGraph::ArcMap<SmartGraph::Arc> acr(to);
+  ListGraph::EdgeMap<SmartGraph::Edge> ecr(to);
 
   graphCopy(from, to).
@@ -160,8 +144,4 @@
     nodeCrossRef(ncr).arcCrossRef(acr).edgeCrossRef(ecr).
     node(fn, tn).arc(fa, ta).edge(fe, te).run();
-
-  check(countNodes(from) == countNodes(to), "Wrong copy.");
-  check(countEdges(from) == countEdges(to), "Wrong copy.");
-  check(countArcs(from) == countArcs(to), "Wrong copy.");
 
   for (SmartGraph::NodeIt it(from); it != INVALID; ++it) {
@@ -188,12 +168,12 @@
   }
 
-  for (typename GR::NodeIt it(to); it != INVALID; ++it) {
+  for (ListGraph::NodeIt it(to); it != INVALID; ++it) {
     check(nr[ncr[it]] == it, "Wrong copy.");
   }
 
-  for (typename GR::ArcIt it(to); it != INVALID; ++it) {
+  for (ListGraph::ArcIt it(to); it != INVALID; ++it) {
     check(ar[acr[it]] == it, "Wrong copy.");
   }
-  for (typename GR::EdgeIt it(to); it != INVALID; ++it) {
+  for (ListGraph::EdgeIt it(to); it != INVALID; ++it) {
     check(er[ecr[it]] == it, "Wrong copy.");
   }
@@ -201,187 +181,10 @@
   check(ta == ar[fa], "Wrong copy.");
   check(te == er[fe], "Wrong copy.");
-
-  // Test repeated copy
-  graphCopy(from, to).run();
-
-  check(countNodes(from) == countNodes(to), "Wrong copy.");
-  check(countEdges(from) == countEdges(to), "Wrong copy.");
-  check(countArcs(from) == countArcs(to), "Wrong copy.");
-}
-
-template <typename GR>
-void bpgraph_copy_test() {
-  const int nn = 10;
-
-  // Build a graph
-  SmartBpGraph from;
-  SmartBpGraph::NodeMap<int> fnm(from);
-  SmartBpGraph::RedNodeMap<int> frnm(from);
-  SmartBpGraph::BlueNodeMap<int> fbnm(from);
-  SmartBpGraph::ArcMap<int> fam(from);
-  SmartBpGraph::EdgeMap<int> fem(from);
-  SmartBpGraph::Node fn = INVALID;
-  SmartBpGraph::RedNode frn = INVALID;
-  SmartBpGraph::BlueNode fbn = INVALID;
-  SmartBpGraph::Arc fa = INVALID;
-  SmartBpGraph::Edge fe = INVALID;
-
-  std::vector<SmartBpGraph::RedNode> frnv;
-  for (int i = 0; i < nn; ++i) {
-    SmartBpGraph::RedNode node = from.addRedNode();
-    frnv.push_back(node);
-    fnm[node] = i * i;
-    frnm[node] = i + i;
-    if (i == 0) {
-      fn = node;
-      frn = node;
-    }
-  }
-
-  std::vector<SmartBpGraph::BlueNode> fbnv;
-  for (int i = 0; i < nn; ++i) {
-    SmartBpGraph::BlueNode node = from.addBlueNode();
-    fbnv.push_back(node);
-    fnm[node] = i * i;
-    fbnm[node] = i + i;
-    if (i == 0) fbn = node;
-  }
-
-  for (int i = 0; i < nn; ++i) {
-    for (int j = 0; j < nn; ++j) {
-      SmartBpGraph::Edge edge = from.addEdge(frnv[i], fbnv[j]);
-      fem[edge] = i * i + j * j;
-      fam[from.direct(edge, true)] = i + j * j;
-      fam[from.direct(edge, false)] = i * i + j;
-      if (i == 0 && j == 0) fa = from.direct(edge, true);
-      if (i == 0 && j == 0) fe = edge;
-    }
-  }
-
-  // Test graph copy
-  GR to;
-  typename GR::template NodeMap<int> tnm(to);
-  typename GR::template RedNodeMap<int> trnm(to);
-  typename GR::template BlueNodeMap<int> tbnm(to);
-  typename GR::template ArcMap<int> tam(to);
-  typename GR::template EdgeMap<int> tem(to);
-  typename GR::Node tn;
-  typename GR::RedNode trn;
-  typename GR::BlueNode tbn;
-  typename GR::Arc ta;
-  typename GR::Edge te;
-
-  SmartBpGraph::NodeMap<typename GR::Node> nr(from);
-  SmartBpGraph::RedNodeMap<typename GR::RedNode> rnr(from);
-  SmartBpGraph::BlueNodeMap<typename GR::BlueNode> bnr(from);
-  SmartBpGraph::ArcMap<typename GR::Arc> ar(from);
-  SmartBpGraph::EdgeMap<typename GR::Edge> er(from);
-
-  typename GR::template NodeMap<SmartBpGraph::Node> ncr(to);
-  typename GR::template RedNodeMap<SmartBpGraph::RedNode> rncr(to);
-  typename GR::template BlueNodeMap<SmartBpGraph::BlueNode> bncr(to);
-  typename GR::template ArcMap<SmartBpGraph::Arc> acr(to);
-  typename GR::template EdgeMap<SmartBpGraph::Edge> ecr(to);
-
-  bpGraphCopy(from, to).
-    nodeMap(fnm, tnm).
-    redNodeMap(frnm, trnm).blueNodeMap(fbnm, tbnm).
-    arcMap(fam, tam).edgeMap(fem, tem).
-    nodeRef(nr).redRef(rnr).blueRef(bnr).
-    arcRef(ar).edgeRef(er).
-    nodeCrossRef(ncr).redCrossRef(rncr).blueCrossRef(bncr).
-    arcCrossRef(acr).edgeCrossRef(ecr).
-    node(fn, tn).redNode(frn, trn).blueNode(fbn, tbn).
-    arc(fa, ta).edge(fe, te).run();
-
-  check(countNodes(from) == countNodes(to), "Wrong copy.");
-  check(countRedNodes(from) == countRedNodes(to), "Wrong copy.");
-  check(countBlueNodes(from) == countBlueNodes(to), "Wrong copy.");
-  check(countEdges(from) == countEdges(to), "Wrong copy.");
-  check(countArcs(from) == countArcs(to), "Wrong copy.");
-
-  for (SmartBpGraph::NodeIt it(from); it != INVALID; ++it) {
-    check(ncr[nr[it]] == it, "Wrong copy.");
-    check(fnm[it] == tnm[nr[it]], "Wrong copy.");
-  }
-
-  for (SmartBpGraph::RedNodeIt it(from); it != INVALID; ++it) {
-    check(ncr[nr[it]] == it, "Wrong copy.");
-    check(fnm[it] == tnm[nr[it]], "Wrong copy.");
-    check(rnr[it] == nr[it], "Wrong copy.");
-    check(rncr[rnr[it]] == it, "Wrong copy.");
-    check(frnm[it] == trnm[rnr[it]], "Wrong copy.");
-    check(to.red(rnr[it]), "Wrong copy.");
-  }
-
-  for (SmartBpGraph::BlueNodeIt it(from); it != INVALID; ++it) {
-    check(ncr[nr[it]] == it, "Wrong copy.");
-    check(fnm[it] == tnm[nr[it]], "Wrong copy.");
-    check(bnr[it] == nr[it], "Wrong copy.");
-    check(bncr[bnr[it]] == it, "Wrong copy.");
-    check(fbnm[it] == tbnm[bnr[it]], "Wrong copy.");
-    check(to.blue(bnr[it]), "Wrong copy.");
-  }
-
-  for (SmartBpGraph::ArcIt it(from); it != INVALID; ++it) {
-    check(acr[ar[it]] == it, "Wrong copy.");
-    check(fam[it] == tam[ar[it]], "Wrong copy.");
-    check(nr[from.source(it)] == to.source(ar[it]), "Wrong copy.");
-    check(nr[from.target(it)] == to.target(ar[it]), "Wrong copy.");
-  }
-
-  for (SmartBpGraph::EdgeIt it(from); it != INVALID; ++it) {
-    check(ecr[er[it]] == it, "Wrong copy.");
-    check(fem[it] == tem[er[it]], "Wrong copy.");
-    check(nr[from.u(it)] == to.u(er[it]) || nr[from.u(it)] == to.v(er[it]),
-          "Wrong copy.");
-    check(nr[from.v(it)] == to.u(er[it]) || nr[from.v(it)] == to.v(er[it]),
-          "Wrong copy.");
-    check((from.u(it) != from.v(it)) == (to.u(er[it]) != to.v(er[it])),
-          "Wrong copy.");
-  }
-
-  for (typename GR::NodeIt it(to); it != INVALID; ++it) {
-    check(nr[ncr[it]] == it, "Wrong copy.");
-  }
-  for (typename GR::RedNodeIt it(to); it != INVALID; ++it) {
-    check(rncr[it] == ncr[it], "Wrong copy.");
-    check(rnr[rncr[it]] == it, "Wrong copy.");
-  }
-  for (typename GR::BlueNodeIt it(to); it != INVALID; ++it) {
-    check(bncr[it] == ncr[it], "Wrong copy.");
-    check(bnr[bncr[it]] == it, "Wrong copy.");
-  }
-  for (typename GR::ArcIt it(to); it != INVALID; ++it) {
-    check(ar[acr[it]] == it, "Wrong copy.");
-  }
-  for (typename GR::EdgeIt it(to); it != INVALID; ++it) {
-    check(er[ecr[it]] == it, "Wrong copy.");
-  }
-  check(tn == nr[fn], "Wrong copy.");
-  check(trn == rnr[frn], "Wrong copy.");
-  check(tbn == bnr[fbn], "Wrong copy.");
-  check(ta == ar[fa], "Wrong copy.");
-  check(te == er[fe], "Wrong copy.");
-
-  // Test repeated copy
-  bpGraphCopy(from, to).run();
-
-  check(countNodes(from) == countNodes(to), "Wrong copy.");
-  check(countRedNodes(from) == countRedNodes(to), "Wrong copy.");
-  check(countBlueNodes(from) == countBlueNodes(to), "Wrong copy.");
-  check(countEdges(from) == countEdges(to), "Wrong copy.");
-  check(countArcs(from) == countArcs(to), "Wrong copy.");
 }
 
 
 int main() {
-  digraph_copy_test<SmartDigraph>();
-  digraph_copy_test<ListDigraph>();
-  digraph_copy_test<StaticDigraph>();
-  graph_copy_test<SmartGraph>();
-  graph_copy_test<ListGraph>();
-  bpgraph_copy_test<SmartBpGraph>();
-  bpgraph_copy_test<ListBpGraph>();
+  digraph_copy_test();
+  graph_copy_test();
 
   return 0;
Index: test/graph_test.cc
===================================================================
--- test/graph_test.cc	(revision 1270)
+++ test/graph_test.cc	(revision 787)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -67,5 +67,4 @@
   Edge e2 = G.addEdge(n2, n1),
        e3 = G.addEdge(n2, n3);
-  ::lemon::ignore_unused_variable_warning(e2,e3);
 
   checkGraphNodeList(G, 3);
@@ -100,5 +99,4 @@
        e3 = G.addEdge(n2, n3), e4 = G.addEdge(n1, n4),
        e5 = G.addEdge(n4, n3);
-  ::lemon::ignore_unused_variable_warning(e1,e3,e4,e5);
 
   checkGraphNodeList(G, 4);
@@ -180,5 +178,4 @@
        e3 = G.addEdge(n2, n3), e4 = G.addEdge(n1, n4),
        e5 = G.addEdge(n4, n3);
-  ::lemon::ignore_unused_variable_warning(e1,e3,e4,e5);
 
   // Check edge deletion
@@ -221,5 +218,4 @@
   Edge e1 = G.addEdge(n1, n2), e2 = G.addEdge(n2, n1),
        e3 = G.addEdge(n2, n3);
-  ::lemon::ignore_unused_variable_warning(e1,e2,e3);
 
   checkGraphNodeList(G, 3);
@@ -269,5 +265,5 @@
   checkGraphEdgeList(G, 3);
   checkGraphArcList(G, 6);
-
+  
   G.addEdge(G.addNode(), G.addNode());
 
@@ -386,5 +382,4 @@
     e1 = g.addEdge(n1, n2),
     e2 = g.addEdge(n2, n3);
-  ::lemon::ignore_unused_variable_warning(e2);
 
   check(g.valid(n1), "Wrong validity check");
@@ -519,5 +514,5 @@
   G.resize(dim);
   check(G.dimension() == dim, "Wrong dimension");
-
+  
   checkGraphNodeList(G, 1 << dim);
   checkGraphEdgeList(G, dim * (1 << (dim-1)));
@@ -525,5 +520,4 @@
 
   Node n = G.nodeFromId(dim);
-  ::lemon::ignore_unused_variable_warning(n);
 
   for (NodeIt n(G); n != INVALID; ++n) {
Index: test/graph_test.h
===================================================================
--- test/graph_test.h	(revision 1337)
+++ test/graph_test.h	(revision 463)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -39,102 +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
-  }
-
-  template<class Graph>
-  void checkGraphRedNodeList(const Graph &G, int cnt)
-  {
-    typename Graph::RedNodeIt n(G);
-    for(int i=0;i<cnt;i++) {
-      check(n!=INVALID,"Wrong red Node list linking.");
-      check(G.red(n),"Wrong node set check.");
-      check(!G.blue(n),"Wrong node set check.");
-      typename Graph::Node nn = n;
-      check(G.asRedNodeUnsafe(nn) == n,"Wrong node conversion.");
-      check(G.asRedNode(nn) == n,"Wrong node conversion.");
-      check(G.asBlueNode(nn) == INVALID,"Wrong node conversion.");
-      ++n;
-    }
-    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
-  }
-
-  template<class Graph>
-  void checkGraphBlueNodeList(const Graph &G, int cnt)
-  {
-    typename Graph::BlueNodeIt n(G);
-    for(int i=0;i<cnt;i++) {
-      check(n!=INVALID,"Wrong blue Node list linking.");
-      check(G.blue(n),"Wrong node set check.");
-      check(!G.red(n),"Wrong node set check.");
-      typename Graph::Node nn = n;
-      check(G.asBlueNodeUnsafe(nn) == n,"Wrong node conversion.");
-      check(G.asBlueNode(nn) == n,"Wrong node conversion.");
-      check(G.asRedNode(nn) == INVALID,"Wrong node conversion.");
-      ++n;
-    }
-    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 +55,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 +70,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 +85,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 +99,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 +115,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
-
   }
 
@@ -369,5 +167,4 @@
   template <typename Graph>
   void checkNodeIds(const Graph& G) {
-    typedef typename Graph::Node Node;
     std::set<int> values;
     for (typename Graph::NodeIt n(G); n != INVALID; ++n) {
@@ -377,36 +174,8 @@
       values.insert(G.id(n));
     }
-    check(G.maxId(Node()) <= G.maxNodeId(), "Wrong maximum id");
-  }
-
-  template <typename Graph>
-  void checkRedNodeIds(const Graph& G) {
-    typedef typename Graph::RedNode RedNode;
-    std::set<int> values;
-    for (typename Graph::RedNodeIt n(G); n != INVALID; ++n) {
-      check(G.red(n), "Wrong partition");
-      check(values.find(G.id(n)) == values.end(), "Wrong id");
-      check(G.id(n) <= G.maxRedId(), "Wrong maximum id");
-      values.insert(G.id(n));
-    }
-    check(G.maxId(RedNode()) == G.maxRedId(), "Wrong maximum id");
-  }
-
-  template <typename Graph>
-  void checkBlueNodeIds(const Graph& G) {
-    typedef typename Graph::BlueNode BlueNode;
-    std::set<int> values;
-    for (typename Graph::BlueNodeIt n(G); n != INVALID; ++n) {
-      check(G.blue(n), "Wrong partition");
-      check(values.find(G.id(n)) == values.end(), "Wrong id");
-      check(G.id(n) <= G.maxBlueId(), "Wrong maximum id");
-      values.insert(G.id(n));
-    }
-    check(G.maxId(BlueNode()) == G.maxBlueId(), "Wrong maximum id");
   }
 
   template <typename Graph>
   void checkArcIds(const Graph& G) {
-    typedef typename Graph::Arc Arc;
     std::set<int> values;
     for (typename Graph::ArcIt a(G); a != INVALID; ++a) {
@@ -416,10 +185,8 @@
       values.insert(G.id(a));
     }
-    check(G.maxId(Arc()) <= G.maxArcId(), "Wrong maximum id");
   }
 
   template <typename Graph>
   void checkEdgeIds(const Graph& G) {
-    typedef typename Graph::Edge Edge;
     std::set<int> values;
     for (typename Graph::EdgeIt e(G); e != INVALID; ++e) {
@@ -429,5 +196,4 @@
       values.insert(G.id(e));
     }
-    check(G.maxId(Edge()) <= G.maxEdgeId(), "Wrong maximum id");
   }
 
@@ -463,64 +229,4 @@
 
   template <typename Graph>
-  void checkGraphRedNodeMap(const Graph& G) {
-    typedef typename Graph::Node Node;
-    typedef typename Graph::RedNodeIt RedNodeIt;
-
-    typedef typename Graph::template RedNodeMap<int> IntRedNodeMap;
-    IntRedNodeMap map(G, 42);
-    for (RedNodeIt it(G); it != INVALID; ++it) {
-      check(map[it] == 42, "Wrong map constructor.");
-    }
-    int s = 0;
-    for (RedNodeIt it(G); it != INVALID; ++it) {
-      map[it] = 0;
-      check(map[it] == 0, "Wrong operator[].");
-      map.set(it, s);
-      check(map[it] == s, "Wrong set.");
-      ++s;
-    }
-    s = s * (s - 1) / 2;
-    for (RedNodeIt it(G); it != INVALID; ++it) {
-      s -= map[it];
-    }
-    check(s == 0, "Wrong sum.");
-
-    // map = constMap<Node>(12);
-    // for (NodeIt it(G); it != INVALID; ++it) {
-    //   check(map[it] == 12, "Wrong operator[].");
-    // }
-  }
-
-  template <typename Graph>
-  void checkGraphBlueNodeMap(const Graph& G) {
-    typedef typename Graph::Node Node;
-    typedef typename Graph::BlueNodeIt BlueNodeIt;
-
-    typedef typename Graph::template BlueNodeMap<int> IntBlueNodeMap;
-    IntBlueNodeMap map(G, 42);
-    for (BlueNodeIt it(G); it != INVALID; ++it) {
-      check(map[it] == 42, "Wrong map constructor.");
-    }
-    int s = 0;
-    for (BlueNodeIt it(G); it != INVALID; ++it) {
-      map[it] = 0;
-      check(map[it] == 0, "Wrong operator[].");
-      map.set(it, s);
-      check(map[it] == s, "Wrong set.");
-      ++s;
-    }
-    s = s * (s - 1) / 2;
-    for (BlueNodeIt it(G); it != INVALID; ++it) {
-      s -= map[it];
-    }
-    check(s == 0, "Wrong sum.");
-
-    // map = constMap<Node>(12);
-    // for (NodeIt it(G); it != INVALID; ++it) {
-    //   check(map[it] == 12, "Wrong operator[].");
-    // }
-  }
-
-  template <typename Graph>
   void checkGraphArcMap(const Graph& G) {
     typedef typename Graph::Arc Arc;
Index: test/hao_orlin_test.cc
===================================================================
--- test/hao_orlin_test.cc	(revision 1270)
+++ test/hao_orlin_test.cc	(revision 644)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -67,5 +67,4 @@
   CutMap cut;
   Value v;
-  ::lemon::ignore_unused_variable_warning(v);
 
   HaoOrlin<Digraph, CapMap> ho_test(g, cap);
@@ -85,5 +84,5 @@
 
 template <typename Graph, typename CapMap, typename CutMap>
-typename CapMap::Value
+typename CapMap::Value 
   cutValue(const Graph& graph, const CapMap& cap, const CutMap& cut)
 {
@@ -112,5 +111,5 @@
     ho.run();
     ho.minCutMap(cut);
-
+    
     check(ho.minCutValue() == 1, "Wrong cut value");
     check(ho.minCutValue() == cutValue(graph, cap1, cut), "Wrong cut value");
@@ -128,17 +127,17 @@
     ho.run();
     ho.minCutMap(cut);
-
+    
     check(ho.minCutValue() == 1, "Wrong cut value");
     check(ho.minCutValue() == cutValue(graph, cap3, cut), "Wrong cut value");
   }
-
+  
   typedef Undirector<SmartDigraph> UGraph;
   UGraph ugraph(graph);
-
+  
   {
     HaoOrlin<UGraph, SmartDigraph::ArcMap<int> > ho(ugraph, cap1);
     ho.run();
     ho.minCutMap(cut);
-
+    
     check(ho.minCutValue() == 2, "Wrong cut value");
     check(ho.minCutValue() == cutValue(ugraph, cap1, cut), "Wrong cut value");
@@ -148,5 +147,5 @@
     ho.run();
     ho.minCutMap(cut);
-
+    
     check(ho.minCutValue() == 5, "Wrong cut value");
     check(ho.minCutValue() == cutValue(ugraph, cap2, cut), "Wrong cut value");
@@ -156,5 +155,5 @@
     ho.run();
     ho.minCutMap(cut);
-
+    
     check(ho.minCutValue() == 5, "Wrong cut value");
     check(ho.minCutValue() == cutValue(ugraph, cap3, cut), "Wrong cut value");
Index: test/heap_test.cc
===================================================================
--- test/heap_test.cc	(revision 1270)
+++ test/heap_test.cc	(revision 749)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -31,10 +31,10 @@
 
 #include <lemon/bin_heap.h>
-#include <lemon/quad_heap.h>
-#include <lemon/dheap.h>
+#include <lemon/fourary_heap.h>
+#include <lemon/kary_heap.h>
 #include <lemon/fib_heap.h>
 #include <lemon/pairing_heap.h>
 #include <lemon/radix_heap.h>
-#include <lemon/binomial_heap.h>
+#include <lemon/binom_heap.h>
 #include <lemon/bucket_heap.h>
 
@@ -186,24 +186,24 @@
   }
 
-  // QuadHeap
-  {
-    typedef QuadHeap<Prio, ItemIntMap> IntHeap;
-    checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
-    heapSortTest<IntHeap>();
-    heapIncreaseTest<IntHeap>();
-
-    typedef QuadHeap<Prio, IntNodeMap > NodeHeap;
-    checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
-    dijkstraHeapTest<NodeHeap>(digraph, length, source);
-  }
-
-  // DHeap
-  {
-    typedef DHeap<Prio, ItemIntMap> IntHeap;
-    checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
-    heapSortTest<IntHeap>();
-    heapIncreaseTest<IntHeap>();
-
-    typedef DHeap<Prio, IntNodeMap > NodeHeap;
+  // FouraryHeap
+  {
+    typedef FouraryHeap<Prio, ItemIntMap> IntHeap;
+    checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
+    heapSortTest<IntHeap>();
+    heapIncreaseTest<IntHeap>();
+
+    typedef FouraryHeap<Prio, IntNodeMap > NodeHeap;
+    checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
+    dijkstraHeapTest<NodeHeap>(digraph, length, source);
+  }
+
+  // KaryHeap
+  {
+    typedef KaryHeap<Prio, ItemIntMap> IntHeap;
+    checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
+    heapSortTest<IntHeap>();
+    heapIncreaseTest<IntHeap>();
+
+    typedef KaryHeap<Prio, IntNodeMap > NodeHeap;
     checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
     dijkstraHeapTest<NodeHeap>(digraph, length, source);
@@ -246,12 +246,12 @@
   }
 
-  // BinomialHeap
-  {
-    typedef BinomialHeap<Prio, ItemIntMap> IntHeap;
-    checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
-    heapSortTest<IntHeap>();
-    heapIncreaseTest<IntHeap>();
-
-    typedef BinomialHeap<Prio, IntNodeMap > NodeHeap;
+  // BinomHeap
+  {
+    typedef BinomHeap<Prio, ItemIntMap> IntHeap;
+    checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
+    heapSortTest<IntHeap>();
+    heapIncreaseTest<IntHeap>();
+
+    typedef BinomHeap<Prio, IntNodeMap > NodeHeap;
     checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
     dijkstraHeapTest<NodeHeap>(digraph, length, source);
@@ -273,38 +273,4 @@
   }
 
-  {
-    typedef FibHeap<Prio, ItemIntMap> IntHeap;
-    checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
-    heapSortTest<IntHeap>();
-    heapIncreaseTest<IntHeap>();
-
-    typedef FibHeap<Prio, IntNodeMap > NodeHeap;
-    checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
-    dijkstraHeapTest<NodeHeap>(digraph, length, source);
-  }
-
-  {
-    typedef RadixHeap<ItemIntMap> IntHeap;
-    checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
-    heapSortTest<IntHeap>();
-    heapIncreaseTest<IntHeap>();
-
-    typedef RadixHeap<IntNodeMap > NodeHeap;
-    checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
-    dijkstraHeapTest<NodeHeap>(digraph, length, source);
-  }
-
-  {
-    typedef BucketHeap<ItemIntMap> IntHeap;
-    checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
-    heapSortTest<IntHeap>();
-    heapIncreaseTest<IntHeap>();
-
-    typedef BucketHeap<IntNodeMap > NodeHeap;
-    checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
-    dijkstraHeapTest<NodeHeap>(digraph, length, source);
-  }
-
-
   return 0;
 }
Index: st/lgf_reader_writer_test.cc
===================================================================
--- test/lgf_reader_writer_test.cc	(revision 1270)
+++ 	(revision )
@@ -1,578 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2013
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * 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 <string>
-
-#include <lemon/concepts/digraph.h>
-#include <lemon/concepts/graph.h>
-#include <lemon/concepts/bpgraph.h>
-
-#include <lemon/list_graph.h>
-#include <lemon/smart_graph.h>
-#include <lemon/lgf_reader.h>
-
-#include "test_tools.h"
-
-struct ReaderConverter {
-  int operator()(const std::string& str) const {
-    return str.length();
-  }
-};
-
-struct WriterConverter {
-  std::string operator()(int value) const {
-    return std::string(value, '*');
-  }
-};
-
-void checkDigraphReaderCompile() {
-  typedef lemon::concepts::ExtendableDigraphComponent<
-    lemon::concepts::Digraph> Digraph;
-  Digraph digraph;
-  Digraph::NodeMap<int> node_map(digraph);
-  Digraph::ArcMap<int> arc_map(digraph);
-  Digraph::Node node;
-  Digraph::Arc arc;
-  int attr;
-
-  lemon::DigraphReader<Digraph> reader(digraph, "filename");
-  reader.nodeMap("node_map", node_map);
-  reader.nodeMap("node_map", node_map, ReaderConverter());
-  reader.arcMap("arc_map", arc_map);
-  reader.arcMap("arc_map", arc_map, ReaderConverter());
-  reader.attribute("attr", attr);
-  reader.attribute("attr", attr, ReaderConverter());
-  reader.node("node", node);
-  reader.arc("arc", arc);
-
-  reader.nodes("alt_nodes_caption");
-  reader.arcs("alt_arcs_caption");
-  reader.attributes("alt_attrs_caption");
-
-  reader.useNodes(node_map);
-  reader.useNodes(node_map, WriterConverter());
-  reader.useArcs(arc_map);
-  reader.useArcs(arc_map, WriterConverter());
-
-  reader.skipNodes();
-  reader.skipArcs();
-
-  reader.run();
-
-  lemon::DigraphReader<Digraph> reader2(digraph, std::cin);
-}
-
-void checkDigraphWriterCompile() {
-  typedef lemon::concepts::Digraph Digraph;
-  Digraph digraph;
-  Digraph::NodeMap<int> node_map(digraph);
-  Digraph::ArcMap<int> arc_map(digraph);
-  Digraph::Node node;
-  Digraph::Arc arc;
-  int attr;
-
-  lemon::DigraphWriter<Digraph> writer(digraph, "filename");
-  writer.nodeMap("node_map", node_map);
-  writer.nodeMap("node_map", node_map, WriterConverter());
-  writer.arcMap("arc_map", arc_map);
-  writer.arcMap("arc_map", arc_map, WriterConverter());
-  writer.attribute("attr", attr);
-  writer.attribute("attr", attr, WriterConverter());
-  writer.node("node", node);
-  writer.arc("arc", arc);
-
-  writer.nodes("alt_nodes_caption");
-  writer.arcs("alt_arcs_caption");
-  writer.attributes("alt_attrs_caption");
-
-  writer.skipNodes();
-  writer.skipArcs();
-
-  writer.run();
-}
-
-void checkGraphReaderCompile() {
-  typedef lemon::concepts::ExtendableGraphComponent<
-    lemon::concepts::Graph> Graph;
-  Graph graph;
-  Graph::NodeMap<int> node_map(graph);
-  Graph::ArcMap<int> arc_map(graph);
-  Graph::EdgeMap<int> edge_map(graph);
-  Graph::Node node;
-  Graph::Arc arc;
-  Graph::Edge edge;
-  int attr;
-
-  lemon::GraphReader<Graph> reader(graph, "filename");
-  reader.nodeMap("node_map", node_map);
-  reader.nodeMap("node_map", node_map, ReaderConverter());
-  reader.arcMap("arc_map", arc_map);
-  reader.arcMap("arc_map", arc_map, ReaderConverter());
-  reader.edgeMap("edge_map", edge_map);
-  reader.edgeMap("edge_map", edge_map, ReaderConverter());
-  reader.attribute("attr", attr);
-  reader.attribute("attr", attr, ReaderConverter());
-  reader.node("node", node);
-  reader.arc("arc", arc);
-
-  reader.nodes("alt_nodes_caption");
-  reader.edges("alt_edges_caption");
-  reader.attributes("alt_attrs_caption");
-
-  reader.useNodes(node_map);
-  reader.useNodes(node_map, WriterConverter());
-  reader.useEdges(edge_map);
-  reader.useEdges(edge_map, WriterConverter());
-
-  reader.skipNodes();
-  reader.skipEdges();
-
-  reader.run();
-
-  lemon::GraphReader<Graph> reader2(graph, std::cin);
-}
-
-void checkGraphWriterCompile() {
-  typedef lemon::concepts::Graph Graph;
-  Graph graph;
-  Graph::NodeMap<int> node_map(graph);
-  Graph::ArcMap<int> arc_map(graph);
-  Graph::EdgeMap<int> edge_map(graph);
-  Graph::Node node;
-  Graph::Arc arc;
-  Graph::Edge edge;
-  int attr;
-
-  lemon::GraphWriter<Graph> writer(graph, "filename");
-  writer.nodeMap("node_map", node_map);
-  writer.nodeMap("node_map", node_map, WriterConverter());
-  writer.arcMap("arc_map", arc_map);
-  writer.arcMap("arc_map", arc_map, WriterConverter());
-  writer.edgeMap("edge_map", edge_map);
-  writer.edgeMap("edge_map", edge_map, WriterConverter());
-  writer.attribute("attr", attr);
-  writer.attribute("attr", attr, WriterConverter());
-  writer.node("node", node);
-  writer.arc("arc", arc);
-  writer.edge("edge", edge);
-
-  writer.nodes("alt_nodes_caption");
-  writer.edges("alt_edges_caption");
-  writer.attributes("alt_attrs_caption");
-
-  writer.skipNodes();
-  writer.skipEdges();
-
-  writer.run();
-
-  lemon::GraphWriter<Graph> writer2(graph, std::cout);
-}
-
-void checkBpGraphReaderCompile() {
-  typedef lemon::concepts::ExtendableBpGraphComponent<
-    lemon::concepts::BpGraph> BpGraph;
-  BpGraph graph;
-  BpGraph::NodeMap<int> node_map(graph);
-  BpGraph::RedNodeMap<int> red_node_map(graph);
-  BpGraph::BlueNodeMap<int> blue_node_map(graph);
-  BpGraph::ArcMap<int> arc_map(graph);
-  BpGraph::EdgeMap<int> edge_map(graph);
-  BpGraph::Node node;
-  BpGraph::RedNode red_node;
-  BpGraph::BlueNode blue_node;
-  BpGraph::Arc arc;
-  BpGraph::Edge edge;
-  int attr;
-
-  lemon::BpGraphReader<BpGraph> reader(graph, "filename");
-  reader.nodeMap("node_map", node_map);
-  reader.nodeMap("node_map", node_map, ReaderConverter());
-  reader.redNodeMap("red_node_map", red_node_map);
-  reader.redNodeMap("red_node_map", red_node_map, ReaderConverter());
-  reader.blueNodeMap("blue_node_map", blue_node_map);
-  reader.blueNodeMap("blue_node_map", blue_node_map, ReaderConverter());
-  reader.arcMap("arc_map", arc_map);
-  reader.arcMap("arc_map", arc_map, ReaderConverter());
-  reader.edgeMap("edge_map", edge_map);
-  reader.edgeMap("edge_map", edge_map, ReaderConverter());
-  reader.attribute("attr", attr);
-  reader.attribute("attr", attr, ReaderConverter());
-  reader.node("node", node);
-  reader.redNode("red_node", red_node);
-  reader.blueNode("blue_node", blue_node);
-  reader.arc("arc", arc);
-
-  reader.nodes("alt_nodes_caption");
-  reader.edges("alt_edges_caption");
-  reader.attributes("alt_attrs_caption");
-
-  reader.useNodes(node_map);
-  reader.useNodes(node_map, WriterConverter());
-  reader.useEdges(edge_map);
-  reader.useEdges(edge_map, WriterConverter());
-
-  reader.skipNodes();
-  reader.skipEdges();
-
-  reader.run();
-
-  lemon::BpGraphReader<BpGraph> reader2(graph, std::cin);
-}
-
-void checkBpGraphWriterCompile() {
-  typedef lemon::concepts::BpGraph BpGraph;
-  BpGraph graph;
-  BpGraph::NodeMap<int> node_map(graph);
-  BpGraph::RedNodeMap<int> red_node_map(graph);
-  BpGraph::BlueNodeMap<int> blue_node_map(graph);
-  BpGraph::ArcMap<int> arc_map(graph);
-  BpGraph::EdgeMap<int> edge_map(graph);
-  BpGraph::Node node;
-  BpGraph::RedNode red_node;
-  BpGraph::BlueNode blue_node;
-  BpGraph::Arc arc;
-  BpGraph::Edge edge;
-  int attr;
-
-  lemon::BpGraphWriter<BpGraph> writer(graph, "filename");
-  writer.nodeMap("node_map", node_map);
-  writer.nodeMap("node_map", node_map, WriterConverter());
-  writer.redNodeMap("red_node_map", red_node_map);
-  writer.redNodeMap("red_node_map", red_node_map, WriterConverter());
-  writer.blueNodeMap("blue_node_map", blue_node_map);
-  writer.blueNodeMap("blue_node_map", blue_node_map, WriterConverter());
-  writer.arcMap("arc_map", arc_map);
-  writer.arcMap("arc_map", arc_map, WriterConverter());
-  writer.edgeMap("edge_map", edge_map);
-  writer.edgeMap("edge_map", edge_map, WriterConverter());
-  writer.attribute("attr", attr);
-  writer.attribute("attr", attr, WriterConverter());
-  writer.node("node", node);
-  writer.redNode("red_node", red_node);
-  writer.blueNode("blue_node", blue_node);
-  writer.arc("arc", arc);
-
-  writer.nodes("alt_nodes_caption");
-  writer.edges("alt_edges_caption");
-  writer.attributes("alt_attrs_caption");
-
-  writer.skipNodes();
-  writer.skipEdges();
-
-  writer.run();
-
-  lemon::BpGraphWriter<BpGraph> writer2(graph, std::cout);
-}
-
-void checkDigraphReaderWriter() {
-  typedef lemon::SmartDigraph Digraph;
-  Digraph digraph;
-  Digraph::Node n1 = digraph.addNode();
-  Digraph::Node n2 = digraph.addNode();
-  Digraph::Node n3 = digraph.addNode();
-
-  Digraph::Arc a1 = digraph.addArc(n1, n2);
-  Digraph::Arc a2 = digraph.addArc(n2, n3);
-
-  Digraph::NodeMap<int> node_map(digraph);
-  node_map[n1] = 11;
-  node_map[n2] = 12;
-  node_map[n3] = 13;
-
-  Digraph::ArcMap<int> arc_map(digraph);
-  arc_map[a1] = 21;
-  arc_map[a2] = 22;
-
-  int attr = 100;
-
-  std::ostringstream os;
-  lemon::DigraphWriter<Digraph> writer(digraph, os);
-
-  writer.nodeMap("node_map1", node_map);
-  writer.nodeMap("node_map2", node_map, WriterConverter());
-  writer.arcMap("arc_map1", arc_map);
-  writer.arcMap("arc_map2", arc_map, WriterConverter());
-  writer.node("node", n2);
-  writer.arc("arc", a1);
-  writer.attribute("attr1", attr);
-  writer.attribute("attr2", attr, WriterConverter());
-
-  writer.run();
-
-  typedef lemon::ListDigraph ExpDigraph;
-  ExpDigraph exp_digraph;
-  ExpDigraph::NodeMap<int> exp_node_map1(exp_digraph);
-  ExpDigraph::NodeMap<int> exp_node_map2(exp_digraph);
-  ExpDigraph::ArcMap<int> exp_arc_map1(exp_digraph);
-  ExpDigraph::ArcMap<int> exp_arc_map2(exp_digraph);
-  ExpDigraph::Node exp_n2;
-  ExpDigraph::Arc exp_a1;
-  int exp_attr1;
-  int exp_attr2;
-
-  std::istringstream is(os.str());
-  lemon::DigraphReader<ExpDigraph> reader(exp_digraph, is);
-
-  reader.nodeMap("node_map1", exp_node_map1);
-  reader.nodeMap("node_map2", exp_node_map2, ReaderConverter());
-  reader.arcMap("arc_map1", exp_arc_map1);
-  reader.arcMap("arc_map2", exp_arc_map2, ReaderConverter());
-  reader.node("node", exp_n2);
-  reader.arc("arc", exp_a1);
-  reader.attribute("attr1", exp_attr1);
-  reader.attribute("attr2", exp_attr2, ReaderConverter());
-
-  reader.run();
-
-  check(lemon::countNodes(exp_digraph) == 3, "Wrong number of nodes");
-  check(lemon::countArcs(exp_digraph) == 2, "Wrong number of arcs");
-  check(exp_node_map1[exp_n2] == 12, "Wrong map value");
-  check(exp_node_map2[exp_n2] == 12, "Wrong map value");
-  check(exp_arc_map1[exp_a1] == 21, "Wrong map value");
-  check(exp_arc_map2[exp_a1] == 21, "Wrong map value");
-  check(exp_attr1 == 100, "Wrong attr value");
-  check(exp_attr2 == 100, "Wrong attr value");
-}
-
-void checkGraphReaderWriter() {
-  typedef lemon::SmartGraph Graph;
-  Graph graph;
-  Graph::Node n1 = graph.addNode();
-  Graph::Node n2 = graph.addNode();
-  Graph::Node n3 = graph.addNode();
-
-  Graph::Edge e1 = graph.addEdge(n1, n2);
-  Graph::Edge e2 = graph.addEdge(n2, n3);
-
-  Graph::NodeMap<int> node_map(graph);
-  node_map[n1] = 11;
-  node_map[n2] = 12;
-  node_map[n3] = 13;
-
-  Graph::EdgeMap<int> edge_map(graph);
-  edge_map[e1] = 21;
-  edge_map[e2] = 22;
-
-  Graph::ArcMap<int> arc_map(graph);
-  arc_map[graph.direct(e1, true)] = 211;
-  arc_map[graph.direct(e1, false)] = 212;
-  arc_map[graph.direct(e2, true)] = 221;
-  arc_map[graph.direct(e2, false)] = 222;
-
-  int attr = 100;
-
-  std::ostringstream os;
-  lemon::GraphWriter<Graph> writer(graph, os);
-
-  writer.nodeMap("node_map1", node_map);
-  writer.nodeMap("node_map2", node_map, WriterConverter());
-  writer.edgeMap("edge_map1", edge_map);
-  writer.edgeMap("edge_map2", edge_map, WriterConverter());
-  writer.arcMap("arc_map1", arc_map);
-  writer.arcMap("arc_map2", arc_map, WriterConverter());
-  writer.node("node", n2);
-  writer.edge("edge", e1);
-  writer.arc("arc", graph.direct(e1, false));
-  writer.attribute("attr1", attr);
-  writer.attribute("attr2", attr, WriterConverter());
-
-  writer.run();
-
-  typedef lemon::ListGraph ExpGraph;
-  ExpGraph exp_graph;
-  ExpGraph::NodeMap<int> exp_node_map1(exp_graph);
-  ExpGraph::NodeMap<int> exp_node_map2(exp_graph);
-  ExpGraph::EdgeMap<int> exp_edge_map1(exp_graph);
-  ExpGraph::EdgeMap<int> exp_edge_map2(exp_graph);
-  ExpGraph::ArcMap<int> exp_arc_map1(exp_graph);
-  ExpGraph::ArcMap<int> exp_arc_map2(exp_graph);
-  ExpGraph::Node exp_n2;
-  ExpGraph::Edge exp_e1;
-  ExpGraph::Arc exp_a1;
-  int exp_attr1;
-  int exp_attr2;
-
-  std::istringstream is(os.str());
-  lemon::GraphReader<ExpGraph> reader(exp_graph, is);
-
-  reader.nodeMap("node_map1", exp_node_map1);
-  reader.nodeMap("node_map2", exp_node_map2, ReaderConverter());
-  reader.edgeMap("edge_map1", exp_edge_map1);
-  reader.edgeMap("edge_map2", exp_edge_map2, ReaderConverter());
-  reader.arcMap("arc_map1", exp_arc_map1);
-  reader.arcMap("arc_map2", exp_arc_map2, ReaderConverter());
-  reader.node("node", exp_n2);
-  reader.edge("edge", exp_e1);
-  reader.arc("arc", exp_a1);
-  reader.attribute("attr1", exp_attr1);
-  reader.attribute("attr2", exp_attr2, ReaderConverter());
-
-  reader.run();
-
-  check(lemon::countNodes(exp_graph) == 3, "Wrong number of nodes");
-  check(lemon::countEdges(exp_graph) == 2, "Wrong number of edges");
-  check(lemon::countArcs(exp_graph) == 4, "Wrong number of arcs");
-  check(exp_node_map1[exp_n2] == 12, "Wrong map value");
-  check(exp_node_map2[exp_n2] == 12, "Wrong map value");
-  check(exp_edge_map1[exp_e1] == 21, "Wrong map value");
-  check(exp_edge_map2[exp_e1] == 21, "Wrong map value");
-  check(exp_arc_map1[exp_a1] == 212, "Wrong map value");
-  check(exp_arc_map2[exp_a1] == 212, "Wrong map value");
-  check(exp_attr1 == 100, "Wrong attr value");
-  check(exp_attr2 == 100, "Wrong attr value");
-}
-
-void checkBpGraphReaderWriter() {
-  typedef lemon::SmartBpGraph Graph;
-  Graph graph;
-  Graph::RedNode rn1 = graph.addRedNode();
-  Graph::RedNode rn2 = graph.addRedNode();
-  Graph::RedNode rn3 = graph.addRedNode();
-  Graph::BlueNode bn1 = graph.addBlueNode();
-  Graph::BlueNode bn2 = graph.addBlueNode();
-  Graph::Node n = bn1;
-
-  Graph::Edge e1 = graph.addEdge(rn1, bn1);
-  Graph::Edge e2 = graph.addEdge(rn2, bn1);
-
-  Graph::NodeMap<int> node_map(graph);
-  node_map[rn1] = 11;
-  node_map[rn2] = 12;
-  node_map[rn3] = 13;
-  node_map[bn1] = 14;
-  node_map[bn2] = 15;
-
-  Graph::NodeMap<int> red_node_map(graph);
-  red_node_map[rn1] = 411;
-  red_node_map[rn2] = 412;
-  red_node_map[rn3] = 413;
-
-  Graph::NodeMap<int> blue_node_map(graph);
-  blue_node_map[bn1] = 414;
-  blue_node_map[bn2] = 415;
-
-  Graph::EdgeMap<int> edge_map(graph);
-  edge_map[e1] = 21;
-  edge_map[e2] = 22;
-
-  Graph::ArcMap<int> arc_map(graph);
-  arc_map[graph.direct(e1, true)] = 211;
-  arc_map[graph.direct(e1, false)] = 212;
-  arc_map[graph.direct(e2, true)] = 221;
-  arc_map[graph.direct(e2, false)] = 222;
-
-  int attr = 100;
-
-  std::ostringstream os;
-  lemon::BpGraphWriter<Graph> writer(graph, os);
-
-  writer.nodeMap("node_map1", node_map);
-  writer.nodeMap("node_map2", node_map, WriterConverter());
-  writer.nodeMap("red_node_map1", red_node_map);
-  writer.nodeMap("red_node_map2", red_node_map, WriterConverter());
-  writer.nodeMap("blue_node_map1", blue_node_map);
-  writer.nodeMap("blue_node_map2", blue_node_map, WriterConverter());
-  writer.edgeMap("edge_map1", edge_map);
-  writer.edgeMap("edge_map2", edge_map, WriterConverter());
-  writer.arcMap("arc_map1", arc_map);
-  writer.arcMap("arc_map2", arc_map, WriterConverter());
-  writer.node("node", n);
-  writer.redNode("red_node", rn1);
-  writer.blueNode("blue_node", bn2);
-  writer.edge("edge", e1);
-  writer.arc("arc", graph.direct(e1, false));
-  writer.attribute("attr1", attr);
-  writer.attribute("attr2", attr, WriterConverter());
-
-  writer.run();
-
-  typedef lemon::ListBpGraph ExpGraph;
-  ExpGraph exp_graph;
-  ExpGraph::NodeMap<int> exp_node_map1(exp_graph);
-  ExpGraph::NodeMap<int> exp_node_map2(exp_graph);
-  ExpGraph::RedNodeMap<int> exp_red_node_map1(exp_graph);
-  ExpGraph::RedNodeMap<int> exp_red_node_map2(exp_graph);
-  ExpGraph::BlueNodeMap<int> exp_blue_node_map1(exp_graph);
-  ExpGraph::BlueNodeMap<int> exp_blue_node_map2(exp_graph);
-  ExpGraph::EdgeMap<int> exp_edge_map1(exp_graph);
-  ExpGraph::EdgeMap<int> exp_edge_map2(exp_graph);
-  ExpGraph::ArcMap<int> exp_arc_map1(exp_graph);
-  ExpGraph::ArcMap<int> exp_arc_map2(exp_graph);
-  ExpGraph::Node exp_n;
-  ExpGraph::RedNode exp_rn1;
-  ExpGraph::BlueNode exp_bn2;
-  ExpGraph::Edge exp_e1;
-  ExpGraph::Arc exp_a1;
-  int exp_attr1;
-  int exp_attr2;
-
-  std::istringstream is(os.str());
-  lemon::BpGraphReader<ExpGraph> reader(exp_graph, is);
-
-  reader.nodeMap("node_map1", exp_node_map1);
-  reader.nodeMap("node_map2", exp_node_map2, ReaderConverter());
-  reader.redNodeMap("red_node_map1", exp_red_node_map1);
-  reader.redNodeMap("red_node_map2", exp_red_node_map2, ReaderConverter());
-  reader.blueNodeMap("blue_node_map1", exp_blue_node_map1);
-  reader.blueNodeMap("blue_node_map2", exp_blue_node_map2, ReaderConverter());
-  reader.edgeMap("edge_map1", exp_edge_map1);
-  reader.edgeMap("edge_map2", exp_edge_map2, ReaderConverter());
-  reader.arcMap("arc_map1", exp_arc_map1);
-  reader.arcMap("arc_map2", exp_arc_map2, ReaderConverter());
-  reader.node("node", exp_n);
-  reader.redNode("red_node", exp_rn1);
-  reader.blueNode("blue_node", exp_bn2);
-  reader.edge("edge", exp_e1);
-  reader.arc("arc", exp_a1);
-  reader.attribute("attr1", exp_attr1);
-  reader.attribute("attr2", exp_attr2, ReaderConverter());
-
-  reader.run();
-
-  check(lemon::countNodes(exp_graph) == 5, "Wrong number of nodes");
-  check(lemon::countRedNodes(exp_graph) == 3, "Wrong number of red nodes");
-  check(lemon::countBlueNodes(exp_graph) == 2, "Wrong number of blue nodes");
-  check(lemon::countEdges(exp_graph) == 2, "Wrong number of edges");
-  check(lemon::countArcs(exp_graph) == 4, "Wrong number of arcs");
-  check(exp_node_map1[exp_n] == 14, "Wrong map value");
-  check(exp_node_map2[exp_n] == 14, "Wrong map value");
-  check(exp_red_node_map1[exp_rn1] == 411, "Wrong map value");
-  check(exp_red_node_map2[exp_rn1] == 411, "Wrong map value");
-  check(exp_blue_node_map1[exp_bn2] == 415, "Wrong map value");
-  check(exp_blue_node_map2[exp_bn2] == 415, "Wrong map value");
-  check(exp_edge_map1[exp_e1] == 21, "Wrong map value");
-  check(exp_edge_map2[exp_e1] == 21, "Wrong map value");
-  check(exp_arc_map1[exp_a1] == 212, "Wrong map value");
-  check(exp_arc_map2[exp_a1] == 212, "Wrong map value");
-  check(exp_attr1 == 100, "Wrong attr value");
-  check(exp_attr2 == 100, "Wrong attr value");
-}
-
-
-int main() {
-  { // Check digrpah
-    checkDigraphReaderWriter();
-  }
-  { // Check graph
-    checkGraphReaderWriter();
-  }
-  { // Check bipartite graph
-    checkBpGraphReaderWriter();
-  }
-  return 0;
-}
Index: st/lgf_test.cc
===================================================================
--- test/lgf_test.cc	(revision 1270)
+++ 	(revision )
@@ -1,169 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2013
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * 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/list_graph.h>
-#include <lemon/lgf_reader.h>
-#include "test_tools.h"
-
-using namespace lemon;
-
-char test_lgf[] =
-  "@nodes\n"
-  "label\n"
-  "0\n"
-  "1\n"
-  "@arcs\n"
-  "     label\n"
-  "0 1  0\n"
-  "1 0  1\n"
-  "@attributes\n"
-  "source 0\n"
-  "target 1\n";
-
-char test_lgf_nomap[] =
-  "@nodes\n"
-  "label\n"
-  "0\n"
-  "1\n"
-  "@arcs\n"
-  "     -\n"
-  "0 1\n";
-
-char test_lgf_bad1[] =
-  "@nodes\n"
-  "label\n"
-  "0\n"
-  "1\n"
-  "@arcs\n"
-  "     - another\n"
-  "0 1\n";
-
-char test_lgf_bad2[] =
-  "@nodes\n"
-  "label\n"
-  "0\n"
-  "1\n"
-  "@arcs\n"
-  "     label -\n"
-  "0 1\n";
-
-
-int main()
-{
-  {
-    ListDigraph d;
-    ListDigraph::Node s,t;
-    ListDigraph::ArcMap<int> label(d);
-    std::istringstream input(test_lgf);
-    digraphReader(d, input).
-      node("source", s).
-      node("target", t).
-      arcMap("label", label).
-      run();
-    check(countNodes(d) == 2,"There should be 2 nodes");
-    check(countArcs(d) == 2,"There should be 2 arcs");
-  }
-  {
-    ListGraph g;
-    ListGraph::Node s,t;
-    ListGraph::EdgeMap<int> label(g);
-    std::istringstream input(test_lgf);
-    graphReader(g, input).
-      node("source", s).
-      node("target", t).
-      edgeMap("label", label).
-      run();
-    check(countNodes(g) == 2,"There should be 2 nodes");
-    check(countEdges(g) == 2,"There should be 2 arcs");
-  }
-
-  {
-    ListDigraph d;
-    std::istringstream input(test_lgf_nomap);
-    digraphReader(d, input).
-      run();
-    check(countNodes(d) == 2,"There should be 2 nodes");
-    check(countArcs(d) == 1,"There should be 1 arc");
-  }
-  {
-    ListGraph g;
-    std::istringstream input(test_lgf_nomap);
-    graphReader(g, input).
-      run();
-    check(countNodes(g) == 2,"There should be 2 nodes");
-    check(countEdges(g) == 1,"There should be 1 edge");
-  }
-
-  {
-    ListDigraph d;
-    std::istringstream input(test_lgf_bad1);
-    bool ok=false;
-    try {
-      digraphReader(d, input).
-        run();
-    }
-    catch (FormatError&)
-      {
-        ok = true;
-      }
-    check(ok,"FormatError exception should have occured");
-  }
-  {
-    ListGraph g;
-    std::istringstream input(test_lgf_bad1);
-    bool ok=false;
-    try {
-      graphReader(g, input).
-        run();
-    }
-    catch (FormatError&)
-      {
-        ok = true;
-      }
-    check(ok,"FormatError exception should have occured");
-  }
-
-  {
-    ListDigraph d;
-    std::istringstream input(test_lgf_bad2);
-    bool ok=false;
-    try {
-      digraphReader(d, input).
-        run();
-    }
-    catch (FormatError&)
-      {
-        ok = true;
-      }
-    check(ok,"FormatError exception should have occured");
-  }
-  {
-    ListGraph g;
-    std::istringstream input(test_lgf_bad2);
-    bool ok=false;
-    try {
-      graphReader(g, input).
-        run();
-    }
-    catch (FormatError&)
-      {
-        ok = true;
-      }
-    check(ok,"FormatError exception should have occured");
-  }
-}
Index: test/lp_test.cc
===================================================================
--- test/lp_test.cc	(revision 1337)
+++ test/lp_test.cc	(revision 678)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -21,5 +21,5 @@
 #include "test_tools.h"
 #include <lemon/tolerance.h>
-#include <lemon/concept_check.h>
+
 #include <lemon/config.h>
 
@@ -40,31 +40,5 @@
 #endif
 
-#ifdef LEMON_HAVE_LP
-#include <lemon/lp.h>
-#endif
 using namespace lemon;
-
-int countCols(LpBase & lp) {
-  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;
-}
-
-int countRows(LpBase & lp) {
-  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;
-}
-
 
 void lpTest(LpSolver& lp)
@@ -72,18 +46,4 @@
 
   typedef LpSolver LP;
-
-  // Test LpBase::clear()
-  check(countRows(lp)==0, "Wrong number of rows");
-  check(countCols(lp)==0, "Wrong number of cols");
-  lp.addCol(); lp.addRow(); lp.addRow();
-  check(countRows(lp)==2, "Wrong number of rows");
-  check(countCols(lp)==1, "Wrong number of cols");
-  lp.clear();
-  check(countRows(lp)==0, "Wrong number of rows");
-  check(countCols(lp)==0, "Wrong number of cols");
-  lp.addCol(); lp.addCol(); lp.addCol(); lp.addRow();
-  check(countRows(lp)==1, "Wrong number of rows");
-  check(countCols(lp)==3, "Wrong number of cols");
-  lp.clear();
 
   std::vector<LP::Col> x(10);
@@ -207,17 +167,4 @@
     c = ((2 >= p1) >= 3);
 
-    { //Tests for #430
-      LP::Col v=lp.addCol();
-      LP::Constr c = v >= -3;
-      c = c <= 4;
-      LP::Constr c2;
-#if ( __GNUC__ == 4 ) && ( __GNUC_MINOR__ == 3 )
-      c2 = ( -3 <= v ) <= 4;
-#else
-      c2 = -3 <= v <= 4;
-#endif
-
-    }
-
     e[x[3]]=2;
     e[x[3]]=4;
@@ -259,5 +206,6 @@
   {
     LP::DualExpr e,f,g;
-    LP::Row p1 = INVALID, p2 = INVALID;
+    LP::Row p1 = INVALID, p2 = INVALID, p3 = INVALID,
+      p4 = INVALID, p5 = INVALID;
 
     e[p1]=2;
@@ -430,13 +378,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 836)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -104,5 +104,4 @@
     NullMap<A,B> map1;
     NullMap<A,B> map2 = map1;
-    ::lemon::ignore_unused_variable_warning(map2);
     map1 = nullMap<A,B>();
   }
@@ -115,6 +114,4 @@
     ConstMap<A,B> map2 = B();
     ConstMap<A,B> map3 = map1;
-    ::lemon::ignore_unused_variable_warning(map2,map3);
-
     map1 = constMap<A>(B());
     map1 = constMap<A,B>();
@@ -122,6 +119,4 @@
     ConstMap<A,C> map4(C(1));
     ConstMap<A,C> map5 = map4;
-    ::lemon::ignore_unused_variable_warning(map5);
-
     map4 = constMap<A>(C(2));
     map4.setAll(C(3));
@@ -144,6 +139,4 @@
     IdentityMap<A> map1;
     IdentityMap<A> map2 = map1;
-    ::lemon::ignore_unused_variable_warning(map2);
-
     map1 = identityMap<A>();
 
@@ -205,7 +198,5 @@
     checkConcept<ReadMap<B,double>, CompMap>();
     CompMap map1 = CompMap(DoubleMap(),ReadMap<B,A>());
-    ::lemon::ignore_unused_variable_warning(map1);
     CompMap map2 = composeMap(DoubleMap(), ReadMap<B,A>());
-    ::lemon::ignore_unused_variable_warning(map2);
 
     SparseMap<double, bool> m1(false); m1[3.14] = true;
@@ -220,7 +211,5 @@
     checkConcept<ReadMap<A,double>, CombMap>();
     CombMap map1 = CombMap(DoubleMap(), DoubleMap());
-    ::lemon::ignore_unused_variable_warning(map1);
     CombMap map2 = combineMap(DoubleMap(), DoubleMap(), std::plus<double>());
-    ::lemon::ignore_unused_variable_warning(map2);
 
     check(combineMap(constMap<B,int,2>(), identityMap<B>(), &binc)[B()] == 3,
@@ -234,13 +223,8 @@
     FunctorToMap<F> map1;
     FunctorToMap<F> map2 = FunctorToMap<F>(F());
-    ::lemon::ignore_unused_variable_warning(map2);
-
     B b = functorToMap(F())[A()];
-    ::lemon::ignore_unused_variable_warning(b);
 
     checkConcept<ReadMap<A,B>, MapToFunctor<ReadMap<A,B> > >();
-    MapToFunctor<ReadMap<A,B> > map =
-      MapToFunctor<ReadMap<A,B> >(ReadMap<A,B>());
-    ::lemon::ignore_unused_variable_warning(map);
+    MapToFunctor<ReadMap<A,B> > map = MapToFunctor<ReadMap<A,B> >(ReadMap<A,B>());
 
     check(functorToMap(&func)[A()] == 3,
@@ -260,8 +244,5 @@
       ConvertMap<ReadMap<double, int>, double> >();
     ConvertMap<RangeMap<bool>, int> map1(rangeMap(1, true));
-    ::lemon::ignore_unused_variable_warning(map1);
     ConvertMap<RangeMap<bool>, int> map2 = convertMap<int>(rangeMap(2, false));
-    ::lemon::ignore_unused_variable_warning(map2);
-
   }
 
@@ -397,5 +378,5 @@
           it != map2.end(); ++it )
       check(v1[i++] == *it, "Something is wrong with LoggerBoolMap");
-
+    
     typedef ListDigraph Graph;
     DIGRAPH_TYPEDEFS(Graph);
@@ -406,5 +387,5 @@
     Node n2 = gr.addNode();
     Node n3 = gr.addNode();
-
+    
     gr.addArc(n3, n0);
     gr.addArc(n3, n2);
@@ -412,5 +393,5 @@
     gr.addArc(n2, n1);
     gr.addArc(n0, n1);
-
+    
     {
       std::vector<Node> v;
@@ -423,10 +404,10 @@
       std::vector<Node> v(countNodes(gr));
       dfs(gr).processedMap(loggerBoolMap(v.begin())).run();
-
+      
       check(v.size()==4 && v[0]==n1 && v[1]==n2 && v[2]==n0 && v[3]==n3,
             "Something is wrong with LoggerBoolMap");
     }
   }
-
+  
   // IdMap, RangeIdMap
   {
@@ -438,5 +419,5 @@
     checkConcept<ReadMap<Node, int>, RangeIdMap<Graph, Node> >();
     checkConcept<ReadMap<Arc, int>, RangeIdMap<Graph, Arc> >();
-
+    
     Graph gr;
     IdMap<Graph, Node> nmap(gr);
@@ -444,14 +425,14 @@
     RangeIdMap<Graph, Node> nrmap(gr);
     RangeIdMap<Graph, Arc> armap(gr);
-
+    
     Node n0 = gr.addNode();
     Node n1 = gr.addNode();
     Node n2 = gr.addNode();
-
+    
     Arc a0 = gr.addArc(n0, n1);
     Arc a1 = gr.addArc(n0, n2);
     Arc a2 = gr.addArc(n2, n1);
     Arc a3 = gr.addArc(n2, n0);
-
+    
     check(nmap[n0] == gr.id(n0) && nmap(gr.id(n0)) == n0, "Wrong IdMap");
     check(nmap[n1] == gr.id(n1) && nmap(gr.id(n1)) == n1, "Wrong IdMap");
@@ -465,5 +446,5 @@
     check(nmap.inverse()[gr.id(n0)] == n0, "Wrong IdMap::InverseMap");
     check(amap.inverse()[gr.id(a0)] == a0, "Wrong IdMap::InverseMap");
-
+    
     check(nrmap.size() == 3 && armap.size() == 4,
           "Wrong RangeIdMap::size()");
@@ -472,5 +453,5 @@
     check(nrmap[n1] == 1 && nrmap(1) == n1, "Wrong RangeIdMap");
     check(nrmap[n2] == 2 && nrmap(2) == n2, "Wrong RangeIdMap");
-
+    
     check(armap[a0] == 0 && armap(0) == a0, "Wrong RangeIdMap");
     check(armap[a1] == 1 && armap(1) == a1, "Wrong RangeIdMap");
@@ -480,12 +461,12 @@
     check(nrmap.inverse()[0] == n0, "Wrong RangeIdMap::InverseMap");
     check(armap.inverse()[0] == a0, "Wrong RangeIdMap::InverseMap");
-
+    
     gr.erase(n1);
-
+    
     if (nrmap[n0] == 1) nrmap.swap(n0, n2);
     nrmap.swap(n2, n0);
     if (armap[a1] == 1) armap.swap(a1, a3);
     armap.swap(a3, a1);
-
+    
     check(nrmap.size() == 2 && armap.size() == 2,
           "Wrong RangeIdMap::size()");
@@ -493,5 +474,5 @@
     check(nrmap[n0] == 1 && nrmap(1) == n0, "Wrong RangeIdMap");
     check(nrmap[n2] == 0 && nrmap(0) == n2, "Wrong RangeIdMap");
-
+    
     check(armap[a1] == 1 && armap(1) == a1, "Wrong RangeIdMap");
     check(armap[a3] == 0 && armap(0) == a3, "Wrong RangeIdMap");
@@ -500,10 +481,10 @@
     check(armap.inverse()[0] == a3, "Wrong RangeIdMap::InverseMap");
   }
-
+  
   // SourceMap, TargetMap, ForwardMap, BackwardMap, InDegMap, OutDegMap
   {
     typedef ListGraph Graph;
     GRAPH_TYPEDEFS(Graph);
-
+    
     checkConcept<ReadMap<Arc, Node>, SourceMap<Graph> >();
     checkConcept<ReadMap<Arc, Node>, TargetMap<Graph> >();
@@ -517,5 +498,5 @@
     Node n1 = gr.addNode();
     Node n2 = gr.addNode();
-
+    
     gr.addEdge(n0,n1);
     gr.addEdge(n1,n2);
@@ -524,10 +505,10 @@
     gr.addEdge(n1,n2);
     gr.addEdge(n0,n1);
-
+    
     for (EdgeIt e(gr); e != INVALID; ++e) {
       check(forwardMap(gr)[e] == gr.direct(e, true), "Wrong ForwardMap");
       check(backwardMap(gr)[e] == gr.direct(e, false), "Wrong BackwardMap");
     }
-
+    
     check(mapCompare(gr,
           sourceMap(orienter(gr, constMap<Edge, bool>(true))),
@@ -536,12 +517,11 @@
 
     typedef Orienter<Graph, const ConstMap<Edge, bool> > Digraph;
-    ConstMap<Edge, bool> true_edge_map(true);
-    Digraph dgr(gr, true_edge_map);
+    Digraph dgr(gr, constMap<Edge, bool>(true));
     OutDegMap<Digraph> odm(dgr);
     InDegMap<Digraph> idm(dgr);
-
+    
     check(odm[n0] == 3 && odm[n1] == 2 && odm[n2] == 1, "Wrong OutDegMap");
     check(idm[n0] == 0 && idm[n1] == 3 && idm[n2] == 3, "Wrong InDegMap");
-
+   
     gr.addEdge(n2, n0);
 
@@ -549,5 +529,5 @@
     check(idm[n0] == 1 && idm[n1] == 3 && idm[n2] == 3, "Wrong InDegMap");
   }
-
+  
   // CrossRefMap
   {
@@ -561,17 +541,17 @@
     checkConcept<ReadWriteMap<Node, double>,
                  CrossRefMap<Graph, Node, double> >();
-
+    
     Graph gr;
     typedef CrossRefMap<Graph, Node, char> CRMap;
     CRMap map(gr);
-
+    
     Node n0 = gr.addNode();
     Node n1 = gr.addNode();
     Node n2 = gr.addNode();
-
+    
     map.set(n0, 'A');
     map.set(n1, 'B');
     map.set(n2, 'C');
-
+    
     check(map[n0] == 'A' && map('A') == n0 && map.inverse()['A'] == n0,
           "Wrong CrossRefMap");
@@ -582,9 +562,9 @@
     check(map.count('A') == 1 && map.count('B') == 1 && map.count('C') == 1,
           "Wrong CrossRefMap::count()");
-
+    
     CRMap::ValueIt it = map.beginValue();
     check(*it++ == 'A' && *it++ == 'B' && *it++ == 'C' &&
           it == map.endValue(), "Wrong value iterator");
-
+    
     map.set(n2, 'A');
 
@@ -624,14 +604,14 @@
     checkConcept<ReadWriteMap<Node, int>,
                  CrossRefMap<Graph, Node, int> >();
-
+    
     Graph gr;
     typedef CrossRefMap<Graph, Node, char> CRMap;
     typedef CRMap::ValueIterator ValueIt;
     CRMap map(gr);
-
+    
     Node n0 = gr.addNode();
     Node n1 = gr.addNode();
     Node n2 = gr.addNode();
-
+    
     map.set(n0, 'A');
     map.set(n1, 'B');
@@ -650,5 +630,5 @@
           it == map.endValue(), "Wrong value iterator");
   }
-
+  
   // Iterable bool map
   {
@@ -661,5 +641,4 @@
     const int num = 10;
     Graph g;
-    Ibm map0(g, true);
     std::vector<Item> items;
     for (int i = 0; i < num; ++i) {
@@ -731,28 +710,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
-
   }
 
@@ -767,5 +722,4 @@
     const int num = 10;
     Graph g;
-    Iim map0(g, 0);
     std::vector<Item> items;
     for (int i = 0; i < num; ++i) {
@@ -805,13 +759,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
 
   }
@@ -827,5 +772,4 @@
     const int num = 10;
     Graph g;
-    Ivm map0(g, 0.0);
     std::vector<Item> items;
     for (int i = 0; i < num; ++i) {
@@ -873,16 +817,6 @@
     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
-
-  }
-
+  }
+  
   // Graph map utilities:
   // mapMin(), mapMax(), mapMinValue(), mapMaxValue()
@@ -896,14 +830,14 @@
     Node n2 = g.addNode();
     Node n3 = g.addNode();
-
+    
     SmartDigraph::NodeMap<int> map1(g);
     SmartDigraph::ArcMap<char> map2(g);
     ConstMap<Node, A> cmap1 = A();
     ConstMap<Arc, C> cmap2 = C(0);
-
+    
     map1[n1] = 10;
     map1[n2] = 5;
     map1[n3] = 12;
-
+    
     // mapMin(), mapMax(), mapMinValue(), mapMaxValue()
     check(mapMin(g, map1) == n2, "Wrong mapMin()");
@@ -924,5 +858,5 @@
     Arc a3 = g.addArc(n2, n3);
     Arc a4 = g.addArc(n3, n1);
-
+    
     map2[a1] = 'b';
     map2[a2] = 'a';
@@ -991,5 +925,5 @@
     check(mapCountIf(g, map2, Less<char>('a')) == 0,
           "Wrong mapCountIf()");
-
+     
     // MapIt, ConstMapIt
 /*
@@ -1001,5 +935,5 @@
     check(*std::max_element(ConstMapIt(map1), ConstMapIt(INVALID)) == 12,
           "Wrong NodeMap<>::MapIt");
-
+    
     int sum = 0;
     std::for_each(MapIt(map1), MapIt(INVALID), Sum<int>(sum));
@@ -1018,23 +952,23 @@
     SmartDigraph::NodeMap<int> map3(g, 0);
     SmartDigraph::ArcMap<char> map4(g, 'a');
-
+    
     check(!mapCompare(g, map1, map3), "Wrong mapCompare()");
-    check(!mapCompare(g, map2, map4), "Wrong mapCompare()");
-
+    check(!mapCompare(g, map2, map4), "Wrong mapCompare()");    
+    
     mapCopy(g, map1, map3);
     mapCopy(g, map2, map4);
 
     check(mapCompare(g, map1, map3), "Wrong mapCompare() or mapCopy()");
-    check(mapCompare(g, map2, map4), "Wrong mapCompare() or mapCopy()");
-
+    check(mapCompare(g, map2, map4), "Wrong mapCompare() or mapCopy()");    
+    
     Undirector<SmartDigraph> ug(g);
     Undirector<SmartDigraph>::EdgeMap<char> umap1(ug, 'x');
     Undirector<SmartDigraph>::ArcMap<double> umap2(ug, 3.14);
-
+    
     check(!mapCompare(g, map2, umap1), "Wrong mapCompare() or mapCopy()");
     check(!mapCompare(g, umap1, map2), "Wrong mapCompare() or mapCopy()");
     check(!mapCompare(ug, map2, umap1), "Wrong mapCompare() or mapCopy()");
     check(!mapCompare(ug, umap1, map2), "Wrong mapCompare() or mapCopy()");
-
+    
     mapCopy(g, map2, umap1);
 
@@ -1043,14 +977,14 @@
     check(mapCompare(ug, map2, umap1), "Wrong mapCompare() or mapCopy()");
     check(mapCompare(ug, umap1, map2), "Wrong mapCompare() or mapCopy()");
-
+    
     mapCopy(g, map2, umap1);
     mapCopy(g, umap1, map2);
     mapCopy(ug, map2, umap1);
     mapCopy(ug, umap1, map2);
-
+    
     check(!mapCompare(ug, umap1, umap2), "Wrong mapCompare() or mapCopy()");
     mapCopy(ug, umap1, umap2);
     check(mapCompare(ug, umap1, umap2), "Wrong mapCompare() or mapCopy()");
-
+    
     check(!mapCompare(g, map1, constMap<Node>(2)), "Wrong mapCompare()");
     mapFill(g, map1, 2);
@@ -1061,5 +995,5 @@
     check(mapCompare(g, constMap<Arc>('z'), map2), "Wrong mapCopy()");
   }
-
+  
   return 0;
 }
Index: test/matching_test.cc
===================================================================
--- test/matching_test.cc	(revision 1270)
+++ test/matching_test.cc	(revision 641)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -135,5 +135,5 @@
   mat_test.startDense();
   mat_test.run();
-
+  
   const_mat_test.matchingSize();
   const_mat_test.matching(e);
@@ -144,7 +144,6 @@
   const_mat_test.mate(n);
 
-  MaxMatching<Graph>::Status stat =
+  MaxMatching<Graph>::Status stat = 
     const_mat_test.status(n);
-  ::lemon::ignore_unused_variable_warning(stat);
   const MaxMatching<Graph>::StatusMap& smap =
     const_mat_test.statusMap();
@@ -172,5 +171,5 @@
   mat_test.start();
   mat_test.run();
-
+  
   const_mat_test.matchingWeight();
   const_mat_test.matchingSize();
@@ -181,5 +180,5 @@
   e = mmap[n];
   const_mat_test.mate(n);
-
+  
   int k = 0;
   const_mat_test.dualValue();
@@ -209,5 +208,5 @@
   mat_test.start();
   mat_test.run();
-
+  
   const_mat_test.matchingWeight();
   const_mat_test.matching(e);
@@ -217,5 +216,5 @@
   e = mmap[n];
   const_mat_test.mate(n);
-
+  
   int k = 0;
   const_mat_test.dualValue();
@@ -403,44 +402,20 @@
       edgeMap("weight", weight).run();
 
-    bool perfect;
-    {
-      MaxMatching<SmartGraph> mm(graph);
-      mm.run();
-      checkMatching(graph, mm);
-      perfect = 2 * mm.matchingSize() == countNodes(graph);
-    }
-
-    {
-      MaxWeightedMatching<SmartGraph> mwm(graph, weight);
-      mwm.run();
-      checkWeightedMatching(graph, weight, mwm);
-    }
-
-    {
-      MaxWeightedMatching<SmartGraph> mwm(graph, weight);
-      mwm.init();
-      mwm.start();
-      checkWeightedMatching(graph, weight, mwm);
-    }
-
-    {
-      MaxWeightedPerfectMatching<SmartGraph> mwpm(graph, weight);
-      bool result = mwpm.run();
-
-      check(result == perfect, "Perfect matching found");
-      if (perfect) {
-        checkWeightedPerfectMatching(graph, weight, mwpm);
-      }
-    }
-
-    {
-      MaxWeightedPerfectMatching<SmartGraph> mwpm(graph, weight);
-      mwpm.init();
-      bool result = mwpm.start();
-
-      check(result == perfect, "Perfect matching found");
-      if (perfect) {
-        checkWeightedPerfectMatching(graph, weight, mwpm);
-      }
+    MaxMatching<SmartGraph> mm(graph);
+    mm.run();
+    checkMatching(graph, mm);
+
+    MaxWeightedMatching<SmartGraph> mwm(graph, weight);
+    mwm.run();
+    checkWeightedMatching(graph, weight, mwm);
+
+    MaxWeightedPerfectMatching<SmartGraph> mwpm(graph, weight);
+    bool perfect = mwpm.run();
+
+    check(perfect == (mm.matchingSize() * 2 == countNodes(graph)),
+          "Perfect matching found");
+
+    if (perfect) {
+      checkWeightedPerfectMatching(graph, weight, mwpm);
     }
   }
Index: st/max_cardinality_search_test.cc
===================================================================
--- test/max_cardinality_search_test.cc	(revision 1270)
+++ 	(revision )
@@ -1,162 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2013
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * 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 <iostream>
-
-#include "test_tools.h"
-#include <lemon/smart_graph.h>
-#include <lemon/max_cardinality_search.h>
-#include <lemon/concepts/digraph.h>
-#include <lemon/concepts/maps.h>
-#include <lemon/concepts/heap.h>
-#include <lemon/lgf_reader.h>
-
-using namespace lemon;
-using namespace std;
-
-char test_lgf[] =
-  "@nodes\n"
-  "label\n"
-  "0\n"
-  "1\n"
-  "2\n"
-  "3\n"
-  "@arcs\n"
-  "    label capacity\n"
-  "0 1 0     2\n"
-  "1 0 1     2\n"
-  "2 1 2     1\n"
-  "2 3 3     3\n"
-  "3 2 4     3\n"
-  "3 1 5     5\n"
-  "@attributes\n"
-  "s 0\n"
-  "x 1\n"
-  "y 2\n"
-  "z 3\n";
-
-void checkMaxCardSearchCompile() {
-
-  typedef concepts::Digraph Digraph;
-  typedef int Value;
-  typedef Digraph::Node Node;
-  typedef Digraph::Arc Arc;
-  typedef concepts::ReadMap<Arc,Value> CapMap;
-  typedef concepts::ReadWriteMap<Node,Value> CardMap;
-  typedef concepts::ReadWriteMap<Node,bool> ProcMap;
-  typedef Digraph::NodeMap<int> HeapCrossRef;
-
-  Digraph g;
-  Node n,s;
-  CapMap cap;
-  CardMap card;
-  ProcMap proc;
-  HeapCrossRef crossref(g);
-
-  typedef MaxCardinalitySearch<Digraph,CapMap>
-    ::SetCapacityMap<CapMap>
-    ::SetCardinalityMap<CardMap>
-    ::SetProcessedMap<ProcMap>
-    ::SetStandardHeap<BinHeap<Value,HeapCrossRef> >
-    ::Create MaxCardType;
-
-  MaxCardType maxcard(g,cap);
-  const MaxCardType& const_maxcard = maxcard;
-
-  const MaxCardType::Heap& heap_const = const_maxcard.heap();
-  MaxCardType::Heap& heap = const_cast<MaxCardType::Heap&>(heap_const);
-  maxcard.heap(heap,crossref);
-
-  maxcard.capacityMap(cap).cardinalityMap(card).processedMap(proc);
-
-  maxcard.init();
-  maxcard.addSource(s);
-  n = maxcard.nextNode();
-   maxcard.processNextNode();
-   maxcard.start();
-   maxcard.run(s);
-   maxcard.run();
- }
-
- void checkWithIntMap( std::istringstream& input)
- {
-   typedef SmartDigraph Digraph;
-   typedef Digraph::Node Node;
-   typedef Digraph::ArcMap<int> CapMap;
-
-   Digraph g;
-   Node s,x,y,z,a;
-   CapMap cap(g);
-
-   DigraphReader<Digraph>(g,input).
-     arcMap("capacity", cap).
-     node("s",s).
-     node("x",x).
-     node("y",y).
-     node("z",z).
-     run();
-
-   MaxCardinalitySearch<Digraph,CapMap> maxcard(g,cap);
-
-   maxcard.init();
-   maxcard.addSource(s);
-   maxcard.start(x);
-
-   check(maxcard.processed(s) && !maxcard.processed(x) &&
-         !maxcard.processed(y), "Wrong processed()!");
-
-   a=maxcard.nextNode();
-   check(maxcard.processNextNode()==a,
-         "Wrong nextNode() or processNextNode() return value!");
-
-   check(maxcard.processed(a), "Wrong processNextNode()!");
-
-   maxcard.start();
-   check(maxcard.cardinality(x)==2 && maxcard.cardinality(y)>=4,
-         "Wrong cardinalities!");
- }
-
- void checkWithConst1Map(std::istringstream &input) {
-   typedef SmartDigraph Digraph;
-   typedef Digraph::Node Node;
-
-   Digraph g;
-   Node s,x,y,z;
-
-  DigraphReader<Digraph>(g,input).
-    node("s",s).
-    node("x",x).
-    node("y",y).
-    node("z",z).
-    run();
-
-  MaxCardinalitySearch<Digraph> maxcard(g);
-  maxcard.run(s);
-  check(maxcard.cardinality(x)==1 &&
-        maxcard.cardinality(y)+maxcard.cardinality(z)==3,
-        "Wrong cardinalities!");
-}
-
-int main() {
-
-  std::istringstream input1(test_lgf);
-  checkWithIntMap(input1);
-
-  std::istringstream input2(test_lgf);
-  checkWithConst1Map(input2);
-}
Index: st/max_clique_test.cc
===================================================================
--- test/max_clique_test.cc	(revision 1270)
+++ 	(revision )
@@ -1,188 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2013
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * 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 <sstream>
-#include <lemon/list_graph.h>
-#include <lemon/full_graph.h>
-#include <lemon/grid_graph.h>
-#include <lemon/lgf_reader.h>
-#include <lemon/grosso_locatelli_pullan_mc.h>
-
-#include "test_tools.h"
-
-using namespace lemon;
-
-char test_lgf[] =
-  "@nodes\n"
-  "label max_clique\n"
-  "1     0\n"
-  "2     0\n"
-  "3     0\n"
-  "4     1\n"
-  "5     1\n"
-  "6     1\n"
-  "7     1\n"
-  "@edges\n"
-  "    label\n"
-  "1 2     1\n"
-  "1 3     2\n"
-  "1 4     3\n"
-  "1 6     4\n"
-  "2 3     5\n"
-  "2 5     6\n"
-  "2 7     7\n"
-  "3 4     8\n"
-  "3 5     9\n"
-  "4 5    10\n"
-  "4 6    11\n"
-  "4 7    12\n"
-  "5 6    13\n"
-  "5 7    14\n"
-  "6 7    15\n";
-
-
-// Check with general graphs
-template <typename Param>
-void checkMaxCliqueGeneral(Param rule) {
-  typedef ListGraph GR;
-  typedef GrossoLocatelliPullanMc<GR> McAlg;
-  typedef McAlg::CliqueNodeIt CliqueIt;
-
-  // Basic tests
-  {
-    GR g;
-    GR::NodeMap<bool> map(g);
-    McAlg mc(g);
-    mc.iterationLimit(50);
-    check(mc.run(rule) == McAlg::SIZE_LIMIT, "Wrong termination cause");
-    check(mc.cliqueSize() == 0, "Wrong clique size");
-    check(CliqueIt(mc) == INVALID, "Wrong CliqueNodeIt");
-
-    GR::Node u = g.addNode();
-    check(mc.run(rule) == McAlg::SIZE_LIMIT, "Wrong termination cause");
-    check(mc.cliqueSize() == 1, "Wrong clique size");
-    mc.cliqueMap(map);
-    check(map[u], "Wrong clique map");
-    CliqueIt it1(mc);
-    check(static_cast<GR::Node>(it1) == u && ++it1 == INVALID,
-          "Wrong CliqueNodeIt");
-
-    GR::Node v = g.addNode();
-    check(mc.run(rule) == McAlg::ITERATION_LIMIT, "Wrong termination cause");
-    check(mc.cliqueSize() == 1, "Wrong clique size");
-    mc.cliqueMap(map);
-    check((map[u] && !map[v]) || (map[v] && !map[u]), "Wrong clique map");
-    CliqueIt it2(mc);
-    check(it2 != INVALID && ++it2 == INVALID, "Wrong CliqueNodeIt");
-
-    g.addEdge(u, v);
-    check(mc.run(rule) == McAlg::SIZE_LIMIT, "Wrong termination cause");
-    check(mc.cliqueSize() == 2, "Wrong clique size");
-    mc.cliqueMap(map);
-    check(map[u] && map[v], "Wrong clique map");
-    CliqueIt it3(mc);
-    check(it3 != INVALID && ++it3 != INVALID && ++it3 == INVALID,
-          "Wrong CliqueNodeIt");
-  }
-
-  // Test graph
-  {
-    GR g;
-    GR::NodeMap<bool> max_clique(g);
-    GR::NodeMap<bool> map(g);
-    std::istringstream input(test_lgf);
-    graphReader(g, input)
-      .nodeMap("max_clique", max_clique)
-      .run();
-
-    McAlg mc(g);
-    mc.iterationLimit(50);
-    check(mc.run(rule) == McAlg::ITERATION_LIMIT, "Wrong termination cause");
-    check(mc.cliqueSize() == 4, "Wrong clique size");
-    mc.cliqueMap(map);
-    for (GR::NodeIt n(g); n != INVALID; ++n) {
-      check(map[n] == max_clique[n], "Wrong clique map");
-    }
-    int cnt = 0;
-    for (CliqueIt n(mc); n != INVALID; ++n) {
-      cnt++;
-      check(map[n] && max_clique[n], "Wrong CliqueNodeIt");
-    }
-    check(cnt == 4, "Wrong CliqueNodeIt");
-  }
-}
-
-// Check with full graphs
-template <typename Param>
-void checkMaxCliqueFullGraph(Param rule) {
-  typedef FullGraph GR;
-  typedef GrossoLocatelliPullanMc<FullGraph> McAlg;
-  typedef McAlg::CliqueNodeIt CliqueIt;
-
-  for (int size = 0; size <= 40; size = size * 3 + 1) {
-    GR g(size);
-    GR::NodeMap<bool> map(g);
-    McAlg mc(g);
-    check(mc.run(rule) == McAlg::SIZE_LIMIT, "Wrong termination cause");
-    check(mc.cliqueSize() == size, "Wrong clique size");
-    mc.cliqueMap(map);
-    for (GR::NodeIt n(g); n != INVALID; ++n) {
-      check(map[n], "Wrong clique map");
-    }
-    int cnt = 0;
-    for (CliqueIt n(mc); n != INVALID; ++n) cnt++;
-    check(cnt == size, "Wrong CliqueNodeIt");
-  }
-}
-
-// Check with grid graphs
-template <typename Param>
-void checkMaxCliqueGridGraph(Param rule) {
-  GridGraph g(5, 7);
-  GridGraph::NodeMap<char> map(g);
-  GrossoLocatelliPullanMc<GridGraph> mc(g);
-
-  mc.iterationLimit(100);
-  check(mc.run(rule) == mc.ITERATION_LIMIT, "Wrong termination cause");
-  check(mc.cliqueSize() == 2, "Wrong clique size");
-
-  mc.stepLimit(100);
-  check(mc.run(rule) == mc.STEP_LIMIT, "Wrong termination cause");
-  check(mc.cliqueSize() == 2, "Wrong clique size");
-
-  mc.sizeLimit(2);
-  check(mc.run(rule) == mc.SIZE_LIMIT, "Wrong termination cause");
-  check(mc.cliqueSize() == 2, "Wrong clique size");
-}
-
-
-int main() {
-  checkMaxCliqueGeneral(GrossoLocatelliPullanMc<ListGraph>::RANDOM);
-  checkMaxCliqueGeneral(GrossoLocatelliPullanMc<ListGraph>::DEGREE_BASED);
-  checkMaxCliqueGeneral(GrossoLocatelliPullanMc<ListGraph>::PENALTY_BASED);
-
-  checkMaxCliqueFullGraph(GrossoLocatelliPullanMc<FullGraph>::RANDOM);
-  checkMaxCliqueFullGraph(GrossoLocatelliPullanMc<FullGraph>::DEGREE_BASED);
-  checkMaxCliqueFullGraph(GrossoLocatelliPullanMc<FullGraph>::PENALTY_BASED);
-
-  checkMaxCliqueGridGraph(GrossoLocatelliPullanMc<GridGraph>::RANDOM);
-  checkMaxCliqueGridGraph(GrossoLocatelliPullanMc<GridGraph>::DEGREE_BASED);
-  checkMaxCliqueGridGraph(GrossoLocatelliPullanMc<GridGraph>::PENALTY_BASED);
-
-  return 0;
-}
Index: st/max_flow_test.cc
===================================================================
--- test/max_flow_test.cc	(revision 1270)
+++ 	(revision )
@@ -1,395 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2013
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * 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 <iostream>
-
-#include "test_tools.h"
-#include <lemon/smart_graph.h>
-#include <lemon/preflow.h>
-#include <lemon/edmonds_karp.h>
-#include <lemon/concepts/digraph.h>
-#include <lemon/concepts/maps.h>
-#include <lemon/lgf_reader.h>
-#include <lemon/elevator.h>
-
-using namespace lemon;
-
-char test_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"
-  "    label capacity\n"
-  "0 1 0     20\n"
-  "0 2 1     0\n"
-  "1 1 2     3\n"
-  "1 2 3     8\n"
-  "1 3 4     8\n"
-  "2 5 5     5\n"
-  "3 2 6     5\n"
-  "3 5 7     5\n"
-  "3 6 8     5\n"
-  "4 3 9     3\n"
-  "5 7 10    3\n"
-  "5 6 11    10\n"
-  "5 8 12    10\n"
-  "6 8 13    8\n"
-  "8 9 14    20\n"
-  "8 1 15    5\n"
-  "9 5 16    5\n"
-  "@attributes\n"
-  "source 1\n"
-  "target 8\n";
-
-
-// Checks the general interface of a max flow algorithm
-template <typename GR, typename CAP>
-struct MaxFlowClassConcept
-{
-
-  template <typename MF>
-  struct Constraints {
-
-    typedef typename GR::Node Node;
-    typedef typename GR::Arc Arc;
-    typedef typename CAP::Value Value;
-    typedef concepts::ReadWriteMap<Arc, Value> FlowMap;
-    typedef concepts::WriteMap<Node, bool> CutMap;
-
-    GR g;
-    Node n;
-    Arc e;
-    CAP cap;
-    FlowMap flow;
-    CutMap cut;
-    Value v;
-    bool b;
-
-    void constraints() {
-      checkConcept<concepts::Digraph, GR>();
-
-      const Constraints& me = *this;
-
-      typedef typename MF
-          ::template SetFlowMap<FlowMap>
-          ::Create MaxFlowType;
-      typedef typename MF::Create MaxFlowType2;
-      MaxFlowType max_flow(me.g, me.cap, me.n, me.n);
-      const MaxFlowType& const_max_flow = max_flow;
-
-      max_flow
-          .capacityMap(cap)
-          .flowMap(flow)
-          .source(n)
-          .target(n);
-
-      typename MaxFlowType::Tolerance tol = const_max_flow.tolerance();
-      max_flow.tolerance(tol);
-
-      max_flow.init();
-      max_flow.init(cap);
-      max_flow.run();
-
-      v = const_max_flow.flowValue();
-      v = const_max_flow.flow(e);
-      const FlowMap& fm = const_max_flow.flowMap();
-
-      b = const_max_flow.minCut(n);
-      const_max_flow.minCutMap(cut);
-
-      ::lemon::ignore_unused_variable_warning(fm);
-    }
-
-  };
-
-};
-
-// Checks the specific parts of Preflow's interface
-void checkPreflowCompile()
-{
-  typedef int Value;
-  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;
-  Digraph::Node n;
-  CapMap cap;
-
-  typedef Preflow<Digraph, CapMap>
-      ::SetElevator<Elev>
-      ::SetStandardElevator<LinkedElev>
-      ::Create PreflowType;
-  PreflowType preflow_test(g, cap, n, n);
-  const PreflowType& const_preflow_test = preflow_test;
-
-  const PreflowType::Elevator& elev = const_preflow_test.elevator();
-  preflow_test.elevator(const_cast<PreflowType::Elevator&>(elev));
-
-  bool b = preflow_test.init(cap);
-  preflow_test.startFirstPhase();
-  preflow_test.startSecondPhase();
-  preflow_test.runMinCut();
-
-  ::lemon::ignore_unused_variable_warning(b);
-}
-
-// Checks the specific parts of EdmondsKarp's interface
-void checkEdmondsKarpCompile()
-{
-  typedef int Value;
-  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;
-  Digraph::Node n;
-  CapMap cap;
-
-  EdmondsKarp<Digraph, CapMap> ek_test(g, cap, n, n);
-
-  ek_test.init(cap);
-  bool b = ek_test.checkedInit(cap);
-  b = ek_test.augment();
-  ek_test.start();
-
-  ::lemon::ignore_unused_variable_warning(b);
-}
-
-
-template <typename T>
-T cutValue (const SmartDigraph& g,
-              const SmartDigraph::NodeMap<bool>& cut,
-              const SmartDigraph::ArcMap<T>& cap) {
-
-  T c=0;
-  for(SmartDigraph::ArcIt e(g); e!=INVALID; ++e) {
-    if (cut[g.source(e)] && !cut[g.target(e)]) c+=cap[e];
-  }
-  return c;
-}
-
-template <typename T>
-bool checkFlow(const SmartDigraph& g,
-               const SmartDigraph::ArcMap<T>& flow,
-               const SmartDigraph::ArcMap<T>& cap,
-               SmartDigraph::Node s, SmartDigraph::Node t) {
-
-  for (SmartDigraph::ArcIt e(g); e != INVALID; ++e) {
-    if (flow[e] < 0 || flow[e] > cap[e]) return false;
-  }
-
-  for (SmartDigraph::NodeIt n(g); n != INVALID; ++n) {
-    if (n == s || n == t) continue;
-    T sum = 0;
-    for (SmartDigraph::OutArcIt e(g, n); e != INVALID; ++e) {
-      sum += flow[e];
-    }
-    for (SmartDigraph::InArcIt e(g, n); e != INVALID; ++e) {
-      sum -= flow[e];
-    }
-    if (sum != 0) return false;
-  }
-  return true;
-}
-
-void initFlowTest()
-{
-  DIGRAPH_TYPEDEFS(SmartDigraph);
-
-  SmartDigraph g;
-  SmartDigraph::ArcMap<int> cap(g),iflow(g);
-  Node s=g.addNode(); Node t=g.addNode();
-  Node n1=g.addNode(); Node n2=g.addNode();
-  Arc a;
-  a=g.addArc(s,n1); cap[a]=20; iflow[a]=20;
-  a=g.addArc(n1,n2); cap[a]=10; iflow[a]=0;
-  a=g.addArc(n2,t); cap[a]=20; iflow[a]=0;
-
-  Preflow<SmartDigraph> pre(g,cap,s,t);
-  pre.init(iflow);
-  pre.startFirstPhase();
-  check(pre.flowValue() == 10, "The incorrect max flow value.");
-  check(pre.minCut(s), "Wrong min cut (Node s).");
-  check(pre.minCut(n1), "Wrong min cut (Node n1).");
-  check(!pre.minCut(n2), "Wrong min cut (Node n2).");
-  check(!pre.minCut(t), "Wrong min cut (Node t).");
-}
-
-template <typename MF, typename SF>
-void checkMaxFlowAlg() {
-  typedef SmartDigraph Digraph;
-  DIGRAPH_TYPEDEFS(Digraph);
-
-  typedef typename MF::Value Value;
-  typedef Digraph::ArcMap<Value> CapMap;
-  typedef CapMap FlowMap;
-  typedef BoolNodeMap CutMap;
-
-  Digraph g;
-  Node s, t;
-  CapMap cap(g);
-  std::istringstream input(test_lgf);
-  DigraphReader<Digraph>(g,input)
-      .arcMap("capacity", cap)
-      .node("source",s)
-      .node("target",t)
-      .run();
-
-  MF max_flow(g, cap, s, t);
-  max_flow.run();
-
-  check(checkFlow(g, max_flow.flowMap(), cap, s, t),
-        "The flow is not feasible.");
-
-  CutMap min_cut(g);
-  max_flow.minCutMap(min_cut);
-  Value min_cut_value = cutValue(g, min_cut, cap);
-
-  check(max_flow.flowValue() == min_cut_value,
-        "The max flow value is not equal to the min cut value.");
-
-  FlowMap flow(g);
-  for (ArcIt e(g); e != INVALID; ++e) flow[e] = max_flow.flowMap()[e];
-
-  Value flow_value = max_flow.flowValue();
-
-  for (ArcIt e(g); e != INVALID; ++e) cap[e] = 2 * cap[e];
-  max_flow.init(flow);
-
-  SF::startFirstPhase(max_flow);       // start first phase of the algorithm
-
-  CutMap min_cut1(g);
-  max_flow.minCutMap(min_cut1);
-  min_cut_value = cutValue(g, min_cut1, cap);
-
-  check(max_flow.flowValue() == min_cut_value &&
-        min_cut_value == 2 * flow_value,
-        "The max flow value or the min cut value is wrong.");
-
-  SF::startSecondPhase(max_flow);       // start second phase of the algorithm
-
-  check(checkFlow(g, max_flow.flowMap(), cap, s, t),
-        "The flow is not feasible.");
-
-  CutMap min_cut2(g);
-  max_flow.minCutMap(min_cut2);
-  min_cut_value = cutValue(g, min_cut2, cap);
-
-  check(max_flow.flowValue() == min_cut_value &&
-        min_cut_value == 2 * flow_value,
-        "The max flow value or the min cut value was not doubled");
-
-
-  max_flow.flowMap(flow);
-
-  NodeIt tmp1(g, s);
-  ++tmp1;
-  if (tmp1 != INVALID) s = tmp1;
-
-  NodeIt tmp2(g, t);
-  ++tmp2;
-  if (tmp2 != INVALID) t = tmp2;
-
-  max_flow.source(s);
-  max_flow.target(t);
-
-  max_flow.run();
-
-  CutMap min_cut3(g);
-  max_flow.minCutMap(min_cut3);
-  min_cut_value=cutValue(g, min_cut3, cap);
-
-  check(max_flow.flowValue() == min_cut_value,
-        "The max flow value or the min cut value is wrong.");
-}
-
-// Struct for calling start functions of a general max flow algorithm
-template <typename MF>
-struct GeneralStartFunctions {
-
-  static void startFirstPhase(MF& mf) {
-    mf.start();
-  }
-
-  static void startSecondPhase(MF& mf) {
-    ::lemon::ignore_unused_variable_warning(mf);
-  }
-
-};
-
-// Struct for calling start functions of Preflow
-template <typename MF>
-struct PreflowStartFunctions {
-
-  static void startFirstPhase(MF& mf) {
-    mf.startFirstPhase();
-  }
-
-  static void startSecondPhase(MF& mf) {
-    mf.startSecondPhase();
-  }
-
-};
-
-int main() {
-
-  typedef concepts::Digraph GR;
-  typedef concepts::ReadMap<GR::Arc, int> CM1;
-  typedef concepts::ReadMap<GR::Arc, double> CM2;
-
-  // Check the interface of Preflow
-  checkConcept< MaxFlowClassConcept<GR, CM1>,
-                Preflow<GR, CM1> >();
-  checkConcept< MaxFlowClassConcept<GR, CM2>,
-                Preflow<GR, CM2> >();
-
-  // Check the interface of EdmondsKarp
-  checkConcept< MaxFlowClassConcept<GR, CM1>,
-                EdmondsKarp<GR, CM1> >();
-  checkConcept< MaxFlowClassConcept<GR, CM2>,
-                EdmondsKarp<GR, CM2> >();
-
-  // Check Preflow
-  typedef Preflow<SmartDigraph, SmartDigraph::ArcMap<int> > PType1;
-  typedef Preflow<SmartDigraph, SmartDigraph::ArcMap<float> > PType2;
-  checkMaxFlowAlg<PType1, PreflowStartFunctions<PType1> >();
-  checkMaxFlowAlg<PType2, PreflowStartFunctions<PType2> >();
-  initFlowTest();
-
-  // Check EdmondsKarp
-  typedef EdmondsKarp<SmartDigraph, SmartDigraph::ArcMap<int> > EKType1;
-  typedef EdmondsKarp<SmartDigraph, SmartDigraph::ArcMap<float> > EKType2;
-  checkMaxFlowAlg<EKType1, GeneralStartFunctions<EKType1> >();
-  checkMaxFlowAlg<EKType2, GeneralStartFunctions<EKType2> >();
-
-  initFlowTest();
-
-  return 0;
-}
Index: test/min_cost_arborescence_test.cc
===================================================================
--- test/min_cost_arborescence_test.cc	(revision 1270)
+++ test/min_cost_arborescence_test.cc	(revision 672)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -92,5 +92,4 @@
   VType c;
   bool b;
-  ::lemon::ignore_unused_variable_warning(c,b);
   int i;
   CostMap cost;
@@ -112,5 +111,5 @@
   b = const_mcarb_test.emptyQueue();
   i = const_mcarb_test.queueSize();
-
+  
   c = const_mcarb_test.arborescenceCost();
   b = const_mcarb_test.arborescence(e);
@@ -122,12 +121,12 @@
   b = const_mcarb_test.reached(n);
   b = const_mcarb_test.processed(n);
-
+  
   i = const_mcarb_test.dualNum();
   c = const_mcarb_test.dualValue();
   i = const_mcarb_test.dualSize(i);
   c = const_mcarb_test.dualValue(i);
-
-  ::lemon::ignore_unused_variable_warning(am);
-  ::lemon::ignore_unused_variable_warning(pm);
+  
+  ignore_unused_variable_warning(am);
+  ignore_unused_variable_warning(pm);
 }
 
Index: test/min_cost_flow_test.cc
===================================================================
--- test/min_cost_flow_test.cc	(revision 1318)
+++ test/min_cost_flow_test.cc	(revision 885)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -53,5 +53,5 @@
   "   11     0    0    0    0  -10    0\n"
   "   12   -20  -27    0  -30  -30  -20\n"
-  "\n"
+  "\n"                
   "@arcs\n"
   "       cost  cap low1 low2 low3\n"
@@ -103,5 +103,5 @@
   "6 7     30      0  -1000\n"
   "7 5   -120      0      0\n";
-
+  
 char test_neg2_lgf[] =
   "@nodes\n"
@@ -152,5 +152,5 @@
     void constraints() {
       checkConcept<concepts::Digraph, GR>();
-
+      
       const Constraints& me = *this;
 
@@ -158,5 +158,5 @@
       const MCF& const_mcf = mcf;
 
-      b = mcf.reset().resetParams()
+      b = mcf.reset()
              .lowerMap(me.lower)
              .upperMap(me.upper)
@@ -181,5 +181,5 @@
     typedef concepts::WriteMap<Arc, Value> FlowMap;
     typedef concepts::WriteMap<Node, Cost> PotMap;
-
+  
     GR g;
     VAM lower;
@@ -235,5 +235,5 @@
            typename CM, typename SM, typename FM, typename PM >
 bool checkPotential( const GR& gr, const LM& lower, const UM& upper,
-                     const CM& cost, const SM& supply, const FM& flow,
+                     const CM& cost, const SM& supply, const FM& flow, 
                      const PM& pi, SupplyType type )
 {
@@ -248,5 +248,5 @@
           (red_cost < 0 && flow[e] == upper[e]);
   }
-
+  
   for (NodeIt n(gr); opt && n != INVALID; ++n) {
     typename SM::Value sum = 0;
@@ -261,5 +261,5 @@
     }
   }
-
+  
   return opt;
 }
@@ -286,5 +286,5 @@
     }
   }
-
+  
   for (NodeIt n(gr); n != INVALID; ++n) {
     dual_cost -= red_supply[n] * pi[n];
@@ -295,5 +295,5 @@
     dual_cost -= (upper[a] - lower[a]) * std::max(-red_cost, 0);
   }
-
+  
   return dual_cost == total;
 }
@@ -333,5 +333,5 @@
 {
   MCF mcf1(gr), mcf2(neg1_gr), mcf3(neg2_gr);
-
+  
   // Basic tests
   mcf1.upperMap(u).costMap(c).supplyMap(s1);
@@ -347,5 +347,5 @@
   checkMcf(mcf1, mcf1.run(param), gr, l2, u, c, s2,
            mcf1.OPTIMAL, true,     8010, test_str + "-4");
-  mcf1.resetParams().supplyMap(s1);
+  mcf1.reset().supplyMap(s1);
   checkMcf(mcf1, mcf1.run(param), gr, l1, cu, cc, s1,
            mcf1.OPTIMAL, true,       74, test_str + "-5");
@@ -364,5 +364,5 @@
 
   // Tests for the GEQ form
-  mcf1.resetParams().upperMap(u).costMap(c).supplyMap(s5);
+  mcf1.reset().upperMap(u).costMap(c).supplyMap(s5);
   checkMcf(mcf1, mcf1.run(param), gr, l1, u, c, s5,
            mcf1.OPTIMAL, true,     3530, test_str + "-10", GEQ);
@@ -381,5 +381,5 @@
   checkMcf(mcf2, mcf2.run(param), neg1_gr, neg1_l1, neg1_u2, neg1_c, neg1_s,
            mcf2.OPTIMAL, true,   -40000, test_str + "-14");
-  mcf2.resetParams().lowerMap(neg1_l2).costMap(neg1_c).supplyMap(neg1_s);
+  mcf2.reset().lowerMap(neg1_l2).costMap(neg1_c).supplyMap(neg1_s);
   checkMcf(mcf2, mcf2.run(param), neg1_gr, neg1_l2, neg1_u1, neg1_c, neg1_s,
            mcf2.UNBOUNDED, false,     0, test_str + "-15");
@@ -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");  
 }
 
@@ -442,5 +436,5 @@
     .node("target", w)
     .run();
-
+  
   std::istringstream neg_inp1(test_neg1_lgf);
   DigraphReader<Digraph>(neg1_gr, neg_inp1)
@@ -450,5 +444,5 @@
     .nodeMap("sup", neg1_s)
     .run();
-
+  
   std::istringstream neg_inp2(test_neg2_lgf);
   DigraphReader<Digraph>(neg2_gr, neg_inp2)
@@ -456,5 +450,5 @@
     .nodeMap("sup", neg2_s)
     .run();
-
+  
   // Check the interface of NetworkSimplex
   {
@@ -508,5 +502,5 @@
 
   // Test NetworkSimplex
-  {
+  { 
     typedef NetworkSimplex<Digraph> MCF;
     runMcfGeqTests<MCF>(MCF::FIRST_ELIGIBLE, "NS-FE", true);
@@ -521,5 +515,5 @@
     runMcfLeqTests<MCF>(MCF::ALTERING_LIST,  "NS-AL");
   }
-
+  
   // Test CapacityScaling
   {
Index: test/min_mean_cycle_test.cc
===================================================================
--- test/min_mean_cycle_test.cc	(revision 1270)
+++ test/min_mean_cycle_test.cc	(revision 816)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -26,7 +26,7 @@
 #include <lemon/concept_check.h>
 
-#include <lemon/karp_mmc.h>
-#include <lemon/hartmann_orlin_mmc.h>
-#include <lemon/howard_mmc.h>
+#include <lemon/karp.h>
+#include <lemon/hartmann_orlin.h>
+#include <lemon/howard.h>
 
 #include "test_tools.h"
@@ -62,7 +62,7 @@
   "7 7    4    4    4   -1   0  0  0  1\n";
 
-
+                        
 // Check the interface of an MMC algorithm
-template <typename GR, typename Cost>
+template <typename GR, typename Value>
 struct MmcClassConcept
 {
@@ -74,28 +74,28 @@
       typedef typename MMC
         ::template SetPath<ListPath<GR> >
-        ::template SetLargeCost<Cost>
+        ::template SetLargeValue<Value>
         ::Create MmcAlg;
-      MmcAlg mmc(me.g, me.cost);
+      MmcAlg mmc(me.g, me.length);
       const MmcAlg& const_mmc = mmc;
-
+      
       typename MmcAlg::Tolerance tol = const_mmc.tolerance();
       mmc.tolerance(tol);
-
+      
       b = mmc.cycle(p).run();
-      b = mmc.findCycleMean();
+      b = mmc.findMinMean();
       b = mmc.findCycle();
 
-      v = const_mmc.cycleCost();
-      i = const_mmc.cycleSize();
+      v = const_mmc.cycleLength();
+      i = const_mmc.cycleArcNum();
       d = const_mmc.cycleMean();
       p = const_mmc.cycle();
     }
 
-    typedef concepts::ReadMap<typename GR::Arc, Cost> CM;
-
+    typedef concepts::ReadMap<typename GR::Arc, Value> LM;
+  
     GR g;
-    CM cost;
+    LM length;
     ListPath<GR> p;
-    Cost v;
+    Value v;
     int i;
     double d;
@@ -109,11 +109,11 @@
                  const SmartDigraph::ArcMap<int>& lm,
                  const SmartDigraph::ArcMap<int>& cm,
-                 int cost, int size) {
+                 int length, int size) {
   MMC alg(gr, lm);
-  check(alg.findCycleMean(), "Wrong result");
-  check(alg.cycleMean() == static_cast<double>(cost) / size,
+  alg.findMinMean();
+  check(alg.cycleMean() == static_cast<double>(length) / size,
         "Wrong cycle mean");
   alg.findCycle();
-  check(alg.cycleCost() == cost && alg.cycleSize() == size,
+  check(alg.cycleLength() == length && alg.cycleArcNum() == size,
         "Wrong path");
   SmartDigraph::ArcMap<int> cycle(gr, 0);
@@ -149,26 +149,26 @@
     typedef concepts::Digraph GR;
 
-    // KarpMmc
+    // Karp
     checkConcept< MmcClassConcept<GR, int>,
-                  KarpMmc<GR, concepts::ReadMap<GR::Arc, int> > >();
+                  Karp<GR, concepts::ReadMap<GR::Arc, int> > >();
     checkConcept< MmcClassConcept<GR, float>,
-                  KarpMmc<GR, concepts::ReadMap<GR::Arc, float> > >();
-
-    // HartmannOrlinMmc
+                  Karp<GR, concepts::ReadMap<GR::Arc, float> > >();
+    
+    // HartmannOrlin
     checkConcept< MmcClassConcept<GR, int>,
-                  HartmannOrlinMmc<GR, concepts::ReadMap<GR::Arc, int> > >();
+                  HartmannOrlin<GR, concepts::ReadMap<GR::Arc, int> > >();
     checkConcept< MmcClassConcept<GR, float>,
-                  HartmannOrlinMmc<GR, concepts::ReadMap<GR::Arc, float> > >();
-
-    // HowardMmc
+                  HartmannOrlin<GR, concepts::ReadMap<GR::Arc, float> > >();
+    
+    // Howard
     checkConcept< MmcClassConcept<GR, int>,
-                  HowardMmc<GR, concepts::ReadMap<GR::Arc, int> > >();
+                  Howard<GR, concepts::ReadMap<GR::Arc, int> > >();
     checkConcept< MmcClassConcept<GR, float>,
-                  HowardMmc<GR, concepts::ReadMap<GR::Arc, float> > >();
-
-    check((IsSameType<HowardMmc<GR, concepts::ReadMap<GR::Arc, int> >
-           ::LargeCost, long_int>::result == 1), "Wrong LargeCost type");
-    check((IsSameType<HowardMmc<GR, concepts::ReadMap<GR::Arc, float> >
-           ::LargeCost, double>::result == 1), "Wrong LargeCost type");
+                  Howard<GR, concepts::ReadMap<GR::Arc, float> > >();
+
+    if (IsSameType<Howard<GR, concepts::ReadMap<GR::Arc, int> >::LargeValue,
+          long_int>::result == 0) check(false, "Wrong LargeValue type");
+    if (IsSameType<Howard<GR, concepts::ReadMap<GR::Arc, float> >::LargeValue,
+          double>::result == 0) check(false, "Wrong LargeValue type");
   }
 
@@ -177,9 +177,9 @@
     typedef SmartDigraph GR;
     DIGRAPH_TYPEDEFS(GR);
-
+    
     GR gr;
     IntArcMap l1(gr), l2(gr), l3(gr), l4(gr);
     IntArcMap c1(gr), c2(gr), c3(gr), c4(gr);
-
+    
     std::istringstream input(test_lgf);
     digraphReader(gr, input).
@@ -195,27 +195,20 @@
 
     // Karp
-    checkMmcAlg<KarpMmc<GR, IntArcMap> >(gr, l1, c1,  6, 3);
-    checkMmcAlg<KarpMmc<GR, IntArcMap> >(gr, l2, c2,  5, 2);
-    checkMmcAlg<KarpMmc<GR, IntArcMap> >(gr, l3, c3,  0, 1);
-    checkMmcAlg<KarpMmc<GR, IntArcMap> >(gr, l4, c4, -1, 1);
+    checkMmcAlg<Karp<GR, IntArcMap> >(gr, l1, c1,  6, 3);
+    checkMmcAlg<Karp<GR, IntArcMap> >(gr, l2, c2,  5, 2);
+    checkMmcAlg<Karp<GR, IntArcMap> >(gr, l3, c3,  0, 1);
+    checkMmcAlg<Karp<GR, IntArcMap> >(gr, l4, c4, -1, 1);
 
     // HartmannOrlin
-    checkMmcAlg<HartmannOrlinMmc<GR, IntArcMap> >(gr, l1, c1,  6, 3);
-    checkMmcAlg<HartmannOrlinMmc<GR, IntArcMap> >(gr, l2, c2,  5, 2);
-    checkMmcAlg<HartmannOrlinMmc<GR, IntArcMap> >(gr, l3, c3,  0, 1);
-    checkMmcAlg<HartmannOrlinMmc<GR, IntArcMap> >(gr, l4, c4, -1, 1);
+    checkMmcAlg<HartmannOrlin<GR, IntArcMap> >(gr, l1, c1,  6, 3);
+    checkMmcAlg<HartmannOrlin<GR, IntArcMap> >(gr, l2, c2,  5, 2);
+    checkMmcAlg<HartmannOrlin<GR, IntArcMap> >(gr, l3, c3,  0, 1);
+    checkMmcAlg<HartmannOrlin<GR, IntArcMap> >(gr, l4, c4, -1, 1);
 
     // Howard
-    checkMmcAlg<HowardMmc<GR, IntArcMap> >(gr, l1, c1,  6, 3);
-    checkMmcAlg<HowardMmc<GR, IntArcMap> >(gr, l2, c2,  5, 2);
-    checkMmcAlg<HowardMmc<GR, IntArcMap> >(gr, l3, c3,  0, 1);
-    checkMmcAlg<HowardMmc<GR, IntArcMap> >(gr, l4, c4, -1, 1);
-
-    // Howard with iteration limit
-    HowardMmc<GR, IntArcMap> mmc(gr, l1);
-    check((mmc.findCycleMean(2) == HowardMmc<GR, IntArcMap>::ITERATION_LIMIT),
-      "Wrong termination cause");
-    check((mmc.findCycleMean(4) == HowardMmc<GR, IntArcMap>::OPTIMAL),
-      "Wrong termination cause");
+    checkMmcAlg<Howard<GR, IntArcMap> >(gr, l1, c1,  6, 3);
+    checkMmcAlg<Howard<GR, IntArcMap> >(gr, l2, c2,  5, 2);
+    checkMmcAlg<Howard<GR, IntArcMap> >(gr, l3, c3,  0, 1);
+    checkMmcAlg<Howard<GR, IntArcMap> >(gr, l4, c4, -1, 1);
   }
 
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: st/nagamochi_ibaraki_test.cc
===================================================================
--- test/nagamochi_ibaraki_test.cc	(revision 1270)
+++ 	(revision )
@@ -1,142 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2013
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * 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 <sstream>
-
-#include <lemon/smart_graph.h>
-#include <lemon/adaptors.h>
-#include <lemon/concepts/graph.h>
-#include <lemon/concepts/maps.h>
-#include <lemon/lgf_reader.h>
-#include <lemon/nagamochi_ibaraki.h>
-
-#include "test_tools.h"
-
-using namespace lemon;
-using namespace std;
-
-const std::string lgf =
-  "@nodes\n"
-  "label\n"
-  "0\n"
-  "1\n"
-  "2\n"
-  "3\n"
-  "4\n"
-  "5\n"
-  "@edges\n"
-  "     cap1 cap2 cap3\n"
-  "0 1  1    1    1   \n"
-  "0 2  2    2    4   \n"
-  "1 2  4    4    4   \n"
-  "3 4  1    1    1   \n"
-  "3 5  2    2    4   \n"
-  "4 5  4    4    4   \n"
-  "2 3  1    6    6   \n";
-
-void checkNagamochiIbarakiCompile()
-{
-  typedef int Value;
-  typedef concepts::Graph Graph;
-
-  typedef Graph::Node Node;
-  typedef Graph::Edge Edge;
-  typedef concepts::ReadMap<Edge, Value> CapMap;
-  typedef concepts::WriteMap<Node, bool> CutMap;
-
-  Graph g;
-  Node n;
-  CapMap cap;
-  CutMap cut;
-  Value v;
-  bool b;
-  ::lemon::ignore_unused_variable_warning(v,b);
-
-  NagamochiIbaraki<Graph, CapMap> ni_test(g, cap);
-  const NagamochiIbaraki<Graph, CapMap>& const_ni_test = ni_test;
-
-  ni_test.init();
-  ni_test.start();
-  b = ni_test.processNextPhase();
-  ni_test.run();
-
-  v = const_ni_test.minCutValue();
-  v = const_ni_test.minCutMap(cut);
-}
-
-template <typename Graph, typename CapMap, typename CutMap>
-typename CapMap::Value
-  cutValue(const Graph& graph, const CapMap& cap, const CutMap& cut)
-{
-  typename CapMap::Value sum = 0;
-  for (typename Graph::EdgeIt e(graph); e != INVALID; ++e) {
-    if (cut[graph.u(e)] != cut[graph.v(e)]) {
-      sum += cap[e];
-    }
-  }
-  return sum;
-}
-
-int main() {
-  SmartGraph graph;
-  SmartGraph::EdgeMap<int> cap1(graph), cap2(graph), cap3(graph);
-  SmartGraph::NodeMap<bool> cut(graph);
-
-  istringstream input(lgf);
-  graphReader(graph, input)
-    .edgeMap("cap1", cap1)
-    .edgeMap("cap2", cap2)
-    .edgeMap("cap3", cap3)
-    .run();
-
-  {
-    NagamochiIbaraki<SmartGraph> ni(graph, cap1);
-    ni.run();
-    ni.minCutMap(cut);
-
-    check(ni.minCutValue() == 1, "Wrong cut value");
-    check(ni.minCutValue() == cutValue(graph, cap1, cut), "Wrong cut value");
-  }
-  {
-    NagamochiIbaraki<SmartGraph> ni(graph, cap2);
-    ni.run();
-    ni.minCutMap(cut);
-
-    check(ni.minCutValue() == 3, "Wrong cut value");
-    check(ni.minCutValue() == cutValue(graph, cap2, cut), "Wrong cut value");
-  }
-  {
-    NagamochiIbaraki<SmartGraph> ni(graph, cap3);
-    ni.run();
-    ni.minCutMap(cut);
-
-    check(ni.minCutValue() == 5, "Wrong cut value");
-    check(ni.minCutValue() == cutValue(graph, cap3, cut), "Wrong cut value");
-  }
-  {
-    NagamochiIbaraki<SmartGraph>::SetUnitCapacity::Create ni(graph);
-    ni.run();
-    ni.minCutMap(cut);
-
-    ConstMap<SmartGraph::Edge, int> cap4(1);
-    check(ni.minCutValue() == 1, "Wrong cut value");
-    check(ni.minCutValue() == cutValue(graph, cap4, cut), "Wrong cut value");
-  }
-
-  return 0;
-}
Index: test/path_test.cc
===================================================================
--- test/path_test.cc	(revision 1270)
+++ test/path_test.cc	(revision 463)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -22,5 +22,4 @@
 #include <lemon/concepts/path.h>
 #include <lemon/concepts/digraph.h>
-#include <lemon/concept_check.h>
 
 #include <lemon/path.h>
@@ -32,308 +31,14 @@
 using namespace lemon;
 
-template <typename GR>
-void checkConcepts() {
-  checkConcept<concepts::Path<GR>, concepts::Path<GR> >();
-  checkConcept<concepts::Path<GR>, Path<GR> >();
-  checkConcept<concepts::Path<GR>, SimplePath<GR> >();
-  checkConcept<concepts::Path<GR>, StaticPath<GR> >();
-  checkConcept<concepts::Path<GR>, ListPath<GR> >();
+void check_concepts() {
+  checkConcept<concepts::Path<ListDigraph>, concepts::Path<ListDigraph> >();
+  checkConcept<concepts::Path<ListDigraph>, Path<ListDigraph> >();
+  checkConcept<concepts::Path<ListDigraph>, SimplePath<ListDigraph> >();
+  checkConcept<concepts::Path<ListDigraph>, StaticPath<ListDigraph> >();
+  checkConcept<concepts::Path<ListDigraph>, ListPath<ListDigraph> >();
 }
 
-// Conecpt checking for path structures
-void checkPathConcepts() {
-  checkConcepts<concepts::Digraph>();
-  checkConcepts<ListDigraph>();
-}
-
-// Check if proper copy consructor is called (use valgrind for testing)
-template <typename GR, typename P1, typename P2>
-void checkCopy(typename GR::Arc a) {
-  P1 p;
-  p.addBack(a);
-  P1 q;
-  q = p;
-  P1 r(p);
-  P2 q2;
-  q2 = p;
-  P2 r2(p);
-}
-
-// Tests for copy constructors and assignment operators of paths
-void checkPathCopy() {
-  ListDigraph g;
-  ListDigraph::Arc a = g.addArc(g.addNode(), g.addNode());
-
-  typedef Path<ListDigraph> Path1;
-  typedef SimplePath<ListDigraph> Path2;
-  typedef ListPath<ListDigraph> Path3;
-  typedef StaticPath<ListDigraph> Path4;
-  checkCopy<ListDigraph, Path1, Path2>(a);
-  checkCopy<ListDigraph, Path1, Path3>(a);
-  checkCopy<ListDigraph, Path1, Path4>(a);
-  checkCopy<ListDigraph, Path2, Path1>(a);
-  checkCopy<ListDigraph, Path2, Path3>(a);
-  checkCopy<ListDigraph, Path2, Path4>(a);
-  checkCopy<ListDigraph, Path3, Path1>(a);
-  checkCopy<ListDigraph, Path3, Path2>(a);
-  checkCopy<ListDigraph, Path3, Path4>(a);
-}
-
-// Class for testing path functions
-class CheckPathFunctions {
-  typedef ListDigraph GR;
-  DIGRAPH_TYPEDEFS(GR);
-  GR gr;
-  const GR& cgr;
-  Node n1, n2, n3, n4;
-  Node tmp_n;
-  Arc a1, a2, a3, a4;
-  Arc tmp_a;
-
-public:
-
-  CheckPathFunctions() : cgr(gr) {
-    n1 = gr.addNode();
-    n2 = gr.addNode();
-    n3 = gr.addNode();
-    n4 = gr.addNode();
-    a1 = gr.addArc(n1, n2);
-    a2 = gr.addArc(n2, n3);
-    a3 = gr.addArc(n3, n4);
-    a4 = gr.addArc(n4, n1);
-  }
-
-  void run() {
-    checkBackAndFrontInsertablePath<Path<GR> >();
-    checkBackAndFrontInsertablePath<ListPath<GR> >();
-    checkBackInsertablePath<SimplePath<GR> >();
-
-    checkListPathSplitAndSplice();
-  }
-
-private:
-
-  template <typename P>
-  void checkBackInsertablePath() {
-
-    // Create and check empty path
-    P p;
-    const P& cp = p;
-    check(cp.empty(), "The path is not empty");
-    check(cp.length() == 0, "The path is not empty");
-//    check(cp.front() == INVALID, "Wrong front()");
-//    check(cp.back() == INVALID, "Wrong back()");
-    typename P::ArcIt ai(cp);
-    check(ai == INVALID, "Wrong ArcIt");
-    check(pathSource(cgr, cp) == INVALID, "Wrong pathSource()");
-    check(pathTarget(cgr, cp) == INVALID, "Wrong pathTarget()");
-    check(checkPath(cgr, cp), "Wrong checkPath()");
-    PathNodeIt<P> ni(cgr, cp);
-    check(ni == INVALID, "Wrong PathNodeIt");
-
-    // Check single-arc path
-    p.addBack(a1);
-    check(!cp.empty(), "Wrong empty()");
-    check(cp.length() == 1, "Wrong length");
-    check(cp.front() == a1, "Wrong front()");
-    check(cp.back() == a1, "Wrong back()");
-    check(cp.nth(0) == a1, "Wrong nth()");
-    ai = cp.nthIt(0);
-    check((tmp_a = ai) == a1, "Wrong nthIt()");
-    check(++ai == INVALID, "Wrong nthIt()");
-    typename P::ArcIt ai2(cp);
-    check((tmp_a = ai2) == a1, "Wrong ArcIt");
-    check(++ai2 == INVALID, "Wrong ArcIt");
-    check(pathSource(cgr, cp) == n1, "Wrong pathSource()");
-    check(pathTarget(cgr, cp) == n2, "Wrong pathTarget()");
-    check(checkPath(cgr, cp), "Wrong checkPath()");
-    PathNodeIt<P> ni2(cgr, cp);
-    check((tmp_n = ni2) == n1, "Wrong PathNodeIt");
-    check((tmp_n = ++ni2) == n2, "Wrong PathNodeIt");
-    check(++ni2 == INVALID, "Wrong PathNodeIt");
-
-    // Check adding more arcs
-    p.addBack(a2);
-    p.addBack(a3);
-    check(!cp.empty(), "Wrong empty()");
-    check(cp.length() == 3, "Wrong length");
-    check(cp.front() == a1, "Wrong front()");
-    check(cp.back() == a3, "Wrong back()");
-    check(cp.nth(0) == a1, "Wrong nth()");
-    check(cp.nth(1) == a2, "Wrong nth()");
-    check(cp.nth(2) == a3, "Wrong nth()");
-    typename P::ArcIt ai3(cp);
-    check((tmp_a = ai3) == a1, "Wrong ArcIt");
-    check((tmp_a = ++ai3) == a2, "Wrong nthIt()");
-    check((tmp_a = ++ai3) == a3, "Wrong nthIt()");
-    check(++ai3 == INVALID, "Wrong nthIt()");
-    ai = cp.nthIt(0);
-    check((tmp_a = ai) == a1, "Wrong nthIt()");
-    check((tmp_a = ++ai) == a2, "Wrong nthIt()");
-    ai = cp.nthIt(2);
-    check((tmp_a = ai) == a3, "Wrong nthIt()");
-    check(++ai == INVALID, "Wrong nthIt()");
-    check(pathSource(cgr, cp) == n1, "Wrong pathSource()");
-    check(pathTarget(cgr, cp) == n4, "Wrong pathTarget()");
-    check(checkPath(cgr, cp), "Wrong checkPath()");
-    PathNodeIt<P> ni3(cgr, cp);
-    check((tmp_n = ni3) == n1, "Wrong PathNodeIt");
-    check((tmp_n = ++ni3) == n2, "Wrong PathNodeIt");
-    check((tmp_n = ++ni3) == n3, "Wrong PathNodeIt");
-    check((tmp_n = ++ni3) == n4, "Wrong PathNodeIt");
-    check(++ni3 == INVALID, "Wrong PathNodeIt");
-
-    // Check arc removal and addition
-    p.eraseBack();
-    p.eraseBack();
-    p.addBack(a2);
-    check(!cp.empty(), "Wrong empty()");
-    check(cp.length() == 2, "Wrong length");
-    check(cp.front() == a1, "Wrong front()");
-    check(cp.back() == a2, "Wrong back()");
-    check(pathSource(cgr, cp) == n1, "Wrong pathSource()");
-    check(pathTarget(cgr, cp) == n3, "Wrong pathTarget()");
-    check(checkPath(cgr, cp), "Wrong checkPath()");
-
-    // Check clear()
-    p.clear();
-    check(cp.empty(), "The path is not empty");
-    check(cp.length() == 0, "The path is not empty");
-
-    // Check inconsistent path
-    p.addBack(a4);
-    p.addBack(a2);
-    p.addBack(a1);
-    check(!cp.empty(), "Wrong empty()");
-    check(cp.length() == 3, "Wrong length");
-    check(cp.front() == a4, "Wrong front()");
-    check(cp.back() == a1, "Wrong back()");
-    check(pathSource(cgr, cp) == n4, "Wrong pathSource()");
-    check(pathTarget(cgr, cp) == n2, "Wrong pathTarget()");
-    check(!checkPath(cgr, cp), "Wrong checkPath()");
-  }
-
-  template <typename P>
-  void checkBackAndFrontInsertablePath() {
-
-    // Include back insertable test cases
-    checkBackInsertablePath<P>();
-
-    // Check front and back insertion
-    P p;
-    const P& cp = p;
-    p.addFront(a4);
-    p.addBack(a1);
-    p.addFront(a3);
-    check(!cp.empty(), "Wrong empty()");
-    check(cp.length() == 3, "Wrong length");
-    check(cp.front() == a3, "Wrong front()");
-    check(cp.back() == a1, "Wrong back()");
-    check(cp.nth(0) == a3, "Wrong nth()");
-    check(cp.nth(1) == a4, "Wrong nth()");
-    check(cp.nth(2) == a1, "Wrong nth()");
-    typename P::ArcIt ai(cp);
-    check((tmp_a = ai) == a3, "Wrong ArcIt");
-    check((tmp_a = ++ai) == a4, "Wrong nthIt()");
-    check((tmp_a = ++ai) == a1, "Wrong nthIt()");
-    check(++ai == INVALID, "Wrong nthIt()");
-    ai = cp.nthIt(0);
-    check((tmp_a = ai) == a3, "Wrong nthIt()");
-    check((tmp_a = ++ai) == a4, "Wrong nthIt()");
-    ai = cp.nthIt(2);
-    check((tmp_a = ai) == a1, "Wrong nthIt()");
-    check(++ai == INVALID, "Wrong nthIt()");
-    check(pathSource(cgr, cp) == n3, "Wrong pathSource()");
-    check(pathTarget(cgr, cp) == n2, "Wrong pathTarget()");
-    check(checkPath(cgr, cp), "Wrong checkPath()");
-
-    // Check eraseFront()
-    p.eraseFront();
-    p.addBack(a2);
-    check(!cp.empty(), "Wrong empty()");
-    check(cp.length() == 3, "Wrong length");
-    check(cp.front() == a4, "Wrong front()");
-    check(cp.back() == a2, "Wrong back()");
-    check(cp.nth(0) == a4, "Wrong nth()");
-    check(cp.nth(1) == a1, "Wrong nth()");
-    check(cp.nth(2) == a2, "Wrong nth()");
-    typename P::ArcIt ai2(cp);
-    check((tmp_a = ai2) == a4, "Wrong ArcIt");
-    check((tmp_a = ++ai2) == a1, "Wrong nthIt()");
-    check((tmp_a = ++ai2) == a2, "Wrong nthIt()");
-    check(++ai2 == INVALID, "Wrong nthIt()");
-    ai = cp.nthIt(0);
-    check((tmp_a = ai) == a4, "Wrong nthIt()");
-    check((tmp_a = ++ai) == a1, "Wrong nthIt()");
-    ai = cp.nthIt(2);
-    check((tmp_a = ai) == a2, "Wrong nthIt()");
-    check(++ai == INVALID, "Wrong nthIt()");
-    check(pathSource(cgr, cp) == n4, "Wrong pathSource()");
-    check(pathTarget(cgr, cp) == n3, "Wrong pathTarget()");
-    check(checkPath(cgr, cp), "Wrong checkPath()");
-  }
-
-  void checkListPathSplitAndSplice() {
-
-    // Build a path with spliceFront() and spliceBack()
-    ListPath<GR> p1, p2, p3, p4;
-    p1.addBack(a3);
-    p1.addFront(a2);
-    p2.addBack(a1);
-    p1.spliceFront(p2);
-    p3.addFront(a4);
-    p1.spliceBack(p3);
-    check(p1.length() == 4, "Wrong length");
-    check(p1.front() == a1, "Wrong front()");
-    check(p1.back() == a4, "Wrong back()");
-    ListPath<GR>::ArcIt ai(p1);
-    check((tmp_a = ai) == a1, "Wrong ArcIt");
-    check((tmp_a = ++ai) == a2, "Wrong nthIt()");
-    check((tmp_a = ++ai) == a3, "Wrong nthIt()");
-    check((tmp_a = ++ai) == a4, "Wrong nthIt()");
-    check(++ai == INVALID, "Wrong nthIt()");
-    check(checkPath(cgr, p1), "Wrong checkPath()");
-
-    // Check split()
-    p1.split(p1.nthIt(2), p2);
-    check(p1.length() == 2, "Wrong length");
-    ai = p1.nthIt(0);
-    check((tmp_a = ai) == a1, "Wrong ArcIt");
-    check((tmp_a = ++ai) == a2, "Wrong nthIt()");
-    check(++ai == INVALID, "Wrong nthIt()");
-    check(checkPath(cgr, p1), "Wrong checkPath()");
-    check(p2.length() == 2, "Wrong length");
-    ai = p2.nthIt(0);
-    check((tmp_a = ai) == a3, "Wrong ArcIt");
-    check((tmp_a = ++ai) == a4, "Wrong nthIt()");
-    check(++ai == INVALID, "Wrong nthIt()");
-    check(checkPath(cgr, p2), "Wrong checkPath()");
-
-    // Check split() and splice()
-    p1.spliceFront(p2);
-    p1.split(p1.nthIt(2), p2);
-    p2.split(p2.nthIt(1), p3);
-    p2.spliceBack(p1);
-    p2.splice(p2.nthIt(1), p3);
-    check(p2.length() == 4, "Wrong length");
-    check(p2.front() == a1, "Wrong front()");
-    check(p2.back() == a4, "Wrong back()");
-    ai = p2.nthIt(0);
-    check((tmp_a = ai) == a1, "Wrong ArcIt");
-    check((tmp_a = ++ai) == a2, "Wrong nthIt()");
-    check((tmp_a = ++ai) == a3, "Wrong nthIt()");
-    check((tmp_a = ++ai) == a4, "Wrong nthIt()");
-    check(++ai == INVALID, "Wrong nthIt()");
-    check(checkPath(cgr, p2), "Wrong checkPath()");
-  }
-
-};
-
 int main() {
-  checkPathConcepts();
-  checkPathCopy();
-  CheckPathFunctions cpf;
-  cpf.run();
-
+  check_concepts();
   return 0;
 }
Index: test/preflow_test.cc
===================================================================
--- test/preflow_test.cc	(revision 736)
+++ test/preflow_test.cc	(revision 736)
@@ -0,0 +1,250 @@
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library.
+ *
+ * Copyright (C) 2003-2009
+ * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
+ * (Egervary Research Group on Combinatorial Optimization, EGRES).
+ *
+ * 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 <iostream>
+
+#include "test_tools.h"
+#include <lemon/smart_graph.h>
+#include <lemon/preflow.h>
+#include <lemon/concepts/digraph.h>
+#include <lemon/concepts/maps.h>
+#include <lemon/lgf_reader.h>
+#include <lemon/elevator.h>
+
+using namespace lemon;
+
+char test_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"
+  "    label capacity\n"
+  "0 1 0     20\n"
+  "0 2 1     0\n"
+  "1 1 2     3\n"
+  "1 2 3     8\n"
+  "1 3 4     8\n"
+  "2 5 5     5\n"
+  "3 2 6     5\n"
+  "3 5 7     5\n"
+  "3 6 8     5\n"
+  "4 3 9     3\n"
+  "5 7 10    3\n"
+  "5 6 11    10\n"
+  "5 8 12    10\n"
+  "6 8 13    8\n"
+  "8 9 14    20\n"
+  "8 1 15    5\n"
+  "9 5 16    5\n"
+  "@attributes\n"
+  "source 1\n"
+  "target 8\n";
+
+void checkPreflowCompile()
+{
+  typedef int VType;
+  typedef concepts::Digraph Digraph;
+
+  typedef Digraph::Node Node;
+  typedef Digraph::Arc Arc;
+  typedef concepts::ReadMap<Arc,VType> CapMap;
+  typedef concepts::ReadWriteMap<Arc,VType> FlowMap;
+  typedef concepts::WriteMap<Node,bool> CutMap;
+
+  typedef Elevator<Digraph, Digraph::Node> Elev;
+  typedef LinkedElevator<Digraph, Digraph::Node> LinkedElev;
+
+  Digraph g;
+  Node n;
+  Arc e;
+  CapMap cap;
+  FlowMap flow;
+  CutMap cut;
+  VType v;
+  bool b;
+
+  typedef Preflow<Digraph, CapMap>
+            ::SetFlowMap<FlowMap>
+            ::SetElevator<Elev>
+            ::SetStandardElevator<LinkedElev>
+            ::Create PreflowType;
+  PreflowType preflow_test(g, cap, n, n);
+  const PreflowType& const_preflow_test = preflow_test;
+  
+  const PreflowType::Elevator& elev = const_preflow_test.elevator();
+  preflow_test.elevator(const_cast<PreflowType::Elevator&>(elev));
+  PreflowType::Tolerance tol = const_preflow_test.tolerance();
+  preflow_test.tolerance(tol);
+
+  preflow_test
+    .capacityMap(cap)
+    .flowMap(flow)
+    .source(n)
+    .target(n);
+
+  preflow_test.init();
+  preflow_test.init(cap);
+  preflow_test.startFirstPhase();
+  preflow_test.startSecondPhase();
+  preflow_test.run();
+  preflow_test.runMinCut();
+
+  v = const_preflow_test.flowValue();
+  v = const_preflow_test.flow(e);
+  const FlowMap& fm = const_preflow_test.flowMap();
+  b = const_preflow_test.minCut(n);
+  const_preflow_test.minCutMap(cut);
+  
+  ignore_unused_variable_warning(fm);
+}
+
+int cutValue (const SmartDigraph& g,
+              const SmartDigraph::NodeMap<bool>& cut,
+              const SmartDigraph::ArcMap<int>& cap) {
+
+  int c=0;
+  for(SmartDigraph::ArcIt e(g); e!=INVALID; ++e) {
+    if (cut[g.source(e)] && !cut[g.target(e)]) c+=cap[e];
+  }
+  return c;
+}
+
+bool checkFlow(const SmartDigraph& g,
+               const SmartDigraph::ArcMap<int>& flow,
+               const SmartDigraph::ArcMap<int>& cap,
+               SmartDigraph::Node s, SmartDigraph::Node t) {
+
+  for (SmartDigraph::ArcIt e(g); e != INVALID; ++e) {
+    if (flow[e] < 0 || flow[e] > cap[e]) return false;
+  }
+
+  for (SmartDigraph::NodeIt n(g); n != INVALID; ++n) {
+    if (n == s || n == t) continue;
+    int sum = 0;
+    for (SmartDigraph::OutArcIt e(g, n); e != INVALID; ++e) {
+      sum += flow[e];
+    }
+    for (SmartDigraph::InArcIt e(g, n); e != INVALID; ++e) {
+      sum -= flow[e];
+    }
+    if (sum != 0) return false;
+  }
+  return true;
+}
+
+int main() {
+
+  typedef SmartDigraph Digraph;
+
+  typedef Digraph::Node Node;
+  typedef Digraph::NodeIt NodeIt;
+  typedef Digraph::ArcIt ArcIt;
+  typedef Digraph::ArcMap<int> CapMap;
+  typedef Digraph::ArcMap<int> FlowMap;
+  typedef Digraph::NodeMap<bool> CutMap;
+
+  typedef Preflow<Digraph, CapMap> PType;
+
+  Digraph g;
+  Node s, t;
+  CapMap cap(g);
+  std::istringstream input(test_lgf);
+  DigraphReader<Digraph>(g,input).
+    arcMap("capacity", cap).
+    node("source",s).
+    node("target",t).
+    run();
+
+  PType preflow_test(g, cap, s, t);
+  preflow_test.run();
+
+  check(checkFlow(g, preflow_test.flowMap(), cap, s, t),
+        "The flow is not feasible.");
+
+  CutMap min_cut(g);
+  preflow_test.minCutMap(min_cut);
+  int min_cut_value=cutValue(g,min_cut,cap);
+
+  check(preflow_test.flowValue() == min_cut_value,
+        "The max flow value is not equal to the three min cut values.");
+
+  FlowMap flow(g);
+  for(ArcIt e(g); e!=INVALID; ++e) flow[e] = preflow_test.flowMap()[e];
+
+  int flow_value=preflow_test.flowValue();
+
+  for(ArcIt e(g); e!=INVALID; ++e) cap[e]=2*cap[e];
+  preflow_test.init(flow);
+  preflow_test.startFirstPhase();
+
+  CutMap min_cut1(g);
+  preflow_test.minCutMap(min_cut1);
+  min_cut_value=cutValue(g,min_cut1,cap);
+
+  check(preflow_test.flowValue() == min_cut_value &&
+        min_cut_value == 2*flow_value,
+        "The max flow value or the min cut value is wrong.");
+
+  preflow_test.startSecondPhase();
+
+  check(checkFlow(g, preflow_test.flowMap(), cap, s, t),
+        "The flow is not feasible.");
+
+  CutMap min_cut2(g);
+  preflow_test.minCutMap(min_cut2);
+  min_cut_value=cutValue(g,min_cut2,cap);
+
+  check(preflow_test.flowValue() == min_cut_value &&
+        min_cut_value == 2*flow_value,
+        "The max flow value or the three min cut values were not doubled");
+
+
+  preflow_test.flowMap(flow);
+
+  NodeIt tmp1(g,s);
+  ++tmp1;
+  if ( tmp1 != INVALID ) s=tmp1;
+
+  NodeIt tmp2(g,t);
+  ++tmp2;
+  if ( tmp2 != INVALID ) t=tmp2;
+
+  preflow_test.source(s);
+  preflow_test.target(t);
+
+  preflow_test.run();
+
+  CutMap min_cut3(g);
+  preflow_test.minCutMap(min_cut3);
+  min_cut_value=cutValue(g,min_cut3,cap);
+
+
+  check(preflow_test.flowValue() == min_cut_value,
+        "The max flow value or the three min cut values are incorrect.");
+
+  return 0;
+}
Index: test/radix_sort_test.cc
===================================================================
--- test/radix_sort_test.cc	(revision 1341)
+++ test/radix_sort_test.cc	(revision 467)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -17,6 +17,4 @@
  */
 
-#include <lemon/core.h>
-
 #include <lemon/time_measure.h>
 #include <lemon/smart_graph.h>
@@ -28,5 +26,4 @@
 
 #include <vector>
-#include <list>
 #include <algorithm>
 
@@ -43,56 +40,6 @@
 int negate(int a) { return - a; }
 
-template<class T>
-bool isTheSame(T &a, T&b)
-{
-  typename T::iterator ai=a.begin();
-  typename T::iterator bi=b.begin();
-  for(;ai!=a.end()||bi!=b.end();++ai,++bi)
-    if(*ai!=*bi) return false;
-  return ai==a.end()&&bi==b.end();
-}
 
-template<class T>
-T listsort(typename T::iterator b, typename T::iterator e)
-{
-  if(b==e) return T();
-  typename T::iterator bn=b;
-  if(++bn==e) {
-    T l;
-    l.push_back(*b);
-    return l;
-  }
-  typename T::iterator m=b;
-  bool x=false;
-  for(typename T::iterator i=b;i!=e;++i,x=!x)
-    if(x) ++m;
-  T l1(listsort<T>(b,m));
-  T l2(listsort<T>(m,e));
-  T l;
-  while((!l1.empty())&&(!l2.empty()))
-    if(l1.front()<=l2.front())
-      {
-        l.push_back(l1.front());
-        l1.pop_front();
-      }
-    else {
-      l.push_back(l2.front());
-      l2.pop_front();
-    }
-  while(!l1.empty())
-    {
-      l.push_back(l1.front());
-      l1.pop_front();
-    }
-  while(!l2.empty())
-    {
-      l.push_back(l2.front());
-      l2.pop_front();
-    }
-  return l;
-}
-
-template<class T>
-void generateIntSequence(int n, T & data) {
+void generateIntSequence(int n, std::vector<int>& data) {
   int prime = 9973;
   int root = 136, value = 1;
@@ -103,6 +50,5 @@
 }
 
-template<class T>
-void generateCharSequence(int n, T & data) {
+void generateCharSequence(int n, std::vector<unsigned char>& data) {
   int prime = 251;
   int root = 3, value = root;
@@ -126,13 +72,13 @@
     }
 
-    // radixSort(data2.begin(), data2.end(), Negate());
-    // for (int i = 0; i < n; ++i) {
-    //   check(data1[i] == data2[n - 1 - i], "Test failed");
-    // }
+    radixSort(data2.begin(), data2.end(), Negate());
+    for (int i = 0; i < n; ++i) {
+      check(data1[i] == data2[n - 1 - i], "Test failed");
+    }
 
-    // radixSort(data2.begin(), data2.end(), negate);
-    // for (int i = 0; i < n; ++i) {
-    //   check(data1[i] == data2[n - 1 - i], "Test failed");
-    // }
+    radixSort(data2.begin(), data2.end(), negate);
+    for (int i = 0; i < n; ++i) {
+      check(data1[i] == data2[n - 1 - i], "Test failed");
+    }
 
   }
@@ -149,40 +95,4 @@
       check(data1[i] == data2[i], "Test failed");
     }
-
-  }
-  {
-    std::list<int> data1;
-    generateIntSequence(n, data1);
-
-    std::list<int> data2(listsort<std::list<int> >(data1.begin(), data1.end()));
-
-    radixSort(data1.begin(), data1.end());
-
-    check(isTheSame(data1,data2), "Test failed");
-
-
-    // radixSort(data2.begin(), data2.end(), Negate());
-    // check(isTheSame(data1,data2), "Test failed");
-    // for (int i = 0; i < n; ++i) {
-    //   check(data1[i] == data2[n - 1 - i], "Test failed");
-    // }
-
-    // radixSort(data2.begin(), data2.end(), negate);
-    // for (int i = 0; i < n; ++i) {
-    //   check(data1[i] == data2[n - 1 - i], "Test failed");
-    // }
-
-  }
-
-  {
-    std::list<unsigned char> data1(n);
-    generateCharSequence(n, data1);
-
-    std::list<unsigned char> data2(listsort<std::list<unsigned char> >
-                                   (data1.begin(),
-                                    data1.end()));
-
-    radixSort(data1.begin(), data1.end());
-    check(isTheSame(data1,data2), "Test failed");
 
   }
@@ -227,35 +137,4 @@
 
   }
-  {
-    std::list<int> data1;
-    generateIntSequence(n, data1);
-
-    std::list<int> data2(listsort<std::list<int> >(data1.begin(),
-                                                   data1.end()));
-    stableRadixSort(data1.begin(), data1.end());
-    check(isTheSame(data1,data2), "Test failed");
-
-    // stableRadixSort(data2.begin(), data2.end(), Negate());
-    // for (int i = 0; i < n; ++i) {
-    //   check(data1[i] == data2[n - 1 - i], "Test failed");
-    // }
-
-    // stableRadixSort(data2.begin(), data2.end(), negate);
-    // for (int i = 0; i < n; ++i) {
-    //   check(data1[i] == data2[n - 1 - i], "Test failed");
-    // }
-  }
-
-  {
-    std::list<unsigned char> data1(n);
-    generateCharSequence(n, data1);
-
-    std::list<unsigned char> data2(listsort<std::list<unsigned char> >
-                                   (data1.begin(),
-                                    data1.end()));
-    radixSort(data1.begin(), data1.end());
-    check(isTheSame(data1,data2), "Test failed");
-
-  }
 }
 
Index: test/suurballe_test.cc
===================================================================
--- test/suurballe_test.cc	(revision 1270)
+++ test/suurballe_test.cc	(revision 670)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -24,5 +24,4 @@
 #include <lemon/suurballe.h>
 #include <lemon/concepts/digraph.h>
-#include <lemon/concepts/heap.h>
 
 #include "test_tools.h"
@@ -82,12 +81,6 @@
   typedef Digraph::Arc Arc;
   typedef concepts::ReadMap<Arc, VType> LengthMap;
-
-  typedef Suurballe<Digraph, LengthMap> ST;
-  typedef Suurballe<Digraph, LengthMap>
-    ::SetFlowMap<ST::FlowMap>
-    ::SetPotentialMap<ST::PotentialMap>
-    ::SetPath<SimplePath<Digraph> >
-    ::SetHeap<concepts::Heap<VType, Digraph::NodeMap<int> > >
-    ::Create SuurballeType;
+  
+  typedef Suurballe<Digraph, LengthMap> SuurballeType;
 
   Digraph g;
@@ -109,15 +102,10 @@
   k = suurb_test.run(n, n, k);
   suurb_test.init(n);
-  suurb_test.fullInit(n);
-  suurb_test.start(n);
-  suurb_test.start(n, k);
   k = suurb_test.findFlow(n);
   k = suurb_test.findFlow(n, k);
   suurb_test.findPaths();
-
+  
   int f;
   VType c;
-  ::lemon::ignore_unused_variable_warning(f,c);
-
   c = const_suurb_test.totalLength();
   f = const_suurb_test.flow(e);
@@ -129,7 +117,7 @@
   k = const_suurb_test.pathNum();
   Path<Digraph> p = const_suurb_test.path(k);
-
-  ::lemon::ignore_unused_variable_warning(fm);
-  ::lemon::ignore_unused_variable_warning(pm);
+  
+  ignore_unused_variable_warning(fm);
+  ignore_unused_variable_warning(pm);
 }
 
@@ -208,9 +196,7 @@
     run();
 
-  // Check run()
+  // Find 2 paths
   {
     Suurballe<ListDigraph> suurballe(digraph, length);
-
-    // Find 2 paths
     check(suurballe.run(s, t) == 2, "Wrong number of paths");
     check(checkFlow(digraph, suurballe.flowMap(), s, t, 2),
@@ -222,6 +208,9 @@
     for (int i = 0; i < suurballe.pathNum(); ++i)
       check(checkPath(digraph, suurballe.path(i), s, t), "Wrong path");
-
-    // Find 3 paths
+  }
+
+  // Find 3 paths
+  {
+    Suurballe<ListDigraph> suurballe(digraph, length);
     check(suurballe.run(s, t, 3) == 3, "Wrong number of paths");
     check(checkFlow(digraph, suurballe.flowMap(), s, t, 3),
@@ -233,6 +222,9 @@
     for (int i = 0; i < suurballe.pathNum(); ++i)
       check(checkPath(digraph, suurballe.path(i), s, t), "Wrong path");
-
-    // Find 5 paths (only 3 can be found)
+  }
+
+  // Find 5 paths (only 3 can be found)
+  {
+    Suurballe<ListDigraph> suurballe(digraph, length);
     check(suurballe.run(s, t, 5) == 3, "Wrong number of paths");
     check(checkFlow(digraph, suurballe.flowMap(), s, t, 3),
@@ -246,22 +238,4 @@
   }
 
-  // Check fullInit() + start()
-  {
-    Suurballe<ListDigraph> suurballe(digraph, length);
-    suurballe.fullInit(s);
-
-    // Find 2 paths
-    check(suurballe.start(t) == 2, "Wrong number of paths");
-    check(suurballe.totalLength() == 510, "The flow is not optimal");
-
-    // Find 3 paths
-    check(suurballe.start(t, 3) == 3, "Wrong number of paths");
-    check(suurballe.totalLength() == 1040, "The flow is not optimal");
-
-    // Find 5 paths (only 3 can be found)
-    check(suurballe.start(t, 5) == 3, "Wrong number of paths");
-    check(suurballe.totalLength() == 1040, "The flow is not optimal");
-  }
-
   return 0;
 }
Index: test/test_tools.h
===================================================================
--- test/test_tools.h	(revision 956)
+++ test/test_tools.h	(revision 810)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -46,5 +46,5 @@
     } else { }                                                          \
   }                                                                     \
-
+    
 
 #endif
Index: test/time_measure_test.cc
===================================================================
--- test/time_measure_test.cc	(revision 1270)
+++ test/time_measure_test.cc	(revision 605)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -18,5 +18,4 @@
 
 #include <lemon/time_measure.h>
-#include <lemon/concept_check.h>
 
 using namespace lemon;
@@ -34,8 +33,5 @@
 
   for(int i=0;i<1000;i++)
-    {
-      TimeStamp x(T);
-      ::lemon::ignore_unused_variable_warning(x);
-    }
+    TimeStamp x(T);
 }
 
Index: st/tsp_test.cc
===================================================================
--- test/tsp_test.cc	(revision 1303)
+++ 	(revision )
@@ -1,287 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2013
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * 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 <iostream>
-
-#include <lemon/full_graph.h>
-#include <lemon/math.h>
-#include <lemon/maps.h>
-#include <lemon/random.h>
-#include <lemon/dim2.h>
-
-#include <lemon/nearest_neighbor_tsp.h>
-#include <lemon/greedy_tsp.h>
-#include <lemon/insertion_tsp.h>
-#include <lemon/christofides_tsp.h>
-#include <lemon/opt2_tsp.h>
-
-#include "test_tools.h"
-
-using namespace lemon;
-
-// // Tests checkMetricCost() function
-// void metricCostTest() {
-//   GRAPH_TYPEDEFS(FullGraph);
-//   FullGraph g(10);
-//   check(checkMetricCost(g, constMap<Edge>(0)), "Wrong checkMetricCost()");
-//   check(checkMetricCost(g, constMap<Edge>(1)), "Wrong checkMetricCost()");
-//   check(!checkMetricCost(g, constMap<Edge>(-1)), "Wrong checkMetricCost()");
-//
-//   FullGraph::EdgeMap<float> cost(g);
-//   for (NodeIt u(g); u != INVALID; ++u) {
-//     for (NodeIt v(g); v != INVALID; ++v) {
-//       if (u == v) continue;
-//       float x1 = g.id(u), x2 = g.id(v);
-//       float y1 = x1 * x1, y2 = x2 * x2;
-//       cost[g.edge(u, v)] = std::sqrt((x2-x1)*(x2-x1) + (y2-y1)*(y2-y1));
-//     }
-//   }
-//   check(checkMetricCost(g, cost), "Wrong checkMetricCost()");
-//   float eps = Tolerance<float>::defaultEpsilon();
-//   cost[g.edge(g(0), g(9))] =
-//     cost[g.edge(g(0), g(8))] + cost[g.edge(g(8), g(9))] + eps * 2;
-//   check(!checkMetricCost(g, cost), "Wrong checkMetricCost()");
-//   check(checkMetricCost(g, cost, Tolerance<float>(eps * 4)),
-//     "Wrong checkMetricCost()");
-// }
-
-// Checks tour validity
-template <typename Container>
-bool checkTour(const FullGraph &gr, const Container &p) {
-  FullGraph::NodeMap<bool> used(gr, false);
-
-  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;
-    }
-
-  return (node_cnt == gr.nodeNum());
-}
-
-// Checks tour validity
-bool checkTourPath(const FullGraph &gr, const Path<FullGraph> &p) {
-  FullGraph::NodeMap<bool> used(gr, false);
-
-  if (!checkPath(gr, p)) return false;
-  if (gr.nodeNum() <= 1 && p.length() != 0) return false;
-  if (gr.nodeNum() > 1 && p.length() != gr.nodeNum()) return false;
-
-  for (int i = 0; i < p.length(); ++i) {
-    if (used[gr.target(p.nth(i))]) return false;
-    used[gr.target(p.nth(i))] = true;
-  }
-  return true;
-}
-
-// Checks tour cost
-template <typename CostMap>
-bool checkCost(const FullGraph &gr, const std::vector<FullGraph::Node> &p,
-               const CostMap &cost, typename CostMap::Value total)
-{
-  typedef typename CostMap::Value Cost;
-
-  Cost s = 0;
-  for (int i = 0; i < int(p.size()) - 1; ++i)
-    s += cost[gr.edge(p[i], p[i+1])];
-  if (int(p.size()) >= 2)
-    s += cost[gr.edge(p.back(), p.front())];
-
-  return !Tolerance<Cost>().different(s, total);
-}
-
-// Checks tour cost
-template <typename CostMap>
-bool checkCost(const FullGraph &, const Path<FullGraph> &p,
-               const CostMap &cost, typename CostMap::Value total)
-{
-  typedef typename CostMap::Value Cost;
-
-  Cost s = 0;
-  for (int i = 0; i < p.length(); ++i)
-    s += cost[p.nth(i)];
-
-  return !Tolerance<Cost>().different(s, total);
-}
-
-// Tests a TSP algorithm on small graphs
-template <typename TSP>
-void tspTestSmall(const std::string &alg_name) {
-  GRAPH_TYPEDEFS(FullGraph);
-
-  for (int n = 0; n <= 5; ++n) {
-    FullGraph g(n);
-    unsigned nsize = n;
-    int esize = n <= 1 ? 0 : n;
-
-    ConstMap<Edge, int> cost_map(1);
-    TSP alg(g, cost_map);
-
-    check(alg.run() == esize, alg_name + ": Wrong total cost");
-    check(alg.tourCost() == esize, alg_name + ": Wrong total cost");
-
-    std::list<Node> list1(nsize), list2;
-    std::vector<Node> vec1(nsize), vec2;
-    alg.tourNodes(list1.begin());
-    alg.tourNodes(vec1.begin());
-    alg.tourNodes(std::front_inserter(list2));
-    alg.tourNodes(std::back_inserter(vec2));
-    check(checkTour(g, alg.tourNodes()), alg_name + ": Wrong node sequence");
-    check(checkTour(g, list1), alg_name + ": Wrong node sequence");
-    check(checkTour(g, vec1), alg_name + ": Wrong node sequence");
-    check(checkTour(g, list2), alg_name + ": Wrong node sequence");
-    check(checkTour(g, vec2), alg_name + ": Wrong node sequence");
-    check(checkCost(g, vec1, constMap<Edge, int>(1), esize),
-      alg_name + ": Wrong tour cost");
-
-    SimplePath<FullGraph> path;
-    alg.tour(path);
-    check(path.length() == esize, alg_name + ": Wrong tour");
-    check(checkTourPath(g, path), alg_name + ": Wrong tour");
-    check(checkCost(g, path, constMap<Edge, int>(1), esize),
-      alg_name + ": Wrong tour cost");
-  }
-}
-
-// Tests a TSP algorithm on random graphs
-template <typename TSP>
-void tspTestRandom(const std::string &alg_name) {
-  GRAPH_TYPEDEFS(FullGraph);
-
-  FullGraph g(20);
-  FullGraph::NodeMap<dim2::Point<double> > pos(g);
-  DoubleEdgeMap cost(g);
-
-  TSP alg(g, cost);
-  Opt2Tsp<DoubleEdgeMap > opt2(g, cost);
-
-  for (int i = 1; i <= 3; i++) {
-    for (NodeIt u(g); u != INVALID; ++u) {
-      pos[u] = dim2::Point<double>(rnd(), rnd());
-    }
-    for (NodeIt u(g); u != INVALID; ++u) {
-      for (NodeIt v(g); v != INVALID; ++v) {
-        if (u == v) continue;
-        cost[g.edge(u, v)] = (pos[u] - pos[v]).normSquare();
-      }
-    }
-
-    check(alg.run() > 0, alg_name + ": Wrong total cost");
-
-    std::vector<Node> vec;
-    alg.tourNodes(std::back_inserter(vec));
-    check(checkTour(g, vec), alg_name + ": Wrong node sequence");
-    check(checkCost(g, vec, cost, alg.tourCost()),
-      alg_name + ": Wrong tour cost");
-
-    SimplePath<FullGraph> path;
-    alg.tour(path);
-    check(checkTourPath(g, path), alg_name + ": Wrong tour");
-    check(checkCost(g, path, cost, alg.tourCost()),
-      alg_name + ": Wrong tour cost");
-
-    check(!Tolerance<double>().less(alg.tourCost(), opt2.run(alg.tourNodes())),
-      "2-opt improvement: Wrong total cost");
-    check(checkTour(g, opt2.tourNodes()),
-      "2-opt improvement: Wrong node sequence");
-    check(checkCost(g, opt2.tourNodes(), cost, opt2.tourCost()),
-      "2-opt improvement: Wrong tour cost");
-
-    check(!Tolerance<double>().less(alg.tourCost(), opt2.run(path)),
-      "2-opt improvement: Wrong total cost");
-    check(checkTour(g, opt2.tourNodes()),
-      "2-opt improvement: Wrong node sequence");
-    check(checkCost(g, opt2.tourNodes(), cost, opt2.tourCost()),
-      "2-opt improvement: Wrong tour cost");
-  }
-}
-
-// Algorithm class for Nearest Insertion
-template <typename CM>
-class NearestInsertionTsp : public InsertionTsp<CM> {
-public:
-  NearestInsertionTsp(const FullGraph &gr, const CM &cost)
-    : InsertionTsp<CM>(gr, cost) {}
-  typename CM::Value run() {
-    return InsertionTsp<CM>::run(InsertionTsp<CM>::NEAREST);
-  }
-};
-
-// Algorithm class for Farthest Insertion
-template <typename CM>
-class FarthestInsertionTsp : public InsertionTsp<CM> {
-public:
-  FarthestInsertionTsp(const FullGraph &gr, const CM &cost)
-    : InsertionTsp<CM>(gr, cost) {}
-  typename CM::Value run() {
-    return InsertionTsp<CM>::run(InsertionTsp<CM>::FARTHEST);
-  }
-};
-
-// Algorithm class for Cheapest Insertion
-template <typename CM>
-class CheapestInsertionTsp : public InsertionTsp<CM> {
-public:
-  CheapestInsertionTsp(const FullGraph &gr, const CM &cost)
-    : InsertionTsp<CM>(gr, cost) {}
-  typename CM::Value run() {
-    return InsertionTsp<CM>::run(InsertionTsp<CM>::CHEAPEST);
-  }
-};
-
-// Algorithm class for Random Insertion
-template <typename CM>
-class RandomInsertionTsp : public InsertionTsp<CM> {
-public:
-  RandomInsertionTsp(const FullGraph &gr, const CM &cost)
-    : InsertionTsp<CM>(gr, cost) {}
-  typename CM::Value run() {
-    return InsertionTsp<CM>::run(InsertionTsp<CM>::RANDOM);
-  }
-};
-
-int main() {
-  GRAPH_TYPEDEFS(FullGraph);
-
-  // metricCostTest();
-
-  tspTestSmall<NearestNeighborTsp<ConstMap<Edge, int> > >("Nearest Neighbor");
-  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<RandomInsertionTsp<ConstMap<Edge, int> > >("Random Insertion");
-  tspTestSmall<ChristofidesTsp<ConstMap<Edge, int> > >("Christofides");
-  tspTestSmall<Opt2Tsp<ConstMap<Edge, int> > >("2-opt");
-
-  tspTestRandom<NearestNeighborTsp<DoubleEdgeMap > >("Nearest Neighbor");
-  tspTestRandom<GreedyTsp<DoubleEdgeMap > >("Greedy");
-  tspTestRandom<NearestInsertionTsp<DoubleEdgeMap > >("Nearest Insertion");
-  tspTestRandom<FarthestInsertionTsp<DoubleEdgeMap > >("Farthest Insertion");
-  tspTestRandom<CheapestInsertionTsp<DoubleEdgeMap > >("Cheapest Insertion");
-  tspTestRandom<RandomInsertionTsp<DoubleEdgeMap > >("Random Insertion");
-  tspTestRandom<ChristofidesTsp<DoubleEdgeMap > >("Christofides");
-  tspTestRandom<Opt2Tsp<DoubleEdgeMap > >("2-opt");
-
-  return 0;
-}
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/Makefile.am
===================================================================
--- tools/Makefile.am	(revision 721)
+++ tools/Makefile.am	(revision 721)
@@ -0,0 +1,17 @@
+EXTRA_DIST += \
+	tools/CMakeLists.txt
+
+if WANT_TOOLS
+
+bin_PROGRAMS += \
+	tools/dimacs-solver \
+	tools/dimacs-to-lgf \
+	tools/lgf-gen
+
+dist_bin_SCRIPTS += tools/lemon-0.x-to-1.x.sh
+
+endif WANT_TOOLS
+
+tools_dimacs_solver_SOURCES = tools/dimacs-solver.cc
+tools_dimacs_to_lgf_SOURCES = tools/dimacs-to-lgf.cc
+tools_lgf_gen_SOURCES = tools/lgf-gen.cc
Index: tools/dimacs-solver.cc
===================================================================
--- tools/dimacs-solver.cc	(revision 1271)
+++ tools/dimacs-solver.cc	(revision 691)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -89,8 +89,8 @@
   pre.run();
   if(report) std::cerr << "Run Preflow: " << ti << '\n';
-  if(report) std::cerr << "\nMax flow value: " << pre.flowValue() << '\n';
-}
-
-template<class Value, class LargeValue>
+  if(report) std::cerr << "\nMax flow value: " << pre.flowValue() << '\n';  
+}
+
+template<class Value>
 void solve_min(ArgParser &ap, std::istream &is, std::ostream &,
                Value infty, DimacsDescriptor &desc)
@@ -118,18 +118,15 @@
   if (report) std::cerr << "Read the file: " << ti << '\n';
 
-  typedef NetworkSimplex<Digraph, Value> MCF;
-  ti.restart();
-  MCF ns(g);
+  ti.restart();
+  NetworkSimplex<Digraph, Value> ns(g);
   ns.lowerMap(lower).upperMap(cap).costMap(cost).supplyMap(sup);
   if (sum_sup > 0) ns.supplyType(ns.LEQ);
   if (report) std::cerr << "Setup NetworkSimplex class: " << ti << '\n';
   ti.restart();
-  typename MCF::ProblemType res = ns.run();
+  bool res = ns.run();
   if (report) {
     std::cerr << "Run NetworkSimplex: " << ti << "\n\n";
-    std::cerr << "Feasible flow: " << (res == MCF::OPTIMAL ? "found" :
-                                       "not found") << '\n';
-    if (res) std::cerr << "Min flow cost: "
-                       << ns.template totalCost<LargeValue>() << '\n';
+    std::cerr << "Feasible flow: " << (res ? "found" : "not found") << '\n';
+    if (res) std::cerr << "Min flow cost: " << ns.totalCost() << '\n';
   }
 }
@@ -151,9 +148,9 @@
   if(report) std::cerr << "Run MaxMatching: " << ti << '\n';
   if(report) std::cerr << "\nCardinality of max matching: "
-                       << mat.matchingSize() << '\n';
-}
-
-
-template<class Value, class LargeValue>
+                       << mat.matchingSize() << '\n';  
+}
+
+
+template<class Value>
 void solve(ArgParser &ap, std::istream &is, std::ostream &os,
            DimacsDescriptor &desc)
@@ -169,9 +166,9 @@
       exit(1);
     }
-
+  
   switch(desc.type)
     {
     case DimacsDescriptor::MIN:
-      solve_min<Value, LargeValue>(ap,is,os,infty,desc);
+      solve_min<Value>(ap,is,os,infty,desc);
       break;
     case DimacsDescriptor::MAX:
@@ -190,4 +187,7 @@
 
 int main(int argc, const char *argv[]) {
+  typedef SmartDigraph Digraph;
+
+  typedef Digraph::Arc Arc;
 
   std::string inputName;
@@ -238,5 +238,5 @@
 
   DimacsDescriptor desc = dimacsType(is);
-
+  
   if(!ap.given("q"))
     {
@@ -263,16 +263,14 @@
       std::cout << "\n\n";
     }
-
+    
   if(ap.given("double"))
-    solve<double, double>(ap,is,os,desc);
+    solve<double>(ap,is,os,desc);
   else if(ap.given("ldouble"))
-    solve<long double, long double>(ap,is,os,desc);
+    solve<long double>(ap,is,os,desc);
 #ifdef LEMON_HAVE_LONG_LONG
   else if(ap.given("long"))
-    solve<long long, long long>(ap,is,os,desc);
-  else solve<int, long long>(ap,is,os,desc);
-#else
-  else solve<int, long>(ap,is,os,desc);
+    solve<long long>(ap,is,os,desc);
 #endif
+  else solve<int>(ap,is,os,desc);
 
   return 0;
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 {
