Merge pull request #1902 from Project-OSRM/4.9.1

Bug fix release 4.9.1
Include the travel mode in the last instruction by copying it from the previous instruction.
2016-01-19 19:00:11 -05:00 · 2016-01-19 23:23:32 +01:00 · 2016-01-19 21:26:30 +01:00 · 2016-01-19 20:31:14 +01:00 · 2016-01-19 20:31:03 +01:00 · 2016-01-19 17:38:02 +01:00
400 changed files with 24017 additions and 10388 deletions
@@ -0,0 +1,4 @@
+---
+Checks:          '-clang-analyzer-*,google-*,llvm-*,misc-*,readability-*,-google-build-explicit-make-pair,-google-explicit-constructor,-google-readability-braces-around-statements,-google-readability-casting,-google-readability-namespace-comments,-google-readability-function,-google-readability-todo,-google-runtime-int,-llvm-namespace-comment,-llvm-header-guard,-llvm-twine-local,-misc-argument-comment,-readability-braces-around-statements,-readability-identifier-naming'
+...
+
@@ -40,8 +40,6 @@ Thumbs.db
 # build related files #
 #######################
 /build/
-/util/fingerprint_impl.hpp
-/util/git_sha.cpp
 /cmake/postinst

 # Eclipse related files #
@@ -1,65 +1,146 @@
 language: cpp
-compiler:
-  - gcc
-#  - clang
-# Make sure CMake is installed
-install:
- - sudo apt-add-repository -y ppa:ubuntu-toolchain-r/test
- - sudo add-apt-repository -y ppa:boost-latest/ppa
- - sudo apt-get update >/dev/null
- - sudo apt-get -q install protobuf-compiler libprotoc-dev libprotobuf7 libprotobuf-dev libbz2-dev libstxxl-dev libstxxl1 libxml2-dev libzip-dev lua5.1 liblua5.1-0-dev rubygems libtbb-dev
- - sudo apt-get -q install g++-4.8
- - sudo apt-get install libboost1.54-all-dev
- - sudo apt-get install libgdal-dev
- # luabind
- - curl https://gist.githubusercontent.com/DennisOSRM/f2eb7b948e6fe1ae319e/raw/install-luabind.sh | sudo bash
- # osmosis
- - curl -s https://gist.githubusercontent.com/DennisOSRM/803a64a9178ec375069f/raw/ | sudo bash
- # cmake
- - curl -s https://gist.githubusercontent.com/DennisOSRM/5fad9bee5c7f09fd7fc9/raw/ | sudo bash
- # osmpbf library
- - curl -s https://gist.githubusercontent.com/DennisOSRM/13b1b4fe38a57ead850e/raw/install_osmpbf.sh | sudo bash
-before_script:
- - rvm use 1.9.3
- - gem install bundler
- - bundle install
- - mkdir build
- - cd build
- - cmake .. $CMAKEOPTIONS -DBUILD_TOOLS=1
-script:
- - make
- - make tests
- - make benchmarks
- - ./algorithm-tests
- - ./datastructure-tests
- - cd ..
- - cucumber -p verify
-after_script:
-# - cd ..
-# - cucumber -p verify
+sudo: required
+dist: trusty
+
+notifications:
+  email: false
+
 branches:
  only:
    - master
    - develop
-cache:
- bundler
- apt
-env:
- - CMAKEOPTIONS="-DCMAKE_BUILD_TYPE=Release -DCMAKE_CXX_COMPILER=g++-4.8" OSRM_PORT=5000 OSRM_TIMEOUT=60
- - CMAKEOPTIONS="-DCMAKE_BUILD_TYPE=Debug -DCMAKE_CXX_COMPILER=g++-4.8" OSRM_PORT=5010 OSRM_TIMEOUT=60
- - CMAKEOPTIONS="-DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=ON -DCMAKE_CXX_COMPILER=g++-4.8" OSRM_PORT=5020 OSRM_TIMEOUT=60
-notifications:
- slack: mapbox:4A6euphDwfxAQnhLurXbu6A1
- irc:
-  channels:
-    - irc.oftc.net#osrm
-  on_success: change
-  on_failure: always
-  use_notice: true
-  skip_join: false

-  recipients:
-    - patrick@mapbox.com
-  email:
-    on_success: change
-    on_failure: always
+matrix:
+  include:
+
+    # 1/ Linux Clang Builds
+
+    - os: linux
+      compiler: clang
+      addons: &clang38
+        apt:
+          sources: ['llvm-toolchain-precise', 'ubuntu-toolchain-r-test']
+          packages: ['clang-3.8', 'libbz2-dev', 'libstxxl-dev', 'libstxxl1', 'libxml2-dev', 'libzip-dev', 'lua5.1', 'liblua5.1-0-dev', 'rubygems-integration', 'libtbb-dev', 'libgdal-dev', 'libluabind-dev', 'libboost-all-dev']
+      env: COMPILER='clang++-3.8' BUILD_TYPE='Release'
+
+    - os: linux
+      compiler: clang
+      addons: &clang38
+        apt:
+          sources: ['llvm-toolchain-precise', 'ubuntu-toolchain-r-test']
+          packages: ['clang-3.8', 'libbz2-dev', 'libstxxl-dev', 'libstxxl1', 'libxml2-dev', 'libzip-dev', 'lua5.1', 'liblua5.1-0-dev', 'rubygems-integration', 'libtbb-dev', 'libgdal-dev', 'libluabind-dev', 'libboost-all-dev']
+      env: COMPILER='clang++-3.8' BUILD_TYPE='Release' BUILD_SHARED_LIBS=ON
+
+    - os: linux
+      compiler: clang
+      addons: *clang38
+      env: COMPILER='clang++-3.8' BUILD_TYPE='Debug'
+
+
+    # 2/ Linux GCC Builds
+    - os: linux
+      compiler: gcc
+      addons: &gcc48
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: ['g++-4.8', 'libbz2-dev', 'libstxxl-dev', 'libstxxl1', 'libxml2-dev', 'libzip-dev', 'lua5.1', 'liblua5.1-0-dev', 'rubygems-integration', 'libtbb-dev', 'libgdal-dev', 'libluabind-dev', 'libboost-all-dev']
+      env: COMPILER='g++-4.8' BUILD_TYPE='Release'
+
+    - os: linux
+      compiler: gcc
+      addons: *gcc48
+      env: COMPILER='g++-4.8' BUILD_TYPE='Debug'
+
+
+    - os: linux
+      compiler: gcc
+      addons: &gcc5
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: ['g++-5', 'libbz2-dev', 'libstxxl-dev', 'libstxxl1', 'libxml2-dev', 'libzip-dev', 'lua5.1', 'liblua5.1-0-dev', 'rubygems-integration', 'libtbb-dev', 'libgdal-dev', 'libluabind-dev', 'libboost-all-dev']
+      env: COMPILER='g++-5' BUILD_TYPE='Release'
+
+    - os: linux
+      compiler: gcc
+      addons: &gcc5
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: ['g++-5', 'libbz2-dev', 'libstxxl-dev', 'libstxxl1', 'libxml2-dev', 'libzip-dev', 'lua5.1', 'liblua5.1-0-dev', 'rubygems-integration', 'libtbb-dev', 'libgdal-dev', 'libluabind-dev', 'libboost-all-dev']
+      env: COMPILER='g++-5' BUILD_TYPE='Release' BUILD_SHARED_LIBS=ON
+
+    - os: linux
+      compiler: gcc
+      addons: *gcc5
+      env: COMPILER='g++-5' BUILD_TYPE='Debug'
+
+
+    # Disabled until tests all pass on OSX:
+    #
+    # 3/ OSX Clang Builds
+    #- os: osx
+    #  osx_image: xcode6.4
+    #  compiler: clang
+    #  env: COMPILER='clang++' BUILD_TYPE='Debug'
+
+    #- os: osx
+    #  osx_image: xcode6.4
+    #  compiler: clang
+    #  env: COMPILER='clang++' BUILD_TYPE='Release'
+
+    #- os: osx
+    #  osx_image: xcode6.4
+    #  compiler: clang
+    #  env: COMPILER='clang++' BUILD_TYPE='Release' BUILD_SHARED_LIBS=ON
+
+    #- os: osx
+    #  osx_image: xcode7
+    #  compiler: clang
+    #  env: COMPILER='clang++' BUILD_TYPE='Debug'
+
+    #- os: osx
+    #  osx_image: xcode7
+    #  compiler: clang
+    #  env: COMPILER='clang++' BUILD_TYPE='Release'
+
+    #- os: osx
+    #  osx_image: xcode7
+    #  compiler: clang
+    #  env: COMPILER='clang++' BUILD_TYPE='Release' BUILD_SHARED_LIBS=ON
+
+
+install:
+  - DEPS_DIR="${TRAVIS_BUILD_DIR}/deps"
+  - mkdir -p ${DEPS_DIR} && cd ${DEPS_DIR}
+  - |
+    if [[ "${TRAVIS_OS_NAME}" == "linux" ]]; then
+      CMAKE_URL="http://www.cmake.org/files/v3.3/cmake-3.3.2-Linux-x86_64.tar.gz"
+      mkdir cmake && travis_retry wget --quiet -O - ${CMAKE_URL} | tar --strip-components=1 -xz -C cmake
+      export PATH=${DEPS_DIR}/cmake/bin:${PATH}
+
+      OSMOSIS_URL="http://bretth.dev.openstreetmap.org/osmosis-build/osmosis-latest.tgz"
+      mkdir osmosis && travis_retry wget --quiet -O - ${OSMOSIS_URL} | tar -xz -C osmosis
+      export PATH=${DEPS_DIR}/osmosis/bin:${PATH}
+
+    elif [[ "${TRAVIS_OS_NAME}" == "osx" ]]; then
+      brew install cmake boost libzip libstxxl libxml2 lua51 luabind tbb GDAL osmosis
+    fi
+
+before_script:
+  - cd ${TRAVIS_BUILD_DIR}
+  - rvm use 1.9.3
+  - gem install bundler
+  - bundle install
+  - mkdir build && cd build
+  - export CXX=${COMPILER}
+  - export OSRM_PORT=5000 OSRM_TIMEOUT=60
+  - cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DBUILD_SHARED_LIBS=${BUILD_SHARED_LIBS:-OFF} -DBUILD_TOOLS=1
+
+script:
+  - make --jobs=2
+  - make tests --jobs=2
+  - make benchmarks
+  - ./algorithm-tests
+  - ./datastructure-tests
+  - ./util-tests
+  - cd ..
+  - cucumber -p verify
@@ -7,13 +7,15 @@ This process created the file `CMakeCache.txt' and the directory `CMakeFiles'. P
 endif()

 project(OSRM C CXX)
+set(OSRM_VERSION_MAJOR 4)
+set(OSRM_VERSION_MINOR 9)
+set(OSRM_VERSION_PATCH 0)
+
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 include(CheckCXXCompilerFlag)
 include(FindPackageHandleStandardArgs)

 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
-include(GetGitRevisionDescription)
-git_describe(GIT_DESCRIPTION)

 set(bitness 32)
 if(CMAKE_SIZEOF_VOID_P EQUAL 8)
@@ -28,56 +30,62 @@ if(WIN32 AND MSVC_VERSION LESS 1800)
 endif()

 option(ENABLE_JSON_LOGGING "Adds additional JSON debug logging to the response" OFF)
-option(WITH_TOOLS "Build OSRM tools" OFF)
+option(DEBUG_GEOMETRY "Enables an option to dump GeoJSON of the final routing graph" OFF)
 option(BUILD_TOOLS "Build OSRM tools" OFF)

+include_directories(${CMAKE_CURRENT_SOURCE_DIR})
+include_directories(${CMAKE_CURRENT_BINARY_DIR})
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include/)
-include_directories(${CMAKE_CURRENT_SOURCE_DIR}/third_party/)
-include_directories(${CMAKE_CURRENT_SOURCE_DIR}/third_party/libosmium/include/)
+include_directories(SYSTEM ${CMAKE_CURRENT_SOURCE_DIR}/third_party/)
+include_directories(SYSTEM ${CMAKE_CURRENT_SOURCE_DIR}/third_party/libosmium/include/)

-add_custom_target(FingerPrintConfigure ALL
-  ${CMAKE_COMMAND} -DSOURCE_DIR=${CMAKE_SOURCE_DIR}
-    -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/FingerPrint-Config.cmake
+add_custom_target(FingerPrintConfigure ALL ${CMAKE_COMMAND}
+  "-DOUTPUT_DIR=${CMAKE_CURRENT_BINARY_DIR}"
+  "-DSOURCE_DIR=${CMAKE_CURRENT_SOURCE_DIR}"
+  -P "${CMAKE_CURRENT_SOURCE_DIR}/cmake/FingerPrint-Config.cmake"
  COMMENT "Configuring revision fingerprint"
  VERBATIM)

-add_custom_target(tests DEPENDS datastructure-tests algorithm-tests)
+add_custom_target(tests DEPENDS datastructure-tests algorithm-tests util-tests)
 add_custom_target(benchmarks DEPENDS rtree-bench)

 set(BOOST_COMPONENTS date_time filesystem iostreams program_options regex system thread unit_test_framework)

 configure_file(
-  ${CMAKE_CURRENT_SOURCE_DIR}/util/git_sha.cpp.in
-  ${CMAKE_CURRENT_SOURCE_DIR}/util/git_sha.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/util/version.hpp.in
+  ${CMAKE_CURRENT_BINARY_DIR}/util/version.hpp
 )
-file(GLOB ExtractorGlob extractor/*.cpp)
-file(GLOB ImporterGlob data_structures/import_edge.cpp data_structures/external_memory_node.cpp)
+file(GLOB ExtractorGlob extractor/*.cpp data_structures/hilbert_value.cpp)
+file(GLOB ImporterGlob data_structures/import_edge.cpp data_structures/external_memory_node.cpp data_structures/raster_source.cpp)
 add_library(IMPORT OBJECT ${ImporterGlob})
 add_library(LOGGER OBJECT util/simple_logger.cpp)
 add_library(PHANTOMNODE OBJECT data_structures/phantom_node.cpp)
+add_library(RASTERSOURCE OBJECT data_structures/raster_source.cpp)
 add_library(EXCEPTION OBJECT util/osrm_exception.cpp)
 add_library(MERCATOR OBJECT util/mercator.cpp)
 add_library(ANGLE OBJECT util/compute_angle.cpp)

 set(ExtractorSources extract.cpp ${ExtractorGlob})
-add_executable(osrm-extract ${ExtractorSources} $<TARGET_OBJECTS:COORDINATE> $<TARGET_OBJECTS:FINGERPRINT> $<TARGET_OBJECTS:GITDESCRIPTION> $<TARGET_OBJECTS:IMPORT> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:MERCATOR>)
+add_executable(osrm-extract ${ExtractorSources} $<TARGET_OBJECTS:COORDINATE> $<TARGET_OBJECTS:FINGERPRINT> $<TARGET_OBJECTS:IMPORT> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:MERCATOR> $<TARGET_OBJECTS:COMPRESSEDEDGE> $<TARGET_OBJECTS:GRAPHCOMPRESSOR> $<TARGET_OBJECTS:RESTRICTION> $<TARGET_OBJECTS:ANGLE>)

 add_library(RESTRICTION OBJECT data_structures/restriction_map.cpp)
+add_library(COMPRESSEDEDGE OBJECT data_structures/compressed_edge_container.cpp)
+add_library(GRAPHCOMPRESSOR OBJECT algorithms/graph_compressor.cpp)

 file(GLOB PrepareGlob contractor/*.cpp data_structures/hilbert_value.cpp {RestrictionMapGlob})
 set(PrepareSources prepare.cpp ${PrepareGlob})
-add_executable(osrm-prepare ${PrepareSources} $<TARGET_OBJECTS:ANGLE> $<TARGET_OBJECTS:FINGERPRINT> $<TARGET_OBJECTS:GITDESCRIPTION> $<TARGET_OBJECTS:COORDINATE> $<TARGET_OBJECTS:IMPORT> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:RESTRICTION> $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:MERCATOR>)
+add_executable(osrm-prepare ${PrepareSources} $<TARGET_OBJECTS:ANGLE> $<TARGET_OBJECTS:FINGERPRINT> $<TARGET_OBJECTS:COORDINATE> $<TARGET_OBJECTS:IMPORT> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:RESTRICTION> $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:MERCATOR> $<TARGET_OBJECTS:COMPRESSEDEDGE> $<TARGET_OBJECTS:GRAPHCOMPRESSOR>)

 file(GLOB ServerGlob server/*.cpp)
 file(GLOB DescriptorGlob descriptors/*.cpp)
 file(GLOB DatastructureGlob data_structures/search_engine_data.cpp data_structures/route_parameters.cpp util/bearing.cpp)
-list(REMOVE_ITEM DatastructureGlob data_structures/Coordinate.cpp)
-file(GLOB CoordinateGlob data_structures/coordinate*.cpp)
-file(GLOB AlgorithmGlob algorithms/*.cpp)
+file(GLOB CoordinateGlob data_structures/coordinate.cpp algorithms/coordinate_calculation.cpp)
+file(GLOB AlgorithmGlob algorithms/polyline_compressor.cpp algorithms/polyline_formatter.cpp algorithms/douglas_peucker.cpp)
 file(GLOB HttpGlob server/http/*.cpp)
 file(GLOB LibOSRMGlob library/*.cpp)
 file(GLOB DataStructureTestsGlob unit_tests/data_structures/*.cpp data_structures/hilbert_value.cpp)
-file(GLOB AlgorithmTestsGlob unit_tests/algorithms/*.cpp)
+file(GLOB AlgorithmTestsGlob unit_tests/algorithms/*.cpp algorithms/graph_compressor.cpp)
+file(GLOB UtilTestsGlob unit_tests/util/*.cpp)

 set(
  OSRMSources
@@ -89,8 +97,7 @@ set(
 )

 add_library(COORDINATE OBJECT ${CoordinateGlob})
-add_library(GITDESCRIPTION OBJECT util/git_sha.cpp)
-add_library(OSRM ${OSRMSources} $<TARGET_OBJECTS:ANGLE> $<TARGET_OBJECTS:COORDINATE> $<TARGET_OBJECTS:GITDESCRIPTION> $<TARGET_OBJECTS:FINGERPRINT> $<TARGET_OBJECTS:COORDINATE> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:PHANTOMNODE> $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:MERCATOR> $<TARGET_OBJECTS:IMPORT>)
+add_library(OSRM ${OSRMSources} $<TARGET_OBJECTS:ANGLE> $<TARGET_OBJECTS:COORDINATE> $<TARGET_OBJECTS:FINGERPRINT> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:RESTRICTION> $<TARGET_OBJECTS:PHANTOMNODE> $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:MERCATOR> $<TARGET_OBJECTS:IMPORT>)

 add_library(FINGERPRINT OBJECT util/fingerprint.cpp)
 add_dependencies(FINGERPRINT FingerPrintConfigure)
@@ -98,11 +105,12 @@ add_dependencies(OSRM FingerPrintConfigure)
 set_target_properties(FINGERPRINT PROPERTIES LINKER_LANGUAGE CXX)

 add_executable(osrm-routed routed.cpp ${ServerGlob} $<TARGET_OBJECTS:EXCEPTION>)
-add_executable(osrm-datastore datastore.cpp $<TARGET_OBJECTS:COORDINATE> $<TARGET_OBJECTS:FINGERPRINT> $<TARGET_OBJECTS:GITDESCRIPTION> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:MERCATOR>)
+add_executable(osrm-datastore datastore.cpp $<TARGET_OBJECTS:COORDINATE> $<TARGET_OBJECTS:FINGERPRINT> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:MERCATOR>)

 # Unit tests
-add_executable(datastructure-tests EXCLUDE_FROM_ALL unit_tests/datastructure_tests.cpp ${DataStructureTestsGlob} $<TARGET_OBJECTS:COORDINATE> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:PHANTOMNODE> $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:MERCATOR>)
-add_executable(algorithm-tests EXCLUDE_FROM_ALL unit_tests/algorithm_tests.cpp ${AlgorithmTestsGlob} $<TARGET_OBJECTS:COORDINATE> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:PHANTOMNODE> $<TARGET_OBJECTS:EXCEPTION>)
+add_executable(datastructure-tests EXCLUDE_FROM_ALL unit_tests/datastructure_tests.cpp ${DataStructureTestsGlob} $<TARGET_OBJECTS:COORDINATE> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:PHANTOMNODE> $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:MERCATOR> $<TARGET_OBJECTS:COMPRESSEDEDGE> $<TARGET_OBJECTS:GRAPHCOMPRESSOR> $<TARGET_OBJECTS:RESTRICTION> $<TARGET_OBJECTS:RASTERSOURCE>)
+add_executable(algorithm-tests EXCLUDE_FROM_ALL unit_tests/algorithm_tests.cpp ${AlgorithmTestsGlob} $<TARGET_OBJECTS:COORDINATE> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:PHANTOMNODE> $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:RESTRICTION> $<TARGET_OBJECTS:COMPRESSEDEDGE>)
+add_executable(util-tests EXCLUDE_FROM_ALL unit_tests/util_tests.cpp ${UtilTestsGlob})

 # Benchmarks
 add_executable(rtree-bench EXCLUDE_FROM_ALL benchmarks/static_rtree.cpp $<TARGET_OBJECTS:COORDINATE> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:PHANTOMNODE> $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:MERCATOR>)
@@ -114,18 +122,29 @@ endif()
 if(CMAKE_BUILD_TYPE MATCHES Debug)
  message(STATUS "Configuring OSRM in debug mode")
  if(NOT ${CMAKE_CXX_COMPILER_ID} STREQUAL "MSVC")
-    message(STATUS "adding profiling flags")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fprofile-arcs -ftest-coverage -fno-inline")
-    set(CMAKE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fprofile-arcs -ftest-coverage -fno-inline")
+
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-inline -fno-omit-frame-pointer")
+
+  if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Og -ggdb")
+  endif()
+
  endif()
 endif()
 if(CMAKE_BUILD_TYPE MATCHES Release)
  message(STATUS "Configuring OSRM in release mode")
  # Check if LTO is available
-  set(LTO_FLAGS "")
  check_cxx_compiler_flag("-flto" LTO_AVAILABLE)
  if(LTO_AVAILABLE)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -flto")
+    set(OLD_CXX_FLAGS ${CMAKE_CXX_FLAGS})
+    # GCC in addition allows parallelizing LTO
+    if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+      include(ProcessorCount)
+      ProcessorCount(NPROC)
+      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -flto=${NPROC}")
+    else()
+      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -flto")
+    endif()
    set(CHECK_LTO_SRC "int main(){return 0;}")
    check_cxx_source_compiles("${CHECK_LTO_SRC}" LTO_WORKS)
    if(LTO_WORKS)
@@ -142,6 +161,11 @@ if(CMAKE_BUILD_TYPE MATCHES Release)
      set(CMAKE_AR     "/usr/bin/gcc-ar")
      set(CMAKE_RANLIB "/usr/bin/gcc-ranlib")
    endif()
+
+    if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU" AND "${CMAKE_CXX_COMPILER_VERSION}" VERSION_LESS "4.9.0")
+      message(STATUS "Disabling LTO on GCC < 4.9.0 since it is broken, see: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=57038")
+      set(CMAKE_CXX_FLAGS "${OLD_CXX_FLAGS}")
+    endif()
  endif()
 endif()

@@ -151,9 +175,7 @@ endif()

 # Configuring compilers
 if(${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang")
-  # using Clang
-  #  -Weverything -Wno-c++98-compat -Wno-shadow -Wno-exit-time-destructors
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wunreachable-code -pedantic -fPIC")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -pedantic -Wuninitialized -Wunreachable-code -Wstrict-overflow=2 -D_FORTIFY_SOURCE=2 -fPIC")
 elseif(${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU")
  set(COLOR_FLAG "-fdiagnostics-color=auto")
  check_cxx_compiler_flag("-fdiagnostics-color=auto" HAS_COLOR_FLAG)
@@ -161,7 +183,7 @@ elseif(${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU")
    set(COLOR_FLAG "")
  endif()
  # using GCC
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -pedantic -fPIC ${COLOR_FLAG}")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -pedantic -Wuninitialized -Wunreachable-code -Wstrict-overflow=1 -D_FORTIFY_SOURCE=2 ${COLOR_FLAG} -fPIC")
  if(WIN32) # using mingw
    add_definitions(-D_USE_MATH_DEFINES) # define M_PI, M_1_PI etc.
    add_definitions(-DWIN32)
@@ -182,6 +204,26 @@ elseif(${CMAKE_CXX_COMPILER_ID} STREQUAL "MSVC")
  target_link_libraries(osrm-extract wsock32 ws2_32)
 endif()

+# Configuring linker
+execute_process(COMMAND ${CMAKE_CXX_COMPILER} "-Wl,--version" ERROR_QUIET OUTPUT_VARIABLE LINKER_VERSION)
+# For ld.gold and ld.bfs (the GNU linkers) we optimize hard
+if("${LINKER_VERSION}" MATCHES "GNU gold" OR "${LINKER_VERSION}" MATCHES "GNU ld")
+  message(STATUS "Setting linker optimizations")
+  if(NOT ${CMAKE_CXX_COMPILER_ID} STREQUAL "MSVC")
+    # Tell compiler to put every function in separate section, linker can then match sections and functions
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ffunction-sections -fdata-sections")
+    # Tell linker to do dead code and data eminination during link time discarding sections
+    set(LINKER_FLAGS "${LINKER_FLAGS} -Wl,--gc-sections")
+  endif()
+  # Default linker optimization flags
+  set(LINKER_FLAGS "${LINKER_FLAGS} -Wl,-O1 -Wl,--hash-style=gnu -Wl,--sort-common")
+else()
+  message(STATUS "Using unknown linker, not setting linker optimizations")
+endif ()
+set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${LINKER_FLAGS}")
+set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${LINKER_FLAGS}")
+set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${LINKER_FLAGS}")
+
 # Activate C++11
 if(NOT ${CMAKE_CXX_COMPILER_ID} STREQUAL "MSVC")
  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 ")
@@ -209,12 +251,11 @@ if(UNIX AND NOT APPLE)
 endif()

 #Check Boost
-set(BOOST_MIN_VERSION "1.49.0")
-find_package(Boost ${BOOST_MIN_VERSION} COMPONENTS ${BOOST_COMPONENTS} REQUIRED)
+find_package(Boost 1.49.0 COMPONENTS ${BOOST_COMPONENTS} REQUIRED)
 if(NOT Boost_FOUND)
  message(FATAL_ERROR "Fatal error: Boost (version >= 1.49.0) required.\n")
 endif()
-include_directories(${Boost_INCLUDE_DIRS})
+include_directories(SYSTEM ${Boost_INCLUDE_DIRS})

 target_link_libraries(OSRM ${Boost_LIBRARIES})
 target_link_libraries(osrm-extract ${Boost_LIBRARIES})
@@ -223,6 +264,7 @@ target_link_libraries(osrm-routed ${Boost_LIBRARIES} ${OPTIONAL_SOCKET_LIBS} OSR
 target_link_libraries(osrm-datastore ${Boost_LIBRARIES})
 target_link_libraries(datastructure-tests ${Boost_LIBRARIES})
 target_link_libraries(algorithm-tests ${Boost_LIBRARIES} ${OPTIONAL_SOCKET_LIBS} OSRM)
+target_link_libraries(util-tests ${Boost_LIBRARIES})
 target_link_libraries(rtree-bench ${Boost_LIBRARIES})

 find_package(Threads REQUIRED)
@@ -245,12 +287,12 @@ target_link_libraries(osrm-routed ${TBB_LIBRARIES})
 target_link_libraries(datastructure-tests ${TBB_LIBRARIES})
 target_link_libraries(algorithm-tests ${TBB_LIBRARIES})
 target_link_libraries(rtree-bench ${TBB_LIBRARIES})
-include_directories(${TBB_INCLUDE_DIR})
+include_directories(SYSTEM ${TBB_INCLUDE_DIR})

 find_package( Luabind REQUIRED )
 include(check_luabind)

-include_directories(${LUABIND_INCLUDE_DIR})
+include_directories(SYSTEM ${LUABIND_INCLUDE_DIR})
 target_link_libraries(osrm-extract ${LUABIND_LIBRARY})
 target_link_libraries(osrm-prepare ${LUABIND_LIBRARY})

@@ -261,17 +303,18 @@ else()
  target_link_libraries(osrm-extract ${LUA_LIBRARY})
  target_link_libraries(osrm-prepare ${LUA_LIBRARY})
 endif()
-include_directories(${LUA_INCLUDE_DIR})
+include_directories(SYSTEM ${LUA_INCLUDE_DIR})

 find_package(EXPAT REQUIRED)
-include_directories(${EXPAT_INCLUDE_DIRS})
+include_directories(SYSTEM ${EXPAT_INCLUDE_DIRS})
 target_link_libraries(osrm-extract ${EXPAT_LIBRARIES})

 find_package(STXXL REQUIRED)
-include_directories(${STXXL_INCLUDE_DIR})
+include_directories(SYSTEM ${STXXL_INCLUDE_DIR})
 target_link_libraries(OSRM ${STXXL_LIBRARY})
 target_link_libraries(osrm-extract ${STXXL_LIBRARY})
 target_link_libraries(osrm-prepare ${STXXL_LIBRARY})
+target_link_libraries(datastructure-tests ${STXXL_LIBRARY})

 set(OpenMP_FIND_QUIETLY ON)
 find_package(OpenMP)
@@ -280,22 +323,12 @@ if(OPENMP_FOUND)
  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
 endif()

-find_package(OSMPBF REQUIRED)
-include_directories(${OSMPBF_INCLUDE_DIR})
-target_link_libraries(osrm-extract ${OSMPBF_LIBRARY})
-target_link_libraries(osrm-prepare ${OSMPBF_LIBRARY})
-
-find_package(Protobuf REQUIRED)
-include_directories(${PROTOBUF_INCLUDE_DIRS})
-target_link_libraries(osrm-extract ${PROTOBUF_LIBRARY})
-target_link_libraries(osrm-prepare ${PROTOBUF_LIBRARY})
-
 find_package(BZip2 REQUIRED)
-include_directories(${BZIP_INCLUDE_DIRS})
+include_directories(SYSTEM ${BZIP_INCLUDE_DIRS})
 target_link_libraries(osrm-extract ${BZIP2_LIBRARIES})

 find_package(ZLIB REQUIRED)
-include_directories(${ZLIB_INCLUDE_DIRS})
+include_directories(SYSTEM ${ZLIB_INCLUDE_DIRS})
 target_link_libraries(osrm-extract ${ZLIB_LIBRARY})
 target_link_libraries(osrm-routed ${ZLIB_LIBRARY})

@@ -304,16 +337,19 @@ if (ENABLE_JSON_LOGGING)
  add_definitions(-DENABLE_JSON_LOGGING)
 endif()

-if(WITH_TOOLS OR BUILD_TOOLS)
+if (DEBUG_GEOMETRY)
+  message(STATUS "Enabling final edge weight GeoJSON output option")
+  add_definitions(-DDEBUG_GEOMETRY)
+endif()
+
+if(BUILD_TOOLS)
  message(STATUS "Activating OSRM internal tools")
  find_package(GDAL)
  if(GDAL_FOUND)
    add_executable(osrm-components tools/components.cpp $<TARGET_OBJECTS:FINGERPRINT> $<TARGET_OBJECTS:IMPORT> $<TARGET_OBJECTS:COORDINATE> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:RESTRICTION> $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:MERCATOR>)
    target_link_libraries(osrm-components ${TBB_LIBRARIES})
-    include_directories(${GDAL_INCLUDE_DIR})
-    target_link_libraries(
-      osrm-components
-      ${GDAL_LIBRARIES} ${Boost_LIBRARIES})
+    include_directories(SYSTEM ${GDAL_INCLUDE_DIR})
+    target_link_libraries(osrm-components ${GDAL_LIBRARIES} ${Boost_LIBRARIES})
    install(TARGETS osrm-components DESTINATION bin)
  else()
    message(FATAL_ERROR "libgdal and/or development headers not found")
@@ -321,16 +357,16 @@ if(WITH_TOOLS OR BUILD_TOOLS)
  add_executable(osrm-cli tools/simpleclient.cpp $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:COORDINATE>)
  target_link_libraries(osrm-cli ${Boost_LIBRARIES} ${OPTIONAL_SOCKET_LIBS} OSRM)
  target_link_libraries(osrm-cli ${TBB_LIBRARIES})
-  add_executable(osrm-io-benchmark tools/io-benchmark.cpp $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:GITDESCRIPTION> $<TARGET_OBJECTS:LOGGER>)
+  add_executable(osrm-io-benchmark tools/io-benchmark.cpp $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:LOGGER>)
  target_link_libraries(osrm-io-benchmark ${Boost_LIBRARIES})
-  add_executable(osrm-unlock-all tools/unlock_all_mutexes.cpp $<TARGET_OBJECTS:GITDESCRIPTION> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:EXCEPTION>)
+  add_executable(osrm-unlock-all tools/unlock_all_mutexes.cpp $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:EXCEPTION>)
  target_link_libraries(osrm-unlock-all ${Boost_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT})
  if(UNIX AND NOT APPLE)
    target_link_libraries(osrm-unlock-all rt)
  endif()
  add_executable(osrm-check-hsgr tools/check-hsgr.cpp $<TARGET_OBJECTS:FINGERPRINT> $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:IMPORT>)
  target_link_libraries(osrm-check-hsgr ${Boost_LIBRARIES} ${TBB_LIBRARIES})
-  add_executable(osrm-springclean tools/springclean.cpp $<TARGET_OBJECTS:FINGERPRINT> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:GITDESCRIPTION> $<TARGET_OBJECTS:EXCEPTION>)
+  add_executable(osrm-springclean tools/springclean.cpp $<TARGET_OBJECTS:FINGERPRINT> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:EXCEPTION>)
  target_link_libraries(osrm-springclean ${Boost_LIBRARIES})

  install(TARGETS osrm-cli DESTINATION bin)
@@ -340,7 +376,7 @@ if(WITH_TOOLS OR BUILD_TOOLS)
  install(TARGETS osrm-springclean DESTINATION bin)
 endif()

-file(GLOB InstallGlob include/osrm/*.hpp library/osrm.hpp)
+file(GLOB InstallGlob include/osrm/*.hpp)
 file(GLOB VariantGlob third_party/variant/*.hpp)

 # Add RPATH info to executables so that when they are run after being installed
@@ -358,6 +394,7 @@ install(TARGETS osrm-prepare DESTINATION bin)
 install(TARGETS osrm-datastore DESTINATION bin)
 install(TARGETS osrm-routed DESTINATION bin)
 install(TARGETS OSRM DESTINATION lib)
+
 list(GET Boost_LIBRARIES 1 BOOST_LIBRARY_FIRST)
 get_filename_component(BOOST_LIBRARY_LISTING "${BOOST_LIBRARY_FIRST}" PATH)
 set(BOOST_LIBRARY_LISTING "-L${BOOST_LIBRARY_LISTING}")
@@ -366,6 +403,14 @@ foreach(lib ${Boost_LIBRARIES})
  string(REPLACE "lib" "" BOOST_LIBRARY_NAME ${BOOST_LIBRARY_NAME})
  set(BOOST_LIBRARY_LISTING "${BOOST_LIBRARY_LISTING} -l${BOOST_LIBRARY_NAME}")
 endforeach()
+list(GET TBB_LIBRARIES 1 TBB_LIBRARY_FIRST)
+get_filename_component(TBB_LIBRARY_LISTING "${TBB_LIBRARY_FIRST}" PATH)
+set(TBB_LIBRARY_LISTING "-L${TBB_LIBRARY_LISTING}")
+foreach(lib ${TBB_LIBRARIES})
+  get_filename_component(TBB_LIBRARY_NAME "${lib}" NAME_WE)
+  string(REPLACE "lib" "" TBB_LIBRARY_NAME ${TBB_LIBRARY_NAME})
+  set(TBB_LIBRARY_LISTING "${TBB_LIBRARY_LISTING} -l${TBB_LIBRARY_NAME}")
+endforeach()

 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/pkgconfig.in libosrm.pc @ONLY)
 install(FILES ${PROJECT_BINARY_DIR}/libosrm.pc DESTINATION lib/pkgconfig)
@@ -374,3 +419,24 @@ if(BUILD_DEBIAN_PACKAGE)
  include(CPackDebianConfig)
  include(CPack)
 endif()
+
+# add a target to generate API documentation with Doxygen
+find_package(Doxygen)
+if(DOXYGEN_FOUND)
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile.in ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile @ONLY)
+add_custom_target(doc
+${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
+WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+COMMENT "Generating API documentation with Doxygen" VERBATIM
+)
+endif()
+
+# prefix compilation with ccache by default if available and on clang or gcc
+if(${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang" OR ${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU")
+  find_program(CCACHE_FOUND ccache)
+  if(CCACHE_FOUND)
+    set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ccache)
+    set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK ccache)
+    set(ENV{CCACHE_CPP2} "true")
+  endif()
+endif()
@@ -0,0 +1,43 @@
+PROJECT_NAME           = "Project OSRM"
+PROJECT_BRIEF          = "Open Source Routing Machine"
+BUILTIN_STL_SUPPORT    = YES
+
+EXTRACT_ALL            = YES
+EXTRACT_PRIVATE        = YES
+EXTRACT_PACKAGE        = YES
+EXTRACT_STATIC         = YES
+EXTRACT_LOCAL_CLASSES  = YES
+EXTRACT_ANON_NSPACES   = YES
+
+QUIET                  = YES
+
+INPUT                  = @CMAKE_CURRENT_SOURCE_DIR@
+USE_MDFILE_AS_MAINPAGE = @CMAKE_CURRENT_SOURCE_DIR@/README.md
+FILE_PATTERNS          = *.h *.hpp *.c *.cc *.cpp *.md
+RECURSIVE              = YES
+
+EXCLUDE                = @CMAKE_CURRENT_SOURCE_DIR@/third_party \
+                         @CMAKE_CURRENT_SOURCE_DIR@/build \
+                         @CMAKE_CURRENT_SOURCE_DIR@/unit_tests \
+			 @CMAKE_CURRENT_SOURCE_DIR@/benchmarks \
+                         @CMAKE_CURRENT_SOURCE_DIR@/features
+
+SOURCE_BROWSER         = YES
+
+CLANG_ASSISTED_PARSING = NO
+
+HTML_COLORSTYLE_HUE    = 217
+HTML_COLORSTYLE_SAT    = 71
+HTML_COLORSTYLE_GAMMA  = 50
+
+GENERATE_TREEVIEW      = YES
+
+HAVE_DOT               = @DOXYGEN_DOT_FOUND@
+CALL_GRAPH             = YES
+CALLER_GRAPH           = YES
+
+DOT_IMAGE_FORMAT       = svg
+INTERACTIVE_SVG        = YES
+DOT_GRAPH_MAX_NODES    = 500
+DOT_TRANSPARENT        = YES
+DOT_MULTI_TARGETS      = YES
@@ -31,6 +31,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <cmath>

 #include <vector>
+#include <utility>

 struct NormalDistribution
 {
@@ -80,11 +81,11 @@ class BayesClassifier
    };
    using ClassificationT = std::pair<ClassLabel, double>;

-    BayesClassifier(const PositiveDistributionT &positive_distribution,
-                    const NegativeDistributionT &negative_distribution,
+    BayesClassifier(PositiveDistributionT positive_distribution,
+                    NegativeDistributionT negative_distribution,
                    const double positive_apriori_probability)
-        : positive_distribution(positive_distribution),
-          negative_distribution(negative_distribution),
+        : positive_distribution(std::move(positive_distribution)),
+          negative_distribution(std::move(negative_distribution)),
          positive_apriori_probability(positive_apriori_probability),
          negative_apriori_probability(1. - positive_apriori_probability)
    {
@@ -46,7 +46,10 @@ constexpr static const float RAD = 0.017453292519943295769236907684886f;
 constexpr static const float earth_radius = 6372797.560856f;
 }

-double coordinate_calculation::great_circle_distance(const int lat1,
+namespace coordinate_calculation
+{
+
+double haversine_distance(const int lat1,
                                                     const int lon1,
                                                     const int lat2,
                                                     const int lon2)
@@ -74,21 +77,21 @@ double coordinate_calculation::great_circle_distance(const int lat1,
    return earth_radius * cHarv;
 }

-double coordinate_calculation::great_circle_distance(const FixedPointCoordinate &coordinate_1,
+double haversine_distance(const FixedPointCoordinate &coordinate_1,
                                                     const FixedPointCoordinate &coordinate_2)
 {
-    return great_circle_distance(coordinate_1.lat, coordinate_1.lon, coordinate_2.lat,
+    return haversine_distance(coordinate_1.lat, coordinate_1.lon, coordinate_2.lat,
                                 coordinate_2.lon);
 }

-float coordinate_calculation::euclidean_distance(const FixedPointCoordinate &coordinate_1,
+float great_circle_distance(const FixedPointCoordinate &coordinate_1,
                                                 const FixedPointCoordinate &coordinate_2)
 {
-    return euclidean_distance(coordinate_1.lat, coordinate_1.lon, coordinate_2.lat,
+    return great_circle_distance(coordinate_1.lat, coordinate_1.lon, coordinate_2.lat,
                              coordinate_2.lon);
 }

-float coordinate_calculation::euclidean_distance(const int lat1,
+float great_circle_distance(const int lat1,
                                                 const int lon1,
                                                 const int lat2,
                                                 const int lon2)
@@ -108,7 +111,7 @@ float coordinate_calculation::euclidean_distance(const int lat1,
    return std::hypot(x_value, y_value) * earth_radius;
 }

-float coordinate_calculation::perpendicular_distance(const FixedPointCoordinate &source_coordinate,
+float perpendicular_distance(const FixedPointCoordinate &source_coordinate,
                                                     const FixedPointCoordinate &target_coordinate,
                                                     const FixedPointCoordinate &query_location)
 {
@@ -119,7 +122,7 @@ float coordinate_calculation::perpendicular_distance(const FixedPointCoordinate
                                  nearest_location, ratio);
 }

-float coordinate_calculation::perpendicular_distance(const FixedPointCoordinate &segment_source,
+float perpendicular_distance(const FixedPointCoordinate &segment_source,
                                                     const FixedPointCoordinate &segment_target,
                                                     const FixedPointCoordinate &query_location,
                                                     FixedPointCoordinate &nearest_location,
@@ -132,7 +135,7 @@ float coordinate_calculation::perpendicular_distance(const FixedPointCoordinate
        nearest_location, ratio);
 }

-float coordinate_calculation::perpendicular_distance_from_projected_coordinate(
+float perpendicular_distance_from_projected_coordinate(
    const FixedPointCoordinate &source_coordinate,
    const FixedPointCoordinate &target_coordinate,
    const FixedPointCoordinate &query_location,
@@ -146,7 +149,7 @@ float coordinate_calculation::perpendicular_distance_from_projected_coordinate(
                                                            nearest_location, ratio);
 }

-float coordinate_calculation::perpendicular_distance_from_projected_coordinate(
+float perpendicular_distance_from_projected_coordinate(
    const FixedPointCoordinate &segment_source,
    const FixedPointCoordinate &segment_target,
    const FixedPointCoordinate &query_location,
@@ -221,29 +224,29 @@ float coordinate_calculation::perpendicular_distance_from_projected_coordinate(
    BOOST_ASSERT(nearest_location.is_valid());

    const float approximate_distance =
-        coordinate_calculation::euclidean_distance(query_location, nearest_location);
+        great_circle_distance(query_location, nearest_location);
    BOOST_ASSERT(0.f <= approximate_distance);
    return approximate_distance;
 }

-void coordinate_calculation::lat_or_lon_to_string(const int value, std::string &output)
+void lat_or_lon_to_string(const int value, std::string &output)
 {
    char buffer[12];
    buffer[11] = 0; // zero termination
    output = printInt<11, 6>(buffer, value);
 }

-float coordinate_calculation::deg_to_rad(const float degree)
+float deg_to_rad(const float degree)
 {
    return degree * (static_cast<float>(M_PI) / 180.f);
 }

-float coordinate_calculation::rad_to_deg(const float radian)
+float rad_to_deg(const float radian)
 {
    return radian * (180.f * static_cast<float>(M_1_PI));
 }

-float coordinate_calculation::bearing(const FixedPointCoordinate &first_coordinate,
+float bearing(const FixedPointCoordinate &first_coordinate,
                                      const FixedPointCoordinate &second_coordinate)
 {
    const float lon_diff =
@@ -266,3 +269,5 @@ float coordinate_calculation::bearing(const FixedPointCoordinate &first_coordina
    }
    return result;
 }
+
+}
@@ -33,38 +33,38 @@ struct FixedPointCoordinate;
 #include <string>
 #include <utility>

-struct coordinate_calculation
+namespace coordinate_calculation
 {
-    static double
-    great_circle_distance(const int lat1, const int lon1, const int lat2, const int lon2);
+    double
+    haversine_distance(const int lat1, const int lon1, const int lat2, const int lon2);

-    static double great_circle_distance(const FixedPointCoordinate &first_coordinate,
-                                        const FixedPointCoordinate &second_coordinate);
+    double haversine_distance(const FixedPointCoordinate &first_coordinate,
+                                 const FixedPointCoordinate &second_coordinate);

-    static float euclidean_distance(const FixedPointCoordinate &first_coordinate,
-                                    const FixedPointCoordinate &second_coordinate);
+    float great_circle_distance(const FixedPointCoordinate &first_coordinate,
+                             const FixedPointCoordinate &second_coordinate);

-    static float euclidean_distance(const int lat1, const int lon1, const int lat2, const int lon2);
+    float great_circle_distance(const int lat1, const int lon1, const int lat2, const int lon2);

-    static void lat_or_lon_to_string(const int value, std::string &output);
+    void lat_or_lon_to_string(const int value, std::string &output);

-    static float perpendicular_distance(const FixedPointCoordinate &segment_source,
-                                        const FixedPointCoordinate &segment_target,
-                                        const FixedPointCoordinate &query_location);
+    float perpendicular_distance(const FixedPointCoordinate &segment_source,
+                                 const FixedPointCoordinate &segment_target,
+                                 const FixedPointCoordinate &query_location);

-    static float perpendicular_distance(const FixedPointCoordinate &segment_source,
-                                        const FixedPointCoordinate &segment_target,
-                                        const FixedPointCoordinate &query_location,
-                                        FixedPointCoordinate &nearest_location,
-                                        float &ratio);
+    float perpendicular_distance(const FixedPointCoordinate &segment_source,
+                                 const FixedPointCoordinate &segment_target,
+                                 const FixedPointCoordinate &query_location,
+                                 FixedPointCoordinate &nearest_location,
+                                 float &ratio);

-    static float perpendicular_distance_from_projected_coordinate(
+    float perpendicular_distance_from_projected_coordinate(
        const FixedPointCoordinate &segment_source,
        const FixedPointCoordinate &segment_target,
        const FixedPointCoordinate &query_location,
        const std::pair<double, double> &projected_coordinate);

-    static float perpendicular_distance_from_projected_coordinate(
+    float perpendicular_distance_from_projected_coordinate(
        const FixedPointCoordinate &segment_source,
        const FixedPointCoordinate &segment_target,
        const FixedPointCoordinate &query_location,
@@ -72,11 +72,11 @@ struct coordinate_calculation
        FixedPointCoordinate &nearest_location,
        float &ratio);

-    static float deg_to_rad(const float degree);
-    static float rad_to_deg(const float radian);
+    float deg_to_rad(const float degree);
+    float rad_to_deg(const float radian);

-    static float bearing(const FixedPointCoordinate &first_coordinate,
-                         const FixedPointCoordinate &second_coordinate);
-};
+    float bearing(const FixedPointCoordinate &first_coordinate,
+                  const FixedPointCoordinate &second_coordinate);
+}

 #endif // COORDINATE_CALCULATION
@@ -99,8 +99,8 @@ void DouglasPeucker::Run(RandomAccessIt begin, RandomAccessIt end, const unsigne

    {
        BOOST_ASSERT_MSG(zoom_level < DOUGLAS_PEUCKER_THRESHOLDS.size(), "unsupported zoom level");
-        RandomAccessIt left_border = begin;
-        RandomAccessIt right_border = std::next(begin);
+        auto left_border = begin;
+        auto right_border = std::next(begin);
        // Sweep over array and identify those ranges that need to be checked
        do
        {
@@ -0,0 +1,180 @@
+#ifndef GEOSPATIAL_QUERY_HPP
+#define GEOSPATIAL_QUERY_HPP
+
+#include "coordinate_calculation.hpp"
+#include "../typedefs.h"
+#include "../data_structures/phantom_node.hpp"
+#include "../util/bearing.hpp"
+
+#include <osrm/coordinate.hpp>
+
+#include <vector>
+#include <memory>
+#include <algorithm>
+
+// Implements complex queries on top of an RTree and builds PhantomNodes from it.
+//
+// Only holds a weak reference on the RTree!
+template <typename RTreeT> class GeospatialQuery
+{
+    using EdgeData = typename RTreeT::EdgeData;
+    using CoordinateList = typename RTreeT::CoordinateList;
+
+  public:
+    GeospatialQuery(RTreeT &rtree_, std::shared_ptr<CoordinateList> coordinates_)
+        : rtree(rtree_), coordinates(coordinates_)
+    {
+    }
+
+    // Returns nearest PhantomNodes in the given bearing range within max_distance.
+    // Does not filter by small/big component!
+    std::vector<PhantomNodeWithDistance>
+    NearestPhantomNodesInRange(const FixedPointCoordinate &input_coordinate,
+                               const float max_distance,
+                               const int bearing = 0,
+                               const int bearing_range = 180)
+    {
+        auto results =
+            rtree.Nearest(input_coordinate,
+                          [this, bearing, bearing_range, max_distance](const EdgeData &data)
+                          {
+                              return checkSegmentBearing(data, bearing, bearing_range);
+                          },
+                          [max_distance](const std::size_t, const float min_dist)
+                          {
+                              return min_dist > max_distance;
+                          });
+
+        return MakePhantomNodes(input_coordinate, results);
+    }
+
+    // Returns max_results nearest PhantomNodes in the given bearing range.
+    // Does not filter by small/big component!
+    std::vector<PhantomNodeWithDistance>
+    NearestPhantomNodes(const FixedPointCoordinate &input_coordinate,
+                        const unsigned max_results,
+                        const int bearing = 0,
+                        const int bearing_range = 180)
+    {
+        auto results = rtree.Nearest(input_coordinate,
+                                     [this, bearing, bearing_range](const EdgeData &data)
+                                     {
+                                         return checkSegmentBearing(data, bearing, bearing_range);
+                                     },
+                                     [max_results](const std::size_t num_results, const float)
+                                     {
+                                         return num_results >= max_results;
+                                     });
+
+        return MakePhantomNodes(input_coordinate, results);
+    }
+
+    // Returns the nearest phantom node. If this phantom node is not from a big component
+    // a second phantom node is return that is the nearest coordinate in a big component.
+    std::pair<PhantomNode, PhantomNode>
+    NearestPhantomNodeWithAlternativeFromBigComponent(const FixedPointCoordinate &input_coordinate,
+                                                      const int bearing = 0,
+                                                      const int bearing_range = 180)
+    {
+        bool has_small_component = false;
+        bool has_big_component = false;
+        auto results = rtree.Nearest(
+            input_coordinate,
+            [this, bearing, bearing_range, &has_big_component,
+             &has_small_component](const EdgeData &data)
+            {
+                auto use_segment =
+                    (!has_small_component || (!has_big_component && !data.component.is_tiny));
+                auto use_directions = std::make_pair(use_segment, use_segment);
+
+                if (use_segment)
+                {
+                    use_directions = checkSegmentBearing(data, bearing, bearing_range);
+                    if (use_directions.first || use_directions.second)
+                    {
+                        has_big_component = has_big_component || !data.component.is_tiny;
+                        has_small_component = has_small_component || data.component.is_tiny;
+                    }
+                }
+
+                return use_directions;
+            },
+            [&has_big_component](const std::size_t num_results, const float)
+            {
+                return num_results > 0 && has_big_component;
+            });
+
+        if (results.size() == 0)
+        {
+            return std::make_pair(PhantomNode{}, PhantomNode{});
+        }
+
+        BOOST_ASSERT(results.size() > 0);
+        return std::make_pair(MakePhantomNode(input_coordinate, results.front()).phantom_node,
+                              MakePhantomNode(input_coordinate, results.back()).phantom_node);
+    }
+
+  private:
+    std::vector<PhantomNodeWithDistance>
+    MakePhantomNodes(const FixedPointCoordinate &input_coordinate,
+                     const std::vector<EdgeData> &results) const
+    {
+        std::vector<PhantomNodeWithDistance> distance_and_phantoms(results.size());
+        std::transform(results.begin(), results.end(), distance_and_phantoms.begin(),
+                       [this, &input_coordinate](const EdgeData &data)
+                       {
+                           return MakePhantomNode(input_coordinate, data);
+                       });
+        return distance_and_phantoms;
+    }
+
+    PhantomNodeWithDistance MakePhantomNode(const FixedPointCoordinate &input_coordinate,
+                                                   const EdgeData &data) const
+    {
+        FixedPointCoordinate point_on_segment;
+        float ratio;
+        const auto current_perpendicular_distance = coordinate_calculation::perpendicular_distance(
+            coordinates->at(data.u), coordinates->at(data.v), input_coordinate, point_on_segment,
+            ratio);
+
+        auto transformed =
+            PhantomNodeWithDistance { PhantomNode{data, point_on_segment}, current_perpendicular_distance };
+
+        ratio = std::min(1.f, std::max(0.f, ratio));
+
+        if (SPECIAL_NODEID != transformed.phantom_node.forward_node_id)
+        {
+            transformed.phantom_node.forward_weight *= ratio;
+        }
+        if (SPECIAL_NODEID != transformed.phantom_node.reverse_node_id)
+        {
+            transformed.phantom_node.reverse_weight *= 1.f - ratio;
+        }
+        return transformed;
+    }
+
+    std::pair<bool, bool> checkSegmentBearing(const EdgeData &segment,
+                                              const float filter_bearing,
+                                              const float filter_bearing_range)
+    {
+        const float forward_edge_bearing =
+            coordinate_calculation::bearing(coordinates->at(segment.u), coordinates->at(segment.v));
+
+        const float backward_edge_bearing = (forward_edge_bearing + 180) > 360
+                                                ? (forward_edge_bearing - 180)
+                                                : (forward_edge_bearing + 180);
+
+        const bool forward_bearing_valid =
+            bearing::CheckInBounds(forward_edge_bearing, filter_bearing, filter_bearing_range) &&
+            segment.forward_edge_based_node_id != SPECIAL_NODEID;
+        const bool backward_bearing_valid =
+            bearing::CheckInBounds(backward_edge_bearing, filter_bearing, filter_bearing_range) &&
+            segment.reverse_edge_based_node_id != SPECIAL_NODEID;
+        return std::make_pair(forward_bearing_valid, backward_bearing_valid);
+    }
+
+    RTreeT &rtree;
+    const std::shared_ptr<CoordinateList> coordinates;
+};
+
+#endif
@@ -0,0 +1,188 @@
+#include "graph_compressor.hpp"
+
+#include "../data_structures/compressed_edge_container.hpp"
+#include "../data_structures/dynamic_graph.hpp"
+#include "../data_structures/node_based_graph.hpp"
+#include "../data_structures/restriction_map.hpp"
+#include "../data_structures/percent.hpp"
+
+#include "../util/simple_logger.hpp"
+
+GraphCompressor::GraphCompressor(SpeedProfileProperties speed_profile)
+    : speed_profile(std::move(speed_profile))
+{
+}
+
+
+void GraphCompressor::Compress(const std::unordered_set<NodeID>& barrier_nodes,
+                               const std::unordered_set<NodeID>& traffic_lights,
+                               RestrictionMap& restriction_map,
+                               NodeBasedDynamicGraph& graph,
+                               CompressedEdgeContainer& geometry_compressor)
+{
+    const unsigned original_number_of_nodes = graph.GetNumberOfNodes();
+    const unsigned original_number_of_edges = graph.GetNumberOfEdges();
+
+    Percent progress(original_number_of_nodes);
+
+    for (const NodeID node_v : osrm::irange(0u, original_number_of_nodes))
+    {
+        progress.printStatus(node_v);
+
+        // only contract degree 2 vertices
+        if (2 != graph.GetOutDegree(node_v))
+        {
+            continue;
+        }
+
+        // don't contract barrier node
+        if (barrier_nodes.end() != barrier_nodes.find(node_v))
+        {
+            continue;
+        }
+
+        // check if v is a via node for a turn restriction, i.e. a 'directed' barrier node
+        if (restriction_map.IsViaNode(node_v))
+        {
+            continue;
+        }
+
+        //    reverse_e2   forward_e2
+        // u <---------- v -----------> w
+        //    ----------> <-----------
+        //    forward_e1   reverse_e1
+        //
+        // Will be compressed to:
+        //
+        //    reverse_e1
+        // u <---------- w
+        //    ---------->
+        //    forward_e1
+        //
+        // If the edges are compatible.
+
+        const bool reverse_edge_order = graph.GetEdgeData(graph.BeginEdges(node_v)).reversed;
+        const EdgeID forward_e2 = graph.BeginEdges(node_v) + reverse_edge_order;
+        BOOST_ASSERT(SPECIAL_EDGEID != forward_e2);
+        BOOST_ASSERT(forward_e2 >= graph.BeginEdges(node_v) &&
+                     forward_e2 < graph.EndEdges(node_v));
+        const EdgeID reverse_e2 = graph.BeginEdges(node_v) + 1 - reverse_edge_order;
+        BOOST_ASSERT(SPECIAL_EDGEID != reverse_e2);
+        BOOST_ASSERT(reverse_e2 >= graph.BeginEdges(node_v) &&
+                     reverse_e2 < graph.EndEdges(node_v));
+
+        const EdgeData &fwd_edge_data2 = graph.GetEdgeData(forward_e2);
+        const EdgeData &rev_edge_data2 = graph.GetEdgeData(reverse_e2);
+
+        const NodeID node_w = graph.GetTarget(forward_e2);
+        BOOST_ASSERT(SPECIAL_NODEID != node_w);
+        BOOST_ASSERT(node_v != node_w);
+        const NodeID node_u = graph.GetTarget(reverse_e2);
+        BOOST_ASSERT(SPECIAL_NODEID != node_u);
+        BOOST_ASSERT(node_u != node_v);
+
+        const EdgeID forward_e1 = graph.FindEdge(node_u, node_v);
+        BOOST_ASSERT(SPECIAL_EDGEID != forward_e1);
+        BOOST_ASSERT(node_v == graph.GetTarget(forward_e1));
+        const EdgeID reverse_e1 = graph.FindEdge(node_w, node_v);
+        BOOST_ASSERT(SPECIAL_EDGEID != reverse_e1);
+        BOOST_ASSERT(node_v == graph.GetTarget(reverse_e1));
+
+        const EdgeData &fwd_edge_data1 = graph.GetEdgeData(forward_e1);
+        const EdgeData &rev_edge_data1 = graph.GetEdgeData(reverse_e1);
+
+        if (graph.FindEdgeInEitherDirection(node_u, node_w) != SPECIAL_EDGEID)
+        {
+            continue;
+        }
+
+        // this case can happen if two ways with different names overlap
+        if (fwd_edge_data1.name_id != rev_edge_data1.name_id ||
+            fwd_edge_data2.name_id != rev_edge_data2.name_id)
+        {
+            continue;
+        }
+
+        if (fwd_edge_data1.IsCompatibleTo(fwd_edge_data2) && rev_edge_data1.IsCompatibleTo(rev_edge_data2))
+        {
+            BOOST_ASSERT(graph.GetEdgeData(forward_e1).name_id ==
+                         graph.GetEdgeData(reverse_e1).name_id);
+            BOOST_ASSERT(graph.GetEdgeData(forward_e2).name_id ==
+                         graph.GetEdgeData(reverse_e2).name_id);
+
+            // Get distances before graph is modified
+            const int forward_weight1 = graph.GetEdgeData(forward_e1).distance;
+            const int forward_weight2 = graph.GetEdgeData(forward_e2).distance;
+
+            BOOST_ASSERT(0 != forward_weight1);
+            BOOST_ASSERT(0 != forward_weight2);
+
+            const int reverse_weight1 = graph.GetEdgeData(reverse_e1).distance;
+            const int reverse_weight2 = graph.GetEdgeData(reverse_e2).distance;
+
+            BOOST_ASSERT(0 != reverse_weight1);
+            BOOST_ASSERT(0 != reverse_weight2);
+
+            const bool has_node_penalty = traffic_lights.find(node_v) != traffic_lights.end();
+
+            // add weight of e2's to e1
+            graph.GetEdgeData(forward_e1).distance += fwd_edge_data2.distance;
+            graph.GetEdgeData(reverse_e1).distance += rev_edge_data2.distance;
+            if (has_node_penalty)
+            {
+                graph.GetEdgeData(forward_e1).distance +=
+                    speed_profile.traffic_signal_penalty;
+                graph.GetEdgeData(reverse_e1).distance +=
+                    speed_profile.traffic_signal_penalty;
+            }
+
+            // extend e1's to targets of e2's
+            graph.SetTarget(forward_e1, node_w);
+            graph.SetTarget(reverse_e1, node_u);
+
+            // remove e2's (if bidir, otherwise only one)
+            graph.DeleteEdge(node_v, forward_e2);
+            graph.DeleteEdge(node_v, reverse_e2);
+
+            // update any involved turn restrictions
+            restriction_map.FixupStartingTurnRestriction(node_u, node_v, node_w);
+            restriction_map.FixupArrivingTurnRestriction(node_u, node_v, node_w, graph);
+
+            restriction_map.FixupStartingTurnRestriction(node_w, node_v, node_u);
+            restriction_map.FixupArrivingTurnRestriction(node_w, node_v, node_u, graph);
+
+            // store compressed geometry in container
+            geometry_compressor.CompressEdge(
+                forward_e1, forward_e2, node_v, node_w,
+                forward_weight1 + (has_node_penalty ? speed_profile.traffic_signal_penalty : 0),
+                forward_weight2);
+            geometry_compressor.CompressEdge(
+                reverse_e1, reverse_e2, node_v, node_u, reverse_weight1,
+                reverse_weight2 + (has_node_penalty ? speed_profile.traffic_signal_penalty : 0));
+        }
+    }
+
+    PrintStatistics(original_number_of_nodes, original_number_of_edges, graph);
+}
+
+void GraphCompressor::PrintStatistics(unsigned original_number_of_nodes,
+                                      unsigned original_number_of_edges,
+                                      const NodeBasedDynamicGraph& graph) const
+{
+
+    unsigned new_node_count = 0;
+    unsigned new_edge_count = 0;
+
+    for (const auto i : osrm::irange(0u, graph.GetNumberOfNodes()))
+    {
+        if (graph.GetOutDegree(i) > 0)
+        {
+            ++new_node_count;
+            new_edge_count += (graph.EndEdges(i) - graph.BeginEdges(i));
+        }
+    }
+    SimpleLogger().Write() << "Node compression ratio: "
+                           << new_node_count / (double)original_number_of_nodes;
+    SimpleLogger().Write() << "Edge compression ratio: "
+                           << new_edge_count / (double)original_number_of_edges;
+}
@@ -1,6 +1,6 @@
 /*

-Copyright (c) 2013, Project OSRM contributors
+Copyright (c) 2014, Project OSRM, Dennis Luxen, others
 All rights reserved.

 Redistribution and use in source and binary forms, with or without modification,
@@ -24,15 +24,39 @@ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */
+#ifndef GEOMETRY_COMPRESSOR_HPP
+#define GEOMETRY_COMPRESSOR_HPP

-#ifndef SERVER_PATH_H
-#define SERVER_PATH_H
+#include "../typedefs.h"

-#include <boost/filesystem.hpp>
+#include "../extractor/speed_profile.hpp"
+#include "../data_structures/node_based_graph.hpp"

-#include <unordered_map>
-#include <string>
+#include <memory>
+#include <unordered_set>

-using ServerPaths = std::unordered_map<std::string, boost::filesystem::path>;
+class CompressedEdgeContainer;
+class RestrictionMap;

-#endif // SERVER_PATH_H
+class GraphCompressor
+{
+    using EdgeData = NodeBasedDynamicGraph::EdgeData;
+
+public:
+  GraphCompressor(SpeedProfileProperties speed_profile);
+
+    void Compress(const std::unordered_set<NodeID>& barrier_nodes,
+                  const std::unordered_set<NodeID>& traffic_lights,
+                  RestrictionMap& restriction_map,
+                  NodeBasedDynamicGraph& graph,
+                  CompressedEdgeContainer& geometry_compressor);
+private:
+
+   void PrintStatistics(unsigned original_number_of_nodes,
+                        unsigned original_number_of_edges,
+                        const NodeBasedDynamicGraph& graph) const;
+
+    SpeedProfileProperties speed_profile;
+};
+
+#endif
@@ -28,14 +28,13 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef OBJECT_ENCODER_HPP
 #define OBJECT_ENCODER_HPP

-#include "../util/string_util.hpp"
-
 #include <boost/assert.hpp>
 #include <boost/archive/iterators/base64_from_binary.hpp>
 #include <boost/archive/iterators/binary_from_base64.hpp>
 #include <boost/archive/iterators/transform_width.hpp>

 #include <algorithm>
+#include <iterator>
 #include <string>
 #include <vector>

@@ -66,8 +65,8 @@ struct ObjectEncoder
        encoded.resize(sizeof(ObjectT));
        encoded.assign(base64_t(&data[0]),
                       base64_t(&data[0] + (data.size() - number_of_padded_chars)));
-        replaceAll(encoded, "+", "-");
-        replaceAll(encoded, "/", "_");
+        std::replace(begin(encoded), end(encoded), '+', '-');
+        std::replace(begin(encoded), end(encoded), '/', '_');
    }

    template <class ObjectT> static void DecodeFromBase64(const std::string &input, ObjectT &object)
@@ -75,11 +74,10 @@ struct ObjectEncoder
        try
        {
            std::string encoded(input);
-            // replace "-" with "+" and "_" with "/"
-            replaceAll(encoded, "-", "+");
-            replaceAll(encoded, "_", "/");
+            std::replace(begin(encoded), end(encoded), '-', '+');
+            std::replace(begin(encoded), end(encoded), '_', '/');

-            std::copy(binary_t(encoded.begin()), binary_t(encoded.begin() + encoded.length() - 1),
+            std::copy(binary_t(encoded.begin()), binary_t(encoded.begin() + encoded.length()),
                      reinterpret_cast<char *>(&object));
        }
        catch (...)
@@ -25,17 +25,14 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

-#ifndef TINY_COMPONENTS_HPP
-#define TINY_COMPONENTS_HPP
+#ifndef TARJAN_SCC_HPP
+#define TARJAN_SCC_HPP

 #include "../typedefs.h"
 #include "../data_structures/deallocating_vector.hpp"
 #include "../data_structures/import_edge.hpp"
 #include "../data_structures/query_node.hpp"
 #include "../data_structures/percent.hpp"
-#include "../data_structures/restriction.hpp"
-#include "../data_structures/restriction_map.hpp"
-#include "../data_structures/turn_instructions.hpp"

 #include "../util/integer_range.hpp"
 #include "../util/simple_logger.hpp"
@@ -43,17 +40,13 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "../util/timing_util.hpp"

 #include <osrm/coordinate.hpp>
-
 #include <boost/assert.hpp>
-
-#include <tbb/parallel_sort.h>
-
 #include <cstdint>

 #include <memory>
+#include <algorithm>
+#include <climits>
 #include <stack>
-#include <unordered_map>
-#include <unordered_set>
 #include <vector>

 template <typename GraphT> class TarjanSCC
@@ -75,27 +68,21 @@ template <typename GraphT> class TarjanSCC

    std::vector<unsigned> components_index;
    std::vector<NodeID> component_size_vector;
-    std::shared_ptr<GraphT> m_node_based_graph;
-    std::unordered_set<NodeID> barrier_node_set;
-    RestrictionMap m_restriction_map;
+    std::shared_ptr<const GraphT> m_graph;
    std::size_t size_one_counter;

  public:
-    template <class ContainerT>
-    TarjanSCC(std::shared_ptr<GraphT> graph,
-              const RestrictionMap &restrictions,
-              const ContainerT &barrier_node_list)
-        : components_index(graph->GetNumberOfNodes(), SPECIAL_NODEID), m_node_based_graph(graph),
-          m_restriction_map(restrictions), size_one_counter(0)
+    TarjanSCC(std::shared_ptr<const GraphT> graph)
+        : components_index(graph->GetNumberOfNodes(), SPECIAL_NODEID), m_graph(graph),
+          size_one_counter(0)
    {
-        barrier_node_set.insert(std::begin(barrier_node_list), std::end(barrier_node_list));
-        BOOST_ASSERT(m_node_based_graph->GetNumberOfNodes() > 0);
+        BOOST_ASSERT(m_graph->GetNumberOfNodes() > 0);
    }

    void run()
    {
        TIMER_START(SCC_RUN);
-        const NodeID max_node_id = m_node_based_graph->GetNumberOfNodes();
+        const NodeID max_node_id = m_graph->GetNumberOfNodes();

        // The following is a hack to distinguish between stuff that happens
        // before the recursive call and stuff that happens after
@@ -140,30 +127,9 @@ template <typename GraphT> class TarjanSCC
                    tarjan_node_list[v].on_stack = true;
                    ++index;

-                    const NodeID to_node_of_only_restriction =
-                        m_restriction_map.CheckForEmanatingIsOnlyTurn(u, v);
-
-                    for (const auto current_edge : m_node_based_graph->GetAdjacentEdgeRange(v))
+                    for (const auto current_edge : m_graph->GetAdjacentEdgeRange(v))
                    {
-                        const auto vprime = m_node_based_graph->GetTarget(current_edge);
-
-                        // Traverse outgoing edges
-                        if (barrier_node_set.find(v) != barrier_node_set.end() && u != vprime)
-                        {
-                            continue;
-                        }
-
-                        if (to_node_of_only_restriction != std::numeric_limits<unsigned>::max() &&
-                            vprime == to_node_of_only_restriction)
-                        {
-                            // At an only_-restriction but not at the right turn
-                            // continue;
-                        }
-
-                        if (m_restriction_map.CheckIfTurnIsRestricted(u, v, vprime))
-                        {
-                            // continue;
-                        }
+                        const auto vprime = m_graph->GetTarget(current_edge);

                        if (SPECIAL_NODEID == tarjan_node_list[vprime].index)
                        {
@@ -182,9 +148,8 @@ template <typename GraphT> class TarjanSCC
                else
                {
                    processing_node_before_recursion[v] = true;
-                    tarjan_node_list[currentFrame.parent].low_link =
-                        std::min(tarjan_node_list[currentFrame.parent].low_link,
-                                 tarjan_node_list[v].low_link);
+                    tarjan_node_list[u].low_link =
+                        std::min(tarjan_node_list[u].low_link, tarjan_node_list[v].low_link);
                    // after recursion, lets do cycle checking
                    // Check if we found a cycle. This is the bottom part of the recursion
                    if (tarjan_node_list[v].low_link == tarjan_node_list[v].index)
@@ -228,12 +193,12 @@ template <typename GraphT> class TarjanSCC

    std::size_t get_size_one_count() const { return size_one_counter; }

-    unsigned get_component_size(const NodeID node) const
+    unsigned get_component_size(const unsigned component_id) const
    {
-        return component_size_vector[components_index[node]];
+        return component_size_vector[component_id];
    }

    unsigned get_component_id(const NodeID node) const { return components_index[node]; }
 };

-#endif /* TINY_COMPONENTS_HPP */
+#endif /* TARJAN_SCC_HPP */
@@ -0,0 +1,108 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef TRIP_BRUTE_FORCE_HPP
+#define TRIP_BRUTE_FORCE_HPP
+
+#include "../data_structures/search_engine.hpp"
+#include "../util/dist_table_wrapper.hpp"
+#include "../util/simple_logger.hpp"
+
+#include <osrm/json_container.hpp>
+
+#include <cstdlib>
+#include <algorithm>
+#include <string>
+#include <iterator>
+#include <vector>
+#include <limits>
+
+namespace osrm
+{
+namespace trip
+{
+
+// computes the distance of a given permutation
+EdgeWeight ReturnDistance(const DistTableWrapper<EdgeWeight> &dist_table,
+                          const std::vector<NodeID> &location_order,
+                          const EdgeWeight min_route_dist,
+                          const std::size_t component_size)
+{
+    EdgeWeight route_dist = 0;
+    std::size_t i = 0;
+    while (i < location_order.size() && (route_dist < min_route_dist))
+    {
+        route_dist += dist_table(location_order[i], location_order[(i + 1) % component_size]);
+        BOOST_ASSERT_MSG(dist_table(location_order[i], location_order[(i + 1) % component_size]) !=
+                             INVALID_EDGE_WEIGHT,
+                         "invalid route found");
+        ++i;
+    }
+
+    return route_dist;
+}
+
+// computes the route by computing all permutations and selecting the shortest
+template <typename NodeIDIterator>
+std::vector<NodeID> BruteForceTrip(const NodeIDIterator start,
+                                   const NodeIDIterator end,
+                                   const std::size_t number_of_locations,
+                                   const DistTableWrapper<EdgeWeight> &dist_table)
+{
+    (void)number_of_locations; // unused
+
+    const auto component_size = std::distance(start, end);
+
+    std::vector<NodeID> perm(start, end);
+    std::vector<NodeID> route;
+    route.reserve(component_size);
+
+    EdgeWeight min_route_dist = INVALID_EDGE_WEIGHT;
+
+    // check length of all possible permutation of the component ids
+
+    BOOST_ASSERT_MSG(perm.size() > 0, "no permutation given");
+    BOOST_ASSERT_MSG(*(std::max_element(std::begin(perm), std::end(perm))) < number_of_locations,
+                     "invalid node id");
+    BOOST_ASSERT_MSG(*(std::min_element(std::begin(perm), std::end(perm))) >= 0, "invalid node id");
+
+    do
+    {
+        const auto new_distance = ReturnDistance(dist_table, perm, min_route_dist, component_size);
+        if (new_distance <= min_route_dist)
+        {
+            min_route_dist = new_distance;
+            route = perm;
+        }
+    } while (std::next_permutation(std::begin(perm), std::end(perm)));
+
+    return route;
+}
+
+} // end namespace trip
+} // end namespace osrm
+#endif // TRIP_BRUTE_FORCE_HPP
@@ -0,0 +1,222 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef TRIP_FARTHEST_INSERTION_HPP
+#define TRIP_FARTHEST_INSERTION_HPP
+
+#include "../data_structures/search_engine.hpp"
+#include "../util/dist_table_wrapper.hpp"
+
+#include <osrm/json_container.hpp>
+#include <boost/assert.hpp>
+
+#include <cstdlib>
+#include <algorithm>
+#include <string>
+#include <vector>
+#include <limits>
+
+namespace osrm
+{
+namespace trip
+{
+
+// given a route and a new location, find the best place of insertion and
+// check the distance of roundtrip when the new location is additionally visited
+using NodeIDIter = std::vector<NodeID>::iterator;
+std::pair<EdgeWeight, NodeIDIter>
+GetShortestRoundTrip(const NodeID new_loc,
+                     const DistTableWrapper<EdgeWeight> &dist_table,
+                     const std::size_t number_of_locations,
+                     std::vector<NodeID> &route)
+{
+    (void)number_of_locations; // unused
+
+    auto min_trip_distance = INVALID_EDGE_WEIGHT;
+    NodeIDIter next_insert_point_candidate;
+
+    // for all nodes in the current trip find the best insertion resulting in the shortest path
+    // assert min 2 nodes in route
+    const auto start = std::begin(route);
+    const auto end = std::end(route);
+    for (auto from_node = start; from_node != end; ++from_node)
+    {
+        auto to_node = std::next(from_node);
+        if (to_node == end)
+        {
+            to_node = start;
+        }
+
+        const auto dist_from = dist_table(*from_node, new_loc);
+        const auto dist_to = dist_table(new_loc, *to_node);
+        const auto trip_dist = dist_from + dist_to - dist_table(*from_node, *to_node);
+
+        BOOST_ASSERT_MSG(dist_from != INVALID_EDGE_WEIGHT, "distance has invalid edge weight");
+        BOOST_ASSERT_MSG(dist_to != INVALID_EDGE_WEIGHT, "distance has invalid edge weight");
+        // This is not neccessarily true:
+        // Lets say you have an edge (u, v) with duration 100. If you place a coordinate exactly in
+        // the middle of the segment yielding (u, v'), the adjusted duration will be 100 * 0.5 = 50.
+        // Now imagine two coordinates. One placed at 0.99 and one at 0.999. This means (u, v') now
+        // has a duration of 100 * 0.99 = 99, but (u, v'') also has a duration of 100 * 0.995 = 99.
+        // In which case (v', v'') has a duration of 0.
+        // BOOST_ASSERT_MSG(trip_dist >= 0, "previous trip was not minimal. something's wrong");
+
+        // from all possible insertions to the current trip, choose the shortest of all insertions
+        if (trip_dist < min_trip_distance)
+        {
+            min_trip_distance = trip_dist;
+            next_insert_point_candidate = to_node;
+        }
+    }
+    BOOST_ASSERT_MSG(min_trip_distance != INVALID_EDGE_WEIGHT, "trip has invalid edge weight");
+
+    return std::make_pair(min_trip_distance, next_insert_point_candidate);
+}
+
+template <typename NodeIDIterator>
+// given two initial start nodes, find a roundtrip route using the farthest insertion algorithm
+std::vector<NodeID> FindRoute(const std::size_t &number_of_locations,
+                              const std::size_t &component_size,
+                              const NodeIDIterator &start,
+                              const NodeIDIterator &end,
+                              const DistTableWrapper<EdgeWeight> &dist_table,
+                              const NodeID &start1,
+                              const NodeID &start2)
+{
+    BOOST_ASSERT_MSG(number_of_locations >= component_size,
+                     "component size bigger than total number of locations");
+
+    std::vector<NodeID> route;
+    route.reserve(number_of_locations);
+
+    // tracks which nodes have been already visited
+    std::vector<bool> visited(number_of_locations, false);
+
+    visited[start1] = true;
+    visited[start2] = true;
+    route.push_back(start1);
+    route.push_back(start2);
+
+    // add all other nodes missing (two nodes are already in the initial start trip)
+    for (std::size_t j = 2; j < component_size; ++j)
+    {
+
+        auto farthest_distance = std::numeric_limits<int>::min();
+        auto next_node = -1;
+        NodeIDIter next_insert_point;
+
+        // find unvisited loc i that is the farthest away from all other visited locs
+        for (auto i = start; i != end; ++i)
+        {
+            // find the shortest distance from i to all visited nodes
+            if (!visited[*i])
+            {
+                const auto insert_candidate =
+                    GetShortestRoundTrip(*i, dist_table, number_of_locations, route);
+
+                BOOST_ASSERT_MSG(insert_candidate.first != INVALID_EDGE_WEIGHT,
+                                 "shortest round trip is invalid");
+
+                // add the location to the current trip such that it results in the shortest total
+                // tour
+                if (insert_candidate.first >= farthest_distance)
+                {
+                    farthest_distance = insert_candidate.first;
+                    next_node = *i;
+                    next_insert_point = insert_candidate.second;
+                }
+            }
+        }
+
+        BOOST_ASSERT_MSG(next_node >= 0, "next node to visit is invalid");
+
+        // mark as visited and insert node
+        visited[next_node] = true;
+        route.insert(next_insert_point, next_node);
+    }
+    return route;
+}
+
+template <typename NodeIDIterator>
+std::vector<NodeID> FarthestInsertionTrip(const NodeIDIterator &start,
+                                          const NodeIDIterator &end,
+                                          const std::size_t number_of_locations,
+                                          const DistTableWrapper<EdgeWeight> &dist_table)
+{
+    //////////////////////////////////////////////////////////////////////////////////////////////////
+    // START FARTHEST INSERTION HERE
+    // 1. start at a random round trip of 2 locations
+    // 2. find the location that is the farthest away from the visited locations and whose insertion
+    // will make the round trip the longest
+    // 3. add the found location to the current round trip such that round trip is the shortest
+    // 4. repeat 2-3 until all locations are visited
+    // 5. DONE!
+    //////////////////////////////////////////////////////////////////////////////////////////////////
+
+    const auto component_size = std::distance(start, end);
+    BOOST_ASSERT(component_size >= 0);
+
+    auto max_from = -1;
+    auto max_to = -1;
+
+    if (static_cast<std::size_t>(component_size) == number_of_locations)
+    {
+        // find the pair of location with the biggest distance and make the pair the initial start
+        // trip
+        const auto index = std::distance(
+            std::begin(dist_table), std::max_element(std::begin(dist_table), std::end(dist_table)));
+        max_from = index / number_of_locations;
+        max_to = index % number_of_locations;
+    }
+    else
+    {
+        auto max_dist = 0;
+        for (auto x = start; x != end; ++x)
+        {
+            for (auto y = start; y != end; ++y)
+            {
+                const auto xy_dist = dist_table(*x, *y);
+                if (xy_dist > max_dist)
+                {
+                    max_dist = xy_dist;
+                    max_from = *x;
+                    max_to = *y;
+                }
+            }
+        }
+    }
+    BOOST_ASSERT(max_from >= 0);
+    BOOST_ASSERT(max_to >= 0);
+    BOOST_ASSERT_MSG(static_cast<std::size_t>(max_from) < number_of_locations, "start node");
+    BOOST_ASSERT_MSG(static_cast<std::size_t>(max_to) < number_of_locations, "start node");
+    return FindRoute(number_of_locations, component_size, start, end, dist_table, max_from, max_to);
+}
+
+} // end namespace trip
+} // end namespace osrm
+
+#endif // TRIP_FARTHEST_INSERTION_HPP
@@ -0,0 +1,122 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef TRIP_NEAREST_NEIGHBOUR_HPP
+#define TRIP_NEAREST_NEIGHBOUR_HPP
+
+#include "../data_structures/search_engine.hpp"
+#include "../util/simple_logger.hpp"
+#include "../util/dist_table_wrapper.hpp"
+
+#include <osrm/json_container.hpp>
+
+#include <cstdlib>
+#include <algorithm>
+#include <string>
+#include <vector>
+#include <limits>
+
+namespace osrm
+{
+namespace trip
+{
+template <typename NodeIDIterator>
+std::vector<NodeID> NearestNeighbourTrip(const NodeIDIterator &start,
+                                         const NodeIDIterator &end,
+                                         const std::size_t number_of_locations,
+                                         const DistTableWrapper<EdgeWeight> &dist_table)
+{
+    //////////////////////////////////////////////////////////////////////////////////////////////////
+    // START GREEDY NEAREST NEIGHBOUR HERE
+    // 1. grab a random location and mark as starting point
+    // 2. find the nearest unvisited neighbour, set it as the current location and mark as visited
+    // 3. repeat 2 until there is no unvisited location
+    // 4. return route back to starting point
+    // 5. compute route
+    // 6. repeat 1-5 with different starting points and choose iteration with shortest trip
+    // 7. DONE!
+    //////////////////////////////////////////////////////////////////////////////////////////////////
+    std::vector<NodeID> route;
+    route.reserve(number_of_locations);
+
+    const auto component_size = std::distance(start, end);
+    auto shortest_trip_distance = INVALID_EDGE_WEIGHT;
+
+    // ALWAYS START AT ANOTHER STARTING POINT
+    for (auto start_node = start; start_node != end; ++start_node)
+    {
+        NodeID curr_node = *start_node;
+
+        std::vector<NodeID> curr_route;
+        curr_route.reserve(component_size);
+        curr_route.push_back(*start_node);
+
+        // visited[i] indicates whether node i was already visited by the salesman
+        std::vector<bool> visited(number_of_locations, false);
+        visited[*start_node] = true;
+
+        // 3. REPEAT FOR EVERY UNVISITED NODE
+        EdgeWeight trip_dist = 0;
+        for (std::size_t via_point = 1; via_point < component_size; ++via_point)
+        {
+            EdgeWeight min_dist = INVALID_EDGE_WEIGHT;
+            NodeID min_id = SPECIAL_NODEID;
+
+            // 2. FIND NEAREST NEIGHBOUR
+            for (auto next = start; next != end; ++next)
+            {
+                const auto curr_dist = dist_table(curr_node, *next);
+                BOOST_ASSERT_MSG(curr_dist != INVALID_EDGE_WEIGHT, "invalid distance found");
+                if (!visited[*next] && curr_dist < min_dist)
+                {
+                    min_dist = curr_dist;
+                    min_id = *next;
+                }
+            }
+
+            BOOST_ASSERT_MSG(min_id != SPECIAL_NODEID, "no next node found");
+
+            visited[min_id] = true;
+            curr_route.push_back(min_id);
+            trip_dist += min_dist;
+            curr_node = min_id;
+        }
+
+        // check round trip with this starting point is shorter than the shortest round trip found
+        // till now
+        if (trip_dist < shortest_trip_distance)
+        {
+            shortest_trip_distance = trip_dist;
+            route = std::move(curr_route);
+        }
+    }
+    return route;
+}
+
+} // end namespace trip
+} // end namespace osrm
+#endif // TRIP_NEAREST_NEIGHBOUR_HPP
@@ -25,41 +25,40 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

-#include "bearing.hpp"
+#ifndef TRIP_BRUTE_FORCE_HPP
+#define TRIP_BRUTE_FORCE_HPP

-std::string bearing::get(const double heading) noexcept
+#include "../data_structures/search_engine.hpp"
+#include "../util/simple_logger.hpp"
+
+#include <osrm/json_container.hpp>
+
+#include <cstdlib>
+#include <algorithm>
+#include <string>
+#include <vector>
+#include <limits>
+
+namespace osrm
+{
+namespace trip
+{
+
+// todo: yet to be implemented
+void TabuSearchTrip(std::vector<unsigned> &location,
+                    const PhantomNodeArray &phantom_node_vector,
+                    const std::vector<EdgeWeight> &dist_table,
+                    InternalRouteResult &min_route,
+                    std::vector<int> &min_loc_permutation)
 {
-    if (heading <= 22.5)
-    {
-        return "N";
-    }
-    if (heading <= 67.5)
-    {
-        return "NE";
-    }
-    if (heading <= 112.5)
-    {
-        return "E";
-    }
-    if (heading <= 157.5)
-    {
-        return "SE";
-    }
-    if (heading <= 202.5)
-    {
-        return "S";
-    }
-    if (heading <= 247.5)
-    {
-        return "SW";
-    }
-    if (heading <= 292.5)
-    {
-        return "W";
-    }
-    if (heading <= 337.5)
-    {
-        return "NW";
-    }
-    return "N";
 }
+
+void TabuSearchTrip(const PhantomNodeArray &phantom_node_vector,
+                    const std::vector<EdgeWeight> &dist_table,
+                    InternalRouteResult &min_route,
+                    std::vector<int> &min_loc_permutation)
+{
+}
+}
+}
+#endif // TRIP_BRUTE_FORCE_HPP
@@ -2,33 +2,49 @@
 SETLOCAL
 SET EL=0

+ECHO ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ %~f0 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+SET PROJECT_DIR=%CD%
+ECHO PROJECT_DIR^: %PROJECT_DIR%
+ECHO NUMBER_OF_PROCESSORS^: %NUMBER_OF_PROCESSORS%
+ECHO cmake^: && cmake --version
+
+ECHO activating VS command prompt ...
+SET PATH=C:\Program Files (x86)\MSBuild\14.0\Bin;%PATH%
+CALL "C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat" amd64
+
 ECHO platform^: %platform%
 :: HARDCODE "x64" as it is uppercase on AppVeyor and download from S3 is case sensitive
 SET DEPSPKG=osrm-deps-win-x64-14.0.7z

 :: local development
-IF "%computername%"=="MB" GOTO SKIPDL
+ECHO LOCAL_DEV^: %LOCAL_DEV%
+IF NOT DEFINED LOCAL_DEV SET LOCAL_DEV=0
+IF DEFINED LOCAL_DEV IF %LOCAL_DEV% EQU 1 IF EXIST %DEPSPKG% ECHO skipping deps download && GOTO SKIPDL

 IF EXIST %DEPSPKG% DEL %DEPSPKG%
 IF %ERRORLEVEL% NEQ 0 GOTO ERROR

 ECHO downloading %DEPSPKG%
-powershell Invoke-WebRequest https://mapbox.s3.amazonaws.com/windows-builds/windows-deps/$env:DEPSPKG -OutFile C:\projects\osrm\$env:DEPSPKG
+powershell Invoke-WebRequest https://mapbox.s3.amazonaws.com/windows-builds/windows-build-deps/$env:DEPSPKG -OutFile $env:PROJECT_DIR\$env:DEPSPKG
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+:SKIPDL
+
+IF EXIST osrm-deps ECHO deleting osrm-deps... && RD /S /Q osrm-deps
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+IF EXIST build ECHO deletings build dir... && RD /S /Q build
 IF %ERRORLEVEL% NEQ 0 GOTO ERROR

 7z -y x %DEPSPKG% | %windir%\system32\FIND "ing archive"
 IF %ERRORLEVEL% NEQ 0 GOTO ERROR

-:SKIPDL
-
-IF EXIST build rd /s /q build
-IF %ERRORLEVEL% NEQ 0 GOTO ERROR
-mkdir build
+MKDIR build
 IF %ERRORLEVEL% NEQ 0 GOTO ERROR
 cd build
 IF %ERRORLEVEL% NEQ 0 GOTO ERROR

-SET OSRMDEPSDIR=c:\projects\osrm\osrm-deps
+SET OSRMDEPSDIR=%PROJECT_DIR%\osrm-deps
 set PREFIX=%OSRMDEPSDIR%/libs
 set BOOST_ROOT=%OSRMDEPSDIR%/boost
 set TBB_INSTALL_DIR=%OSRMDEPSDIR%/tbb
@@ -36,9 +52,9 @@ set TBB_ARCH_PLATFORM=intel64/vc14

 ECHO calling cmake ....
 cmake .. ^
-G "Visual Studio 14 Win64" ^
+-G "Visual Studio 14 2015 Win64" ^
 -DBOOST_ROOT=%BOOST_ROOT% ^
-DBoost_ADDITIONAL_VERSIONS=1.57 ^
+-DBoost_ADDITIONAL_VERSIONS=1.58 ^
 -DBoost_USE_MULTITHREADED=ON ^
 -DBoost_USE_STATIC_LIBS=ON ^
 -DCMAKE_BUILD_TYPE=%CONFIGURATION% ^
@@ -60,54 +76,47 @@ msbuild OSRM.sln ^
 /flp2:logfile=build_warnings.txt;warningsonly
 IF %ERRORLEVEL% NEQ 0 GOTO ERROR

-ECHO ========= TODO^: CREATE PACKAGES ==========
-
-CD c:\projects\osrm\build\%Configuration%
+CD %PROJECT_DIR%\build
 IF %ERRORLEVEL% NEQ 0 GOTO ERROR

-SET PATH=c:\projects\osrm\osrm-deps\libs\bin;%PATH%
+SET PATH=%PROJECT_DIR%\osrm-deps\libs\bin;%PATH%

 ECHO running datastructure-tests.exe ...
-datastructure-tests.exe
+%Configuration%\datastructure-tests.exe
 IF %ERRORLEVEL% NEQ 0 GOTO ERROR
 ECHO running algorithm-tests.exe ...
-algorithm-tests.exe
+%Configuration%\algorithm-tests.exe
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+IF NOT "%APPVEYOR_REPO_BRANCH%"=="develop" GOTO DONE
+ECHO ========= CREATING PACKAGES ==========
+
+CD %PROJECT_DIR%\build\%Configuration%
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+SET P=%PROJECT_DIR%
+SET ZIP= %P%\osrm_%Configuration%.zip
+IF EXIST %ZIP% ECHO deleting %ZIP% && DEL /F /Q %ZIP%
+IF %ERRORLEVEL% NEQ 0 ECHO deleting %ZIP% FAILED && GOTO ERROR
+
+7z a %ZIP% *.lib *.exe *.pdb %P%/osrm-deps/libs/bin/*.dll -tzip -mx9 | %windir%\system32\FIND "ing archive"
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+CD ..\..\profiles
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+ECHO disk=c:\temp\stxxl,10000,wincall > .stxxl.txt
+7z a %ZIP% * -tzip -mx9 | %windir%\system32\FIND "ing archive"
 IF %ERRORLEVEL% NEQ 0 GOTO ERROR

 GOTO DONE

 :ERROR
+ECHO ~~~~~~~~~~~~~~~~~~~~~~ ERROR %~f0 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ECHO ERRORLEVEL^: %ERRORLEVEL%
 SET EL=%ERRORLEVEL%
-ECHO ============== ERROR ===============

 :DONE
-ECHO ============= DONE ===============
-CD C:\projects\osrm
+ECHO ~~~~~~~~~~~~~~~~~~~~~~ DONE %~f0 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
 EXIT /b %EL%
-
-
-
-
-  - cd c:/projects/osrm
-  - mkdir build
-  - cd build
-  - echo Running cmake...
-  - call "%VS120COMNTOOLS%\..\..\VC\vcvarsall.bat" x86_amd64
-  - SET PATH=C:\Program Files (x86)\MSBuild\12.0\bin\;%PATH%
-  - SET P=c:/projects/osrm
-  - set TBB_INSTALL_DIR=%P%/tbb
-  - set TBB_ARCH_PLATFORM=intel64/vc12
-  - cmake .. -G "Visual Studio 14 Win64" -DCMAKE_BUILD_TYPE=%Configuration% -DCMAKE_INSTALL_PREFIX=%P%/libs -DBOOST_ROOT=%P%/boost_min -DBoost_ADDITIONAL_VERSIONS=1.57 -DBoost_USE_STATIC_LIBS=ON
-  - SET PLATFORM_TOOLSET=v140
-  - SET TOOLS_VERSION=14.0
-  - msbuild /p:Platform=x64 /clp:Verbosity=minimal /toolsversion:%TOOLS_VERSION% /p:PlatformToolset=%PLATFORM_TOOLSET% /nologo OSRM.sln
-  - msbuild /p:Platform=x64 /clp:Verbosity=minimal /toolsversion:%TOOLS_VERSION% /p:PlatformToolset=%PLATFORM_TOOLSET% /nologo tests.vcxproj
-  - cd %Configuration%
-  - if "%APPVEYOR_REPO_BRANCH%"=="develop" (7z a %P%/osrm_%Configuration%.zip *.exe *.pdb %P%/libs/bin/*.dll -tzip)
-  - cd ..\..\profiles
-  - echo disk=c:\temp\stxxl,10000,wincall > .stxxl.txt
-  - if "%APPVEYOR_REPO_BRANCH%"=="develop" (7z a %P%/osrm_%Configuration%.zip * -tzip)
-  - set PATH=%PATH%;c:/projects/osrm/libs/bin
-  - cd c:/projects/osrm/build/%Configuration%
-  - datastructure-tests.exe
-  - algorithm-tests.exe
@@ -7,17 +7,13 @@ environment:
 init:
  - git config --global core.autocrlf input

-os: Visual Studio 2015 RC
+os: Visual Studio 2015

 # clone directory
 clone_folder: c:\projects\osrm

 platform: x64

-install:
-  - set PATH=C:\Program Files (x86)\MSBuild\14.0\Bin;%PATH%
-  - CALL "C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat" amd64
-
 build_script:
  - CALL appveyor-build.bat

@@ -25,16 +25,16 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

-#include "../data_structures/original_edge_data.hpp"
 #include "../data_structures/query_node.hpp"
-#include "../data_structures/shared_memory_vector_wrapper.hpp"
 #include "../data_structures/static_rtree.hpp"
-#include "../util/boost_filesystem_2_fix.hpp"
 #include "../data_structures/edge_based_node.hpp"
+#include "../algorithms/geospatial_query.hpp"
+#include "../util/timing_util.hpp"

 #include <osrm/coordinate.hpp>

 #include <random>
+#include <iostream>

 // Choosen by a fair W20 dice roll (this value is completely arbitrary)
 constexpr unsigned RANDOM_SEED = 13;
@@ -46,6 +46,7 @@ constexpr int32_t WORLD_MAX_LON = 180 * COORDINATE_PRECISION;
 using RTreeLeaf = EdgeBasedNode;
 using FixedPointCoordinateListPtr = std::shared_ptr<std::vector<FixedPointCoordinate>>;
 using BenchStaticRTree = StaticRTree<RTreeLeaf, ShM<FixedPointCoordinate, false>::vector, false>;
+using BenchQuery = GeospatialQuery<BenchStaticRTree>;

 FixedPointCoordinateListPtr LoadCoordinates(const boost::filesystem::path &nodes_file)
 {
@@ -66,7 +67,28 @@ FixedPointCoordinateListPtr LoadCoordinates(const boost::filesystem::path &nodes
    return coords;
 }

-void Benchmark(BenchStaticRTree &rtree, unsigned num_queries)
+template <typename QueryT>
+void BenchmarkQuery(const std::vector<FixedPointCoordinate> &queries,
+                    const std::string& name,
+                    QueryT query)
+{
+    std::cout << "Running " << name << " with " << queries.size() << " coordinates: " << std::flush;
+
+    TIMER_START(query);
+    for (const auto &q : queries)
+    {
+        auto result = query(q);
+    }
+    TIMER_STOP(query);
+
+    std::cout << "Took " << TIMER_SEC(query) << " seconds "
+              << "(" << TIMER_MSEC(query) << "ms"
+              << ")  ->  " << TIMER_MSEC(query) / queries.size() << " ms/query "
+              << "(" << TIMER_MSEC(query) << "ms"
+              << ")" << std::endl;
+}
+
+void Benchmark(BenchStaticRTree &rtree, BenchQuery &geo_query, unsigned num_queries)
 {
    std::mt19937 mt_rand(RANDOM_SEED);
    std::uniform_int_distribution<> lat_udist(WORLD_MIN_LAT, WORLD_MAX_LAT);
@@ -74,91 +96,36 @@ void Benchmark(BenchStaticRTree &rtree, unsigned num_queries)
    std::vector<FixedPointCoordinate> queries;
    for (unsigned i = 0; i < num_queries; i++)
    {
-        queries.emplace_back(FixedPointCoordinate(lat_udist(mt_rand), lon_udist(mt_rand)));
+        queries.emplace_back(lat_udist(mt_rand), lon_udist(mt_rand));
    }

-    {
-        const unsigned num_results = 5;
-        std::cout << "#### IncrementalFindPhantomNodeForCoordinate : " << num_results
-                  << " phantom nodes"
-                  << "\n";
+    BenchmarkQuery(queries, "raw RTree queries (1 result)", [&rtree](const FixedPointCoordinate &q)
+                   {
+                       return rtree.Nearest(q, 1);
+                   });
+    BenchmarkQuery(queries, "raw RTree queries (10 results)",
+                   [&rtree](const FixedPointCoordinate &q)
+                   {
+                       return rtree.Nearest(q, 10);
+                   });

-        TIMER_START(query_phantom);
-        std::vector<PhantomNode> phantom_node_vector;
-        for (const auto &q : queries)
-        {
-            phantom_node_vector.clear();
-            rtree.IncrementalFindPhantomNodeForCoordinate(q, phantom_node_vector, 3, num_results);
-            phantom_node_vector.clear();
-            rtree.IncrementalFindPhantomNodeForCoordinate(q, phantom_node_vector, 17, num_results);
-        }
-        TIMER_STOP(query_phantom);
-
-        std::cout << "Took " << TIMER_MSEC(query_phantom) << " msec for " << num_queries
-                  << " queries."
-                  << "\n";
-        std::cout << TIMER_MSEC(query_phantom) / ((double)num_queries) << " msec/query."
-                  << "\n";
-
-        std::cout << "#### LocateClosestEndPointForCoordinate"
-                  << "\n";
-    }
-
-    TIMER_START(query_endpoint);
-    FixedPointCoordinate result;
-    for (const auto &q : queries)
-    {
-        rtree.LocateClosestEndPointForCoordinate(q, result, 3);
-    }
-    TIMER_STOP(query_endpoint);
-
-    std::cout << "Took " << TIMER_MSEC(query_endpoint) << " msec for " << num_queries << " queries."
-              << "\n";
-    std::cout << TIMER_MSEC(query_endpoint) / ((double)num_queries) << " msec/query."
-              << "\n";
-
-    std::cout << "#### FindPhantomNodeForCoordinate"
-              << "\n";
-
-    TIMER_START(query_node);
-    for (const auto &q : queries)
-    {
-        PhantomNode phantom;
-        rtree.FindPhantomNodeForCoordinate(q, phantom, 3);
-    }
-    TIMER_STOP(query_node);
-
-    std::cout << "Took " << TIMER_MSEC(query_node) << " msec for " << num_queries << " queries."
-              << "\n";
-    std::cout << TIMER_MSEC(query_node) / ((double)num_queries) << " msec/query."
-              << "\n";
-
-    {
-        const unsigned num_results = 1;
-        std::cout << "#### IncrementalFindPhantomNodeForCoordinate : " << num_results
-                  << " phantom nodes"
-                  << "\n";
-
-        TIMER_START(query_phantom);
-        std::vector<PhantomNode> phantom_node_vector;
-        for (const auto &q : queries)
-        {
-            phantom_node_vector.clear();
-            rtree.IncrementalFindPhantomNodeForCoordinate(q, phantom_node_vector, 3, num_results);
-            phantom_node_vector.clear();
-            rtree.IncrementalFindPhantomNodeForCoordinate(q, phantom_node_vector, 17, num_results);
-        }
-        TIMER_STOP(query_phantom);
-
-        std::cout << "Took " << TIMER_MSEC(query_phantom) << " msec for " << num_queries
-                  << " queries."
-                  << "\n";
-        std::cout << TIMER_MSEC(query_phantom) / ((double)num_queries) << " msec/query."
-                  << "\n";
-
-        std::cout << "#### LocateClosestEndPointForCoordinate"
-                  << "\n";
-    }
+    BenchmarkQuery(queries, "big component alternative queries",
+                   [&geo_query](const FixedPointCoordinate &q)
+                   {
+                       return geo_query.NearestPhantomNodeWithAlternativeFromBigComponent(q);
+                   });
+    BenchmarkQuery(queries, "max distance 1000", [&geo_query](const FixedPointCoordinate &q)
+                   {
+                       return geo_query.NearestPhantomNodesInRange(q, 1000);
+                   });
+    BenchmarkQuery(queries, "PhantomNode query (1 result)", [&geo_query](const FixedPointCoordinate &q)
+                   {
+                       return geo_query.NearestPhantomNodes(q, 1);
+                   });
+    BenchmarkQuery(queries, "PhantomNode query (10 result)", [&geo_query](const FixedPointCoordinate &q)
+                   {
+                       return geo_query.NearestPhantomNodes(q, 10);
+                   });
 }

 int main(int argc, char **argv)
@@ -177,8 +144,9 @@ int main(int argc, char **argv)
    auto coords = LoadCoordinates(nodesPath);

    BenchStaticRTree rtree(ramPath, filePath, coords);
+    BenchQuery query(rtree, coords);

-    Benchmark(rtree, 10000);
+    Benchmark(rtree, query, 10000);

    return 0;
 }
@@ -1,19 +1,33 @@
@ECHO OFF
+SETLOCAL
+SET EL=0
+
+ECHO ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ %~f0 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 SET PLATFORM=x64
 SET CONFIGURATION=Release
+::SET LOCAL_DEV=1

-WHERE msbuild
-IF %ERRORLEVEL% EQU 0 GOTO RUNBUILD
+FOR /F "tokens=*" %%i in ('git rev-parse --abbrev-ref HEAD') do SET APPVEYOR_REPO_BRANCH=%%i
+ECHO APPVEYOR_REPO_BRANCH^: %APPVEYOR_REPO_BRANCH%

-SET PATH=C:\mb\windows-builds-64\tmp-bin\cmake-3.1.0-win32-x86\bin;%PATH%
+SET PATH=C:\mb\windows-builds-64\tmp-bin\cmake-3.4.0-win32-x86\bin;%PATH%
 SET PATH=C:\Program Files\7-Zip;%PATH%
-ECHO activating VS command prompt ...
-SET PATH=C:\Program Files (x86)\MSBuild\14.0\Bin;%PATH%
-CALL "C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat" amd64
-
-:RUNBUILD

 powershell Set-ExecutionPolicy -Scope CurrentUser -ExecutionPolicy Unrestricted -Force
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
 CALL appveyor-build.bat
-EXIT /b %ERRORLEVEL%
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+GOTO DONE
+
+
+:ERROR
+ECHO ~~~~~~~~~~~~~~~~~~~~~~ ERROR %~f0 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ECHO ERRORLEVEL^: %ERRORLEVEL%
+SET EL=%ERRORLEVEL%
+
+:DONE
+ECHO ~~~~~~~~~~~~~~~~~~~~~~ DONE %~f0 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+EXIT /b %EL%
@@ -34,7 +34,7 @@ SET(CPACK_DEBIAN_PACKAGE_SECTION     "devel")
 SET(CPACK_DEBIAN_PACKAGE_DESCRIPTION "Open Source Routing Machine (OSRM) is a high-performance routing engine.
  It combines sophisticated routing algorithms with the open and free data of the OpenStreetMap."
 )
-SET(CPACK_DEBIAN_PACKAGE_DEPENDS     "libc6-dev, libprotobuf-dev, libosmpbf-dev, libbz2-1.0, libstxxl1, libxml2, libzip2, liblua5.1-0, libtbb2, libboost-all-dev")
+SET(CPACK_DEBIAN_PACKAGE_DEPENDS     "libc6-dev, libbz2-1.0, libstxxl1, libxml2, libzip2, liblua5.1-0, libtbb2, libboost-all-dev")

 file(GLOB_RECURSE ProfileGlob ${CMAKE_SOURCE_DIR}/profiles/*)
 install(FILES ${ProfileGlob} DESTINATION "share/doc/${LOWER_PROJECT_NAME}/profiles")
@@ -1,54 +0,0 @@
-# Locate OSMPBF library
-# This module defines
-#  OSMPBF_FOUND, if false, do not try to link to OSMPBF
-#  OSMPBF_LIBRARIES
-#  OSMPBF_INCLUDE_DIR, where to find OSMPBF.hpp
-#
-# Note that the expected include convention is
-#  #include <osmpbf/osmpbf.h>
-# and not
-#  #include <osmpbf.h>
-
-IF( NOT OSMPBF_FIND_QUIETLY )
-    MESSAGE(STATUS "Looking for OSMPBF...")
-ENDIF()
-
-FIND_PATH(OSMPBF_INCLUDE_DIR osmpbf.h
-  HINTS
-  $ENV{OSMPBF_DIR}
-  PATH_SUFFIXES OSMPBF include/osmpbf include
-  PATHS
-  ~/Library/Frameworks
-  /Library/Frameworks
-  /usr/local
-  /usr
-  /opt/local # DarwinPorts
-  /opt
-)
-
-FIND_LIBRARY(OSMPBF_LIBRARY
-  NAMES osmpbf
-  HINTS
-  $ENV{OSMPBF_DIR}
-  PATH_SUFFIXES lib64 lib
-  PATHS
-  ~/Library/Frameworks
-  /Library/Frameworks
-  /usr/local
-  /usr
-  /opt/local
-  /opt
-)
-
-INCLUDE(FindPackageHandleStandardArgs)
-# handle the QUIETLY and REQUIRED arguments and set OSMPBF_FOUND to TRUE if
-# all listed variables are TRUE
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(OSMPBF  DEFAULT_MSG  OSMPBF_LIBRARY OSMPBF_INCLUDE_DIR)
-
-IF( NOT OSMPBF_FIND_QUIETLY )
-    IF( OSMPBF_FOUND )
-        MESSAGE(STATUS "Found OSMPBF: ${OSMPBF_LIBRARY}" )
-    ENDIF()
-ENDIF()
-
-#MARK_AS_ADVANCED(OSMPBF_INCLUDE_DIR OSMPBF_LIBRARIES OSMPBF_LIBRARY OSMPBF_LIBRARY_DBG) 
@@ -1,10 +1,24 @@
-set(OLDFILE ${SOURCE_DIR}/util/fingerprint_impl.hpp)
-if (EXISTS ${OLDFILE})
-	file(REMOVE_RECURSE ${OLDFILE})
-endif()
+set(OLDFILE ${OUTPUT_DIR}/util/fingerprint_impl.hpp)
+set(NEWFILE ${OLDFILE}.tmp)
+set(INFILE ${SOURCE_DIR}/util/fingerprint_impl.hpp.in)
 file(MD5 ${SOURCE_DIR}/prepare.cpp MD5PREPARE)
 file(MD5 ${SOURCE_DIR}/data_structures/static_rtree.hpp MD5RTREE)
 file(MD5 ${SOURCE_DIR}/util/graph_loader.hpp MD5GRAPH)
 file(MD5 ${SOURCE_DIR}/server/data_structures/internal_datafacade.hpp MD5OBJECTS)

-CONFIGURE_FILE(${SOURCE_DIR}/util/fingerprint_impl.hpp.in ${SOURCE_DIR}/util/fingerprint_impl.hpp)
+CONFIGURE_FILE(${INFILE} ${NEWFILE})
+
+file(MD5 ${NEWFILE} MD5NEW)
+
+if (EXISTS ${OLDFILE})
+    file(MD5 ${OLDFILE} MD5OLD)
+    if(NOT ${MD5NEW} STREQUAL ${MD5OLD})
+        file(REMOVE_RECURSE ${OLDFILE})
+        file(RENAME ${NEWFILE} ${OLDFILE})
+    else()
+        file(REMOVE_RECURSE ${NEWFILE})
+        message(STATUS "Fingerprint unchanged, not regenerating")
+    endif()
+else()
+    file(RENAME ${NEWFILE} ${OLDFILE})
+endif()
@@ -1,123 +0,0 @@
-# - Returns a version string from Git
-#
-# These functions force a re-configure on each git commit so that you can
-# trust the values of the variables in your build system.
-#
-#  get_git_head_revision(<refspecvar> <hashvar> [<additional arguments to git describe> ...])
-#
-# Returns the refspec and sha hash of the current head revision
-#
-#  git_describe(<var> [<additional arguments to git describe> ...])
-#
-# Returns the results of git describe on the source tree, and adjusting
-# the output so that it tests false if an error occurs.
-#
-#  git_get_exact_tag(<var> [<additional arguments to git describe> ...])
-#
-# Returns the results of git describe --exact-match on the source tree,
-# and adjusting the output so that it tests false if there was no exact
-# matching tag.
-#
-# Requires CMake 2.6 or newer (uses the 'function' command)
-#
-# Original Author:
-# 2009-2010 Ryan Pavlik <rpavlik@iastate.edu> <abiryan@ryand.net>
-# http://academic.cleardefinition.com
-# Iowa State University HCI Graduate Program/VRAC
-#
-# Copyright Iowa State University 2009-2010.
-# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at
-# http://www.boost.org/LICENSE_1_0.txt)
-
-if(__get_git_revision_description)
-	return()
-endif()
-set(__get_git_revision_description YES)
-
-# We must run the following at "include" time, not at function call time,
-# to find the path to this module rather than the path to a calling list file
-get_filename_component(_gitdescmoddir ${CMAKE_CURRENT_LIST_FILE} PATH)
-
-function(get_git_head_revision _refspecvar _hashvar)
-	set(GIT_PARENT_DIR "${CMAKE_SOURCE_DIR}")
-	set(GIT_DIR "${GIT_PARENT_DIR}/.git")
-	while(NOT EXISTS "${GIT_DIR}")	# .git dir not found, search parent directories
-		set(GIT_PREVIOUS_PARENT "${GIT_PARENT_DIR}")
-		get_filename_component(GIT_PARENT_DIR ${GIT_PARENT_DIR} PATH)
-		if(GIT_PARENT_DIR STREQUAL GIT_PREVIOUS_PARENT)
-			# We have reached the root directory, we are not in git
-			set(${_refspecvar} "GITDIR-NOTFOUND" PARENT_SCOPE)
-			set(${_hashvar} "GITDIR-NOTFOUND" PARENT_SCOPE)
-			return()
-		endif()
-		set(GIT_DIR "${GIT_PARENT_DIR}/.git")
-	endwhile()
-	set(GIT_DATA "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/git-data")
-	if(NOT EXISTS "${GIT_DATA}")
-		file(MAKE_DIRECTORY "${GIT_DATA}")
-	endif()
-
-	if(NOT EXISTS "${GIT_DIR}/HEAD")
-		return()
-	endif()
-	set(HEAD_FILE "${GIT_DATA}/HEAD")
-	configure_file("${GIT_DIR}/HEAD" "${HEAD_FILE}" COPYONLY)
-
-	configure_file("${_gitdescmoddir}/GetGitRevisionDescription.cmake.in"
-		"${GIT_DATA}/grabRef.cmake"
-		@ONLY)
-	include("${GIT_DATA}/grabRef.cmake")
-
-	set(${_refspecvar} "${HEAD_REF}" PARENT_SCOPE)
-	set(${_hashvar} "${HEAD_HASH}" PARENT_SCOPE)
-endfunction()
-
-function(git_describe _var)
-	if(NOT GIT_FOUND)
-		find_package(Git QUIET)
-	endif()
-	get_git_head_revision(refspec hash)
-	if(NOT GIT_FOUND)
-		set(${_var} "GIT-NOTFOUND" PARENT_SCOPE)
-		return()
-	endif()
-	if(NOT hash)
-		set(${_var} "HEAD-HASH-NOTFOUND" PARENT_SCOPE)
-		return()
-	endif()
-
-	# TODO sanitize
-	#if((${ARGN}" MATCHES "&&") OR
-	#	(ARGN MATCHES "||") OR
-	#	(ARGN MATCHES "\\;"))
-	#	message("Please report the following error to the project!")
-	#	message(FATAL_ERROR "Looks like someone's doing something nefarious with git_describe! Passed arguments ${ARGN}")
-	#endif()
-
-	#message(STATUS "Arguments to execute_process: ${ARGN}")
-
-	execute_process(COMMAND
-		"${GIT_EXECUTABLE}"
-		describe
-		${hash}
-		${ARGN}
-		WORKING_DIRECTORY
-		"${CMAKE_SOURCE_DIR}"
-		RESULT_VARIABLE
-		res
-		OUTPUT_VARIABLE
-		out
-		ERROR_QUIET
-		OUTPUT_STRIP_TRAILING_WHITESPACE)
-	if(NOT res EQUAL 0)
-		set(out "${out}-${res}-NOTFOUND")
-	endif()
-
-	set(${_var} "${out}" PARENT_SCOPE)
-endfunction()
-
-function(git_get_exact_tag _var)
-	git_describe(out --exact-match ${ARGN})
-	set(${_var} "${out}" PARENT_SCOPE)
-endfunction()
@@ -1,38 +0,0 @@
-# 
-# Internal file for GetGitRevisionDescription.cmake
-#
-# Requires CMake 2.6 or newer (uses the 'function' command)
-#
-# Original Author:
-# 2009-2010 Ryan Pavlik <rpavlik@iastate.edu> <abiryan@ryand.net>
-# http://academic.cleardefinition.com
-# Iowa State University HCI Graduate Program/VRAC
-#
-# Copyright Iowa State University 2009-2010.
-# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at
-# http://www.boost.org/LICENSE_1_0.txt)
-
-set(HEAD_HASH)
-
-file(READ "@HEAD_FILE@" HEAD_CONTENTS LIMIT 1024)
-
-string(STRIP "${HEAD_CONTENTS}" HEAD_CONTENTS)
-if(HEAD_CONTENTS MATCHES "ref")
-	# named branch
-	string(REPLACE "ref: " "" HEAD_REF "${HEAD_CONTENTS}")
-	if(EXISTS "@GIT_DIR@/${HEAD_REF}")
-		configure_file("@GIT_DIR@/${HEAD_REF}" "@GIT_DATA@/head-ref" COPYONLY)
-	elseif(EXISTS "@GIT_DIR@/logs/${HEAD_REF}")
-		configure_file("@GIT_DIR@/logs/${HEAD_REF}" "@GIT_DATA@/head-ref" COPYONLY)
-		set(HEAD_HASH "${HEAD_REF}")
-	endif()
-else()
-	# detached HEAD
-	configure_file("@GIT_DIR@/HEAD" "@GIT_DATA@/head-ref" COPYONLY)
-endif()
-
-if(NOT HEAD_HASH)
-	file(READ "@GIT_DATA@/head-ref" HEAD_HASH LIMIT 1024)
-	string(STRIP "${HEAD_HASH}" HEAD_HASH)
-endif()
@@ -1,7 +1,7 @@
 INCLUDE (CheckCXXSourceCompiles)
 unset(LUABIND_WORKS CACHE)
 unset(LUABIND51_WORKS CACHE)
-set (LUABIND_CHECK_SRC "#include  \"lua.h\"\n#include <luabind/luabind.hpp>\n int main() { lua_State *myLuaState = luaL_newstate(); luabind::open(myLuaState);  return 0;}")
+set (LUABIND_CHECK_SRC "extern \"C\" {\n#include \"lua.h\"\n#include \"lauxlib.h\"\n}\n#include <luabind/open.hpp>\nint main() { lua_State *x = luaL_newstate(); luabind::open(x); }")
 set (CMAKE_TRY_COMPILE_CONFIGURATION ${CMAKE_BUILD_TYPE})
 set (CMAKE_REQUIRED_INCLUDES "${Boost_INCLUDE_DIR};${LUABIND_INCLUDE_DIR};${LUA_INCLUDE_DIR}")
 set (CMAKE_REQUIRED_LIBRARIES "${LUABIND_LIBRARY};${LUA_LIBRARY}")
@@ -1,11 +1,11 @@
 prefix=@CMAKE_INSTALL_PREFIX@
-includedir=${prefix}/include/osrm
+includedir=${prefix}/include
 libdir=${prefix}/lib

 Name: libOSRM
 Description: Project OSRM library
-Version: @GIT_DESCRIPTION@
+Version: v@OSRM_VERSION_MAJOR@.@OSRM_VERSION_MINOR@.@OSRM_VERSION_PATCH@
 Requires:
 Libs: -L${libdir} -lOSRM
-Libs.private: @BOOST_LIBRARY_LISTING@
+Libs.private: @BOOST_LIBRARY_LISTING@ @TBB_LIBRARY_LISTING@
 Cflags: -I${includedir}
@@ -50,6 +50,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 #include <algorithm>
 #include <limits>
+#include <memory>
 #include <vector>

 class Contractor
@@ -157,6 +158,15 @@ class Contractor

  public:
    template <class ContainerT> Contractor(int nodes, ContainerT &input_edge_list)
+      : Contractor(nodes, input_edge_list, {}, {})
+    {
+    }
+
+    template <class ContainerT>
+    Contractor(int nodes,
+               ContainerT &input_edge_list,
+               std::vector<float> &&node_levels_)
+        : node_levels(std::move(node_levels_))
    {
        std::vector<ContractorEdge> edges;
        edges.reserve(input_edge_list.size() * 2);
@@ -172,7 +182,8 @@ class Contractor
                SimpleLogger().Write(logWARNING)
                    << "Edge weight large -> "
                    << static_cast<unsigned int>(std::max(diter->weight, 1)) << " : "
-                    << static_cast<unsigned int>(diter->source) << " -> " << static_cast<unsigned int>(diter->target);
+                    << static_cast<unsigned int>(diter->source) << " -> "
+                    << static_cast<unsigned int>(diter->target);
            }
 #endif
            edges.emplace_back(diter->source, diter->target,
@@ -284,7 +295,7 @@ class Contractor

    ~Contractor() {}

-    void Run()
+    void Run(double core_factor = 1.0)
    {
        // for the preperation we can use a big grain size, which is much faster (probably cache)
        constexpr size_t InitGrainSize = 100000;
@@ -303,39 +314,59 @@ class Contractor
        ThreadDataContainer thread_data_list(number_of_nodes);

        NodeID number_of_contracted_nodes = 0;
-        std::vector<RemainingNodeData> remaining_nodes(number_of_nodes);
-        std::vector<float> node_priorities(number_of_nodes);
-        std::vector<NodePriorityData> node_data(number_of_nodes);
+        std::vector<NodePriorityData> node_data;
+        std::vector<float> node_priorities;
+        is_core_node.resize(number_of_nodes, false);

+        std::vector<RemainingNodeData> remaining_nodes(number_of_nodes);
        // initialize priorities in parallel
        tbb::parallel_for(tbb::blocked_range<int>(0, number_of_nodes, InitGrainSize),
-                          [&remaining_nodes](const tbb::blocked_range<int> &range)
+                          [this, &remaining_nodes](const tbb::blocked_range<int> &range)
                          {
-                              for (int x = range.begin(); x != range.end(); ++x)
+                              for (int x = range.begin(), end = range.end(); x != end; ++x)
                              {
                                  remaining_nodes[x].id = x;
                              }
                          });

-        std::cout << "initializing elimination PQ ..." << std::flush;
-        tbb::parallel_for(tbb::blocked_range<int>(0, number_of_nodes, PQGrainSize),
-                          [this, &node_priorities, &node_data, &thread_data_list](
-                              const tbb::blocked_range<int> &range)
-                          {
-                              ContractorThreadData *data = thread_data_list.getThreadData();
-                              for (int x = range.begin(); x != range.end(); ++x)
-                              {
-                                  node_priorities[x] =
-                                      this->EvaluateNodePriority(data, &node_data[x], x);
-                              }
-                          });
-        std::cout << "ok" << std::endl << "preprocessing " << number_of_nodes << " nodes ..."
-                  << std::flush;
-
-        bool flushed_contractor = false;
-        while (number_of_nodes > 2 && number_of_contracted_nodes < number_of_nodes)
+        bool use_cached_node_priorities = !node_levels.empty();
+        if (use_cached_node_priorities)
        {
-            if (!flushed_contractor && (number_of_contracted_nodes > (number_of_nodes * 0.65)))
+            std::cout << "using cached node priorities ..." << std::flush;
+            node_priorities.swap(node_levels);
+            std::cout << "ok" << std::endl;
+        }
+        else
+        {
+            node_data.resize(number_of_nodes);
+            node_priorities.resize(number_of_nodes);
+            node_levels.resize(number_of_nodes);
+
+            std::cout << "initializing elimination PQ ..." << std::flush;
+            tbb::parallel_for(tbb::blocked_range<int>(0, number_of_nodes, PQGrainSize),
+                              [this, &node_priorities, &node_data, &thread_data_list](
+                                  const tbb::blocked_range<int> &range)
+                              {
+                                  ContractorThreadData *data = thread_data_list.getThreadData();
+                                  for (int x = range.begin(), end = range.end(); x != end; ++x)
+                                  {
+                                      node_priorities[x] =
+                                          this->EvaluateNodePriority(data, &node_data[x], x);
+                                  }
+                              });
+            std::cout << "ok" << std::endl;
+        }
+        BOOST_ASSERT(node_priorities.size() == number_of_nodes);
+
+        std::cout << "preprocessing " << number_of_nodes << " nodes ..." << std::flush;
+
+        unsigned current_level = 0;
+        bool flushed_contractor = false;
+        while (number_of_nodes > 2 &&
+               number_of_contracted_nodes < static_cast<NodeID>(number_of_nodes * core_factor))
+        {
+            if (!flushed_contractor && (number_of_contracted_nodes >
+                                        static_cast<NodeID>(number_of_nodes * 0.65 * core_factor)))
            {
                DeallocatingVector<ContractorEdge> new_edge_set; // this one is not explicitely
                                                                 // cleared since it goes out of
@@ -349,33 +380,37 @@ class Contractor
                std::vector<float> new_node_priority(remaining_nodes.size());
                // this map gives the old IDs from the new ones, necessary to get a consistent graph
                // at the end of contraction
-                orig_node_id_to_new_id_map.resize(remaining_nodes.size());
+                orig_node_id_from_new_node_id_map.resize(remaining_nodes.size());
                // this map gives the new IDs from the old ones, necessary to remap targets from the
                // remaining graph
                std::vector<NodeID> new_node_id_from_orig_id_map(number_of_nodes, UINT_MAX);

-                // build forward and backward renumbering map and remap ids in remaining_nodes and
-                // Priorities.
                for (const auto new_node_id : osrm::irange<std::size_t>(0, remaining_nodes.size()))
                {
+                    auto& node = remaining_nodes[new_node_id];
+                    BOOST_ASSERT(node_priorities.size() > node.id);
+                    new_node_priority[new_node_id] = node_priorities[node.id];
+                }
+
+                // build forward and backward renumbering map and remap ids in remaining_nodes
+                for (const auto new_node_id : osrm::irange<std::size_t>(0, remaining_nodes.size()))
+                {
+                    auto& node = remaining_nodes[new_node_id];
                    // create renumbering maps in both directions
-                    orig_node_id_to_new_id_map[new_node_id] = remaining_nodes[new_node_id].id;
-                    new_node_id_from_orig_id_map[remaining_nodes[new_node_id].id] = new_node_id;
-                    new_node_priority[new_node_id] =
-                        node_priorities[remaining_nodes[new_node_id].id];
-                    remaining_nodes[new_node_id].id = new_node_id;
+                    orig_node_id_from_new_node_id_map[new_node_id] = node.id;
+                    new_node_id_from_orig_id_map[node.id] = new_node_id;
+                    node.id = new_node_id;
                }
                // walk over all nodes
-                for (const auto i :
-                     osrm::irange<std::size_t>(0, contractor_graph->GetNumberOfNodes()))
+                for (const auto source :
+                     osrm::irange<NodeID>(0, contractor_graph->GetNumberOfNodes()))
                {
-                    const NodeID source = i;
                    for (auto current_edge : contractor_graph->GetAdjacentEdgeRange(source))
                    {
                        ContractorGraph::EdgeData &data =
                            contractor_graph->GetEdgeData(current_edge);
                        const NodeID target = contractor_graph->GetTarget(current_edge);
-                        if (SPECIAL_NODEID == new_node_id_from_orig_id_map[i])
+                        if (SPECIAL_NODEID == new_node_id_from_orig_id_map[source])
                        {
                            external_edge_list.push_back({source, target, data});
                        }
@@ -410,7 +445,7 @@ class Contractor
                contractor_graph.reset();

                // create new graph
-                std::sort(new_edge_set.begin(), new_edge_set.end());
+                tbb::parallel_sort(new_edge_set.begin(), new_edge_set.end());
                contractor_graph =
                    std::make_shared<ContractorGraph>(remaining_nodes.size(), new_edge_set);

@@ -422,14 +457,13 @@ class Contractor
                thread_data_list.number_of_nodes = contractor_graph->GetNumberOfNodes();
            }

-            const int last = (int)remaining_nodes.size();
-            tbb::parallel_for(tbb::blocked_range<int>(0, last, IndependentGrainSize),
+            tbb::parallel_for(tbb::blocked_range<std::size_t>(0, remaining_nodes.size(), IndependentGrainSize),
                              [this, &node_priorities, &remaining_nodes, &thread_data_list](
-                                  const tbb::blocked_range<int> &range)
+                                  const tbb::blocked_range<std::size_t> &range)
                              {
                                  ContractorThreadData *data = thread_data_list.getThreadData();
                                  // determine independent node set
-                                  for (int i = range.begin(); i != range.end(); ++i)
+                                  for (auto i = range.begin(), end = range.end(); i != end; ++i)
                                  {
                                      const NodeID node = remaining_nodes[i].id;
                                      remaining_nodes[i].is_independent =
@@ -437,43 +471,74 @@ class Contractor
                                  }
                              });

-            const auto first = stable_partition(remaining_nodes.begin(), remaining_nodes.end(),
+            // sort all remaining nodes to the beginning of the sequence
+            const auto begin_independent_nodes = stable_partition(remaining_nodes.begin(), remaining_nodes.end(),
                                                [](RemainingNodeData node_data)
                                                {
                                                    return !node_data.is_independent;
                                                });
-            const int first_independent_node = static_cast<int>(first - remaining_nodes.begin());
+            auto begin_independent_nodes_idx = std::distance(remaining_nodes.begin(), begin_independent_nodes);
+            auto end_independent_nodes_idx = remaining_nodes.size();
+
+            if (!use_cached_node_priorities)
+            {
+                // write out contraction level
+                tbb::parallel_for(
+                    tbb::blocked_range<std::size_t>(begin_independent_nodes_idx, end_independent_nodes_idx, ContractGrainSize),
+                    [this, remaining_nodes, flushed_contractor, current_level](const tbb::blocked_range<std::size_t> &range)
+                    {
+                        if (flushed_contractor)
+                        {
+                            for (int position = range.begin(), end = range.end(); position != end; ++position)
+                            {
+                                const NodeID x = remaining_nodes[position].id;
+                                node_levels[orig_node_id_from_new_node_id_map[x]] = current_level;
+                            }
+                        }
+                        else
+                        {
+                            for (int position = range.begin(), end = range.end(); position != end; ++position)
+                            {
+                                const NodeID x = remaining_nodes[position].id;
+                                node_levels[x] = current_level;
+                            }
+                        }
+                    });
+            }

            // contract independent nodes
            tbb::parallel_for(
-                tbb::blocked_range<int>(first_independent_node, last, ContractGrainSize),
-                [this, &remaining_nodes, &thread_data_list](const tbb::blocked_range<int> &range)
+                tbb::blocked_range<std::size_t>(begin_independent_nodes_idx, end_independent_nodes_idx, ContractGrainSize),
+                [this, &remaining_nodes, &thread_data_list](const tbb::blocked_range<std::size_t> &range)
                {
                    ContractorThreadData *data = thread_data_list.getThreadData();
-                    for (int position = range.begin(); position != range.end(); ++position)
+                    for (int position = range.begin(), end = range.end(); position != end; ++position)
                    {
                        const NodeID x = remaining_nodes[position].id;
                        this->ContractNode<false>(data, x);
                    }
                });
+
+            tbb::parallel_for(
+                tbb::blocked_range<int>(begin_independent_nodes_idx, end_independent_nodes_idx, DeleteGrainSize),
+                [this, &remaining_nodes, &thread_data_list](const tbb::blocked_range<int> &range)
+                {
+                    ContractorThreadData *data = thread_data_list.getThreadData();
+                    for (int position = range.begin(), end = range.end(); position != end; ++position)
+                    {
+                        const NodeID x = remaining_nodes[position].id;
+                        this->DeleteIncomingEdges(data, x);
+                    }
+                });
+
            // make sure we really sort each block
            tbb::parallel_for(
                thread_data_list.data.range(),
                [&](const ThreadDataContainer::EnumerableThreadData::range_type &range)
                {
                    for (auto &data : range)
-                        std::sort(data->inserted_edges.begin(), data->inserted_edges.end());
-                });
-            tbb::parallel_for(
-                tbb::blocked_range<int>(first_independent_node, last, DeleteGrainSize),
-                [this, &remaining_nodes, &thread_data_list](const tbb::blocked_range<int> &range)
-                {
-                    ContractorThreadData *data = thread_data_list.getThreadData();
-                    for (int position = range.begin(); position != range.end(); ++position)
-                    {
-                        const NodeID x = remaining_nodes[position].id;
-                        this->DeleteIncomingEdges(data, x);
-                    }
+                        tbb::parallel_sort(data->inserted_edges.begin(),
+                                           data->inserted_edges.end());
                });

            // insert new edges
@@ -501,30 +566,32 @@ class Contractor
                data->inserted_edges.clear();
            }

-            tbb::parallel_for(
-                tbb::blocked_range<int>(first_independent_node, last, NeighboursGrainSize),
-                [this, &remaining_nodes, &node_priorities, &node_data, &thread_data_list](
-                    const tbb::blocked_range<int> &range)
-                {
-                    ContractorThreadData *data = thread_data_list.getThreadData();
-                    for (int position = range.begin(); position != range.end(); ++position)
+            if (!use_cached_node_priorities)
+            {
+                tbb::parallel_for(
+                    tbb::blocked_range<int>(begin_independent_nodes_idx, end_independent_nodes_idx, NeighboursGrainSize),
+                    [this, &node_priorities, &remaining_nodes, &node_data, &thread_data_list](
+                        const tbb::blocked_range<int> &range)
                    {
-                        NodeID x = remaining_nodes[position].id;
-                        this->UpdateNodeNeighbours(node_priorities, node_data, data, x);
-                    }
-                });
+                        ContractorThreadData *data = thread_data_list.getThreadData();
+                        for (int position = range.begin(), end = range.end(); position != end; ++position)
+                        {
+                            NodeID x = remaining_nodes[position].id;
+                            this->UpdateNodeNeighbours(node_priorities, node_data, data, x);
+                        }
+                    });
+            }

            // remove contracted nodes from the pool
-            number_of_contracted_nodes += last - first_independent_node;
-            remaining_nodes.resize(first_independent_node);
-            remaining_nodes.shrink_to_fit();
+            number_of_contracted_nodes += end_independent_nodes_idx - begin_independent_nodes_idx;
+            remaining_nodes.resize(begin_independent_nodes_idx);
            //            unsigned maxdegree = 0;
            //            unsigned avgdegree = 0;
            //            unsigned mindegree = UINT_MAX;
            //            unsigned quaddegree = 0;
            //
            //            for(unsigned i = 0; i < remaining_nodes.size(); ++i) {
-            //                unsigned degree = contractor_graph->EndEdges(remaining_nodes[i].first)
+            //                unsigned degree = contractor_graph->EndEdges(remaining_nodes[i].id)
            //                -
            //                contractor_graph->BeginEdges(remaining_nodes[i].first);
            //                if(degree > maxdegree)
@@ -544,11 +611,61 @@ class Contractor
            //            quad: " << quaddegree;

            p.printStatus(number_of_contracted_nodes);
+            ++current_level;
        }

+        if (remaining_nodes.size() > 2)
+        {
+              if (orig_node_id_from_new_node_id_map.size() > 0)
+              {
+                  tbb::parallel_for(
+                      tbb::blocked_range<int>(0, remaining_nodes.size(), InitGrainSize),
+                      [this, &remaining_nodes](const tbb::blocked_range<int> &range)
+                      {
+                          for (int x = range.begin(), end = range.end(); x != end; ++x)
+                          {
+                              const auto orig_id = remaining_nodes[x].id;
+                              is_core_node[orig_node_id_from_new_node_id_map[orig_id]] = true;
+                          }
+                      });
+              }
+              else
+              {
+                  tbb::parallel_for(
+                      tbb::blocked_range<int>(0, remaining_nodes.size(), InitGrainSize),
+                      [this, &remaining_nodes](const tbb::blocked_range<int> &range)
+                      {
+                          for (int x = range.begin(), end = range.end(); x != end; ++x)
+                          {
+                              const auto orig_id = remaining_nodes[x].id;
+                              is_core_node[orig_id] = true;
+                          }
+                      });
+              }
+        }
+        else
+        {
+            // in this case we don't need core markers since we fully contracted
+            // the graph
+            is_core_node.clear();
+        }
+
+        SimpleLogger().Write() << "[core] " << remaining_nodes.size() << " nodes "
+                               << contractor_graph->GetNumberOfEdges() << " edges." << std::endl;
+
        thread_data_list.data.clear();
    }

+    inline void GetCoreMarker(std::vector<bool> &out_is_core_node)
+    {
+        out_is_core_node.swap(is_core_node);
+    }
+
+    inline void GetNodeLevels(std::vector<float> &out_node_levels)
+    {
+        out_node_levels.swap(node_levels);
+    }
+
    template <class Edge> inline void GetEdges(DeallocatingVector<Edge> &edges)
    {
        Percent p(contractor_graph->GetNumberOfNodes());
@@ -564,10 +681,10 @@ class Contractor
                {
                    const NodeID target = contractor_graph->GetTarget(edge);
                    const ContractorGraph::EdgeData &data = contractor_graph->GetEdgeData(edge);
-                    if (!orig_node_id_to_new_id_map.empty())
+                    if (!orig_node_id_from_new_node_id_map.empty())
                    {
-                        new_edge.source = orig_node_id_to_new_id_map[node];
-                        new_edge.target = orig_node_id_to_new_id_map[target];
+                        new_edge.source = orig_node_id_from_new_node_id_map[node];
+                        new_edge.target = orig_node_id_from_new_node_id_map[target];
                    }
                    else
                    {
@@ -578,9 +695,10 @@ class Contractor
                    BOOST_ASSERT_MSG(UINT_MAX != new_edge.target, "Target id invalid");
                    new_edge.data.distance = data.distance;
                    new_edge.data.shortcut = data.shortcut;
-                    if (!data.is_original_via_node_ID && !orig_node_id_to_new_id_map.empty())
+                    if (!data.is_original_via_node_ID && !orig_node_id_from_new_node_id_map.empty())
                    {
-                        new_edge.data.id = orig_node_id_to_new_id_map[data.id];
+                        // tranlate the _node id_ of the shortcutted node
+                        new_edge.data.id = orig_node_id_from_new_node_id_map[data.id];
                    }
                    else
                    {
@@ -595,10 +713,10 @@ class Contractor
            }
        }
        contractor_graph.reset();
-        orig_node_id_to_new_id_map.clear();
-        orig_node_id_to_new_id_map.shrink_to_fit();
+        orig_node_id_from_new_node_id_map.clear();
+        orig_node_id_from_new_node_id_map.shrink_to_fit();

-        BOOST_ASSERT(0 == orig_node_id_to_new_id_map.capacity());
+        BOOST_ASSERT(0 == orig_node_id_from_new_node_id_map.capacity());

        edges.append(external_edge_list.begin(), external_edge_list.end());
        external_edge_list.clear();
@@ -956,7 +1074,9 @@ class Contractor

    std::shared_ptr<ContractorGraph> contractor_graph;
    stxxl::vector<QueryEdge> external_edge_list;
-    std::vector<NodeID> orig_node_id_to_new_id_map;
+    std::vector<NodeID> orig_node_id_from_new_node_id_map;
+    std::vector<float> node_levels;
+    std::vector<bool> is_core_node;
    XORFastHash fast_hash;
 };

@@ -27,7 +27,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 #include "contractor_options.hpp"

-#include "../util/git_sha.hpp"
+#include "util/version.hpp"
 #include "../util/simple_logger.hpp"

 #include <boost/filesystem.hpp>
@@ -48,15 +48,27 @@ ContractorOptions::ParseArguments(int argc, char *argv[], ContractorConfig &cont
    // declare a group of options that will be allowed both on command line and in config file
    boost::program_options::options_description config_options("Configuration");
    config_options.add_options()(
-        "restrictions,r",
-        boost::program_options::value<boost::filesystem::path>(&contractor_config.restrictions_path),
-        "Restrictions file in .osrm.restrictions format")(
-        "profile,p", boost::program_options::value<boost::filesystem::path>(&contractor_config.profile_path)
-                         ->default_value("profile.lua"),
+        "profile,p",
+        boost::program_options::value<boost::filesystem::path>(&contractor_config.profile_path)
+            ->default_value("profile.lua"),
        "Path to LUA routing profile")(
-        "threads,t", boost::program_options::value<unsigned int>(&contractor_config.requested_num_threads)
-                         ->default_value(tbb::task_scheduler_init::default_num_threads()),
-        "Number of threads to use");
+        "threads,t",
+        boost::program_options::value<unsigned int>(&contractor_config.requested_num_threads)
+            ->default_value(tbb::task_scheduler_init::default_num_threads()),
+        "Number of threads to use")(
+		"core,k", boost::program_options::value<double>(&contractor_config.core_factor)
+						 ->default_value(1.0),"Percentage of the graph (in vertices) to contract [0..1]")(
+		"segment-speed-file", boost::program_options::value<std::string>(&contractor_config.segment_speed_lookup_path),
+						 "Lookup file containing nodeA,nodeB,speed data to adjust edge weights")(
+        "level-cache,o",
+        boost::program_options::value<bool>(&contractor_config.use_cached_priority)->default_value(false),
+        "Use .level file to retain the contaction level for each node from the last run.");
+
+#ifdef DEBUG_GEOMETRY
+    config_options.add_options()(
+		"debug-geometry", boost::program_options::value<std::string>(&contractor_config.debug_geometry_path)
+						 ,"Write out edge-weight debugging geometry data in GeoJSON format to this file");
+#endif

    // hidden options, will be allowed both on command line and in config file, but will not be
    // shown to the user
@@ -98,7 +110,7 @@ ContractorOptions::ParseArguments(int argc, char *argv[], ContractorConfig &cont

    if (option_variables.count("version"))
    {
-        SimpleLogger().Write() << g_GIT_DESCRIPTION;
+        SimpleLogger().Write() << OSRM_VERSION;
        return return_code::exit;
    }

@@ -110,11 +122,6 @@ ContractorOptions::ParseArguments(int argc, char *argv[], ContractorConfig &cont

    boost::program_options::notify(option_variables);

-    if (!option_variables.count("restrictions"))
-    {
-        contractor_config.restrictions_path = contractor_config.osrm_input_path.string() + ".restrictions";
-    }
-
    if (!option_variables.count("input"))
    {
        SimpleLogger().Write() << "\n" << visible_options;
@@ -126,10 +133,10 @@ ContractorOptions::ParseArguments(int argc, char *argv[], ContractorConfig &cont

 void ContractorOptions::GenerateOutputFilesNames(ContractorConfig &contractor_config)
 {
-    contractor_config.node_output_path = contractor_config.osrm_input_path.string() + ".nodes";
-    contractor_config.edge_output_path = contractor_config.osrm_input_path.string() + ".edges";
-    contractor_config.geometry_output_path = contractor_config.osrm_input_path.string() + ".geometry";
+    contractor_config.level_output_path = contractor_config.osrm_input_path.string() + ".level";
+    contractor_config.core_output_path = contractor_config.osrm_input_path.string() + ".core";
    contractor_config.graph_output_path = contractor_config.osrm_input_path.string() + ".hsgr";
-    contractor_config.rtree_nodes_output_path = contractor_config.osrm_input_path.string() + ".ramIndex";
-    contractor_config.rtree_leafs_output_path = contractor_config.osrm_input_path.string() + ".fileIndex";
+    contractor_config.edge_based_graph_path = contractor_config.osrm_input_path.string() + ".ebg";
+    contractor_config.edge_segment_lookup_path = contractor_config.osrm_input_path.string() + ".edge_segment_lookup";
+    contractor_config.edge_penalty_path = contractor_config.osrm_input_path.string() + ".edge_penalties";
 }
@@ -45,17 +45,30 @@ struct ContractorConfig

    boost::filesystem::path config_file_path;
    boost::filesystem::path osrm_input_path;
-    boost::filesystem::path restrictions_path;
    boost::filesystem::path profile_path;

-    std::string node_output_path;
-    std::string edge_output_path;
-    std::string geometry_output_path;
+    std::string level_output_path;
+    std::string core_output_path;
    std::string graph_output_path;
-    std::string rtree_nodes_output_path;
-    std::string rtree_leafs_output_path;
+    std::string edge_based_graph_path;
+
+    std::string edge_segment_lookup_path;
+    std::string edge_penalty_path;
+    bool use_cached_priority;

    unsigned requested_num_threads;
+
+    //A percentage of vertices that will be contracted for the hierarchy.
+    //Offers a trade-off between preprocessing and query time.
+    //The remaining vertices form the core of the hierarchy 
+    //(e.g. 0.8 contracts 80 percent of the hierarchy, leaving a core of 20%)
+    double core_factor;
+
+    std::string segment_speed_lookup_path;
+
+#ifdef DEBUG_GEOMETRY
+    std::string debug_geometry_path;
+#endif
 };

 struct ContractorOptions
@@ -26,25 +26,24 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

 #include "processing_chain.hpp"
+#include "contractor.hpp"

 #include "contractor.hpp"

-#include "../algorithms/crc32_processor.hpp"
 #include "../data_structures/deallocating_vector.hpp"
-#include "../data_structures/static_rtree.hpp"
-#include "../data_structures/restriction_map.hpp"

-#include "../util/git_sha.hpp"
+#include "../algorithms/crc32_processor.hpp"
 #include "../util/graph_loader.hpp"
 #include "../util/integer_range.hpp"
 #include "../util/lua_util.hpp"
-#include "../util/make_unique.hpp"
 #include "../util/osrm_exception.hpp"
 #include "../util/simple_logger.hpp"
 #include "../util/string_util.hpp"
 #include "../util/timing_util.hpp"
 #include "../typedefs.h"

+#include <fast-cpp-csv-parser/csv.h>
+
 #include <boost/filesystem/fstream.hpp>
 #include <boost/program_options.hpp>

@@ -56,6 +55,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <thread>
 #include <vector>

+#include "../util/debug_geometry.hpp"
+
 Prepare::~Prepare() {}

 int Prepare::Run()
@@ -69,58 +70,50 @@ int Prepare::Run()
                  "changing EdgeBasedEdge type has influence on memory consumption!");
 #endif

+    if (config.core_factor > 1.0 || config.core_factor < 0) 
+    {
+       throw osrm::exception("Core factor must be between 0.0 to 1.0 (inclusive)");
+    }
+
    TIMER_START(preparing);

    // Create a new lua state

-    SimpleLogger().Write() << "Generating edge-expanded graph representation";
+    SimpleLogger().Write() << "Loading edge-expanded graph representation";

-    TIMER_START(expansion);
-
-    auto node_based_edge_list = osrm::make_unique<std::vector<EdgeBasedNode>>();;
    DeallocatingVector<EdgeBasedEdge> edge_based_edge_list;
-    auto internal_to_external_node_map = osrm::make_unique<std::vector<QueryNode>>();
-    auto graph_size =
-        BuildEdgeExpandedGraph(*internal_to_external_node_map,
-                               *node_based_edge_list, edge_based_edge_list);

-    auto number_of_node_based_nodes = graph_size.first;
-    auto number_of_edge_based_nodes = graph_size.second;
-
-    TIMER_STOP(expansion);
-
-    SimpleLogger().Write() << "building r-tree ...";
-    TIMER_START(rtree);
-
-    BuildRTree(*node_based_edge_list, *internal_to_external_node_map);
-
-    TIMER_STOP(rtree);
-
-    SimpleLogger().Write() << "writing node map ...";
-    WriteNodeMapping(std::move(internal_to_external_node_map));
+    size_t max_edge_id = LoadEdgeExpandedGraph(
+        config.edge_based_graph_path, edge_based_edge_list, config.edge_segment_lookup_path,
+        config.edge_penalty_path, config.segment_speed_lookup_path);

    // Contracting the edge-expanded graph

    TIMER_START(contraction);
-    auto contracted_edge_list = osrm::make_unique<DeallocatingVector<QueryEdge>>();
-    ContractGraph(number_of_edge_based_nodes, edge_based_edge_list, *contracted_edge_list);
+    std::vector<bool> is_core_node;
+    std::vector<float> node_levels;
+    if (config.use_cached_priority)
+    {
+        ReadNodeLevels(node_levels);
+    }
+    DeallocatingVector<QueryEdge> contracted_edge_list;
+    ContractGraph(max_edge_id, edge_based_edge_list, contracted_edge_list, is_core_node,
+                  node_levels);
    TIMER_STOP(contraction);

    SimpleLogger().Write() << "Contraction took " << TIMER_SEC(contraction) << " sec";

-    std::size_t number_of_used_edges = WriteContractedGraph(number_of_edge_based_nodes,
-                                                            std::move(node_based_edge_list),
-                                                            std::move(contracted_edge_list));
+    std::size_t number_of_used_edges = WriteContractedGraph(max_edge_id, contracted_edge_list);
+    WriteCoreNodeMarker(std::move(is_core_node));
+    if (!config.use_cached_priority)
+    {
+        WriteNodeLevels(std::move(node_levels));
+    }

    TIMER_STOP(preparing);

    SimpleLogger().Write() << "Preprocessing : " << TIMER_SEC(preparing) << " seconds";
-    SimpleLogger().Write() << "Expansion  : " << (number_of_node_based_nodes / TIMER_SEC(expansion))
-                           << " nodes/sec and "
-                           << (number_of_edge_based_nodes / TIMER_SEC(expansion)) << " edges/sec";
-
-    SimpleLogger().Write() << "Contraction: "
-                           << (number_of_edge_based_nodes / TIMER_SEC(contraction))
+    SimpleLogger().Write() << "Contraction: " << ((max_edge_id + 1) / TIMER_SEC(contraction))
                           << " nodes/sec and " << number_of_used_edges / TIMER_SEC(contraction)
                           << " edges/sec";

@@ -129,25 +122,208 @@ int Prepare::Run()
    return 0;
 }

-std::size_t Prepare::WriteContractedGraph(unsigned number_of_edge_based_nodes,
-                                          std::unique_ptr<std::vector<EdgeBasedNode>> node_based_edge_list,
-                                          std::unique_ptr<DeallocatingVector<QueryEdge>> contracted_edge_list)
+namespace std
 {
-    const unsigned crc32_value = CalculateEdgeChecksum(std::move(node_based_edge_list));

+template <> struct hash<std::pair<OSMNodeID, OSMNodeID>>
+{
+    std::size_t operator()(const std::pair<OSMNodeID, OSMNodeID> &k) const
+    {
+        return OSMNodeID_to_uint64_t(k.first) ^ (OSMNodeID_to_uint64_t(k.second) << 12);
+    }
+};
+}
+
+std::size_t Prepare::LoadEdgeExpandedGraph(std::string const &edge_based_graph_filename,
+                                           DeallocatingVector<EdgeBasedEdge> &edge_based_edge_list,
+                                           const std::string &edge_segment_lookup_filename,
+                                           const std::string &edge_penalty_filename,
+                                           const std::string &segment_speed_filename)
+{
+    SimpleLogger().Write() << "Opening " << edge_based_graph_filename;
+    boost::filesystem::ifstream input_stream(edge_based_graph_filename, std::ios::binary);
+
+    const bool update_edge_weights = segment_speed_filename != "";
+
+    boost::filesystem::ifstream edge_segment_input_stream;
+    boost::filesystem::ifstream edge_fixed_penalties_input_stream;
+
+    if (update_edge_weights)
+    {
+        edge_segment_input_stream.open(edge_segment_lookup_filename, std::ios::binary);
+        edge_fixed_penalties_input_stream.open(edge_penalty_filename, std::ios::binary);
+        if (!edge_segment_input_stream || !edge_fixed_penalties_input_stream)
+        {
+            throw osrm::exception("Could not load .edge_segment_lookup or .edge_penalties, did you "
+                                  "run osrm-extract with '--generate-edge-lookup'?");
+        }
+    }
+
+    const FingerPrint fingerprint_valid = FingerPrint::GetValid();
+    FingerPrint fingerprint_loaded;
+    input_stream.read((char *)&fingerprint_loaded, sizeof(FingerPrint));
+    fingerprint_loaded.TestPrepare(fingerprint_valid);
+
+    size_t number_of_edges = 0;
+    size_t max_edge_id = SPECIAL_EDGEID;
+    input_stream.read((char *)&number_of_edges, sizeof(size_t));
+    input_stream.read((char *)&max_edge_id, sizeof(size_t));
+
+    edge_based_edge_list.resize(number_of_edges);
+    SimpleLogger().Write() << "Reading " << number_of_edges << " edges from the edge based graph";
+
+    std::unordered_map<std::pair<OSMNodeID, OSMNodeID>, unsigned> segment_speed_lookup;
+
+    if (update_edge_weights)
+    {
+        SimpleLogger().Write() << "Segment speed data supplied, will update edge weights from "
+                               << segment_speed_filename;
+        io::CSVReader<3> csv_in(segment_speed_filename);
+        csv_in.set_header("from_node", "to_node", "speed");
+        uint64_t from_node_id;
+        uint64_t to_node_id;
+        unsigned speed;
+        while (csv_in.read_row(from_node_id, to_node_id, speed))
+        {
+            segment_speed_lookup[std::make_pair(OSMNodeID(from_node_id), OSMNodeID(to_node_id))] = speed;
+        }
+    }
+
+    DEBUG_GEOMETRY_START(config);
+
+    // TODO: can we read this in bulk?  DeallocatingVector isn't necessarily
+    // all stored contiguously
+    for (; number_of_edges > 0; --number_of_edges)
+    {
+        EdgeBasedEdge inbuffer;
+        input_stream.read((char *) &inbuffer, sizeof(EdgeBasedEdge));
+
+        if (update_edge_weights)
+        {
+            // Processing-time edge updates
+            unsigned fixed_penalty;
+            edge_fixed_penalties_input_stream.read(reinterpret_cast<char *>(&fixed_penalty),
+                                                   sizeof(fixed_penalty));
+
+            int new_weight = 0;
+
+            unsigned num_osm_nodes = 0;
+            edge_segment_input_stream.read(reinterpret_cast<char *>(&num_osm_nodes),
+                                           sizeof(num_osm_nodes));
+            OSMNodeID previous_osm_node_id;
+            edge_segment_input_stream.read(reinterpret_cast<char *>(&previous_osm_node_id),
+                                           sizeof(previous_osm_node_id));
+            OSMNodeID this_osm_node_id;
+            double segment_length;
+            int segment_weight;
+            --num_osm_nodes;
+            for (; num_osm_nodes != 0; --num_osm_nodes)
+            {
+                edge_segment_input_stream.read(reinterpret_cast<char *>(&this_osm_node_id),
+                                               sizeof(this_osm_node_id));
+                edge_segment_input_stream.read(reinterpret_cast<char *>(&segment_length),
+                                               sizeof(segment_length));
+                edge_segment_input_stream.read(reinterpret_cast<char *>(&segment_weight),
+                                               sizeof(segment_weight));
+
+                auto speed_iter = segment_speed_lookup.find(
+                    std::make_pair(previous_osm_node_id, this_osm_node_id));
+                if (speed_iter != segment_speed_lookup.end())
+                {
+                    // This sets the segment weight using the same formula as the
+                    // EdgeBasedGraphFactory for consistency.  The *why* of this formula
+                    // is lost in the annals of time.
+                    int new_segment_weight =
+                        std::max(1, static_cast<int>(std::floor(
+                                        (segment_length * 10.) / (speed_iter->second / 3.6) + .5)));
+                    new_weight += new_segment_weight;
+
+                    DEBUG_GEOMETRY_EDGE( 
+                            new_segment_weight, 
+                            segment_length,
+                            previous_osm_node_id,
+                            this_osm_node_id);
+                }
+                else
+                {
+                    // If no lookup found, use the original weight value for this segment
+                    new_weight += segment_weight;
+
+                    DEBUG_GEOMETRY_EDGE(
+                            segment_weight,
+                            segment_length,
+                            previous_osm_node_id,
+                            this_osm_node_id);
+                }
+
+                previous_osm_node_id = this_osm_node_id;
+            }
+
+            inbuffer.weight = fixed_penalty + new_weight;
+        }
+
+        edge_based_edge_list.emplace_back(std::move(inbuffer));
+    }
+
+    DEBUG_GEOMETRY_STOP();
+    SimpleLogger().Write() << "Done reading edges";
+    return max_edge_id;
+}
+
+void Prepare::ReadNodeLevels(std::vector<float> &node_levels) const
+{
+    boost::filesystem::ifstream order_input_stream(config.level_output_path, std::ios::binary);
+
+    unsigned level_size;
+    order_input_stream.read((char *)&level_size, sizeof(unsigned));
+    node_levels.resize(level_size);
+    order_input_stream.read((char *)node_levels.data(), sizeof(float) * node_levels.size());
+}
+
+void Prepare::WriteNodeLevels(std::vector<float> &&in_node_levels) const
+{
+    std::vector<float> node_levels(std::move(in_node_levels));
+
+    boost::filesystem::ofstream order_output_stream(config.level_output_path, std::ios::binary);
+
+    unsigned level_size = node_levels.size();
+    order_output_stream.write((char *)&level_size, sizeof(unsigned));
+    order_output_stream.write((char *)node_levels.data(), sizeof(float) * node_levels.size());
+}
+
+void Prepare::WriteCoreNodeMarker(std::vector<bool> &&in_is_core_node) const
+{
+    std::vector<bool> is_core_node(std::move(in_is_core_node));
+    std::vector<char> unpacked_bool_flags(std::move(is_core_node.size()));
+    for (auto i = 0u; i < is_core_node.size(); ++i)
+    {
+        unpacked_bool_flags[i] = is_core_node[i] ? 1 : 0;
+    }
+
+    boost::filesystem::ofstream core_marker_output_stream(config.core_output_path,
+                                                          std::ios::binary);
+    unsigned size = unpacked_bool_flags.size();
+    core_marker_output_stream.write((char *)&size, sizeof(unsigned));
+    core_marker_output_stream.write((char *)unpacked_bool_flags.data(),
+                                    sizeof(char) * unpacked_bool_flags.size());
+}
+
+std::size_t Prepare::WriteContractedGraph(unsigned max_node_id,
+                                          const DeallocatingVector<QueryEdge> &contracted_edge_list)
+{
    // Sorting contracted edges in a way that the static query graph can read some in in-place.
-    tbb::parallel_sort(contracted_edge_list->begin(), contracted_edge_list->end());
-    const unsigned contracted_edge_count = contracted_edge_list->size();
+    tbb::parallel_sort(contracted_edge_list.begin(), contracted_edge_list.end());
+    const unsigned contracted_edge_count = contracted_edge_list.size();
    SimpleLogger().Write() << "Serializing compacted graph of " << contracted_edge_count
                           << " edges";

    const FingerPrint fingerprint = FingerPrint::GetValid();
    boost::filesystem::ofstream hsgr_output_stream(config.graph_output_path, std::ios::binary);
    hsgr_output_stream.write((char *)&fingerprint, sizeof(FingerPrint));
-    const unsigned max_used_node_id = 1 + [&contracted_edge_list]
+    const unsigned max_used_node_id = [&contracted_edge_list]
    {
        unsigned tmp_max = 0;
-        for (const QueryEdge &edge : *contracted_edge_list)
+        for (const QueryEdge &edge : contracted_edge_list)
        {
            BOOST_ASSERT(SPECIAL_NODEID != edge.source);
            BOOST_ASSERT(SPECIAL_NODEID != edge.target);
@@ -157,22 +333,23 @@ std::size_t Prepare::WriteContractedGraph(unsigned number_of_edge_based_nodes,
        return tmp_max;
    }();

-    SimpleLogger().Write(logDEBUG) << "input graph has " << number_of_edge_based_nodes << " nodes";
-    SimpleLogger().Write(logDEBUG) << "contracted graph has " << max_used_node_id << " nodes";
+    SimpleLogger().Write(logDEBUG) << "input graph has " << (max_node_id + 1) << " nodes";
+    SimpleLogger().Write(logDEBUG) << "contracted graph has " << (max_used_node_id + 1) << " nodes";

    std::vector<StaticGraph<EdgeData>::NodeArrayEntry> node_array;
-    node_array.resize(number_of_edge_based_nodes + 1);
+    // make sure we have at least one sentinel
+    node_array.resize(max_node_id + 2);

    SimpleLogger().Write() << "Building node array";
    StaticGraph<EdgeData>::EdgeIterator edge = 0;
    StaticGraph<EdgeData>::EdgeIterator position = 0;
-    StaticGraph<EdgeData>::EdgeIterator last_edge = edge;
+    StaticGraph<EdgeData>::EdgeIterator last_edge;

    // initializing 'first_edge'-field of nodes:
-    for (const auto node : osrm::irange(0u, max_used_node_id))
+    for (const auto node : osrm::irange(0u, max_used_node_id + 1))
    {
        last_edge = edge;
-        while ((edge < contracted_edge_count) && ((*contracted_edge_list)[edge].source == node))
+        while ((edge < contracted_edge_count) && (contracted_edge_list[edge].source == node))
        {
            ++edge;
        }
@@ -180,7 +357,8 @@ std::size_t Prepare::WriteContractedGraph(unsigned number_of_edge_based_nodes,
        position += edge - last_edge;           // remove
    }

-    for (const auto sentinel_counter : osrm::irange<unsigned>(max_used_node_id, node_array.size()))
+    for (const auto sentinel_counter :
+         osrm::irange<unsigned>(max_used_node_id + 1, node_array.size()))
    {
        // sentinel element, guarded against underflow
        node_array[sentinel_counter].first_edge = contracted_edge_count;
@@ -188,9 +366,13 @@ std::size_t Prepare::WriteContractedGraph(unsigned number_of_edge_based_nodes,

    SimpleLogger().Write() << "Serializing node array";

+    RangebasedCRC32 crc32_calculator;
+    const unsigned edges_crc32 = crc32_calculator(contracted_edge_list);
+    SimpleLogger().Write() << "Writing CRC32: " << edges_crc32;
+
    const unsigned node_array_size = node_array.size();
    // serialize crc32, aka checksum
-    hsgr_output_stream.write((char *)&crc32_value, sizeof(unsigned));
+    hsgr_output_stream.write((char *)&edges_crc32, sizeof(unsigned));
    // serialize number of nodes
    hsgr_output_stream.write((char *)&node_array_size, sizeof(unsigned));
    // serialize number of edges
@@ -204,29 +386,28 @@ std::size_t Prepare::WriteContractedGraph(unsigned number_of_edge_based_nodes,

    // serialize all edges
    SimpleLogger().Write() << "Building edge array";
-    edge = 0;
    int number_of_used_edges = 0;

    StaticGraph<EdgeData>::EdgeArrayEntry current_edge;
-    for (const auto edge : osrm::irange<std::size_t>(0, contracted_edge_list->size()))
+    for (const auto edge : osrm::irange<std::size_t>(0, contracted_edge_list.size()))
    {
        // no eigen loops
-        BOOST_ASSERT((*contracted_edge_list)[edge].source != (*contracted_edge_list)[edge].target);
-        current_edge.target = (*contracted_edge_list)[edge].target;
-        current_edge.data = (*contracted_edge_list)[edge].data;
+        BOOST_ASSERT(contracted_edge_list[edge].source != contracted_edge_list[edge].target);
+        current_edge.target = contracted_edge_list[edge].target;
+        current_edge.data = contracted_edge_list[edge].data;

        // every target needs to be valid
-        BOOST_ASSERT(current_edge.target < max_used_node_id);
+        BOOST_ASSERT(current_edge.target <= max_used_node_id);
 #ifndef NDEBUG
        if (current_edge.data.distance <= 0)
        {
            SimpleLogger().Write(logWARNING) << "Edge: " << edge
-                                             << ",source: " << (*contracted_edge_list)[edge].source
-                                             << ", target: " << (*contracted_edge_list)[edge].target
+                                             << ",source: " << contracted_edge_list[edge].source
+                                             << ", target: " << contracted_edge_list[edge].target
                                             << ", dist: " << current_edge.data.distance;

            SimpleLogger().Write(logWARNING) << "Failed at adjacency list of node "
-                                             << (*contracted_edge_list)[edge].source << "/"
+                                             << contracted_edge_list[edge].source << "/"
                                             << node_array.size() - 1;
            return 1;
        }
@@ -240,191 +421,21 @@ std::size_t Prepare::WriteContractedGraph(unsigned number_of_edge_based_nodes,
    return number_of_used_edges;
 }

-unsigned Prepare::CalculateEdgeChecksum(std::unique_ptr<std::vector<EdgeBasedNode>> node_based_edge_list)
-{
-    RangebasedCRC32 crc32;
-    if (crc32.using_hardware())
-    {
-        SimpleLogger().Write() << "using hardware based CRC32 computation";
-    }
-    else
-    {
-        SimpleLogger().Write() << "using software based CRC32 computation";
-    }
-
-    const unsigned crc32_value = crc32(*node_based_edge_list);
-    SimpleLogger().Write() << "CRC32: " << crc32_value;
-
-    return crc32_value;
-}
-
-/**
-    \brief Setups scripting environment (lua-scripting)
-    Also initializes speed profile.
-*/
-void Prepare::SetupScriptingEnvironment(
-    lua_State *lua_state, EdgeBasedGraphFactory::SpeedProfileProperties &speed_profile)
-{
-    // open utility libraries string library;
-    luaL_openlibs(lua_state);
-
-    // adjust lua load path
-    luaAddScriptFolderToLoadPath(lua_state, config.profile_path.string().c_str());
-
-    // Now call our function in a lua script
-    if (0 != luaL_dofile(lua_state, config.profile_path.string().c_str()))
-    {
-        std::stringstream msg;
-        msg << lua_tostring(lua_state, -1) << " occured in scripting block";
-        throw osrm::exception(msg.str());
-    }
-
-    if (0 != luaL_dostring(lua_state, "return traffic_signal_penalty\n"))
-    {
-        std::stringstream msg;
-        msg << lua_tostring(lua_state, -1) << " occured in scripting block";
-        throw osrm::exception(msg.str());
-    }
-    speed_profile.traffic_signal_penalty = 10 * lua_tointeger(lua_state, -1);
-    SimpleLogger().Write(logDEBUG)
-        << "traffic_signal_penalty: " << speed_profile.traffic_signal_penalty;
-
-    if (0 != luaL_dostring(lua_state, "return u_turn_penalty\n"))
-    {
-        std::stringstream msg;
-        msg << lua_tostring(lua_state, -1) << " occured in scripting block";
-        throw osrm::exception(msg.str());
-    }
-
-    speed_profile.u_turn_penalty = 10 * lua_tointeger(lua_state, -1);
-    speed_profile.has_turn_penalty_function = lua_function_exists(lua_state, "turn_function");
-}
-
-/**
-  \brief Build load restrictions from .restriction file
-  */
-std::shared_ptr<RestrictionMap> Prepare::LoadRestrictionMap()
-{
-    boost::filesystem::ifstream input_stream(config.restrictions_path, std::ios::in | std::ios::binary);
-
-    std::vector<TurnRestriction> restriction_list;
-    loadRestrictionsFromFile(input_stream, restriction_list);
-
-    SimpleLogger().Write() << " - " << restriction_list.size() << " restrictions.";
-
-    return std::make_shared<RestrictionMap>(restriction_list);
-}
-
-/**
-  \brief Load node based graph from .osrm file
-  */
-std::shared_ptr<NodeBasedDynamicGraph>
-Prepare::LoadNodeBasedGraph(std::vector<NodeID> &barrier_node_list,
-                            std::vector<NodeID> &traffic_light_list,
-                            std::vector<QueryNode>& internal_to_external_node_map)
-{
-    std::vector<NodeBasedEdge> edge_list;
-
-    boost::filesystem::ifstream input_stream(config.osrm_input_path, std::ios::in | std::ios::binary);
-
-    NodeID number_of_node_based_nodes = loadNodesFromFile(input_stream,
-                                            barrier_node_list, traffic_light_list,
-                                            internal_to_external_node_map);
-
-    SimpleLogger().Write() << " - " << barrier_node_list.size() << " bollard nodes, "
-                           << traffic_light_list.size() << " traffic lights";
-
-    loadEdgesFromFile(input_stream, edge_list);
-
-    if (edge_list.empty())
-    {
-        SimpleLogger().Write(logWARNING) << "The input data is empty, exiting.";
-        return std::shared_ptr<NodeBasedDynamicGraph>();
-    }
-
-    return NodeBasedDynamicGraphFromImportEdges(number_of_node_based_nodes, edge_list);
-}
-
-
-/**
- \brief Building an edge-expanded graph from node-based input and turn restrictions
-*/
-std::pair<std::size_t, std::size_t>
-Prepare::BuildEdgeExpandedGraph(std::vector<QueryNode> &internal_to_external_node_map,
-                                std::vector<EdgeBasedNode> &node_based_edge_list,
-                                DeallocatingVector<EdgeBasedEdge> &edge_based_edge_list)
-{
-    lua_State *lua_state = luaL_newstate();
-    luabind::open(lua_state);
-
-    EdgeBasedGraphFactory::SpeedProfileProperties speed_profile;
-
-    SetupScriptingEnvironment(lua_state, speed_profile);
-
-    auto barrier_node_list = osrm::make_unique<std::vector<NodeID>>();
-    auto traffic_light_list = osrm::make_unique<std::vector<NodeID>>();
-
-    auto restriction_map = LoadRestrictionMap();
-    auto node_based_graph = LoadNodeBasedGraph(*barrier_node_list, *traffic_light_list, internal_to_external_node_map);
-
-    const std::size_t number_of_node_based_nodes = node_based_graph->GetNumberOfNodes();
-
-    EdgeBasedGraphFactory edge_based_graph_factory(node_based_graph,
-                                                   restriction_map,
-                                                   std::move(barrier_node_list),
-                                                   std::move(traffic_light_list),
-                                                   internal_to_external_node_map,
-                                                   speed_profile);
-
-    edge_based_graph_factory.Run(config.edge_output_path, config.geometry_output_path, lua_state);
-    lua_close(lua_state);
-
-    const std::size_t number_of_edge_based_nodes =
-        edge_based_graph_factory.GetNumberOfEdgeBasedNodes();
-
-    BOOST_ASSERT(number_of_edge_based_nodes != std::numeric_limits<unsigned>::max());
-
-    edge_based_graph_factory.GetEdgeBasedEdges(edge_based_edge_list);
-    edge_based_graph_factory.GetEdgeBasedNodes(node_based_edge_list);
-
-    return std::make_pair(number_of_node_based_nodes, number_of_edge_based_nodes);
-}
-
 /**
 \brief Build contracted graph.
 */
-void Prepare::ContractGraph(const std::size_t number_of_edge_based_nodes,
-                            DeallocatingVector<EdgeBasedEdge>& edge_based_edge_list,
-                            DeallocatingVector<QueryEdge>& contracted_edge_list)
+void Prepare::ContractGraph(const unsigned max_edge_id,
+                            DeallocatingVector<EdgeBasedEdge> &edge_based_edge_list,
+                            DeallocatingVector<QueryEdge> &contracted_edge_list,
+                            std::vector<bool> &is_core_node,
+                            std::vector<float> &inout_node_levels) const
 {
-    Contractor contractor(number_of_edge_based_nodes, edge_based_edge_list);
-    contractor.Run();
+    std::vector<float> node_levels;
+    node_levels.swap(inout_node_levels);
+
+    Contractor contractor(max_edge_id + 1, edge_based_edge_list, std::move(node_levels));
+    contractor.Run(config.core_factor);
    contractor.GetEdges(contracted_edge_list);
-}
-
-/**
-  \brief Writing info on original (node-based) nodes
- */
-void Prepare::WriteNodeMapping(std::unique_ptr<std::vector<QueryNode>> internal_to_external_node_map)
-{
-    boost::filesystem::ofstream node_stream(config.node_output_path, std::ios::binary);
-    const unsigned size_of_mapping = internal_to_external_node_map->size();
-    node_stream.write((char *)&size_of_mapping, sizeof(unsigned));
-    if (size_of_mapping > 0)
-    {
-        node_stream.write((char *) internal_to_external_node_map->data(),
-                          size_of_mapping * sizeof(QueryNode));
-    }
-    node_stream.close();
-}
-
-/**
-    \brief Building rtree-based nearest-neighbor data structure
-
-    Saves tree into '.ramIndex' and leaves into '.fileIndex'.
- */
-void Prepare::BuildRTree(const std::vector<EdgeBasedNode> &node_based_edge_list, const std::vector<QueryNode>& internal_to_external_node_map)
-{
-    StaticRTree<EdgeBasedNode>(node_based_edge_list, config.rtree_nodes_output_path.c_str(),
-                               config.rtree_leafs_output_path.c_str(), internal_to_external_node_map);
+    contractor.GetCoreMarker(is_core_node);
+    contractor.GetNodeLevels(inout_node_levels);
 }
@@ -28,11 +28,14 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef PROCESSING_CHAIN_HPP
 #define PROCESSING_CHAIN_HPP

+#include "contractor.hpp"
 #include "contractor_options.hpp"
-#include "edge_based_graph_factory.hpp"
 #include "../data_structures/query_edge.hpp"
 #include "../data_structures/static_graph.hpp"
+#include "../data_structures/deallocating_vector.hpp"
+#include "../data_structures/node_based_graph.hpp"

+struct SpeedProfileProperties;
 struct EdgeBasedNode;
 struct lua_State;

@@ -47,39 +50,35 @@ class Prepare
 {
  public:
    using EdgeData = QueryEdge::EdgeData;
-    using InputEdge = DynamicGraph<EdgeData>::InputEdge;
-    using StaticEdge = StaticGraph<EdgeData>::InputEdge;

-    explicit Prepare(const ContractorConfig& contractor_config)
-        : config(contractor_config) {}
+    explicit Prepare(ContractorConfig contractor_config) : config(std::move(contractor_config)) {}
    Prepare(const Prepare &) = delete;
    ~Prepare();

    int Run();

  protected:
-    void SetupScriptingEnvironment(lua_State *myLuaState,
-                                   EdgeBasedGraphFactory::SpeedProfileProperties &speed_profile);
-    std::shared_ptr<RestrictionMap> LoadRestrictionMap();
-    unsigned CalculateEdgeChecksum(std::unique_ptr<std::vector<EdgeBasedNode>> node_based_edge_list);
-    void ContractGraph(const std::size_t number_of_edge_based_nodes,
-                       DeallocatingVector<EdgeBasedEdge>& edge_based_edge_list,
-                       DeallocatingVector<QueryEdge>& contracted_edge_list);
+    void ContractGraph(const unsigned max_edge_id,
+                       DeallocatingVector<EdgeBasedEdge> &edge_based_edge_list,
+                       DeallocatingVector<QueryEdge> &contracted_edge_list,
+                       std::vector<bool> &is_core_node,
+                       std::vector<float> &node_levels) const;
+    void WriteCoreNodeMarker(std::vector<bool> &&is_core_node) const;
+    void WriteNodeLevels(std::vector<float> &&node_levels) const;
+    void ReadNodeLevels(std::vector<float> &contraction_order) const;
    std::size_t WriteContractedGraph(unsigned number_of_edge_based_nodes,
-                                     std::unique_ptr<std::vector<EdgeBasedNode>> node_based_edge_list,
-                                     std::unique_ptr<DeallocatingVector<QueryEdge>> contracted_edge_list);
-    std::shared_ptr<NodeBasedDynamicGraph> LoadNodeBasedGraph(std::vector<NodeID> &barrier_node_list,
-                                               std::vector<NodeID> &traffic_light_list,
-                                               std::vector<QueryNode>& internal_to_external_node_map);
-    std::pair<std::size_t, std::size_t>
-    BuildEdgeExpandedGraph(std::vector<QueryNode> &internal_to_external_node_map,
-                                       std::vector<EdgeBasedNode> &node_based_edge_list,
-                                       DeallocatingVector<EdgeBasedEdge> &edge_based_edge_list);
-    void WriteNodeMapping(std::unique_ptr<std::vector<QueryNode>> internal_to_external_node_map);
-    void BuildRTree(const std::vector<EdgeBasedNode> &node_based_edge_list,
-                    const std::vector<QueryNode> &internal_to_external_node_map);
+                                     const DeallocatingVector<QueryEdge> &contracted_edge_list);
+    void FindComponents(unsigned max_edge_id,
+                        const DeallocatingVector<EdgeBasedEdge> &edges,
+                        std::vector<EdgeBasedNode> &nodes) const;
+
  private:
    ContractorConfig config;
+    std::size_t LoadEdgeExpandedGraph(const std::string &edge_based_graph_path,
+                                      DeallocatingVector<EdgeBasedEdge> &edge_based_edge_list,
+                                      const std::string &edge_segment_lookup_path,
+                                      const std::string &edge_penalty_path,
+                                      const std::string &segment_speed_path);
 };

 #endif // PROCESSING_CHAIN_HPP
@@ -189,6 +189,11 @@ class BinaryHeap
        return inserted_nodes[heap[1].index].node;
    }

+    Weight MinKey() const {
+      BOOST_ASSERT(heap.size() > 1);
+      return heap[1].weight;
+    }
+
    NodeID DeleteMin()
    {
        BOOST_ASSERT(heap.size() > 1);
@@ -207,7 +212,7 @@ class BinaryHeap
    void DeleteAll()
    {
        auto iend = heap.end();
-        for (typename std::vector<HeapElement>::iterator i = heap.begin() + 1; i != iend; ++i)
+        for (auto i = heap.begin() + 1; i != iend; ++i)
        {
            inserted_nodes[i->index].key = 0;
        }
@@ -232,7 +237,9 @@ class BinaryHeap
    class HeapNode
    {
      public:
-        HeapNode(NodeID n, Key k, Weight w, Data d) : node(n), key(k), weight(w), data(d) {}
+        HeapNode(NodeID n, Key k, Weight w, Data d) : node(n), key(k), weight(w), data(std::move(d))
+        {
+        }

        NodeID node;
        Key key;
@@ -25,7 +25,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

-#include "geometry_compressor.hpp"
+#include "compressed_edge_container.hpp"
 #include "../util/simple_logger.hpp"

 #include <boost/assert.hpp>
@@ -35,13 +35,15 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <limits>
 #include <string>

-GeometryCompressor::GeometryCompressor()
+#include <iostream>
+
+CompressedEdgeContainer::CompressedEdgeContainer()
 {
    m_free_list.reserve(100);
    IncreaseFreeList();
 }

-void GeometryCompressor::IncreaseFreeList()
+void CompressedEdgeContainer::IncreaseFreeList()
 {
    m_compressed_geometries.resize(m_compressed_geometries.size() + 100);
    for (unsigned i = 100; i > 0; --i)
@@ -51,13 +53,13 @@ void GeometryCompressor::IncreaseFreeList()
    }
 }

-bool GeometryCompressor::HasEntryForID(const EdgeID edge_id) const
+bool CompressedEdgeContainer::HasEntryForID(const EdgeID edge_id) const
 {
    auto iter = m_edge_id_to_list_index_map.find(edge_id);
    return iter != m_edge_id_to_list_index_map.end();
 }

-unsigned GeometryCompressor::GetPositionForID(const EdgeID edge_id) const
+unsigned CompressedEdgeContainer::GetPositionForID(const EdgeID edge_id) const
 {
    auto map_iterator = m_edge_id_to_list_index_map.find(edge_id);
    BOOST_ASSERT(map_iterator != m_edge_id_to_list_index_map.end());
@@ -65,7 +67,7 @@ unsigned GeometryCompressor::GetPositionForID(const EdgeID edge_id) const
    return map_iterator->second;
 }

-void GeometryCompressor::SerializeInternalVector(const std::string &path) const
+void CompressedEdgeContainer::SerializeInternalVector(const std::string &path) const
 {

    boost::filesystem::fstream geometry_out_stream(path, std::ios::binary | std::ios::out);
@@ -108,7 +110,7 @@ void GeometryCompressor::SerializeInternalVector(const std::string &path) const
    geometry_out_stream.close();
 }

-void GeometryCompressor::CompressEdge(const EdgeID edge_id_1,
+void CompressedEdgeContainer::CompressEdge(const EdgeID edge_id_1,
                                      const EdgeID edge_id_2,
                                      const NodeID via_node_id,
                                      const NodeID target_node_id,
@@ -153,6 +155,8 @@ void GeometryCompressor::CompressEdge(const EdgeID edge_id_1,

    std::vector<CompressedNode> &edge_bucket_list1 = m_compressed_geometries[edge_bucket_id1];

+    // note we don't save the start coordinate: it is implicitly given by edge 1
+    // weight1 is the distance to the (currently) last coordinate in the bucket
    if (edge_bucket_list1.empty())
    {
        edge_bucket_list1.emplace_back(via_node_id, weight1);
@@ -190,7 +194,7 @@ void GeometryCompressor::CompressEdge(const EdgeID edge_id_1,
    }
 }

-void GeometryCompressor::PrintStatistics() const
+void CompressedEdgeContainer::PrintStatistics() const
 {
    const uint64_t compressed_edges = m_compressed_geometries.size();
    BOOST_ASSERT(0 == compressed_edges % 2);
@@ -215,20 +219,20 @@ void GeometryCompressor::PrintStatistics() const
                                  std::max((uint64_t)1, compressed_edges);
 }

-const std::vector<GeometryCompressor::CompressedNode> &
-GeometryCompressor::GetBucketReference(const EdgeID edge_id) const
+const CompressedEdgeContainer::EdgeBucket&
+CompressedEdgeContainer::GetBucketReference(const EdgeID edge_id) const
 {
    const unsigned index = m_edge_id_to_list_index_map.at(edge_id);
    return m_compressed_geometries.at(index);
 }

-NodeID GeometryCompressor::GetFirstNodeIDOfBucket(const EdgeID edge_id) const
+NodeID CompressedEdgeContainer::GetFirstEdgeTargetID(const EdgeID edge_id) const
 {
    const auto &bucket = GetBucketReference(edge_id);
    BOOST_ASSERT(bucket.size() >= 2);
-    return bucket[1].first;
+    return bucket.front().first;
 }
-NodeID GeometryCompressor::GetLastNodeIDOfBucket(const EdgeID edge_id) const
+NodeID CompressedEdgeContainer::GetLastEdgeSourceID(const EdgeID edge_id) const
 {
    const auto &bucket = GetBucketReference(edge_id);
    BOOST_ASSERT(bucket.size() >= 2);
@@ -35,12 +35,13 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <string>
 #include <vector>

-class GeometryCompressor
+class CompressedEdgeContainer
 {
  public:
    using CompressedNode = std::pair<NodeID, EdgeWeight>;
+    using EdgeBucket = std::vector<CompressedNode>;

-    GeometryCompressor();
+    CompressedEdgeContainer();
    void CompressEdge(const EdgeID surviving_edge_id,
                      const EdgeID removed_edge_id,
                      const NodeID via_node_id,
@@ -52,16 +53,15 @@ class GeometryCompressor
    void PrintStatistics() const;
    void SerializeInternalVector(const std::string &path) const;
    unsigned GetPositionForID(const EdgeID edge_id) const;
-    const std::vector<GeometryCompressor::CompressedNode> &
-    GetBucketReference(const EdgeID edge_id) const;
-    NodeID GetFirstNodeIDOfBucket(const EdgeID edge_id) const;
-    NodeID GetLastNodeIDOfBucket(const EdgeID edge_id) const;
+    const EdgeBucket& GetBucketReference(const EdgeID edge_id) const;
+    NodeID GetFirstEdgeTargetID(const EdgeID edge_id) const;
+    NodeID GetLastEdgeSourceID(const EdgeID edge_id) const;

  private:
    int free_list_maximum = 0;
-    
+
    void IncreaseFreeList();
-    std::vector<std::vector<CompressedNode>> m_compressed_geometries;
+    std::vector<EdgeBucket> m_compressed_geometries;
    std::vector<unsigned> m_free_list;
    std::unordered_map<EdgeID, unsigned> m_edge_id_to_list_index_map;
 };
@@ -1,85 +0,0 @@
-/*
-
-Copyright (c) 2014, Project OSRM contributors
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification,
-are permitted provided that the following conditions are met:
-
-Redistributions of source code must retain the above copyright notice, this list
-of conditions and the following disclaimer.
-Redistributions in binary form must reproduce the above copyright notice, this
-list of conditions and the following disclaimer in the documentation and/or
-other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-*/
-
-#ifndef CONCURRENT_QUEUE_HPP
-#define CONCURRENT_QUEUE_HPP
-
-#include <boost/circular_buffer.hpp>
-#include <condition_variable>
-#include <mutex>
-
-template <typename Data> class ConcurrentQueue
-{
-  public:
-    explicit ConcurrentQueue(const size_t max_size) : m_internal_queue(max_size) {}
-
-    inline void push(const Data &data)
-    {
-        std::unique_lock<std::mutex> lock(m_mutex);
-        m_not_full.wait(lock, [this]
-                        {
-                            return m_internal_queue.size() < m_internal_queue.capacity();
-                        });
-        m_internal_queue.push_back(data);
-        m_not_empty.notify_one();
-    }
-
-    inline bool empty() const { return m_internal_queue.empty(); }
-
-    inline void wait_and_pop(Data &popped_value)
-    {
-        std::unique_lock<std::mutex> lock(m_mutex);
-        m_not_empty.wait(lock, [this]
-                         {
-                             return !m_internal_queue.empty();
-                         });
-        popped_value = m_internal_queue.front();
-        m_internal_queue.pop_front();
-        m_not_full.notify_one();
-    }
-
-    inline bool try_pop(Data &popped_value)
-    {
-        std::unique_lock<std::mutex> lock(m_mutex);
-        if (m_internal_queue.empty())
-        {
-            return false;
-        }
-        popped_value = m_internal_queue.front();
-        m_internal_queue.pop_front();
-        m_not_full.notify_one();
-        return true;
-    }
-
-  private:
-    boost::circular_buffer<Data> m_internal_queue;
-    std::mutex m_mutex;
-    std::condition_variable m_not_empty;
-    std::condition_variable m_not_full;
-};
-
-#endif // CONCURRENT_QUEUE_HPP
@@ -25,7 +25,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

-#include "coordinate_calculation.hpp"
+#include "../algorithms/coordinate_calculation.hpp"

 #ifndef NDEBUG
 #include "../util/simple_logger.hpp"
@@ -36,6 +36,32 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <utility>
 #include <vector>

+template <typename ElementT> struct ConstDeallocatingVectorIteratorState
+{
+    ConstDeallocatingVectorIteratorState()
+        : index(std::numeric_limits<std::size_t>::max()), bucket_list(nullptr)
+    {
+    }
+    explicit ConstDeallocatingVectorIteratorState(const ConstDeallocatingVectorIteratorState &r)
+        : index(r.index), bucket_list(r.bucket_list)
+    {
+    }
+    explicit ConstDeallocatingVectorIteratorState(const std::size_t idx,
+                                             const std::vector<ElementT *> *input_list)
+        : index(idx), bucket_list(input_list)
+    {
+    }
+    std::size_t index;
+    const std::vector<ElementT *> *bucket_list;
+
+    ConstDeallocatingVectorIteratorState &operator=(const ConstDeallocatingVectorIteratorState &other)
+    {
+        index = other.index;
+        bucket_list = other.bucket_list;
+        return *this;
+    }
+};
+
 template <typename ElementT> struct DeallocatingVectorIteratorState
 {
    DeallocatingVectorIteratorState()
@@ -62,6 +88,55 @@ template <typename ElementT> struct DeallocatingVectorIteratorState
    }
 };

+template <typename ElementT, std::size_t ELEMENTS_PER_BLOCK>
+class ConstDeallocatingVectorIterator
+    : public boost::iterator_facade<ConstDeallocatingVectorIterator<ElementT, ELEMENTS_PER_BLOCK>,
+                                    ElementT,
+                                    std::random_access_iterator_tag>
+{
+    ConstDeallocatingVectorIteratorState<ElementT> current_state;
+
+  public:
+    ConstDeallocatingVectorIterator() {}
+    ConstDeallocatingVectorIterator(std::size_t idx, const std::vector<ElementT *> *input_list)
+        : current_state(idx, input_list)
+    {
+    }
+
+    friend class boost::iterator_core_access;
+
+    void advance(std::size_t n) { current_state.index += n; }
+
+    void increment() { advance(1); }
+
+    void decrement() { advance(-1); }
+
+    bool equal(ConstDeallocatingVectorIterator const &other) const
+    {
+        return current_state.index == other.current_state.index;
+    }
+
+    std::ptrdiff_t distance_to(ConstDeallocatingVectorIterator const &other) const
+    {
+        // it is important to implement it 'other minus this'. otherwise sorting breaks
+        return other.current_state.index - current_state.index;
+    }
+
+    ElementT &dereference() const
+    {
+        const std::size_t current_bucket = current_state.index / ELEMENTS_PER_BLOCK;
+        const std::size_t current_index = current_state.index % ELEMENTS_PER_BLOCK;
+        return (current_state.bucket_list->at(current_bucket)[current_index]);
+    }
+
+    ElementT &operator[](const std::size_t index) const
+    {
+        const std::size_t current_bucket = (index + current_state.index) / ELEMENTS_PER_BLOCK;
+        const std::size_t current_index = (index + current_state.index) % ELEMENTS_PER_BLOCK;
+        return (current_state.bucket_list->at(current_bucket)[current_index]);
+    }
+};
+
 template <typename ElementT, std::size_t ELEMENTS_PER_BLOCK>
 class DeallocatingVectorIterator
    : public boost::iterator_facade<DeallocatingVectorIterator<ElementT, ELEMENTS_PER_BLOCK>,
@@ -162,6 +237,12 @@ class DeallocatingVectorRemoveIterator
    }
 };

+template <typename ElementT, std::size_t ELEMENTS_PER_BLOCK>
+class DeallocatingVector;
+
+template<typename T, std::size_t S>
+void swap(DeallocatingVector<T, S>& lhs, DeallocatingVector<T, S>& rhs);
+
 template <typename ElementT, std::size_t ELEMENTS_PER_BLOCK = 8388608 / sizeof(ElementT)>
 class DeallocatingVector
 {
@@ -170,7 +251,7 @@ class DeallocatingVector

  public:
    using iterator = DeallocatingVectorIterator<ElementT, ELEMENTS_PER_BLOCK>;
-    using const_iterator = DeallocatingVectorIterator<ElementT, ELEMENTS_PER_BLOCK>;
+    using const_iterator = ConstDeallocatingVectorIterator<ElementT, ELEMENTS_PER_BLOCK>;

    // this forward-only iterator deallocates all buckets that have been visited
    using deallocation_iterator = DeallocatingVectorRemoveIterator<ElementT, ELEMENTS_PER_BLOCK>;
@@ -182,6 +263,8 @@ class DeallocatingVector

    ~DeallocatingVector() { clear(); }

+    friend void swap<>(DeallocatingVector<ElementT, ELEMENTS_PER_BLOCK>& lhs, DeallocatingVector<ElementT, ELEMENTS_PER_BLOCK>& rhs);
+
    void swap(DeallocatingVector<ElementT, ELEMENTS_PER_BLOCK> &other)
    {
        std::swap(current_size, other.current_size);
@@ -311,4 +394,10 @@ class DeallocatingVector
    }
 };

+template<typename T, std::size_t S>
+void swap(DeallocatingVector<T, S>& lhs, DeallocatingVector<T, S>& rhs)
+{
+    lhs.swap(rhs);
+}
+
 #endif /* DEALLOCATING_VECTOR_HPP */
@@ -90,9 +90,11 @@ template <typename EdgeDataT> class DynamicGraph
     */
    template <class ContainerT> DynamicGraph(const NodeIterator nodes, const ContainerT &graph)
    {
+        // we need to cast here because DeallocatingVector does not have a valid const iterator
+        BOOST_ASSERT(std::is_sorted(const_cast<ContainerT&>(graph).begin(), const_cast<ContainerT&>(graph).end()));
+
        number_of_nodes = nodes;
        number_of_edges = static_cast<EdgeIterator>(graph.size());
-        // node_array.reserve(number_of_nodes + 1);
        node_array.resize(number_of_nodes + 1);
        EdgeIterator edge = 0;
        EdgeIterator position = 0;
@@ -117,6 +119,7 @@ template <typename EdgeDataT> class DynamicGraph
                                             node_array[node].first_edge + node_array[node].edges))
            {
                edge_list[i].target = graph[edge].target;
+                BOOST_ASSERT(edge_list[i].target < number_of_nodes);
                edge_list[i].data = graph[edge].data;
                ++edge;
            }
@@ -136,7 +139,7 @@ template <typename EdgeDataT> class DynamicGraph
        unsigned degree = 0;
        for (const auto edge : osrm::irange(BeginEdges(n), EndEdges(n)))
        {
-            if (GetEdgeData(edge).forward)
+            if (!GetEdgeData(edge).reversed)
            {
                ++degree;
            }
@@ -37,6 +37,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 #include <limits>

+/// This is what StaticRTree serialized and stores on disk
+/// It is generated in EdgeBasedGraphFactory.
 struct EdgeBasedNode
 {
    EdgeBasedNode()
@@ -44,7 +46,7 @@ struct EdgeBasedNode
          u(SPECIAL_NODEID), v(SPECIAL_NODEID), name_id(0),
          forward_weight(INVALID_EDGE_WEIGHT >> 1), reverse_weight(INVALID_EDGE_WEIGHT >> 1),
          forward_offset(0), reverse_offset(0), packed_geometry_id(SPECIAL_EDGEID),
-          component_id(-1), fwd_segment_position(std::numeric_limits<unsigned short>::max()),
+          component{INVALID_COMPONENTID, false}, fwd_segment_position(std::numeric_limits<unsigned short>::max()),
          forward_travel_mode(TRAVEL_MODE_INACCESSIBLE),
          backward_travel_mode(TRAVEL_MODE_INACCESSIBLE)
    {
@@ -60,6 +62,7 @@ struct EdgeBasedNode
                           int forward_offset,
                           int reverse_offset,
                           unsigned packed_geometry_id,
+                           bool is_tiny_component,
                           unsigned component_id,
                           unsigned short fwd_segment_position,
                           TravelMode forward_travel_mode,
@@ -68,7 +71,7 @@ struct EdgeBasedNode
          reverse_edge_based_node_id(reverse_edge_based_node_id), u(u), v(v), name_id(name_id),
          forward_weight(forward_weight), reverse_weight(reverse_weight),
          forward_offset(forward_offset), reverse_offset(reverse_offset),
-          packed_geometry_id(packed_geometry_id), component_id(component_id),
+          packed_geometry_id(packed_geometry_id), component{component_id, is_tiny_component},
          fwd_segment_position(fwd_segment_position), forward_travel_mode(forward_travel_mode),
          backward_travel_mode(backward_travel_mode)
    {
@@ -88,8 +91,6 @@ struct EdgeBasedNode

    bool IsCompressed() const { return packed_geometry_id != SPECIAL_EDGEID; }

-    bool is_in_tiny_cc() const { return 0 != component_id; }
-
    NodeID forward_edge_based_node_id; // needed for edge-expanded graph
    NodeID reverse_edge_based_node_id; // needed for edge-expanded graph
    NodeID u;                          // indices into the coordinates array
@@ -100,7 +101,10 @@ struct EdgeBasedNode
    int forward_offset;          // prefix sum of the weight up the edge TODO: short must suffice
    int reverse_offset;          // prefix sum of the weight from the edge TODO: short must suffice
    unsigned packed_geometry_id; // if set, then the edge represents a packed geometry
-    unsigned component_id;
+    struct {
+        unsigned id : 31;
+        bool is_tiny : 1;
+    } component;
    unsigned short fwd_segment_position; // segment id in a compressed geometry
    TravelMode forward_travel_mode : 4;
    TravelMode backward_travel_mode : 4;
@@ -31,7 +31,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <limits>

 ExternalMemoryNode::ExternalMemoryNode(
-    int lat, int lon, unsigned int node_id, bool barrier, bool traffic_lights)
+    int lat, int lon, OSMNodeID node_id, bool barrier, bool traffic_lights)
    : QueryNode(lat, lon, node_id), barrier(barrier), traffic_lights(traffic_lights)
 {
 }
@@ -40,13 +40,13 @@ ExternalMemoryNode::ExternalMemoryNode() : barrier(false), traffic_lights(false)

 ExternalMemoryNode ExternalMemoryNode::min_value()
 {
-    return ExternalMemoryNode(0, 0, 0, false, false);
+    return ExternalMemoryNode(0, 0, MIN_OSM_NODEID, false, false);
 }

 ExternalMemoryNode ExternalMemoryNode::max_value()
 {
    return ExternalMemoryNode(std::numeric_limits<int>::max(), std::numeric_limits<int>::max(),
-                              std::numeric_limits<unsigned>::max(), false, false);
+                              MAX_OSM_NODEID, false, false);
 }

 bool ExternalMemoryNodeSTXXLCompare::operator()(const ExternalMemoryNode &left,
@@ -34,7 +34,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 struct ExternalMemoryNode : QueryNode
 {
-    ExternalMemoryNode(int lat, int lon, NodeID id, bool barrier, bool traffic_light);
+    ExternalMemoryNode(int lat, int lon, OSMNodeID id, bool barrier, bool traffic_light);

    ExternalMemoryNode();

@@ -91,13 +91,24 @@ template <class CandidateLists> struct HiddenMarkovModel
        : breakage(candidates_list.size()), candidates_list(candidates_list),
          emission_log_probability(emission_log_probability)
    {
-        for (const auto &l : candidates_list)
+        viterbi.resize(candidates_list.size());
+        parents.resize(candidates_list.size());
+        path_lengths.resize(candidates_list.size());
+        suspicious.resize(candidates_list.size());
+        pruned.resize(candidates_list.size());
+        breakage.resize(candidates_list.size());
+        for (const auto i : osrm::irange<std::size_t>(0u, candidates_list.size()))
        {
-            viterbi.emplace_back(l.size());
-            parents.emplace_back(l.size());
-            path_lengths.emplace_back(l.size());
-            suspicious.emplace_back(l.size());
-            pruned.emplace_back(l.size());
+            const auto& num_candidates = candidates_list[i].size();
+            // add empty vectors
+            if (num_candidates > 0)
+            {
+                viterbi[i].resize(num_candidates);
+                parents[i].resize(num_candidates);
+                path_lengths[i].resize(num_candidates);
+                suspicious[i].resize(num_candidates);
+                pruned[i].resize(num_candidates);
+            }
        }

        clear(0);
@@ -121,14 +132,15 @@ template <class CandidateLists> struct HiddenMarkovModel

    std::size_t initialize(std::size_t initial_timestamp)
    {
-        BOOST_ASSERT(initial_timestamp < candidates_list.size());
-
+        auto num_points = candidates_list.size();
        do
        {
+            BOOST_ASSERT(initial_timestamp < num_points);
+
            for (const auto s : osrm::irange<std::size_t>(0u, viterbi[initial_timestamp].size()))
            {
                viterbi[initial_timestamp][s] =
-                    emission_log_probability(candidates_list[initial_timestamp][s].second);
+                    emission_log_probability(candidates_list[initial_timestamp][s].distance);
                parents[initial_timestamp][s] = std::make_pair(initial_timestamp, s);
                pruned[initial_timestamp][s] =
                    viterbi[initial_timestamp][s] < osrm::matching::MINIMAL_LOG_PROB;
@@ -139,9 +151,9 @@ template <class CandidateLists> struct HiddenMarkovModel
            }

            ++initial_timestamp;
-        } while (breakage[initial_timestamp - 1]);
+        } while (initial_timestamp < num_points && breakage[initial_timestamp - 1]);

-        if (initial_timestamp >= viterbi.size())
+        if (initial_timestamp >= num_points)
        {
            return osrm::matching::INVALID_STATE;
        }
@@ -57,7 +57,7 @@ uint64_t HilbertCode::BitInterleaving(const uint32_t latitude, const uint32_t lo

 void HilbertCode::TransposeCoordinate(uint32_t *X) const
 {
-    uint32_t M = 1 << (32 - 1), P, Q, t;
+    uint32_t M = 1u << (32 - 1), P, Q, t;
    int i;
    // Inverse undo
    for (Q = M; Q > 1; Q >>= 1)
@@ -49,8 +49,8 @@ bool NodeBasedEdge::operator<(const NodeBasedEdge &other) const

 NodeBasedEdge::NodeBasedEdge()
    : source(SPECIAL_NODEID), target(SPECIAL_NODEID), name_id(0), weight(0), forward(false),
-      backward(false), roundabout(false), in_tiny_cc(false),
-      access_restricted(false), is_split(false), travel_mode(false)
+      backward(false), roundabout(false),
+      access_restricted(false), startpoint(true), is_split(false), travel_mode(false)
 {
 }

@@ -61,13 +61,13 @@ NodeBasedEdge::NodeBasedEdge(NodeID source,
                             bool forward,
                             bool backward,
                             bool roundabout,
-                             bool in_tiny_cc,
                             bool access_restricted,
+                             bool startpoint,
                             TravelMode travel_mode,
                             bool is_split)
    : source(source), target(target), name_id(name_id), weight(weight), forward(forward),
-      backward(backward), roundabout(roundabout), in_tiny_cc(in_tiny_cc),
-      access_restricted(access_restricted), is_split(is_split), travel_mode(travel_mode)
+      backward(backward), roundabout(roundabout),
+      access_restricted(access_restricted), startpoint(startpoint), is_split(is_split), travel_mode(travel_mode)
 {
 }

@@ -43,8 +43,8 @@ struct NodeBasedEdge
                           bool forward,
                           bool backward,
                           bool roundabout,
-                           bool in_tiny_cc,
                           bool access_restricted,
+                           bool startpoint,
                           TravelMode travel_mode,
                           bool is_split);

@@ -55,12 +55,32 @@ struct NodeBasedEdge
    bool forward : 1;
    bool backward : 1;
    bool roundabout : 1;
-    bool in_tiny_cc : 1;
    bool access_restricted : 1;
+    bool startpoint : 1;
    bool is_split : 1;
    TravelMode travel_mode : 4;
 };

+struct NodeBasedEdgeWithOSM : NodeBasedEdge
+{
+    explicit NodeBasedEdgeWithOSM(OSMNodeID source,
+                           OSMNodeID target,
+                           NodeID name_id,
+                           EdgeWeight weight,
+                           bool forward,
+                           bool backward,
+                           bool roundabout,
+                           bool access_restricted,
+                           bool startpoint,
+                           TravelMode travel_mode,
+                           bool is_split)
+        : NodeBasedEdge(SPECIAL_NODEID, SPECIAL_NODEID, name_id, weight, forward, backward, roundabout, access_restricted, startpoint, travel_mode, is_split),
+        osm_source_id(source), osm_target_id(target) {}
+
+    OSMNodeID osm_source_id;
+    OSMNodeID osm_target_id;
+};
+
 struct EdgeBasedEdge
 {

@@ -25,47 +25,46 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

-#ifndef ITERATOR_RANGE_HPP
-#define ITERATOR_RANGE_HPP
+#ifndef MATRIX_GRAPH_WRAPPER_H
+#define MATRIX_GRAPH_WRAPPER_H

-namespace osrm
-{
-template <typename Iterator> class iter_range
+#include <vector>
+#include <cstddef>
+#include <iterator>
+
+#include "../typedefs.h"
+
+// This Wrapper provides all methods that are needed for TarjanSCC, when the graph is given in a
+// matrix representation (e.g. as output from a distance table call)
+
+template <typename T> class MatrixGraphWrapper
 {
  public:
-    iter_range(Iterator begin, Iterator end) noexcept : begin_(begin), end_(end) {}
+    MatrixGraphWrapper(std::vector<T> table, const std::size_t number_of_nodes)
+        : table_(std::move(table)), number_of_nodes_(number_of_nodes){};

-    Iterator begin() const noexcept { return begin_; }
-    Iterator end() const noexcept { return end_; }
+    std::size_t GetNumberOfNodes() const { return number_of_nodes_; }
+
+    std::vector<T> GetAdjacentEdgeRange(const NodeID node) const
+    {
+
+        std::vector<T> edges;
+        // find all valid adjacent edges and move to vector `edges`
+        for (std::size_t i = 0; i < number_of_nodes_; ++i)
+        {
+            if (*(std::begin(table_) + node * number_of_nodes_ + i) != INVALID_EDGE_WEIGHT)
+            {
+                edges.push_back(i);
+            }
+        }
+        return edges;
+    }
+
+    EdgeWeight GetTarget(const EdgeWeight edge) const { return edge; }

  private:
-    Iterator begin_;
-    Iterator end_;
+    const std::vector<T> table_;
+    const std::size_t number_of_nodes_;
 };

-// Convenience functions for template parameter inference,
-// akin to std::make_pair.
-
-template <typename Iterator>
-iter_range<Iterator> integer_range(Iterator begin, Iterator end) noexcept
-{
-    return iter_range<Iterator>(begin, end);
-}
-
-template <typename Reversable>
-iter_range<typename Reversable::reverse_iterator> reverse(Reversable *reversable) noexcept
-{
-    return iter_range<typename Reversable::reverse_iterator>(reversable->rbegin(),
-                                                             reversable->rend());
-}
-
-template <typename ConstReversable>
-iter_range<typename ConstReversable::const_reverse_iterator>
-const_reverse(const ConstReversable *const_reversable) noexcept
-{
-    return iter_range<typename ConstReversable::const_reverse_iterator>(const_reversable->crbegin(),
-                                                                        const_reversable->crend());
-}
-}
-
-#endif // ITERATOR_RANGE_HPP
+#endif // MATRIX_GRAPH_WRAPPER_H
@@ -30,7 +30,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 #include "dynamic_graph.hpp"
 #include "import_edge.hpp"
-#include "../util/simple_logger.hpp"
+#include "../util/graph_utils.hpp"

 #include <tbb/parallel_sort.h>

@@ -39,196 +39,64 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 struct NodeBasedEdgeData
 {
    NodeBasedEdgeData()
-        : distance(INVALID_EDGE_WEIGHT), edgeBasedNodeID(SPECIAL_NODEID),
-          nameID(std::numeric_limits<unsigned>::max()), isAccessRestricted(false), shortcut(false),
-          forward(false), backward(false), roundabout(false), ignore_in_grid(false),
-          travel_mode(TRAVEL_MODE_INACCESSIBLE)
+        : distance(INVALID_EDGE_WEIGHT), edge_id(SPECIAL_NODEID),
+          name_id(std::numeric_limits<unsigned>::max()), access_restricted(false),
+          reversed(false), roundabout(false), travel_mode(TRAVEL_MODE_INACCESSIBLE)
+    {
+    }
+
+    NodeBasedEdgeData(int distance, unsigned edge_id, unsigned name_id,
+            bool access_restricted, bool reversed,
+            bool roundabout, bool startpoint, TravelMode travel_mode)
+        : distance(distance), edge_id(edge_id), name_id(name_id),
+          access_restricted(access_restricted), reversed(reversed),
+          roundabout(roundabout), startpoint(startpoint), travel_mode(travel_mode)
    {
    }

    int distance;
-    unsigned edgeBasedNodeID;
-    unsigned nameID;
-    bool isAccessRestricted : 1;
-    bool shortcut : 1;
-    bool forward : 1;
-    bool backward : 1;
+    unsigned edge_id;
+    unsigned name_id;
+    bool access_restricted : 1;
+    bool reversed : 1;
    bool roundabout : 1;
-    bool ignore_in_grid : 1;
+    bool startpoint : 1;
    TravelMode travel_mode : 4;

-    void SwapDirectionFlags()
-    {
-        bool temp_flag = forward;
-        forward = backward;
-        backward = temp_flag;
-    }
-
    bool IsCompatibleTo(const NodeBasedEdgeData &other) const
    {
-        return (forward == other.forward) && (backward == other.backward) &&
-               (nameID == other.nameID) && (ignore_in_grid == other.ignore_in_grid) &&
+        return (reversed == other.reversed) && (name_id == other.name_id) &&
               (travel_mode == other.travel_mode);
    }
 };

 using NodeBasedDynamicGraph = DynamicGraph<NodeBasedEdgeData>;

-inline bool validateNeighborHood(const NodeBasedDynamicGraph& graph, const NodeID source)
-{
-    for (auto edge = graph.BeginEdges(source); edge < graph.EndEdges(source); ++edge)
-    {
-        const auto& data = graph.GetEdgeData(edge);
-        if (!data.forward && !data.backward)
-        {
-            SimpleLogger().Write(logWARNING) << "Invalid edge directions";
-            return false;
-        }
-
-        auto target = graph.GetTarget(edge);
-        if (target == SPECIAL_NODEID)
-        {
-            SimpleLogger().Write(logWARNING) << "Invalid edge target";
-            return false;
-        }
-
-        bool found_reverse = false;
-        for (auto rev_edge = graph.BeginEdges(target); rev_edge < graph.EndEdges(target); ++rev_edge)
-        {
-            auto rev_target = graph.GetTarget(rev_edge);
-            if (rev_target == SPECIAL_NODEID)
-            {
-                SimpleLogger().Write(logWARNING) << "Invalid reverse edge target";
-                return false;
-            }
-
-            if (rev_target != source)
-            {
-                continue;
-            }
-
-            if (found_reverse)
-            {
-                SimpleLogger().Write(logWARNING) << "Found more than one reverse edge";
-                return false;
-            }
-
-            const auto& rev_data = graph.GetEdgeData(rev_edge);
-
-            // edge is incoming, this must be an outgoing edge
-            if (data.backward && !rev_data.forward)
-            {
-                SimpleLogger().Write(logWARNING) << "Found no outgoing edge to an incoming edge!";
-                return false;
-            }
-
-            // edge is bi-directional, reverse must be as well
-            if (data.forward && data.backward && (!rev_data.forward || !rev_data.backward))
-            {
-                SimpleLogger().Write(logWARNING) << "Found bi-directional edge that is not bi-directional to both ends";
-                return false;
-            }
-
-            found_reverse = true;
-
-        }
-
-        if (!found_reverse)
-        {
-            SimpleLogger().Write(logWARNING) << "Could not find reverse edge";
-            return false;
-        }
-    }
-
-    return true;
-}
-
-// This function checks if the overal graph is undirected (has an edge in each direction).
-inline bool validateNodeBasedGraph(const NodeBasedDynamicGraph& graph)
-{
-    for (auto source = 0u; source < graph.GetNumberOfNodes(); ++source)
-    {
-        if (!validateNeighborHood(graph, source))
-        {
-            return false;
-        }
-    }
-
-    return true;
-}
-
-// Factory method to create NodeBasedDynamicGraph from NodeBasedEdges
-// The since DynamicGraph expects directed edges, we need to insert
-// two edges for undirected edges.
+/// Factory method to create NodeBasedDynamicGraph from NodeBasedEdges
+/// Since DynamicGraph expects directed edges, we need to insert
+/// two edges for undirected edges.
 inline std::shared_ptr<NodeBasedDynamicGraph>
-NodeBasedDynamicGraphFromImportEdges(int number_of_nodes, std::vector<NodeBasedEdge> &input_edge_list)
+NodeBasedDynamicGraphFromEdges(std::size_t number_of_nodes, const std::vector<NodeBasedEdge> &input_edge_list)
 {
-    static_assert(sizeof(NodeBasedEdgeData) == 16,
-                  "changing node based edge data size changes memory consumption");
-
-    DeallocatingVector<NodeBasedDynamicGraph::InputEdge> edges_list;
-    NodeBasedDynamicGraph::InputEdge edge;
-
-    // Since DynamicGraph assumes directed edges we have to make sure we transformed
-    // the compressed edge format into single directed edges. We do this to make sure
-    // every node also knows its incoming edges, not only its outgoing edges and use the backward=true
-    // flag to indicate which is which.
-    //
-    // We do the transformation in the following way:
-    //
-    // if the edge (a, b) is split:
-    //   1. this edge must be in only one direction, so its a --> b
-    //   2. there must be another directed edge b --> a somewhere in the data
-    // if the edge (a, b) is not split:
-    //   1. this edge be on of a --> b od a <-> b
-    //      (a <-- b gets reducted to b --> a)
-    //   2. a --> b will be transformed to a --> b and b <-- a
-    //   3. a <-> b will be transformed to a <-> b and b <-> a (I think a --> b and b <-- a would work as well though)
-    for (const NodeBasedEdge &import_edge : input_edge_list)
-    {
-        // edges that are not forward get converted by flipping the end points
-        BOOST_ASSERT(import_edge.forward);
-
-        if (import_edge.forward)
+    auto edges_list = directedEdgesFromCompressed<NodeBasedDynamicGraph::InputEdge>(input_edge_list,
+        [](NodeBasedDynamicGraph::InputEdge& output_edge, const NodeBasedEdge& input_edge)
        {
-            edge.source = import_edge.source;
-            edge.target = import_edge.target;
-            edge.data.forward = import_edge.forward;
-            edge.data.backward = import_edge.backward;
+            output_edge.data.distance = static_cast<int>(input_edge.weight);
+            BOOST_ASSERT(output_edge.data.distance > 0);
+
+            output_edge.data.roundabout = input_edge.roundabout;
+            output_edge.data.name_id = input_edge.name_id;
+            output_edge.data.access_restricted = input_edge.access_restricted;
+            output_edge.data.travel_mode = input_edge.travel_mode;
+            output_edge.data.startpoint = input_edge.startpoint;
        }
-
-        BOOST_ASSERT(edge.source != edge.target);
-
-        edge.data.distance = static_cast<int>(import_edge.weight);
-        BOOST_ASSERT(edge.data.distance > 0);
-        edge.data.shortcut = false;
-        edge.data.roundabout = import_edge.roundabout;
-        edge.data.ignore_in_grid = import_edge.in_tiny_cc;
-        edge.data.nameID = import_edge.name_id;
-        edge.data.isAccessRestricted = import_edge.access_restricted;
-        edge.data.travel_mode = import_edge.travel_mode;
-
-        edges_list.push_back(edge);
-
-        if (!import_edge.is_split)
-        {
-            using std::swap; // enable ADL
-            swap(edge.source, edge.target);
-            edge.data.SwapDirectionFlags();
-            edges_list.push_back(edge);
-        }
-    }
+    );

    tbb::parallel_sort(edges_list.begin(), edges_list.end());

    auto graph = std::make_shared<NodeBasedDynamicGraph>(
        static_cast<NodeBasedDynamicGraph::NodeIterator>(number_of_nodes), edges_list);

-
-#ifndef NDEBUG
-    BOOST_ASSERT(validateNodeBasedGraph(*graph));
-#endif
-
    return graph;
 }

@@ -32,10 +32,10 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 struct Cmp
 {
-    using value_type = NodeID;
-    bool operator()(const NodeID left, const NodeID right) const { return left < right; }
-    value_type max_value() { return 0xffffffff; }
-    value_type min_value() { return 0x0; }
+    using value_type = OSMNodeID;
+    bool operator()(const value_type left, const value_type right) const { return left < right; }
+    value_type max_value() { return MAX_OSM_NODEID; }
+    value_type min_value() { return MIN_OSM_NODEID; }
 };

 #endif // NODE_ID_HPP
@@ -42,6 +42,7 @@ PhantomNode::PhantomNode(NodeID forward_node_id,
                         int forward_offset,
                         int reverse_offset,
                         unsigned packed_geometry_id,
+                         bool is_tiny_component,
                         unsigned component_id,
                         FixedPointCoordinate &location,
                         unsigned short fwd_segment_position,
@@ -50,7 +51,7 @@ PhantomNode::PhantomNode(NodeID forward_node_id,
    : forward_node_id(forward_node_id), reverse_node_id(reverse_node_id), name_id(name_id),
      forward_weight(forward_weight), reverse_weight(reverse_weight),
      forward_offset(forward_offset), reverse_offset(reverse_offset),
-      packed_geometry_id(packed_geometry_id), component_id(component_id), location(location),
+      packed_geometry_id(packed_geometry_id), component{component_id, is_tiny_component}, location(location),
      fwd_segment_position(fwd_segment_position), forward_travel_mode(forward_travel_mode),
      backward_travel_mode(backward_travel_mode)
 {
@@ -60,7 +61,7 @@ PhantomNode::PhantomNode()
    : forward_node_id(SPECIAL_NODEID), reverse_node_id(SPECIAL_NODEID),
      name_id(std::numeric_limits<unsigned>::max()), forward_weight(INVALID_EDGE_WEIGHT),
      reverse_weight(INVALID_EDGE_WEIGHT), forward_offset(0), reverse_offset(0),
-      packed_geometry_id(SPECIAL_EDGEID), component_id(std::numeric_limits<unsigned>::max()),
+      packed_geometry_id(SPECIAL_EDGEID), component{INVALID_COMPONENTID, false},
      fwd_segment_position(0), forward_travel_mode(TRAVEL_MODE_INACCESSIBLE),
      backward_travel_mode(TRAVEL_MODE_INACCESSIBLE)
 {
@@ -96,11 +97,9 @@ bool PhantomNode::is_valid(const unsigned number_of_nodes) const
    return location.is_valid() &&
           ((forward_node_id < number_of_nodes) || (reverse_node_id < number_of_nodes)) &&
           ((forward_weight != INVALID_EDGE_WEIGHT) || (reverse_weight != INVALID_EDGE_WEIGHT)) &&
-           (name_id != INVALID_NAMEID);
+           (component.id != INVALID_COMPONENTID) && (name_id != INVALID_NAMEID);
 }

-bool PhantomNode::is_in_tiny_component() const { return component_id != 0; }
-
 bool PhantomNode::is_valid() const { return location.is_valid() && (name_id != INVALID_NAMEID); }

 bool PhantomNode::operator==(const PhantomNode &other) const { return location == other.location; }
@@ -47,6 +47,7 @@ struct PhantomNode
                int forward_offset,
                int reverse_offset,
                unsigned packed_geometry_id,
+                bool is_tiny_component,
                unsigned component_id,
                FixedPointCoordinate &location,
                unsigned short fwd_segment_position,
@@ -68,7 +69,9 @@ struct PhantomNode
        reverse_offset = other.reverse_offset;

        packed_geometry_id = other.packed_geometry_id;
-        component_id = other.component_id;
+
+        component.id = other.component.id;
+        component.is_tiny = other.component.is_tiny;

        location = foot_point;
        fwd_segment_position = other.fwd_segment_position;
@@ -85,11 +88,20 @@ struct PhantomNode
    int forward_offset;
    int reverse_offset;
    unsigned packed_geometry_id;
-    unsigned component_id;
+    struct ComponentType {
+        uint32_t id : 31;
+        bool is_tiny : 1;
+    } component;
+// bit-fields are broken on Windows
+#ifndef _MSC_VER
+    static_assert(sizeof(ComponentType) == 4, "ComponentType needs to 4 bytes big");
+#endif
    FixedPointCoordinate location;
    unsigned short fwd_segment_position;
-    TravelMode forward_travel_mode : 4;
-    TravelMode backward_travel_mode : 4;
+    // note 4 bits would suffice for each,
+    // but the saved byte would be padding anyway
+    TravelMode forward_travel_mode;
+    TravelMode backward_travel_mode;

    int GetForwardWeightPlusOffset() const;

@@ -103,21 +115,19 @@ struct PhantomNode

    bool is_valid() const;

-    bool is_in_tiny_component() const;
-
    bool operator==(const PhantomNode &other) const;
 };

-using PhantomNodeArray = std::vector<std::vector<PhantomNode>>;
+#ifndef _MSC_VER
+static_assert(sizeof(PhantomNode) == 48, "PhantomNode has more padding then expected");
+#endif

-class phantom_node_pair : public std::pair<PhantomNode, PhantomNode>
-{
-};
+using PhantomNodePair = std::pair<PhantomNode, PhantomNode>;

-struct PhantomNodeLists
+struct PhantomNodeWithDistance
 {
-    std::vector<PhantomNode> source_phantom_list;
-    std::vector<PhantomNode> target_phantom_list;
+    PhantomNode phantom_node;
+    double distance;
 };

 struct PhantomNodes
@@ -143,7 +153,7 @@ inline std::ostream &operator<<(std::ostream &out, const PhantomNode &pn)
        << "fwd-o: " << pn.forward_offset << ", "
        << "rev-o: " << pn.reverse_offset << ", "
        << "geom: " << pn.packed_geometry_id << ", "
-        << "comp: " << pn.component_id << ", "
+        << "comp: " << pn.component.is_tiny << " / " << pn.component.id << ", "
        << "pos: " << pn.fwd_segment_position << ", "
        << "loc: " << pn.location;
    return out;
@@ -58,7 +58,7 @@ struct QueryEdge
    QueryEdge() : source(SPECIAL_NODEID), target(SPECIAL_NODEID) {}

    QueryEdge(NodeID source, NodeID target, EdgeData data)
-        : source(source), target(target), data(data)
+        : source(source), target(target), data(std::move(data))
    {
    }

@@ -38,32 +38,32 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 struct QueryNode
 {
-    using key_type = NodeID; // type of NodeID
+    using key_type = OSMNodeID; // type of NodeID
    using value_type = int;  // type of lat,lons

-    explicit QueryNode(int lat, int lon, NodeID node_id) : lat(lat), lon(lon), node_id(node_id) {}
+    explicit QueryNode(int lat, int lon, OSMNodeID node_id) : lat(lat), lon(lon), node_id(node_id) {}
    QueryNode()
        : lat(std::numeric_limits<int>::max()), lon(std::numeric_limits<int>::max()),
-          node_id(std::numeric_limits<unsigned>::max())
+          node_id(SPECIAL_OSM_NODEID)
    {
    }

    int lat;
    int lon;
-    NodeID node_id;
+    OSMNodeID node_id;

    static QueryNode min_value()
    {
        return QueryNode(static_cast<int>(-90 * COORDINATE_PRECISION),
                         static_cast<int>(-180 * COORDINATE_PRECISION),
-                         std::numeric_limits<NodeID>::min());
+                         MIN_OSM_NODEID);
    }

    static QueryNode max_value()
    {
        return QueryNode(static_cast<int>(90 * COORDINATE_PRECISION),
                         static_cast<int>(180 * COORDINATE_PRECISION),
-                         std::numeric_limits<NodeID>::max());
+                         MAX_OSM_NODEID);
    }

    value_type operator[](const std::size_t n) const
@@ -33,9 +33,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "shared_memory_vector_wrapper.hpp"

 #include <fstream>
-#include <vector>
 #include <array>
-
 /*
 * These pre-declarations are needed because parsing C++ is hard
 * and otherwise the compiler gets confused.
@@ -82,7 +80,8 @@ template <unsigned BLOCK_SIZE, bool USE_SHARED_MEMORY> class RangeTable
    }

    // construct table from length vector
-    explicit RangeTable(const std::vector<unsigned> &lengths)
+    template<typename VectorT>
+    explicit RangeTable(const VectorT &lengths)
    {
        const unsigned number_of_blocks = [&lengths]()
        {
@@ -0,0 +1,178 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#include "raster_source.hpp"
+
+#include "../util/simple_logger.hpp"
+#include "../util/timing_util.hpp"
+
+#include <osrm/coordinate.hpp>
+
+#include <cmath>
+
+RasterSource::RasterSource(RasterGrid _raster_data,
+                           std::size_t _width,
+                           std::size_t _height,
+                           int _xmin,
+                           int _xmax,
+                           int _ymin,
+                           int _ymax)
+    : xstep(calcSize(_xmin, _xmax, _width)), ystep(calcSize(_ymin, _ymax, _height)),
+      raster_data(std::move(_raster_data)), width(_width), height(_height), xmin(_xmin),
+      xmax(_xmax), ymin(_ymin), ymax(_ymax)
+{
+    BOOST_ASSERT(xstep != 0);
+    BOOST_ASSERT(ystep != 0);
+}
+
+float RasterSource::calcSize(int min, int max, std::size_t count) const
+{
+    BOOST_ASSERT(count > 0);
+    return (max - min) / (static_cast<float>(count) - 1);
+}
+
+// Query raster source for nearest data point
+RasterDatum RasterSource::getRasterData(const int lon, const int lat) const
+{
+    if (lon < xmin || lon > xmax || lat < ymin || lat > ymax)
+    {
+        return {};
+    }
+
+    const std::size_t xth = static_cast<std::size_t>(round((lon - xmin) / xstep));
+    const std::size_t yth = static_cast<std::size_t>(round((ymax - lat) / ystep));
+
+    return {raster_data(xth, yth)};
+}
+
+// Query raster source using bilinear interpolation
+RasterDatum RasterSource::getRasterInterpolate(const int lon, const int lat) const
+{
+    if (lon < xmin || lon > xmax || lat < ymin || lat > ymax)
+    {
+        return {};
+    }
+
+    const auto xthP = (lon - xmin) / xstep;
+    const auto ythP = (ymax - lat) / ystep;
+
+    const std::size_t top = static_cast<std::size_t>(fmax(floor(ythP), 0));
+    const std::size_t bottom = static_cast<std::size_t>(fmin(ceil(ythP), height - 1));
+    const std::size_t left = static_cast<std::size_t>(fmax(floor(xthP), 0));
+    const std::size_t right = static_cast<std::size_t>(fmin(ceil(xthP), width - 1));
+
+    // Calculate distances from corners for bilinear interpolation
+    const float fromLeft = (lon - left * xstep + xmin) / xstep;
+    const float fromTop = (ymax - top * ystep - lat) / ystep;
+    const float fromRight = 1 - fromLeft;
+    const float fromBottom = 1 - fromTop;
+
+    return {static_cast<std::int32_t>(raster_data(left, top) * (fromRight * fromBottom) +
+                                      raster_data(right, top) * (fromLeft * fromBottom) +
+                                      raster_data(left, bottom) * (fromRight * fromTop) +
+                                      raster_data(right, bottom) * (fromLeft * fromTop))};
+}
+
+// Load raster source into memory
+int SourceContainer::loadRasterSource(const std::string &path_string,
+                                      double xmin,
+                                      double xmax,
+                                      double ymin,
+                                      double ymax,
+                                      std::size_t nrows,
+                                      std::size_t ncols)
+{
+    const auto _xmin = static_cast<int>(xmin * COORDINATE_PRECISION);
+    const auto _xmax = static_cast<int>(xmax * COORDINATE_PRECISION);
+    const auto _ymin = static_cast<int>(ymin * COORDINATE_PRECISION);
+    const auto _ymax = static_cast<int>(ymax * COORDINATE_PRECISION);
+
+    const auto itr = LoadedSourcePaths.find(path_string);
+    if (itr != LoadedSourcePaths.end())
+    {
+        SimpleLogger().Write() << "[source loader] Already loaded source '" << path_string
+                               << "' at source_id " << itr->second;
+        return itr->second;
+    }
+
+    int source_id = static_cast<int>(LoadedSources.size());
+
+    SimpleLogger().Write() << "[source loader] Loading from " << path_string << "  ... ";
+    TIMER_START(loading_source);
+
+    boost::filesystem::path filepath(path_string);
+    if (!boost::filesystem::exists(filepath))
+    {
+        throw osrm::exception("error reading: no such path");
+    }
+
+    RasterGrid rasterData{filepath, ncols, nrows};
+
+    RasterSource source{std::move(rasterData), ncols, nrows, _xmin, _xmax, _ymin, _ymax};
+    TIMER_STOP(loading_source);
+    LoadedSourcePaths.emplace(path_string, source_id);
+    LoadedSources.push_back(std::move(source));
+
+    SimpleLogger().Write() << "[source loader] ok, after " << TIMER_SEC(loading_source) << "s";
+
+    return source_id;
+}
+
+// External function for looking up nearest data point from a specified source
+RasterDatum SourceContainer::getRasterDataFromSource(unsigned int source_id, int lon, int lat)
+{
+    if (LoadedSources.size() < source_id + 1)
+    {
+        throw osrm::exception("error reading: no such loaded source");
+    }
+
+    BOOST_ASSERT(lat < (90 * COORDINATE_PRECISION));
+    BOOST_ASSERT(lat > (-90 * COORDINATE_PRECISION));
+    BOOST_ASSERT(lon < (180 * COORDINATE_PRECISION));
+    BOOST_ASSERT(lon > (-180 * COORDINATE_PRECISION));
+
+    const auto &found = LoadedSources[source_id];
+    return found.getRasterData(lon, lat);
+}
+
+// External function for looking up interpolated data from a specified source
+RasterDatum
+SourceContainer::getRasterInterpolateFromSource(unsigned int source_id, int lon, int lat)
+{
+    if (LoadedSources.size() < source_id + 1)
+    {
+        throw osrm::exception("error reading: no such loaded source");
+    }
+
+    BOOST_ASSERT(lat < (90 * COORDINATE_PRECISION));
+    BOOST_ASSERT(lat > (-90 * COORDINATE_PRECISION));
+    BOOST_ASSERT(lon < (180 * COORDINATE_PRECISION));
+    BOOST_ASSERT(lon > (-180 * COORDINATE_PRECISION));
+
+    const auto &found = LoadedSources[source_id];
+    return found.getRasterInterpolate(lon, lat);
+}
@@ -0,0 +1,175 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef RASTER_SOURCE_HPP
+#define RASTER_SOURCE_HPP
+
+#include "../util/osrm_exception.hpp"
+
+#include <boost/filesystem.hpp>
+#include <boost/filesystem/fstream.hpp>
+#include <boost/spirit/include/qi_int.hpp>
+#include <boost/spirit/include/qi.hpp>
+#include <boost/algorithm/string/trim.hpp>
+#include <boost/assert.hpp>
+
+#include <unordered_map>
+#include <iterator>
+
+/**
+    \brief Small wrapper around raster source queries to optionally provide results
+    gracefully, depending on source bounds
+*/
+struct RasterDatum
+{
+    static std::int32_t get_invalid() { return std::numeric_limits<std::int32_t>::max(); }
+
+    std::int32_t datum = get_invalid();
+
+    RasterDatum() = default;
+
+    RasterDatum(std::int32_t _datum) : datum(_datum) {}
+};
+
+class RasterGrid
+{
+  public:
+    RasterGrid(const boost::filesystem::path &filepath, std::size_t _xdim, std::size_t _ydim)
+    {
+        xdim = _xdim;
+        ydim = _ydim;
+        _data.reserve(ydim * xdim);
+
+        boost::filesystem::ifstream stream(filepath);
+        if (!stream)
+        {
+            throw osrm::exception("Unable to open raster file.");
+        }
+
+        stream.seekg(0, std::ios_base::end);
+        std::string buffer;
+        buffer.resize(static_cast<std::size_t>(stream.tellg()));
+
+        stream.seekg(0, std::ios_base::beg);
+
+        BOOST_ASSERT(buffer.size() > 1);
+        stream.read(&buffer[0], static_cast<std::streamsize>(buffer.size()));
+
+        boost::algorithm::trim(buffer);
+
+        auto itr = buffer.begin();
+        auto end = buffer.end();
+
+        bool r = false;
+        try
+        {
+            r = boost::spirit::qi::parse(
+                itr, end, +boost::spirit::qi::int_ % +boost::spirit::qi::space, _data);
+        }
+        catch (std::exception const &ex)
+        {
+            throw osrm::exception(
+                std::string("Failed to read from raster source with exception: ") + ex.what());
+        }
+
+        if (!r || itr != end)
+        {
+            throw osrm::exception("Failed to parse raster source correctly.");
+        }
+    }
+
+    RasterGrid(const RasterGrid &) = default;
+    RasterGrid &operator=(const RasterGrid &) = default;
+
+    RasterGrid(RasterGrid &&) = default;
+    RasterGrid &operator=(RasterGrid &&) = default;
+
+    std::int32_t operator()(std::size_t x, std::size_t y) { return _data[y * xdim + x]; }
+    std::int32_t operator()(std::size_t x, std::size_t y) const { return _data[(y)*xdim + (x)]; }
+
+  private:
+    std::vector<std::int32_t> _data;
+    std::size_t xdim, ydim;
+};
+
+/**
+    \brief Stores raster source data in memory and provides lookup functions.
+*/
+class RasterSource
+{
+  private:
+    const float xstep;
+    const float ystep;
+
+    float calcSize(int min, int max, std::size_t count) const;
+
+  public:
+    RasterGrid raster_data;
+
+    const std::size_t width;
+    const std::size_t height;
+    const int xmin;
+    const int xmax;
+    const int ymin;
+    const int ymax;
+
+    RasterDatum getRasterData(const int lon, const int lat) const;
+
+    RasterDatum getRasterInterpolate(const int lon, const int lat) const;
+
+    RasterSource(RasterGrid _raster_data,
+                 std::size_t width,
+                 std::size_t height,
+                 int _xmin,
+                 int _xmax,
+                 int _ymin,
+                 int _ymax);
+};
+
+class SourceContainer
+{
+  public:
+    SourceContainer() = default;
+
+    int loadRasterSource(const std::string &path_string,
+                         double xmin,
+                         double xmax,
+                         double ymin,
+                         double ymax,
+                         std::size_t nrows,
+                         std::size_t ncols);
+
+    RasterDatum getRasterDataFromSource(unsigned int source_id, int lon, int lat);
+
+    RasterDatum getRasterInterpolateFromSource(unsigned int source_id, int lon, int lat);
+
+  private:
+    std::vector<RasterSource> LoadedSources;
+    std::unordered_map<std::string, int> LoadedSourcePaths;
+};
+
+#endif /* RASTER_SOURCE_HPP */
@@ -28,7 +28,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef RECTANGLE_HPP
 #define RECTANGLE_HPP

-#include "coordinate_calculation.hpp"
+#include "../algorithms/coordinate_calculation.hpp"

 #include <boost/assert.hpp>

@@ -121,35 +121,35 @@ struct RectangleInt2D
        switch (d)
        {
        case NORTH:
-            min_dist = coordinate_calculation::euclidean_distance(
+            min_dist = coordinate_calculation::great_circle_distance(
                location, FixedPointCoordinate(max_lat, location.lon));
            break;
        case SOUTH:
-            min_dist = coordinate_calculation::euclidean_distance(
+            min_dist = coordinate_calculation::great_circle_distance(
                location, FixedPointCoordinate(min_lat, location.lon));
            break;
        case WEST:
-            min_dist = coordinate_calculation::euclidean_distance(
+            min_dist = coordinate_calculation::great_circle_distance(
                location, FixedPointCoordinate(location.lat, min_lon));
            break;
        case EAST:
-            min_dist = coordinate_calculation::euclidean_distance(
+            min_dist = coordinate_calculation::great_circle_distance(
                location, FixedPointCoordinate(location.lat, max_lon));
            break;
        case NORTH_EAST:
-            min_dist = coordinate_calculation::euclidean_distance(
+            min_dist = coordinate_calculation::great_circle_distance(
                location, FixedPointCoordinate(max_lat, max_lon));
            break;
        case NORTH_WEST:
-            min_dist = coordinate_calculation::euclidean_distance(
+            min_dist = coordinate_calculation::great_circle_distance(
                location, FixedPointCoordinate(max_lat, min_lon));
            break;
        case SOUTH_EAST:
-            min_dist = coordinate_calculation::euclidean_distance(
+            min_dist = coordinate_calculation::great_circle_distance(
                location, FixedPointCoordinate(min_lat, max_lon));
            break;
        case SOUTH_WEST:
-            min_dist = coordinate_calculation::euclidean_distance(
+            min_dist = coordinate_calculation::great_circle_distance(
                location, FixedPointCoordinate(min_lat, min_lon));
            break;
        default:
@@ -170,25 +170,25 @@ struct RectangleInt2D
        const FixedPointCoordinate lower_right(min_lat, max_lon);
        const FixedPointCoordinate lower_left(min_lat, min_lon);

-        min_max_dist =
-            std::min(min_max_dist,
-                     std::max(coordinate_calculation::euclidean_distance(location, upper_left),
-                              coordinate_calculation::euclidean_distance(location, upper_right)));
+        min_max_dist = std::min(
+            min_max_dist,
+            std::max(coordinate_calculation::great_circle_distance(location, upper_left),
+                     coordinate_calculation::great_circle_distance(location, upper_right)));
+
+        min_max_dist = std::min(
+            min_max_dist,
+            std::max(coordinate_calculation::great_circle_distance(location, upper_right),
+                     coordinate_calculation::great_circle_distance(location, lower_right)));

        min_max_dist =
            std::min(min_max_dist,
-                     std::max(coordinate_calculation::euclidean_distance(location, upper_right),
-                              coordinate_calculation::euclidean_distance(location, lower_right)));
+                     std::max(coordinate_calculation::great_circle_distance(location, lower_right),
+                              coordinate_calculation::great_circle_distance(location, lower_left)));

        min_max_dist =
            std::min(min_max_dist,
-                     std::max(coordinate_calculation::euclidean_distance(location, lower_right),
-                              coordinate_calculation::euclidean_distance(location, lower_left)));
-
-        min_max_dist =
-            std::min(min_max_dist,
-                     std::max(coordinate_calculation::euclidean_distance(location, lower_left),
-                              coordinate_calculation::euclidean_distance(location, upper_left)));
+                     std::max(coordinate_calculation::great_circle_distance(location, lower_left),
+                              coordinate_calculation::great_circle_distance(location, upper_left)));
        return min_max_dist;
    }

@@ -198,14 +198,6 @@ struct RectangleInt2D
        const bool lons_contained = (location.lon >= min_lon) && (location.lon <= max_lon);
        return lats_contained && lons_contained;
    }
-
-    friend std::ostream &operator<<(std::ostream &out, const RectangleInt2D &rect)
-    {
-        out << rect.min_lat / COORDINATE_PRECISION << "," << rect.min_lon / COORDINATE_PRECISION
-            << " " << rect.max_lat / COORDINATE_PRECISION << ","
-            << rect.max_lon / COORDINATE_PRECISION;
-        return out;
-    }
 };

 #endif
@@ -36,8 +36,8 @@ struct TurnRestriction
 {
    union WayOrNode
    {
-        NodeID node;
-        EdgeID way;
+        OSMNodeID_weak node;
+        OSMEdgeID_weak way;
    };
    WayOrNode via;
    WayOrNode from;
@@ -33,10 +33,16 @@ RestrictionMap::RestrictionMap(const std::vector<TurnRestriction> &restriction_l
    // a pair of starting edge and a list of all end nodes
    for (auto &restriction : restriction_list)
    {
+        // This downcasting is OK because when this is called, the node IDs have been
+        // renumbered into internal values, which should be well under 2^32
+        // This will be a problem if we have more than 2^32 actual restrictions
+        BOOST_ASSERT(restriction.from.node < std::numeric_limits<NodeID>::max());
+        BOOST_ASSERT(restriction.via.node < std::numeric_limits<NodeID>::max());
        m_restriction_start_nodes.insert(restriction.from.node);
        m_no_turn_via_node_set.insert(restriction.via.node);

-        RestrictionSource restriction_source = {restriction.from.node, restriction.via.node};
+        // This explicit downcasting is also OK for the same reason.
+        RestrictionSource restriction_source = {static_cast<NodeID>(restriction.from.node), static_cast<NodeID>(restriction.via.node)};

        std::size_t index;
        auto restriction_iter = m_restriction_map.find(restriction_source);
@@ -62,6 +68,7 @@ RestrictionMap::RestrictionMap(const std::vector<TurnRestriction> &restriction_l
            }
        }
        ++m_count;
+        BOOST_ASSERT(restriction.to.node < std::numeric_limits<NodeID>::max());
        m_restriction_bucket_list.at(index)
            .emplace_back(restriction.to.node, restriction.flags.is_only);
    }
@@ -156,7 +156,7 @@ class RestrictionMap
    bool
    CheckIfTurnIsRestricted(const NodeID node_u, const NodeID node_v, const NodeID node_w) const;

-    std::size_t size() { return m_count; }
+    std::size_t size() const { return m_count; }

  private:
    // check of node is the start of any restriction
@@ -28,6 +28,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <boost/fusion/container/vector.hpp>
 #include <boost/fusion/sequence/intrinsic.hpp>
 #include <boost/fusion/include/at_c.hpp>
+#include <boost/spirit/include/qi.hpp>

 #include <osrm/route_parameters.hpp>

@@ -36,7 +37,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 RouteParameters::RouteParameters()
    : zoom_level(18), print_instructions(false), alternate_route(true), geometry(true),
      compression(true), deprecatedAPI(false), uturn_default(false), classify(false),
-      matching_beta(-1.0), gps_precision(-1.0), check_sum(-1), num_results(1)
+      matching_beta(5), gps_precision(5), check_sum(-1), num_results(1)
 {
 }

@@ -60,11 +61,9 @@ void RouteParameters::setAlternateRouteFlag(const bool flag) { alternate_route =

 void RouteParameters::setUTurn(const bool flag)
 {
-    uturns.resize(coordinates.size(), uturn_default);
-    if (!uturns.empty())
-    {
-        uturns.back() = flag;
-    }
+    // the API grammar should make sure this never happens
+    BOOST_ASSERT(!uturns.empty());
+    uturns.back() = flag;
 }

 void RouteParameters::setAllUTurns(const bool flag)
@@ -117,6 +116,19 @@ void RouteParameters::addTimestamp(const unsigned timestamp)
    }
 }

+void RouteParameters::addBearing(
+    const boost::fusion::vector<int, boost::optional<int>> &received_bearing,
+        boost::spirit::qi::unused_type /* unused */, bool& pass)
+{
+    pass = false;
+    const int bearing = boost::fusion::at_c<0>(received_bearing);
+    const boost::optional<int> range = boost::fusion::at_c<1>(received_bearing);
+    if (bearing < 0 || bearing > 359) return;
+    if (range && (*range < 0 || *range > 180)) return;
+    bearings.emplace_back(std::make_pair(bearing,range));
+    pass = true;
+}
+
 void RouteParameters::setLanguage(const std::string &language_string)
 {
    language = language_string;
@@ -132,10 +144,36 @@ void RouteParameters::addCoordinate(
    coordinates.emplace_back(
        static_cast<int>(COORDINATE_PRECISION * boost::fusion::at_c<0>(received_coordinates)),
        static_cast<int>(COORDINATE_PRECISION * boost::fusion::at_c<1>(received_coordinates)));
+    is_source.push_back(true);
+    is_destination.push_back(true);
+    uturns.push_back(uturn_default);
 }

-void RouteParameters::getCoordinatesFromGeometry(const std::string geometry_string)
+void RouteParameters::addDestination(
+    const boost::fusion::vector<double, double> &received_coordinates)
+{
+    coordinates.emplace_back(
+        static_cast<int>(COORDINATE_PRECISION * boost::fusion::at_c<0>(received_coordinates)),
+        static_cast<int>(COORDINATE_PRECISION * boost::fusion::at_c<1>(received_coordinates)));
+    is_source.push_back(false);
+    is_destination.push_back(true);
+    uturns.push_back(uturn_default);
+}
+
+void RouteParameters::addSource(
+    const boost::fusion::vector<double, double> &received_coordinates)
+{
+    coordinates.emplace_back(
+        static_cast<int>(COORDINATE_PRECISION * boost::fusion::at_c<0>(received_coordinates)),
+        static_cast<int>(COORDINATE_PRECISION * boost::fusion::at_c<1>(received_coordinates)));
+    is_source.push_back(true);
+    is_destination.push_back(false);
+    uturns.push_back(uturn_default);
+}
+
+void RouteParameters::getCoordinatesFromGeometry(const std::string &geometry_string)
 {
    PolylineCompressor pc;
    coordinates = pc.decode_string(geometry_string);
 }
+
@@ -33,6 +33,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "../routing_algorithms/many_to_many.hpp"
 #include "../routing_algorithms/map_matching.hpp"
 #include "../routing_algorithms/shortest_path.hpp"
+#include "../routing_algorithms/direct_shortest_path.hpp"

 #include <type_traits>

@@ -44,6 +45,7 @@ template <class DataFacadeT> class SearchEngine

  public:
    ShortestPathRouting<DataFacadeT> shortest_path;
+    DirectShortestPathRouting<DataFacadeT> direct_shortest_path;
    AlternativeRouting<DataFacadeT> alternative_path;
    ManyToManyRouting<DataFacadeT> distance_table;
    MapMatching<DataFacadeT> map_matching;
@@ -51,6 +53,7 @@ template <class DataFacadeT> class SearchEngine
    explicit SearchEngine(DataFacadeT *facade)
        : facade(facade),
          shortest_path(facade, engine_working_data),
+          direct_shortest_path(facade, engine_working_data),
          alternative_path(facade, engine_working_data),
          distance_table(facade, engine_working_data),
          map_matching(facade, engine_working_data)
@@ -34,6 +34,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "../typedefs.h"

 #include <osrm/coordinate.hpp>
+#include <utility>

 // Struct fits everything in one cache line
 struct SegmentInformation
@@ -42,13 +43,14 @@ struct SegmentInformation
    NodeID name_id;
    EdgeWeight duration;
    float length;
-    short bearing; // more than enough [0..3600] fits into 12 bits
+    short pre_turn_bearing; // more than enough [0..3600] fits into 12 bits
+    short post_turn_bearing;
    TurnInstruction turn_instruction;
    TravelMode travel_mode;
    bool necessary;
    bool is_via_location;

-    explicit SegmentInformation(const FixedPointCoordinate &location,
+    explicit SegmentInformation(FixedPointCoordinate location,
                                const NodeID name_id,
                                const EdgeWeight duration,
                                const float length,
@@ -56,20 +58,20 @@ struct SegmentInformation
                                const bool necessary,
                                const bool is_via_location,
                                const TravelMode travel_mode)
-        : location(location), name_id(name_id), duration(duration), length(length), bearing(0),
-          turn_instruction(turn_instruction), travel_mode(travel_mode), necessary(necessary),
-          is_via_location(is_via_location)
+        : location(std::move(location)), name_id(name_id), duration(duration), length(length),
+          pre_turn_bearing(0), post_turn_bearing(0), turn_instruction(turn_instruction), travel_mode(travel_mode),
+          necessary(necessary), is_via_location(is_via_location)
    {
    }

-    explicit SegmentInformation(const FixedPointCoordinate &location,
+    explicit SegmentInformation(FixedPointCoordinate location,
                                const NodeID name_id,
                                const EdgeWeight duration,
                                const float length,
                                const TurnInstruction turn_instruction,
                                const TravelMode travel_mode)
-        : location(location), name_id(name_id), duration(duration), length(length), bearing(0),
-          turn_instruction(turn_instruction), travel_mode(travel_mode),
+        : location(std::move(location)), name_id(name_id), duration(duration), length(length),
+          pre_turn_bearing(0), post_turn_bearing(0), turn_instruction(turn_instruction), travel_mode(travel_mode),
          necessary(turn_instruction != TurnInstruction::NoTurn), is_via_location(false)
    {
    }
@@ -99,6 +99,7 @@ class SharedMemory

    SharedMemory() = delete;
    SharedMemory(const SharedMemory &) = delete;
+    SharedMemory &operator=(const SharedMemory &) = delete;

    template <typename IdentifierT>
    SharedMemory(const boost::filesystem::path &lock_file,
@@ -126,7 +127,7 @@ class SharedMemory
            shm = boost::interprocess::xsi_shared_memory(boost::interprocess::open_or_create, key,
                                                         size);
 #ifdef __linux__
-            if (-1 == shmctl(shm.get_shmid(), SHM_LOCK, 0))
+            if (-1 == shmctl(shm.get_shmid(), SHM_LOCK, nullptr))
            {
                if (ENOMEM == errno)
                {
@@ -208,11 +209,13 @@ class SharedMemory
 class SharedMemory
 {
    SharedMemory(const SharedMemory &) = delete;
+    SharedMemory &operator=(const SharedMemory &) = delete;
    // Remove shared memory on destruction
    class shm_remove
    {
      private:
        shm_remove(const shm_remove &) = delete;
+        shm_remove &operator=(const shm_remove &) = delete;
        char *m_shmid;
        bool m_initialized;

@@ -375,6 +378,7 @@ template <class LockFileT = OSRMLockFile> class SharedMemoryFactory_tmpl

    SharedMemoryFactory_tmpl() = delete;
    SharedMemoryFactory_tmpl(const SharedMemoryFactory_tmpl &) = delete;
+    SharedMemoryFactory_tmpl &operator=(const SharedMemoryFactory_tmpl &) = delete;
 };

 using SharedMemoryFactory = SharedMemoryFactory_tmpl<>;
@@ -87,8 +87,11 @@ template <typename EdgeDataT, bool UseSharedMemory = false> class StaticGraph
        return osrm::irange(BeginEdges(node), EndEdges(node));
    }

-    StaticGraph(const int nodes, std::vector<InputEdge> &graph)
+    template<typename ContainerT>
+    StaticGraph(const int nodes, const ContainerT &graph)
    {
+        BOOST_ASSERT(std::is_sorted(const_cast<ContainerT&>(graph).begin(), const_cast<ContainerT&>(graph).end()));
+
        number_of_nodes = nodes;
        number_of_edges = static_cast<EdgeIterator>(graph.size());
        node_array.resize(number_of_nodes + 1);
@@ -38,7 +38,6 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "server/data_structures/datafacade_base.hpp"
 #include "server/data_structures/shared_datatype.hpp"
 #include "server/data_structures/shared_barriers.hpp"
-#include "util/boost_filesystem_2_fix.hpp"
 #include "util/datastore_options.hpp"
 #include "util/simple_logger.hpp"
 #include "util/osrm_exception.hpp"
@@ -46,7 +45,6 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "typedefs.h"

 #include <osrm/coordinate.hpp>
-#include <osrm/server_paths.hpp>

 using RTreeLeaf = BaseDataFacade<QueryEdge::EdgeData>::RTreeLeaf;
 using RTreeNode = StaticRTree<RTreeLeaf, ShM<FixedPointCoordinate, true>::vector, true>::TreeNode;
@@ -63,6 +61,7 @@ using QueryGraph = StaticGraph<QueryEdge::EdgeData>;

 #include <fstream>
 #include <string>
+#include <new>

 // delete a shared memory region. report warning if it could not be deleted
 void delete_region(const SharedDataType region)
@@ -94,346 +93,437 @@ void delete_region(const SharedDataType region)
    }
 }

-int main(const int argc, const char *argv[])
+int main(const int argc, const char *argv[]) try
 {
    LogPolicy::GetInstance().Unmute();
    SharedBarriers barrier;

-    try
-    {
 #ifdef __linux__
-        // try to disable swapping on Linux
-        const bool lock_flags = MCL_CURRENT | MCL_FUTURE;
-        if (-1 == mlockall(lock_flags))
-        {
-            SimpleLogger().Write(logWARNING) << "Process " << argv[0]
-                                             << " could not request RAM lock";
-        }
-#endif
-        try
-        {
-            boost::interprocess::scoped_lock<boost::interprocess::named_mutex> pending_lock(
-                barrier.pending_update_mutex);
-        }
-        catch (...)
-        {
-            // hard unlock in case of any exception.
-            barrier.pending_update_mutex.unlock();
-        }
-    }
-    catch (const std::exception &e)
+    // try to disable swapping on Linux
+    const bool lock_flags = MCL_CURRENT | MCL_FUTURE;
+    if (-1 == mlockall(lock_flags))
    {
-        SimpleLogger().Write(logWARNING) << "[exception] " << e.what();
+        SimpleLogger().Write(logWARNING) << "Process " << argv[0] << " could not request RAM lock";
    }
+#endif

    try
    {
-        SimpleLogger().Write(logDEBUG) << "Checking input parameters";
+        boost::interprocess::scoped_lock<boost::interprocess::named_mutex> pending_lock(
+            barrier.pending_update_mutex);
+    }
+    catch (...)
+    {
+        // hard unlock in case of any exception.
+        barrier.pending_update_mutex.unlock();
+    }

-        ServerPaths server_paths;
-        if (!GenerateDataStoreOptions(argc, argv, server_paths))
-        {
-            return 0;
-        }
+    SimpleLogger().Write(logDEBUG) << "Checking input parameters";

-        if (server_paths.find("hsgrdata") == server_paths.end())
-        {
-            throw osrm::exception("no hsgr file found");
-        }
-        if (server_paths.find("ramindex") == server_paths.end())
-        {
-            throw osrm::exception("no ram index file found");
-        }
-        if (server_paths.find("fileindex") == server_paths.end())
-        {
-            throw osrm::exception("no leaf index file found");
-        }
-        if (server_paths.find("nodesdata") == server_paths.end())
-        {
-            throw osrm::exception("no nodes file found");
-        }
-        if (server_paths.find("edgesdata") == server_paths.end())
-        {
-            throw osrm::exception("no edges file found");
-        }
-        if (server_paths.find("namesdata") == server_paths.end())
-        {
-            throw osrm::exception("no names file found");
-        }
-        if (server_paths.find("geometry") == server_paths.end())
-        {
-            throw osrm::exception("no geometry file found");
-        }
+    std::unordered_map<std::string, boost::filesystem::path> server_paths;
+    if (!GenerateDataStoreOptions(argc, argv, server_paths))
+    {
+        return EXIT_SUCCESS;
+    }

-        ServerPaths::const_iterator paths_iterator = server_paths.find("hsgrdata");
-        BOOST_ASSERT(server_paths.end() != paths_iterator);
-        BOOST_ASSERT(!paths_iterator->second.empty());
-        const boost::filesystem::path &hsgr_path = paths_iterator->second;
-        paths_iterator = server_paths.find("timestamp");
-        BOOST_ASSERT(server_paths.end() != paths_iterator);
-        BOOST_ASSERT(!paths_iterator->second.empty());
-        const boost::filesystem::path &timestamp_path = paths_iterator->second;
-        paths_iterator = server_paths.find("ramindex");
-        BOOST_ASSERT(server_paths.end() != paths_iterator);
-        BOOST_ASSERT(!paths_iterator->second.empty());
-        const boost::filesystem::path &ram_index_path = paths_iterator->second;
-        paths_iterator = server_paths.find("fileindex");
-        BOOST_ASSERT(server_paths.end() != paths_iterator);
-        BOOST_ASSERT(!paths_iterator->second.empty());
-        const boost::filesystem::path index_file_path_absolute =
-            boost::filesystem::portable_canonical(paths_iterator->second);
-        const std::string &file_index_path = index_file_path_absolute.string();
-        paths_iterator = server_paths.find("nodesdata");
-        BOOST_ASSERT(server_paths.end() != paths_iterator);
-        BOOST_ASSERT(!paths_iterator->second.empty());
-        const boost::filesystem::path &nodes_data_path = paths_iterator->second;
-        paths_iterator = server_paths.find("edgesdata");
-        BOOST_ASSERT(server_paths.end() != paths_iterator);
-        BOOST_ASSERT(!paths_iterator->second.empty());
-        const boost::filesystem::path &edges_data_path = paths_iterator->second;
-        paths_iterator = server_paths.find("namesdata");
-        BOOST_ASSERT(server_paths.end() != paths_iterator);
-        BOOST_ASSERT(!paths_iterator->second.empty());
-        const boost::filesystem::path &names_data_path = paths_iterator->second;
-        paths_iterator = server_paths.find("geometry");
-        BOOST_ASSERT(server_paths.end() != paths_iterator);
-        BOOST_ASSERT(!paths_iterator->second.empty());
-        const boost::filesystem::path &geometries_data_path = paths_iterator->second;
+    if (server_paths.find("hsgrdata") == server_paths.end())
+    {
+        throw osrm::exception("no hsgr file found");
+    }
+    if (server_paths.find("ramindex") == server_paths.end())
+    {
+        throw osrm::exception("no ram index file found");
+    }
+    if (server_paths.find("fileindex") == server_paths.end())
+    {
+        throw osrm::exception("no leaf index file found");
+    }
+    if (server_paths.find("nodesdata") == server_paths.end())
+    {
+        throw osrm::exception("no nodes file found");
+    }
+    if (server_paths.find("edgesdata") == server_paths.end())
+    {
+        throw osrm::exception("no edges file found");
+    }
+    if (server_paths.find("namesdata") == server_paths.end())
+    {
+        throw osrm::exception("no names file found");
+    }
+    if (server_paths.find("geometry") == server_paths.end())
+    {
+        throw osrm::exception("no geometry file found");
+    }
+    if (server_paths.find("core") == server_paths.end())
+    {
+        throw osrm::exception("no core file found");
+    }

-        // determine segment to use
-        bool segment2_in_use = SharedMemory::RegionExists(LAYOUT_2);
-        const SharedDataType layout_region = [&]
-        {
-            return segment2_in_use ? LAYOUT_1 : LAYOUT_2;
-        }();
-        const SharedDataType data_region = [&]
-        {
-            return segment2_in_use ? DATA_1 : DATA_2;
-        }();
-        const SharedDataType previous_layout_region = [&]
-        {
-            return segment2_in_use ? LAYOUT_2 : LAYOUT_1;
-        }();
-        const SharedDataType previous_data_region = [&]
-        {
-            return segment2_in_use ? DATA_2 : DATA_1;
-        }();
+    auto paths_iterator = server_paths.find("hsgrdata");
+    BOOST_ASSERT(server_paths.end() != paths_iterator);
+    BOOST_ASSERT(!paths_iterator->second.empty());
+    const boost::filesystem::path &hsgr_path = paths_iterator->second;
+    paths_iterator = server_paths.find("timestamp");
+    BOOST_ASSERT(server_paths.end() != paths_iterator);
+    BOOST_ASSERT(!paths_iterator->second.empty());
+    const boost::filesystem::path &timestamp_path = paths_iterator->second;
+    paths_iterator = server_paths.find("ramindex");
+    BOOST_ASSERT(server_paths.end() != paths_iterator);
+    BOOST_ASSERT(!paths_iterator->second.empty());
+    const boost::filesystem::path &ram_index_path = paths_iterator->second;
+    paths_iterator = server_paths.find("fileindex");
+    BOOST_ASSERT(server_paths.end() != paths_iterator);
+    BOOST_ASSERT(!paths_iterator->second.empty());
+    const boost::filesystem::path index_file_path_absolute =
+        boost::filesystem::canonical(paths_iterator->second);
+    const std::string &file_index_path = index_file_path_absolute.string();
+    paths_iterator = server_paths.find("nodesdata");
+    BOOST_ASSERT(server_paths.end() != paths_iterator);
+    BOOST_ASSERT(!paths_iterator->second.empty());
+    const boost::filesystem::path &nodes_data_path = paths_iterator->second;
+    paths_iterator = server_paths.find("edgesdata");
+    BOOST_ASSERT(server_paths.end() != paths_iterator);
+    BOOST_ASSERT(!paths_iterator->second.empty());
+    const boost::filesystem::path &edges_data_path = paths_iterator->second;
+    paths_iterator = server_paths.find("namesdata");
+    BOOST_ASSERT(server_paths.end() != paths_iterator);
+    BOOST_ASSERT(!paths_iterator->second.empty());
+    const boost::filesystem::path &names_data_path = paths_iterator->second;
+    paths_iterator = server_paths.find("geometry");
+    BOOST_ASSERT(server_paths.end() != paths_iterator);
+    BOOST_ASSERT(!paths_iterator->second.empty());
+    const boost::filesystem::path &geometries_data_path = paths_iterator->second;
+    paths_iterator = server_paths.find("core");
+    BOOST_ASSERT(server_paths.end() != paths_iterator);
+    BOOST_ASSERT(!paths_iterator->second.empty());
+    const boost::filesystem::path &core_marker_path = paths_iterator->second;

-        // Allocate a memory layout in shared memory, deallocate previous
-        SharedMemory *layout_memory =
-            SharedMemoryFactory::Get(layout_region, sizeof(SharedDataLayout));
-        SharedDataLayout *shared_layout_ptr = static_cast<SharedDataLayout *>(layout_memory->Ptr());
-        shared_layout_ptr = new (layout_memory->Ptr()) SharedDataLayout();
+    // determine segment to use
+    bool segment2_in_use = SharedMemory::RegionExists(LAYOUT_2);
+    const SharedDataType layout_region = [&]
+    {
+        return segment2_in_use ? LAYOUT_1 : LAYOUT_2;
+    }();
+    const SharedDataType data_region = [&]
+    {
+        return segment2_in_use ? DATA_1 : DATA_2;
+    }();
+    const SharedDataType previous_layout_region = [&]
+    {
+        return segment2_in_use ? LAYOUT_2 : LAYOUT_1;
+    }();
+    const SharedDataType previous_data_region = [&]
+    {
+        return segment2_in_use ? DATA_2 : DATA_1;
+    }();

-        shared_layout_ptr->SetBlockSize<char>(SharedDataLayout::FILE_INDEX_PATH,
-                                              file_index_path.length() + 1);
+    // Allocate a memory layout in shared memory, deallocate previous
+    auto *layout_memory = SharedMemoryFactory::Get(layout_region, sizeof(SharedDataLayout));
+    auto *shared_layout_ptr = new (layout_memory->Ptr()) SharedDataLayout();

-        // collect number of elements to store in shared memory object
-        SimpleLogger().Write() << "load names from: " << names_data_path;
-        // number of entries in name index
-        boost::filesystem::ifstream name_stream(names_data_path, std::ios::binary);
-        unsigned name_blocks = 0;
-        name_stream.read((char *)&name_blocks, sizeof(unsigned));
-        shared_layout_ptr->SetBlockSize<unsigned>(SharedDataLayout::NAME_OFFSETS, name_blocks);
-        shared_layout_ptr->SetBlockSize<typename RangeTable<16, true>::BlockT>(
-            SharedDataLayout::NAME_BLOCKS, name_blocks);
-        SimpleLogger().Write() << "name offsets size: " << name_blocks;
-        BOOST_ASSERT_MSG(0 != name_blocks, "name file broken");
+    shared_layout_ptr->SetBlockSize<char>(SharedDataLayout::FILE_INDEX_PATH,
+                                          file_index_path.length() + 1);

-        unsigned number_of_chars = 0;
-        name_stream.read((char *)&number_of_chars, sizeof(unsigned));
-        shared_layout_ptr->SetBlockSize<char>(SharedDataLayout::NAME_CHAR_LIST, number_of_chars);
+    // collect number of elements to store in shared memory object
+    SimpleLogger().Write() << "load names from: " << names_data_path;
+    // number of entries in name index
+    boost::filesystem::ifstream name_stream(names_data_path, std::ios::binary);
+    unsigned name_blocks = 0;
+    name_stream.read((char *)&name_blocks, sizeof(unsigned));
+    shared_layout_ptr->SetBlockSize<unsigned>(SharedDataLayout::NAME_OFFSETS, name_blocks);
+    shared_layout_ptr->SetBlockSize<typename RangeTable<16, true>::BlockT>(
+        SharedDataLayout::NAME_BLOCKS, name_blocks);
+    SimpleLogger().Write() << "name offsets size: " << name_blocks;
+    BOOST_ASSERT_MSG(0 != name_blocks, "name file broken");

-        // Loading information for original edges
-        boost::filesystem::ifstream edges_input_stream(edges_data_path, std::ios::binary);
-        unsigned number_of_original_edges = 0;
-        edges_input_stream.read((char *)&number_of_original_edges, sizeof(unsigned));
+    unsigned number_of_chars = 0;
+    name_stream.read((char *)&number_of_chars, sizeof(unsigned));
+    shared_layout_ptr->SetBlockSize<char>(SharedDataLayout::NAME_CHAR_LIST, number_of_chars);

-        // note: settings this all to the same size is correct, we extract them from the same struct
-        shared_layout_ptr->SetBlockSize<NodeID>(SharedDataLayout::VIA_NODE_LIST,
+    // Loading information for original edges
+    boost::filesystem::ifstream edges_input_stream(edges_data_path, std::ios::binary);
+    unsigned number_of_original_edges = 0;
+    edges_input_stream.read((char *)&number_of_original_edges, sizeof(unsigned));
+
+    // note: settings this all to the same size is correct, we extract them from the same struct
+    shared_layout_ptr->SetBlockSize<NodeID>(SharedDataLayout::VIA_NODE_LIST,
+                                            number_of_original_edges);
+    shared_layout_ptr->SetBlockSize<unsigned>(SharedDataLayout::NAME_ID_LIST,
+                                              number_of_original_edges);
+    shared_layout_ptr->SetBlockSize<TravelMode>(SharedDataLayout::TRAVEL_MODE,
                                                number_of_original_edges);
-        shared_layout_ptr->SetBlockSize<unsigned>(SharedDataLayout::NAME_ID_LIST,
-                                                  number_of_original_edges);
-        shared_layout_ptr->SetBlockSize<TravelMode>(SharedDataLayout::TRAVEL_MODE,
-                                                    number_of_original_edges);
-        shared_layout_ptr->SetBlockSize<TurnInstruction>(SharedDataLayout::TURN_INSTRUCTION,
-                                                         number_of_original_edges);
-        // note: there are 32 geometry indicators in one unsigned block
-        shared_layout_ptr->SetBlockSize<unsigned>(SharedDataLayout::GEOMETRIES_INDICATORS,
-                                                  number_of_original_edges);
+    shared_layout_ptr->SetBlockSize<TurnInstruction>(SharedDataLayout::TURN_INSTRUCTION,
+                                                     number_of_original_edges);
+    // note: there are 32 geometry indicators in one unsigned block
+    shared_layout_ptr->SetBlockSize<unsigned>(SharedDataLayout::GEOMETRIES_INDICATORS,
+                                              number_of_original_edges);

-        boost::filesystem::ifstream hsgr_input_stream(hsgr_path, std::ios::binary);
+    boost::filesystem::ifstream hsgr_input_stream(hsgr_path, std::ios::binary);

-        FingerPrint fingerprint_valid = FingerPrint::GetValid();
-        FingerPrint fingerprint_loaded;
-        hsgr_input_stream.read((char *)&fingerprint_loaded, sizeof(FingerPrint));
-        if (fingerprint_loaded.TestGraphUtil(fingerprint_valid))
+    FingerPrint fingerprint_valid = FingerPrint::GetValid();
+    FingerPrint fingerprint_loaded;
+    hsgr_input_stream.read((char *)&fingerprint_loaded, sizeof(FingerPrint));
+    if (fingerprint_loaded.TestGraphUtil(fingerprint_valid))
+    {
+        SimpleLogger().Write(logDEBUG) << "Fingerprint checked out ok";
+    }
+    else
+    {
+        SimpleLogger().Write(logWARNING) << ".hsgr was prepared with different build. "
+                                            "Reprocess to get rid of this warning.";
+    }
+
+    // load checksum
+    unsigned checksum = 0;
+    hsgr_input_stream.read((char *)&checksum, sizeof(unsigned));
+    shared_layout_ptr->SetBlockSize<unsigned>(SharedDataLayout::HSGR_CHECKSUM, 1);
+    // load graph node size
+    unsigned number_of_graph_nodes = 0;
+    hsgr_input_stream.read((char *)&number_of_graph_nodes, sizeof(unsigned));
+
+    BOOST_ASSERT_MSG((0 != number_of_graph_nodes), "number of nodes is zero");
+    shared_layout_ptr->SetBlockSize<QueryGraph::NodeArrayEntry>(SharedDataLayout::GRAPH_NODE_LIST,
+                                                                number_of_graph_nodes);
+
+    // load graph edge size
+    unsigned number_of_graph_edges = 0;
+    hsgr_input_stream.read((char *)&number_of_graph_edges, sizeof(unsigned));
+    // BOOST_ASSERT_MSG(0 != number_of_graph_edges, "number of graph edges is zero");
+    shared_layout_ptr->SetBlockSize<QueryGraph::EdgeArrayEntry>(SharedDataLayout::GRAPH_EDGE_LIST,
+                                                                number_of_graph_edges);
+
+    // load rsearch tree size
+    boost::filesystem::ifstream tree_node_file(ram_index_path, std::ios::binary);
+
+    uint32_t tree_size = 0;
+    tree_node_file.read((char *)&tree_size, sizeof(uint32_t));
+    shared_layout_ptr->SetBlockSize<RTreeNode>(SharedDataLayout::R_SEARCH_TREE, tree_size);
+
+    // load timestamp size
+    std::string m_timestamp;
+    if (boost::filesystem::exists(timestamp_path))
+    {
+        boost::filesystem::ifstream timestamp_stream(timestamp_path);
+        if (!timestamp_stream)
        {
-            SimpleLogger().Write(logDEBUG) << "Fingerprint checked out ok";
+            SimpleLogger().Write(logWARNING) << timestamp_path << " not found. setting to default";
        }
        else
        {
-            SimpleLogger().Write(logWARNING) << ".hsgr was prepared with different build. "
-                                                "Reprocess to get rid of this warning.";
+            getline(timestamp_stream, m_timestamp);
+            timestamp_stream.close();
        }
+    }
+    if (m_timestamp.empty())
+    {
+        m_timestamp = "n/a";
+    }
+    if (25 < m_timestamp.length())
+    {
+        m_timestamp.resize(25);
+    }
+    shared_layout_ptr->SetBlockSize<char>(SharedDataLayout::TIMESTAMP, m_timestamp.length());

-        // load checksum
-        unsigned checksum = 0;
-        hsgr_input_stream.read((char *)&checksum, sizeof(unsigned));
-        shared_layout_ptr->SetBlockSize<unsigned>(SharedDataLayout::HSGR_CHECKSUM, 1);
-        // load graph node size
-        unsigned number_of_graph_nodes = 0;
-        hsgr_input_stream.read((char *)&number_of_graph_nodes, sizeof(unsigned));
+    // load core marker size
+    boost::filesystem::ifstream core_marker_file(core_marker_path, std::ios::binary);

-        BOOST_ASSERT_MSG((0 != number_of_graph_nodes), "number of nodes is zero");
-        shared_layout_ptr->SetBlockSize<QueryGraph::NodeArrayEntry>(
-            SharedDataLayout::GRAPH_NODE_LIST, number_of_graph_nodes);
+    uint32_t number_of_core_markers = 0;
+    core_marker_file.read((char *)&number_of_core_markers, sizeof(uint32_t));
+    shared_layout_ptr->SetBlockSize<unsigned>(SharedDataLayout::CORE_MARKER,
+                                              number_of_core_markers);

-        // load graph edge size
-        unsigned number_of_graph_edges = 0;
-        hsgr_input_stream.read((char *)&number_of_graph_edges, sizeof(unsigned));
-        // BOOST_ASSERT_MSG(0 != number_of_graph_edges, "number of graph edges is zero");
-        shared_layout_ptr->SetBlockSize<QueryGraph::EdgeArrayEntry>(
-            SharedDataLayout::GRAPH_EDGE_LIST, number_of_graph_edges);
+    // load coordinate size
+    boost::filesystem::ifstream nodes_input_stream(nodes_data_path, std::ios::binary);
+    unsigned coordinate_list_size = 0;
+    nodes_input_stream.read((char *)&coordinate_list_size, sizeof(unsigned));
+    shared_layout_ptr->SetBlockSize<FixedPointCoordinate>(SharedDataLayout::COORDINATE_LIST,
+                                                          coordinate_list_size);

-        // load rsearch tree size
-        boost::filesystem::ifstream tree_node_file(ram_index_path, std::ios::binary);
+    // load geometries sizes
+    std::ifstream geometry_input_stream(geometries_data_path.string().c_str(), std::ios::binary);
+    unsigned number_of_geometries_indices = 0;
+    unsigned number_of_compressed_geometries = 0;

-        uint32_t tree_size = 0;
-        tree_node_file.read((char *)&tree_size, sizeof(uint32_t));
-        shared_layout_ptr->SetBlockSize<RTreeNode>(SharedDataLayout::R_SEARCH_TREE, tree_size);
+    geometry_input_stream.read((char *)&number_of_geometries_indices, sizeof(unsigned));
+    shared_layout_ptr->SetBlockSize<unsigned>(SharedDataLayout::GEOMETRIES_INDEX,
+                                              number_of_geometries_indices);
+    boost::iostreams::seek(geometry_input_stream, number_of_geometries_indices * sizeof(unsigned),
+                           BOOST_IOS::cur);
+    geometry_input_stream.read((char *)&number_of_compressed_geometries, sizeof(unsigned));
+    shared_layout_ptr->SetBlockSize<unsigned>(SharedDataLayout::GEOMETRIES_LIST,
+                                              number_of_compressed_geometries);
+    // allocate shared memory block
+    SimpleLogger().Write() << "allocating shared memory of " << shared_layout_ptr->GetSizeOfLayout()
+                           << " bytes";
+    SharedMemory *shared_memory =
+        SharedMemoryFactory::Get(data_region, shared_layout_ptr->GetSizeOfLayout());
+    char *shared_memory_ptr = static_cast<char *>(shared_memory->Ptr());

-        // load timestamp size
-        std::string m_timestamp;
-        if (boost::filesystem::exists(timestamp_path))
+    // read actual data into shared memory object //
+
+    // hsgr checksum
+    unsigned *checksum_ptr = shared_layout_ptr->GetBlockPtr<unsigned, true>(
+        shared_memory_ptr, SharedDataLayout::HSGR_CHECKSUM);
+    *checksum_ptr = checksum;
+
+    // ram index file name
+    char *file_index_path_ptr = shared_layout_ptr->GetBlockPtr<char, true>(
+        shared_memory_ptr, SharedDataLayout::FILE_INDEX_PATH);
+    // make sure we have 0 ending
+    std::fill(file_index_path_ptr,
+              file_index_path_ptr +
+                  shared_layout_ptr->GetBlockSize(SharedDataLayout::FILE_INDEX_PATH),
+              0);
+    std::copy(file_index_path.begin(), file_index_path.end(), file_index_path_ptr);
+
+    // Loading street names
+    unsigned *name_offsets_ptr = shared_layout_ptr->GetBlockPtr<unsigned, true>(
+        shared_memory_ptr, SharedDataLayout::NAME_OFFSETS);
+    if (shared_layout_ptr->GetBlockSize(SharedDataLayout::NAME_OFFSETS) > 0)
+    {
+        name_stream.read((char *)name_offsets_ptr,
+                         shared_layout_ptr->GetBlockSize(SharedDataLayout::NAME_OFFSETS));
+    }
+
+    unsigned *name_blocks_ptr = shared_layout_ptr->GetBlockPtr<unsigned, true>(
+        shared_memory_ptr, SharedDataLayout::NAME_BLOCKS);
+    if (shared_layout_ptr->GetBlockSize(SharedDataLayout::NAME_BLOCKS) > 0)
+    {
+        name_stream.read((char *)name_blocks_ptr,
+                         shared_layout_ptr->GetBlockSize(SharedDataLayout::NAME_BLOCKS));
+    }
+
+    char *name_char_ptr = shared_layout_ptr->GetBlockPtr<char, true>(
+        shared_memory_ptr, SharedDataLayout::NAME_CHAR_LIST);
+    unsigned temp_length;
+    name_stream.read((char *)&temp_length, sizeof(unsigned));
+
+    BOOST_ASSERT_MSG(temp_length ==
+                         shared_layout_ptr->GetBlockSize(SharedDataLayout::NAME_CHAR_LIST),
+                     "Name file corrupted!");
+
+    if (shared_layout_ptr->GetBlockSize(SharedDataLayout::NAME_CHAR_LIST) > 0)
+    {
+        name_stream.read(name_char_ptr,
+                         shared_layout_ptr->GetBlockSize(SharedDataLayout::NAME_CHAR_LIST));
+    }
+
+    name_stream.close();
+
+    // load original edge information
+    NodeID *via_node_ptr = shared_layout_ptr->GetBlockPtr<NodeID, true>(
+        shared_memory_ptr, SharedDataLayout::VIA_NODE_LIST);
+
+    unsigned *name_id_ptr = shared_layout_ptr->GetBlockPtr<unsigned, true>(
+        shared_memory_ptr, SharedDataLayout::NAME_ID_LIST);
+
+    TravelMode *travel_mode_ptr = shared_layout_ptr->GetBlockPtr<TravelMode, true>(
+        shared_memory_ptr, SharedDataLayout::TRAVEL_MODE);
+
+    TurnInstruction *turn_instructions_ptr = shared_layout_ptr->GetBlockPtr<TurnInstruction, true>(
+        shared_memory_ptr, SharedDataLayout::TURN_INSTRUCTION);
+
+    unsigned *geometries_indicator_ptr = shared_layout_ptr->GetBlockPtr<unsigned, true>(
+        shared_memory_ptr, SharedDataLayout::GEOMETRIES_INDICATORS);
+
+    OriginalEdgeData current_edge_data;
+    for (unsigned i = 0; i < number_of_original_edges; ++i)
+    {
+        edges_input_stream.read((char *)&(current_edge_data), sizeof(OriginalEdgeData));
+        via_node_ptr[i] = current_edge_data.via_node;
+        name_id_ptr[i] = current_edge_data.name_id;
+        travel_mode_ptr[i] = current_edge_data.travel_mode;
+        turn_instructions_ptr[i] = current_edge_data.turn_instruction;
+
+        const unsigned bucket = i / 32;
+        const unsigned offset = i % 32;
+        const unsigned value = [&]
        {
-            boost::filesystem::ifstream timestamp_stream(timestamp_path);
-            if (!timestamp_stream)
+            unsigned return_value = 0;
+            if (0 != offset)
            {
-                SimpleLogger().Write(logWARNING) << timestamp_path
-                                                 << " not found. setting to default";
+                return_value = geometries_indicator_ptr[bucket];
            }
-            else
-            {
-                getline(timestamp_stream, m_timestamp);
-                timestamp_stream.close();
-            }
-        }
-        if (m_timestamp.empty())
+            return return_value;
+        }();
+        if (current_edge_data.compressed_geometry)
        {
-            m_timestamp = "n/a";
+            geometries_indicator_ptr[bucket] = (value | (1 << offset));
        }
-        if (25 < m_timestamp.length())
+    }
+    edges_input_stream.close();
+
+    // load compressed geometry
+    unsigned temporary_value;
+    unsigned *geometries_index_ptr = shared_layout_ptr->GetBlockPtr<unsigned, true>(
+        shared_memory_ptr, SharedDataLayout::GEOMETRIES_INDEX);
+    geometry_input_stream.seekg(0, geometry_input_stream.beg);
+    geometry_input_stream.read((char *)&temporary_value, sizeof(unsigned));
+    BOOST_ASSERT(temporary_value ==
+                 shared_layout_ptr->num_entries[SharedDataLayout::GEOMETRIES_INDEX]);
+
+    if (shared_layout_ptr->GetBlockSize(SharedDataLayout::GEOMETRIES_INDEX) > 0)
+    {
+        geometry_input_stream.read(
+            (char *)geometries_index_ptr,
+            shared_layout_ptr->GetBlockSize(SharedDataLayout::GEOMETRIES_INDEX));
+    }
+    unsigned *geometries_list_ptr = shared_layout_ptr->GetBlockPtr<unsigned, true>(
+        shared_memory_ptr, SharedDataLayout::GEOMETRIES_LIST);
+
+    geometry_input_stream.read((char *)&temporary_value, sizeof(unsigned));
+    BOOST_ASSERT(temporary_value ==
+                 shared_layout_ptr->num_entries[SharedDataLayout::GEOMETRIES_LIST]);
+
+    if (shared_layout_ptr->GetBlockSize(SharedDataLayout::GEOMETRIES_LIST) > 0)
+    {
+        geometry_input_stream.read(
+            (char *)geometries_list_ptr,
+            shared_layout_ptr->GetBlockSize(SharedDataLayout::GEOMETRIES_LIST));
+    }
+
+    // Loading list of coordinates
+    FixedPointCoordinate *coordinates_ptr =
+        shared_layout_ptr->GetBlockPtr<FixedPointCoordinate, true>(
+            shared_memory_ptr, SharedDataLayout::COORDINATE_LIST);
+
+    QueryNode current_node;
+    for (unsigned i = 0; i < coordinate_list_size; ++i)
+    {
+        nodes_input_stream.read((char *)&current_node, sizeof(QueryNode));
+        coordinates_ptr[i] = FixedPointCoordinate(current_node.lat, current_node.lon);
+    }
+    nodes_input_stream.close();
+
+    // store timestamp
+    char *timestamp_ptr =
+        shared_layout_ptr->GetBlockPtr<char, true>(shared_memory_ptr, SharedDataLayout::TIMESTAMP);
+    std::copy(m_timestamp.c_str(), m_timestamp.c_str() + m_timestamp.length(), timestamp_ptr);
+
+    // store search tree portion of rtree
+    char *rtree_ptr = shared_layout_ptr->GetBlockPtr<char, true>(shared_memory_ptr,
+                                                                 SharedDataLayout::R_SEARCH_TREE);
+
+    if (tree_size > 0)
+    {
+        tree_node_file.read(rtree_ptr, sizeof(RTreeNode) * tree_size);
+    }
+    tree_node_file.close();
+
+    // load core markers
+    std::vector<char> unpacked_core_markers(number_of_core_markers);
+    core_marker_file.read((char *)unpacked_core_markers.data(),
+                          sizeof(char) * number_of_core_markers);
+
+    unsigned *core_marker_ptr = shared_layout_ptr->GetBlockPtr<unsigned, true>(
+        shared_memory_ptr, SharedDataLayout::CORE_MARKER);
+
+    for (auto i = 0u; i < number_of_core_markers; ++i)
+    {
+        BOOST_ASSERT(unpacked_core_markers[i] == 0 || unpacked_core_markers[i] == 1);
+
+        if (unpacked_core_markers[i] == 1)
        {
-            m_timestamp.resize(25);
-        }
-        shared_layout_ptr->SetBlockSize<char>(SharedDataLayout::TIMESTAMP, m_timestamp.length());
-
-        // load coordinate size
-        boost::filesystem::ifstream nodes_input_stream(nodes_data_path, std::ios::binary);
-        unsigned coordinate_list_size = 0;
-        nodes_input_stream.read((char *)&coordinate_list_size, sizeof(unsigned));
-        shared_layout_ptr->SetBlockSize<FixedPointCoordinate>(SharedDataLayout::COORDINATE_LIST,
-                                                              coordinate_list_size);
-
-        // load geometries sizes
-        std::ifstream geometry_input_stream(geometries_data_path.string().c_str(),
-                                            std::ios::binary);
-        unsigned number_of_geometries_indices = 0;
-        unsigned number_of_compressed_geometries = 0;
-
-        geometry_input_stream.read((char *)&number_of_geometries_indices, sizeof(unsigned));
-        shared_layout_ptr->SetBlockSize<unsigned>(SharedDataLayout::GEOMETRIES_INDEX,
-                                                  number_of_geometries_indices);
-        boost::iostreams::seek(geometry_input_stream,
-                               number_of_geometries_indices * sizeof(unsigned), BOOST_IOS::cur);
-        geometry_input_stream.read((char *)&number_of_compressed_geometries, sizeof(unsigned));
-        shared_layout_ptr->SetBlockSize<unsigned>(SharedDataLayout::GEOMETRIES_LIST,
-                                                  number_of_compressed_geometries);
-        // allocate shared memory block
-        SimpleLogger().Write() << "allocating shared memory of "
-                               << shared_layout_ptr->GetSizeOfLayout() << " bytes";
-        SharedMemory *shared_memory =
-            SharedMemoryFactory::Get(data_region, shared_layout_ptr->GetSizeOfLayout());
-        char *shared_memory_ptr = static_cast<char *>(shared_memory->Ptr());
-
-        // read actual data into shared memory object //
-
-        // hsgr checksum
-        unsigned *checksum_ptr = shared_layout_ptr->GetBlockPtr<unsigned, true>(
-            shared_memory_ptr, SharedDataLayout::HSGR_CHECKSUM);
-        *checksum_ptr = checksum;
-
-        // ram index file name
-        char *file_index_path_ptr = shared_layout_ptr->GetBlockPtr<char, true>(
-            shared_memory_ptr, SharedDataLayout::FILE_INDEX_PATH);
-        // make sure we have 0 ending
-        std::fill(file_index_path_ptr,
-                  file_index_path_ptr +
-                      shared_layout_ptr->GetBlockSize(SharedDataLayout::FILE_INDEX_PATH),
-                  0);
-        std::copy(file_index_path.begin(), file_index_path.end(), file_index_path_ptr);
-
-        // Loading street names
-        unsigned *name_offsets_ptr = shared_layout_ptr->GetBlockPtr<unsigned, true>(
-            shared_memory_ptr, SharedDataLayout::NAME_OFFSETS);
-        if (shared_layout_ptr->GetBlockSize(SharedDataLayout::NAME_OFFSETS) > 0)
-        {
-            name_stream.read((char *)name_offsets_ptr,
-                             shared_layout_ptr->GetBlockSize(SharedDataLayout::NAME_OFFSETS));
-        }
-
-        unsigned *name_blocks_ptr = shared_layout_ptr->GetBlockPtr<unsigned, true>(
-            shared_memory_ptr, SharedDataLayout::NAME_BLOCKS);
-        if (shared_layout_ptr->GetBlockSize(SharedDataLayout::NAME_BLOCKS) > 0)
-        {
-            name_stream.read((char *)name_blocks_ptr,
-                             shared_layout_ptr->GetBlockSize(SharedDataLayout::NAME_BLOCKS));
-        }
-
-        char *name_char_ptr = shared_layout_ptr->GetBlockPtr<char, true>(
-            shared_memory_ptr, SharedDataLayout::NAME_CHAR_LIST);
-        unsigned temp_length;
-        name_stream.read((char *)&temp_length, sizeof(unsigned));
-
-        BOOST_ASSERT_MSG(temp_length ==
-                             shared_layout_ptr->GetBlockSize(SharedDataLayout::NAME_CHAR_LIST),
-                         "Name file corrupted!");
-
-        if (shared_layout_ptr->GetBlockSize(SharedDataLayout::NAME_CHAR_LIST) > 0)
-        {
-            name_stream.read(name_char_ptr,
-                             shared_layout_ptr->GetBlockSize(SharedDataLayout::NAME_CHAR_LIST));
-        }
-
-        name_stream.close();
-
-        // load original edge information
-        NodeID *via_node_ptr = shared_layout_ptr->GetBlockPtr<NodeID, true>(
-            shared_memory_ptr, SharedDataLayout::VIA_NODE_LIST);
-
-        unsigned *name_id_ptr = shared_layout_ptr->GetBlockPtr<unsigned, true>(
-            shared_memory_ptr, SharedDataLayout::NAME_ID_LIST);
-
-        TravelMode *travel_mode_ptr = shared_layout_ptr->GetBlockPtr<TravelMode, true>(
-            shared_memory_ptr, SharedDataLayout::TRAVEL_MODE);
-
-        TurnInstruction *turn_instructions_ptr =
-            shared_layout_ptr->GetBlockPtr<TurnInstruction, true>(
-                shared_memory_ptr, SharedDataLayout::TURN_INSTRUCTION);
-
-        unsigned *geometries_indicator_ptr = shared_layout_ptr->GetBlockPtr<unsigned, true>(
-            shared_memory_ptr, SharedDataLayout::GEOMETRIES_INDICATORS);
-
-        OriginalEdgeData current_edge_data;
-        for (unsigned i = 0; i < number_of_original_edges; ++i)
-        {
-            edges_input_stream.read((char *)&(current_edge_data), sizeof(OriginalEdgeData));
-            via_node_ptr[i] = current_edge_data.via_node;
-            name_id_ptr[i] = current_edge_data.name_id;
-            travel_mode_ptr[i] = current_edge_data.travel_mode;
-            turn_instructions_ptr[i] = current_edge_data.turn_instruction;
-
            const unsigned bucket = i / 32;
            const unsigned offset = i % 32;
            const unsigned value = [&]
@@ -441,125 +531,68 @@ int main(const int argc, const char *argv[])
                unsigned return_value = 0;
                if (0 != offset)
                {
-                    return_value = geometries_indicator_ptr[bucket];
+                    return_value = core_marker_ptr[bucket];
                }
                return return_value;
            }();
-            if (current_edge_data.compressed_geometry)
-            {
-                geometries_indicator_ptr[bucket] = (value | (1 << offset));
-            }
+
+            core_marker_ptr[bucket] = (value | (1 << offset));
        }
-        edges_input_stream.close();
-
-        // load compressed geometry
-        unsigned temporary_value;
-        unsigned *geometries_index_ptr = shared_layout_ptr->GetBlockPtr<unsigned, true>(
-            shared_memory_ptr, SharedDataLayout::GEOMETRIES_INDEX);
-        geometry_input_stream.seekg(0, geometry_input_stream.beg);
-        geometry_input_stream.read((char *)&temporary_value, sizeof(unsigned));
-        BOOST_ASSERT(temporary_value ==
-                     shared_layout_ptr->num_entries[SharedDataLayout::GEOMETRIES_INDEX]);
-
-        if (shared_layout_ptr->GetBlockSize(SharedDataLayout::GEOMETRIES_INDEX) > 0)
-        {
-            geometry_input_stream.read(
-                (char *)geometries_index_ptr,
-                shared_layout_ptr->GetBlockSize(SharedDataLayout::GEOMETRIES_INDEX));
-        }
-        unsigned *geometries_list_ptr = shared_layout_ptr->GetBlockPtr<unsigned, true>(
-            shared_memory_ptr, SharedDataLayout::GEOMETRIES_LIST);
-
-        geometry_input_stream.read((char *)&temporary_value, sizeof(unsigned));
-        BOOST_ASSERT(temporary_value ==
-                     shared_layout_ptr->num_entries[SharedDataLayout::GEOMETRIES_LIST]);
-
-        if (shared_layout_ptr->GetBlockSize(SharedDataLayout::GEOMETRIES_LIST) > 0)
-        {
-            geometry_input_stream.read(
-                (char *)geometries_list_ptr,
-                shared_layout_ptr->GetBlockSize(SharedDataLayout::GEOMETRIES_LIST));
-        }
-
-        // Loading list of coordinates
-        FixedPointCoordinate *coordinates_ptr =
-            shared_layout_ptr->GetBlockPtr<FixedPointCoordinate, true>(
-                shared_memory_ptr, SharedDataLayout::COORDINATE_LIST);
-
-        QueryNode current_node;
-        for (unsigned i = 0; i < coordinate_list_size; ++i)
-        {
-            nodes_input_stream.read((char *)&current_node, sizeof(QueryNode));
-            coordinates_ptr[i] = FixedPointCoordinate(current_node.lat, current_node.lon);
-        }
-        nodes_input_stream.close();
-
-        // store timestamp
-        char *timestamp_ptr = shared_layout_ptr->GetBlockPtr<char, true>(
-            shared_memory_ptr, SharedDataLayout::TIMESTAMP);
-        std::copy(m_timestamp.c_str(), m_timestamp.c_str() + m_timestamp.length(), timestamp_ptr);
-
-        // store search tree portion of rtree
-        char *rtree_ptr = shared_layout_ptr->GetBlockPtr<char, true>(
-            shared_memory_ptr, SharedDataLayout::R_SEARCH_TREE);
-
-        if (tree_size > 0)
-        {
-            tree_node_file.read(rtree_ptr, sizeof(RTreeNode) * tree_size);
-        }
-        tree_node_file.close();
-
-        // load the nodes of the search graph
-        QueryGraph::NodeArrayEntry *graph_node_list_ptr =
-            shared_layout_ptr->GetBlockPtr<QueryGraph::NodeArrayEntry, true>(
-                shared_memory_ptr, SharedDataLayout::GRAPH_NODE_LIST);
-        if (shared_layout_ptr->GetBlockSize(SharedDataLayout::GRAPH_NODE_LIST) > 0)
-        {
-            hsgr_input_stream.read(
-                (char *)graph_node_list_ptr,
-                shared_layout_ptr->GetBlockSize(SharedDataLayout::GRAPH_NODE_LIST));
-        }
-
-        // load the edges of the search graph
-        QueryGraph::EdgeArrayEntry *graph_edge_list_ptr =
-            shared_layout_ptr->GetBlockPtr<QueryGraph::EdgeArrayEntry, true>(
-                shared_memory_ptr, SharedDataLayout::GRAPH_EDGE_LIST);
-        if (shared_layout_ptr->GetBlockSize(SharedDataLayout::GRAPH_EDGE_LIST) > 0)
-        {
-            hsgr_input_stream.read(
-                (char *)graph_edge_list_ptr,
-                shared_layout_ptr->GetBlockSize(SharedDataLayout::GRAPH_EDGE_LIST));
-        }
-        hsgr_input_stream.close();
-
-        // acquire lock
-        SharedMemory *data_type_memory =
-            SharedMemoryFactory::Get(CURRENT_REGIONS, sizeof(SharedDataTimestamp), true, false);
-        SharedDataTimestamp *data_timestamp_ptr =
-            static_cast<SharedDataTimestamp *>(data_type_memory->Ptr());
-
-        boost::interprocess::scoped_lock<boost::interprocess::named_mutex> query_lock(
-            barrier.query_mutex);
-
-        // notify all processes that were waiting for this condition
-        if (0 < barrier.number_of_queries)
-        {
-            barrier.no_running_queries_condition.wait(query_lock);
-        }
-
-        data_timestamp_ptr->layout = layout_region;
-        data_timestamp_ptr->data = data_region;
-        data_timestamp_ptr->timestamp += 1;
-        delete_region(previous_data_region);
-        delete_region(previous_layout_region);
-        SimpleLogger().Write() << "all data loaded";
-
-        shared_layout_ptr->PrintInformation();
    }
-    catch (const std::exception &e)
+
+    // load the nodes of the search graph
+    QueryGraph::NodeArrayEntry *graph_node_list_ptr =
+        shared_layout_ptr->GetBlockPtr<QueryGraph::NodeArrayEntry, true>(
+            shared_memory_ptr, SharedDataLayout::GRAPH_NODE_LIST);
+    if (shared_layout_ptr->GetBlockSize(SharedDataLayout::GRAPH_NODE_LIST) > 0)
    {
-        SimpleLogger().Write(logWARNING) << "caught exception: " << e.what();
+        hsgr_input_stream.read((char *)graph_node_list_ptr,
+                               shared_layout_ptr->GetBlockSize(SharedDataLayout::GRAPH_NODE_LIST));
    }

-    return 0;
+    // load the edges of the search graph
+    QueryGraph::EdgeArrayEntry *graph_edge_list_ptr =
+        shared_layout_ptr->GetBlockPtr<QueryGraph::EdgeArrayEntry, true>(
+            shared_memory_ptr, SharedDataLayout::GRAPH_EDGE_LIST);
+    if (shared_layout_ptr->GetBlockSize(SharedDataLayout::GRAPH_EDGE_LIST) > 0)
+    {
+        hsgr_input_stream.read((char *)graph_edge_list_ptr,
+                               shared_layout_ptr->GetBlockSize(SharedDataLayout::GRAPH_EDGE_LIST));
+    }
+    hsgr_input_stream.close();
+
+    // acquire lock
+    SharedMemory *data_type_memory =
+        SharedMemoryFactory::Get(CURRENT_REGIONS, sizeof(SharedDataTimestamp), true, false);
+    SharedDataTimestamp *data_timestamp_ptr =
+        static_cast<SharedDataTimestamp *>(data_type_memory->Ptr());
+
+    boost::interprocess::scoped_lock<boost::interprocess::named_mutex> query_lock(
+        barrier.query_mutex);
+
+    // notify all processes that were waiting for this condition
+    if (0 < barrier.number_of_queries)
+    {
+        barrier.no_running_queries_condition.wait(query_lock);
+    }
+
+    data_timestamp_ptr->layout = layout_region;
+    data_timestamp_ptr->data = data_region;
+    data_timestamp_ptr->timestamp += 1;
+    delete_region(previous_data_region);
+    delete_region(previous_layout_region);
+    SimpleLogger().Write() << "all data loaded";
+
+    shared_layout_ptr->PrintInformation();
+}
+catch (const std::bad_alloc &e)
+{
+    SimpleLogger().Write(logWARNING) << "[exception] " << e.what();
+    SimpleLogger().Write(logWARNING) << "Please provide more memory or disable locking the virtual "
+                                        "address space (note: this makes OSRM swap, i.e. slow)";
+    return EXIT_FAILURE;
+}
+catch (const std::exception &e)
+{
+    SimpleLogger().Write(logWARNING) << "caught exception: " << e.what();
 }
@@ -28,7 +28,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "description_factory.hpp"

 #include "../algorithms/polyline_formatter.hpp"
-#include "../data_structures/coordinate_calculation.hpp"
+#include "../algorithms/coordinate_calculation.hpp"
 #include "../data_structures/internal_route_result.hpp"
 #include "../data_structures/turn_instructions.hpp"
 #include "../util/container.hpp"
@@ -127,7 +127,7 @@ void DescriptionFactory::Run(const unsigned zoom_level)
    {
        // move down names by one, q&d hack
        path_description[i - 1].name_id = path_description[i].name_id;
-        path_description[i].length = coordinate_calculation::euclidean_distance(
+        path_description[i].length = coordinate_calculation::great_circle_distance(
            path_description[i - 1].location, path_description[i].location);
    }

@@ -230,18 +230,20 @@ void DescriptionFactory::Run(const unsigned zoom_level)
                return;
            }

-            ++necessary_segments;
-
            if (first.is_via_location)
            { // mark the end of a leg (of several segments)
                via_indices.push_back(necessary_segments);
            }

-            const double angle = coordinate_calculation::bearing(first.location, second.location);
-            first.bearing = static_cast<short>(angle * 10);
+            const double post_turn_bearing = coordinate_calculation::bearing(first.location, second.location);
+            const double pre_turn_bearing = coordinate_calculation::bearing(second.location, first.location);
+            first.post_turn_bearing = static_cast<short>(post_turn_bearing * 10);
+            first.pre_turn_bearing = static_cast<short>(pre_turn_bearing * 10);
+
+            ++necessary_segments;
        });

-    via_indices.push_back(necessary_segments + 1);
+    via_indices.push_back(necessary_segments);
    BOOST_ASSERT(via_indices.size() >= 2);
    return;
 }
@@ -28,7 +28,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef DESCRIPTOR_BASE_HPP
 #define DESCRIPTOR_BASE_HPP

-#include "../data_structures/coordinate_calculation.hpp"
+#include "../algorithms/coordinate_calculation.hpp"
 #include "../data_structures/internal_route_result.hpp"
 #include "../data_structures/phantom_node.hpp"
 #include "../typedefs.h"
@@ -35,6 +35,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "../data_structures/segment_information.hpp"
 #include "../data_structures/turn_instructions.hpp"
 #include "../util/bearing.hpp"
+#include "../util/cast.hpp"
 #include "../util/integer_range.hpp"
 #include "../util/json_renderer.hpp"
 #include "../util/simple_logger.hpp"
@@ -43,7 +44,9 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 #include <osrm/json_container.hpp>

+#include <limits>
 #include <algorithm>
+#include <string>

 template <class DataFacadeT> class JSONDescriptor final : public BaseDescriptor<DataFacadeT>
 {
@@ -52,15 +55,8 @@ template <class DataFacadeT> class JSONDescriptor final : public BaseDescriptor<
    DescriptorConfig config;
    DescriptionFactory description_factory, alternate_description_factory;
    FixedPointCoordinate current;
-    unsigned entered_restricted_area_count;
-    struct RoundAbout
-    {
-        RoundAbout() : start_index(INT_MAX), name_id(INVALID_NAMEID), leave_at_exit(INT_MAX) {}
-        int start_index;
-        unsigned name_id;
-        int leave_at_exit;
-    } round_about;

+  public:
    struct Segment
    {
        Segment() : name_id(INVALID_NAMEID), length(-1), position(0) {}
@@ -69,11 +65,12 @@ template <class DataFacadeT> class JSONDescriptor final : public BaseDescriptor<
        int length;
        unsigned position;
    };
+  private:
    std::vector<Segment> shortest_path_segments, alternative_path_segments;
    ExtractRouteNames<DataFacadeT, Segment> GenerateRouteNames;

  public:
-    explicit JSONDescriptor(DataFacadeT *facade) : facade(facade), entered_restricted_area_count(0)
+    explicit JSONDescriptor(DataFacadeT *facade) : facade(facade)
    {
    }

@@ -106,9 +103,6 @@ template <class DataFacadeT> class JSONDescriptor final : public BaseDescriptor<
        if (INVALID_EDGE_WEIGHT == raw_route.shortest_path_length)
        {
            // We do not need to do much, if there is no route ;-)
-            json_result.values["status"] = 207;
-            json_result.values["status_message"] = "Cannot find route between points";
-            // osrm::json::render(reply.content, json_result);
            return;
        }

@@ -119,8 +113,6 @@ template <class DataFacadeT> class JSONDescriptor final : public BaseDescriptor<
        description_factory.SetStartSegment(
            raw_route.segment_end_coordinates.front().source_phantom,
            raw_route.source_traversed_in_reverse.front());
-        json_result.values["status"] = 0;
-        json_result.values["status_message"] = "Found route between points";

        // for each unpacked segment add the leg to the description
        for (const auto i : osrm::irange<std::size_t>(0, raw_route.unpacked_path_segments.size()))
@@ -143,9 +135,7 @@ template <class DataFacadeT> class JSONDescriptor final : public BaseDescriptor<
        }
        if (config.instructions)
        {
-            osrm::json::Array json_route_instructions;
-            BuildTextualDescription(description_factory, json_route_instructions,
-                                    raw_route.shortest_path_length, shortest_path_segments);
+            osrm::json::Array json_route_instructions = BuildTextualDescription(description_factory, shortest_path_segments);
            json_result.values["route_instructions"] = json_route_instructions;
        }
        description_factory.BuildRouteSummary(description_factory.get_entire_length(),
@@ -222,9 +212,7 @@ template <class DataFacadeT> class JSONDescriptor final : public BaseDescriptor<
            osrm::json::Array json_current_alt_instructions;
            if (config.instructions)
            {
-                BuildTextualDescription(
-                    alternate_description_factory, json_current_alt_instructions,
-                    raw_route.alternative_path_length, alternative_path_segments);
+                json_current_alt_instructions = BuildTextualDescription(alternate_description_factory, alternative_path_segments);
                json_alt_instructions.values.push_back(json_current_alt_instructions);
                json_result.values["alternative_instructions"] = json_alt_instructions;
            }
@@ -276,6 +264,11 @@ template <class DataFacadeT> class JSONDescriptor final : public BaseDescriptor<
            json_result.values["alternative_names"] = json_alternate_names_array;
        }

+        json_result.values["hint_data"] = BuildHintData(raw_route);
+    }
+
+    inline osrm::json::Object BuildHintData(const InternalRouteResult& raw_route) const
+    {
        osrm::json::Object json_hint_object;
        json_hint_object.values["checksum"] = facade->GetCheckSum();
        osrm::json::Array json_location_hint_array;
@@ -290,34 +283,36 @@ template <class DataFacadeT> class JSONDescriptor final : public BaseDescriptor<
                                      hint);
        json_location_hint_array.values.push_back(hint);
        json_hint_object.values["locations"] = json_location_hint_array;
-        json_result.values["hint_data"] = json_hint_object;

-        // render the content to the output array
-        // TIMER_START(route_render);
-        // osrm::json::render(reply.content, json_result);
-        // TIMER_STOP(route_render);
-        // SimpleLogger().Write(logDEBUG) << "rendering took: " << TIMER_MSEC(route_render);
+        return json_hint_object;
    }

-    // TODO: reorder parameters
-    inline void BuildTextualDescription(DescriptionFactory &description_factory,
-                                        osrm::json::Array &json_instruction_array,
-                                        const int route_length,
-                                        std::vector<Segment> &route_segments_list)
+    inline osrm::json::Array BuildTextualDescription(const DescriptionFactory &description_factory,
+                                                     std::vector<Segment> &route_segments_list) const
    {
+        osrm::json::Array json_instruction_array;
        // Segment information has following format:
        //["instruction id","streetname",length,position,time,"length","earth_direction",azimuth]
        unsigned necessary_segments_running_index = 0;
+
+        struct RoundAbout
+        {
+            RoundAbout() : start_index(std::numeric_limits<int>::max()), name_id(INVALID_NAMEID), leave_at_exit(std::numeric_limits<int>::max()) {}
+            int start_index;
+            unsigned name_id;
+            int leave_at_exit;
+        } round_about;
+
        round_about.leave_at_exit = 0;
        round_about.name_id = 0;
        std::string temp_dist, temp_length, temp_duration, temp_bearing, temp_instruction;
+        TravelMode last_travel_mode = TRAVEL_MODE_DEFAULT;

        // Fetch data from Factory and generate a string from it.
        for (const SegmentInformation &segment : description_factory.path_description)
        {
            osrm::json::Array json_instruction_row;
            TurnInstruction current_instruction = segment.turn_instruction;
-            entered_restricted_area_count += (current_instruction != segment.turn_instruction);
            if (TurnInstructionsClass::TurnIsNecessary(current_instruction))
            {
                if (TurnInstruction::EnterRoundAbout == current_instruction)
@@ -330,18 +325,18 @@ template <class DataFacadeT> class JSONDescriptor final : public BaseDescriptor<
                    std::string current_turn_instruction;
                    if (TurnInstruction::LeaveRoundAbout == current_instruction)
                    {
-                        temp_instruction = cast::integral_to_string(
+                        temp_instruction = std::to_string(
                            cast::enum_to_underlying(TurnInstruction::EnterRoundAbout));
                        current_turn_instruction += temp_instruction;
                        current_turn_instruction += "-";
-                        temp_instruction = cast::integral_to_string(round_about.leave_at_exit + 1);
+                        temp_instruction = std::to_string(round_about.leave_at_exit + 1);
                        current_turn_instruction += temp_instruction;
                        round_about.leave_at_exit = 0;
                    }
                    else
                    {
                        temp_instruction =
-                            cast::integral_to_string(cast::enum_to_underlying(current_instruction));
+                            std::to_string(cast::enum_to_underlying(current_instruction));
                        current_turn_instruction += temp_instruction;
                    }
                    json_instruction_row.values.push_back(current_turn_instruction);
@@ -351,17 +346,28 @@ template <class DataFacadeT> class JSONDescriptor final : public BaseDescriptor<
                    json_instruction_row.values.push_back(necessary_segments_running_index);
                    json_instruction_row.values.push_back(std::round(segment.duration / 10.));
                    json_instruction_row.values.push_back(
-                        cast::integral_to_string(static_cast<unsigned>(segment.length)) + "m");
-                    const double bearing_value = (segment.bearing / 10.);
-                    json_instruction_row.values.push_back(bearing::get(bearing_value));
+                        std::to_string(static_cast<unsigned>(segment.length)) + "m");
+
+                    // post turn bearing
+                    const double post_turn_bearing_value = (segment.post_turn_bearing / 10.);
+                    json_instruction_row.values.push_back(bearing::get(post_turn_bearing_value));
                    json_instruction_row.values.push_back(
-                        static_cast<unsigned>(round(bearing_value)));
+                        static_cast<unsigned>(round(post_turn_bearing_value)));
+
                    json_instruction_row.values.push_back(segment.travel_mode);
+                    last_travel_mode = segment.travel_mode;
+
+                    // pre turn bearing
+                    const double pre_turn_bearing_value = (segment.pre_turn_bearing / 10.);
+                    json_instruction_row.values.push_back(bearing::get(pre_turn_bearing_value));
+                    json_instruction_row.values.push_back(
+                        static_cast<unsigned>(round(pre_turn_bearing_value)));
+
+                    json_instruction_array.values.push_back(json_instruction_row);

                    route_segments_list.emplace_back(
                        segment.name_id, static_cast<int>(segment.length),
                        static_cast<unsigned>(route_segments_list.size()));
-                    json_instruction_array.values.push_back(json_instruction_row);
                }
            }
            else if (TurnInstruction::StayOnRoundAbout == current_instruction)
@@ -375,8 +381,8 @@ template <class DataFacadeT> class JSONDescriptor final : public BaseDescriptor<
        }

        osrm::json::Array json_last_instruction_row;
-        temp_instruction = cast::integral_to_string(
-            cast::enum_to_underlying(TurnInstruction::ReachedYourDestination));
+        temp_instruction =
+            std::to_string(cast::enum_to_underlying(TurnInstruction::ReachedYourDestination));
        json_last_instruction_row.values.push_back(temp_instruction);
        json_last_instruction_row.values.push_back("");
        json_last_instruction_row.values.push_back(0);
@@ -385,7 +391,12 @@ template <class DataFacadeT> class JSONDescriptor final : public BaseDescriptor<
        json_last_instruction_row.values.push_back("0m");
        json_last_instruction_row.values.push_back(bearing::get(0.0));
        json_last_instruction_row.values.push_back(0.);
+        json_last_instruction_row.values.push_back(last_travel_mode);
+        json_last_instruction_row.values.push_back(bearing::get(0.0));
+        json_last_instruction_row.values.push_back(0.);
        json_instruction_array.values.push_back(json_last_instruction_row);
+
+        return json_instruction_array;
    }
 };

@@ -0,0 +1,21 @@
+FROM ubuntu:14.04
+
+RUN apt-get update -y
+RUN apt-get install -y build-essential git-core python-pip python-software-properties software-properties-common
+
+RUN apt-get -y install gcc-4.8 g++-4.8 libboost1.55-all-dev llvm-3.4
+RUN apt-get -y install libbz2-dev libstxxl-dev libstxxl1 libxml2-dev
+RUN apt-get -y install libzip-dev lua5.1 liblua5.1-0-dev libtbb-dev libgdal-dev ruby1.9
+RUN apt-get -y install curl cmake cmake-curses-gui
+
+RUN pip install awscli
+
+# luabind
+RUN curl https://gist.githubusercontent.com/DennisOSRM/f2eb7b948e6fe1ae319e/raw/install-luabind.sh | sudo bash
+# osmosis
+RUN curl -s https://gist.githubusercontent.com/DennisOSRM/803a64a9178ec375069f/raw/ | sudo bash
+
+RUN useradd -ms /bin/bash mapbox
+USER mapbox
+ENV HOME /home/mapbox
+WORKDIR /home/mapbox
@@ -0,0 +1,6 @@
+# Docker based continious integration
+
+Run ```./docker/build-image.sh``` to build a docker image.
+The image contains all the build dependencies and the state of the local git repository.
+
+Run ```./docker/run-gcc.sh``` to build OSRM with g++ and run all tests.
@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+
+set -e
+set -o pipefail
+
+docker build \
+    -t mapbox/osrm:linux \
+    docker/
+
@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+
+set -e
+set -o pipefail
+
+docker run \
+    -i \
+    -e "CXX=clang++" \
+    -v `pwd`:/home/mapbox/osrm-backend \
+    -t mapbox/osrm:linux \
+    osrm-backend/docker/test.sh
@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+
+set -e
+set -o pipefail
+
+docker run \
+    -i \
+    -e "CXX=g++" \
+    -v `pwd`:/home/mapbox/osrm-backend \
+    -t mapbox/osrm:linux \
+    osrm-backend/docker/test.sh
@@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+
+set -e
+set -o pipefail
+
+export CMAKEOPTIONS="-DCMAKE_BUILD_TYPE=Release"
+export PATH=$PATH:/home/mapbox/.gem/ruby/1.9.1/bin:/home/mapbox/osrm-backend/vendor/bundle/ruby/1.9.1/bin
+
+cd /home/mapbox/osrm-backend
+gem install --user-install bundler
+bundle install --path vendor/bundle
+[ -d build ] && rm -rf build
+mkdir -p build
+cd build
+cmake .. $CMAKEOPTIONS -DBUILD_TOOLS=1
+
+make -j`nproc`
+make tests -j`nproc`
+./datastructure-tests
+./algorithm-tests
+cd ..
+bundle exec cucumber -p verify
@@ -31,53 +31,59 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 #include <boost/filesystem.hpp>

+#include <cstdlib>
 #include <exception>
+#include <new>

-int main(int argc, char *argv[])
+int main(int argc, char *argv[]) try
 {
-    try
+    LogPolicy::GetInstance().Unmute();
+    ExtractorConfig extractor_config;
+
+    const return_code result = ExtractorOptions::ParseArguments(argc, argv, extractor_config);
+
+    if (return_code::fail == result)
    {
-        LogPolicy::GetInstance().Unmute();
-        ExtractorConfig extractor_config;
-
-        const return_code result = ExtractorOptions::ParseArguments(argc, argv, extractor_config);
-
-        if (return_code::fail == result)
-        {
-            return 1;
-        }
-
-        if (return_code::exit == result)
-        {
-            return 0;
-        }
-
-        ExtractorOptions::GenerateOutputFilesNames(extractor_config);
-
-        if (1 > extractor_config.requested_num_threads)
-        {
-            SimpleLogger().Write(logWARNING) << "Number of threads must be 1 or larger";
-            return 1;
-        }
-
-        if (!boost::filesystem::is_regular_file(extractor_config.input_path))
-        {
-            SimpleLogger().Write(logWARNING)
-                << "Input file " << extractor_config.input_path.string() << " not found!";
-            return 1;
-        }
-
-        if (!boost::filesystem::is_regular_file(extractor_config.profile_path))
-        {
-            SimpleLogger().Write(logWARNING) << "Profile " << extractor_config.profile_path.string()
-                                             << " not found!";
-            return 1;
-        }
-        return extractor(extractor_config).run();
+        return EXIT_FAILURE;
    }
-    catch (const std::exception &e)
+
+    if (return_code::exit == result)
    {
-        SimpleLogger().Write(logWARNING) << "[exception] " << e.what();
-        return 1;
+        return EXIT_SUCCESS;
    }
+
+    ExtractorOptions::GenerateOutputFilesNames(extractor_config);
+
+    if (1 > extractor_config.requested_num_threads)
+    {
+        SimpleLogger().Write(logWARNING) << "Number of threads must be 1 or larger";
+        return EXIT_FAILURE;
+    }
+
+    if (!boost::filesystem::is_regular_file(extractor_config.input_path))
+    {
+        SimpleLogger().Write(logWARNING) << "Input file " << extractor_config.input_path.string()
+                                         << " not found!";
+        return EXIT_FAILURE;
+    }
+
+    if (!boost::filesystem::is_regular_file(extractor_config.profile_path))
+    {
+        SimpleLogger().Write(logWARNING) << "Profile " << extractor_config.profile_path.string()
+                                         << " not found!";
+        return EXIT_FAILURE;
+    }
+    return extractor(extractor_config).run();
+}
+catch (const std::bad_alloc &e)
+{
+    SimpleLogger().Write(logWARNING) << "[exception] " << e.what();
+    SimpleLogger().Write(logWARNING)
+        << "Please provide more memory or consider using a larger swapfile";
+    return EXIT_FAILURE;
+}
+catch (const std::exception &e)
+{
+    SimpleLogger().Write(logWARNING) << "[exception] " << e.what();
+    return EXIT_FAILURE;
 }
@@ -26,13 +26,16 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

 #include "edge_based_graph_factory.hpp"
-#include "../algorithms/tiny_components.hpp"
+#include "../algorithms/coordinate_calculation.hpp"
 #include "../data_structures/percent.hpp"
 #include "../util/compute_angle.hpp"
 #include "../util/integer_range.hpp"
 #include "../util/lua_util.hpp"
 #include "../util/simple_logger.hpp"
 #include "../util/timing_util.hpp"
+#include "../util/osrm_exception.hpp"
+
+#include "../util/debug_geometry.hpp"

 #include <boost/assert.hpp>

@@ -40,27 +43,26 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <iomanip>
 #include <limits>

-EdgeBasedGraphFactory::EdgeBasedGraphFactory(std::shared_ptr<NodeBasedDynamicGraph> node_based_graph,
-                                   std::shared_ptr<RestrictionMap> restriction_map,
-                                   std::unique_ptr<std::vector<NodeID>> barrier_node_list,
-                                   std::unique_ptr<std::vector<NodeID>> traffic_light_node_list,
-                                   const std::vector<QueryNode> &node_info_list,
-                                   const SpeedProfileProperties &speed_profile)
-    : speed_profile(speed_profile),
-      m_number_of_edge_based_nodes(std::numeric_limits<unsigned>::max()),
-      m_node_info_list(node_info_list),
-      m_node_based_graph(std::move(node_based_graph)),
-      m_restriction_map(std::move(restriction_map)), max_id(0), removed_node_count(0)
+EdgeBasedGraphFactory::EdgeBasedGraphFactory(
+    std::shared_ptr<NodeBasedDynamicGraph> node_based_graph,
+    const CompressedEdgeContainer &compressed_edge_container,
+    const std::unordered_set<NodeID> &barrier_nodes,
+    const std::unordered_set<NodeID> &traffic_lights,
+    std::shared_ptr<const RestrictionMap> restriction_map,
+    const std::vector<QueryNode> &node_info_list,
+    SpeedProfileProperties speed_profile)
+    : m_max_edge_id(0), m_node_info_list(node_info_list), m_node_based_graph(std::move(node_based_graph)),
+      m_restriction_map(std::move(restriction_map)), m_barrier_nodes(barrier_nodes),
+      m_traffic_lights(traffic_lights), m_compressed_edge_container(compressed_edge_container),
+      speed_profile(std::move(speed_profile))
 {
-    // insert into unordered sets for fast lookup
-    m_barrier_nodes.insert(barrier_node_list->begin(), barrier_node_list->end());
-    m_traffic_lights.insert(traffic_light_node_list->begin(), traffic_light_node_list->end());
 }

 void EdgeBasedGraphFactory::GetEdgeBasedEdges(DeallocatingVector<EdgeBasedEdge> &output_edge_list)
 {
    BOOST_ASSERT_MSG(0 == output_edge_list.size(), "Vector is not empty");
-    m_edge_based_edge_list.swap(output_edge_list);
+    using std::swap; // Koenig swap
+    swap(m_edge_based_edge_list, output_edge_list);
 }

 void EdgeBasedGraphFactory::GetEdgeBasedNodes(std::vector<EdgeBasedNode> &nodes)
@@ -74,12 +76,23 @@ void EdgeBasedGraphFactory::GetEdgeBasedNodes(std::vector<EdgeBasedNode> &nodes)
        BOOST_ASSERT(m_node_info_list.at(node.v).lat != INT_MAX);
    }
 #endif
-    nodes.swap(m_edge_based_node_list);
+    using std::swap; // Koenig swap
+    swap(nodes, m_edge_based_node_list);
+}
+
+void EdgeBasedGraphFactory::GetStartPointMarkers(std::vector<bool> &node_is_startpoint)
+{
+    using std::swap; // Koenig swap
+    swap(m_edge_based_node_is_startpoint, node_is_startpoint);
+}
+
+unsigned EdgeBasedGraphFactory::GetHighestEdgeID()
+{
+    return m_max_edge_id;
 }

 void EdgeBasedGraphFactory::InsertEdgeBasedNode(const NodeID node_u,
-                                                const NodeID node_v,
-                                                const unsigned component_id)
+                                                const NodeID node_v)
 {
    // merge edges together into one EdgeBasedNode
    BOOST_ASSERT(node_u != SPECIAL_NODEID);
@@ -97,23 +110,21 @@ void EdgeBasedGraphFactory::InsertEdgeBasedNode(const NodeID node_u,

    const EdgeData &reverse_data = m_node_based_graph->GetEdgeData(edge_id_2);

-    if (forward_data.edgeBasedNodeID == SPECIAL_NODEID &&
-        reverse_data.edgeBasedNodeID == SPECIAL_NODEID)
+    if (forward_data.edge_id == SPECIAL_NODEID &&
+        reverse_data.edge_id == SPECIAL_NODEID)
    {
        return;
    }

-    BOOST_ASSERT(m_geometry_compressor.HasEntryForID(edge_id_1) ==
-                 m_geometry_compressor.HasEntryForID(edge_id_2));
-    if (m_geometry_compressor.HasEntryForID(edge_id_1))
+    BOOST_ASSERT(m_compressed_edge_container.HasEntryForID(edge_id_1) ==
+                 m_compressed_edge_container.HasEntryForID(edge_id_2));
+    if (m_compressed_edge_container.HasEntryForID(edge_id_1))
    {
-        BOOST_ASSERT(m_geometry_compressor.HasEntryForID(edge_id_2));
+        BOOST_ASSERT(m_compressed_edge_container.HasEntryForID(edge_id_2));

        // reconstruct geometry and put in each individual edge with its offset
-        const std::vector<GeometryCompressor::CompressedNode> &forward_geometry =
-            m_geometry_compressor.GetBucketReference(edge_id_1);
-        const std::vector<GeometryCompressor::CompressedNode> &reverse_geometry =
-            m_geometry_compressor.GetBucketReference(edge_id_2);
+        const auto& forward_geometry = m_compressed_edge_container.GetBucketReference(edge_id_1);
+        const auto& reverse_geometry = m_compressed_edge_container.GetBucketReference(edge_id_2);
        BOOST_ASSERT(forward_geometry.size() == reverse_geometry.size());
        BOOST_ASSERT(0 != forward_geometry.size());
        const unsigned geometry_size = static_cast<unsigned>(forward_geometry.size());
@@ -146,15 +157,6 @@ void EdgeBasedGraphFactory::InsertEdgeBasedNode(const NodeID node_u,

        NodeID current_edge_source_coordinate_id = node_u;

-        if (SPECIAL_NODEID != forward_data.edgeBasedNodeID)
-        {
-            max_id = std::max(forward_data.edgeBasedNodeID, max_id);
-        }
-        if (SPECIAL_NODEID != reverse_data.edgeBasedNodeID)
-        {
-            max_id = std::max(reverse_data.edgeBasedNodeID, max_id);
-        }
-
        // traverse arrays from start and end respectively
        for (const auto i : osrm::irange(0u, geometry_size))
        {
@@ -165,12 +167,13 @@ void EdgeBasedGraphFactory::InsertEdgeBasedNode(const NodeID node_u,

            // build edges
            m_edge_based_node_list.emplace_back(
-                forward_data.edgeBasedNodeID, reverse_data.edgeBasedNodeID,
+                forward_data.edge_id, reverse_data.edge_id,
                current_edge_source_coordinate_id, current_edge_target_coordinate_id,
-                forward_data.nameID, forward_geometry[i].second,
+                forward_data.name_id, forward_geometry[i].second,
                reverse_geometry[geometry_size - 1 - i].second, forward_dist_prefix_sum[i],
-                reverse_dist_prefix_sum[i], m_geometry_compressor.GetPositionForID(edge_id_1),
-                component_id, i, forward_data.travel_mode, reverse_data.travel_mode);
+                reverse_dist_prefix_sum[i], m_compressed_edge_container.GetPositionForID(edge_id_1),
+                false, INVALID_COMPONENTID, i, forward_data.travel_mode, reverse_data.travel_mode);
+            m_edge_based_node_is_startpoint.push_back(forward_data.startpoint || reverse_data.startpoint);
            current_edge_source_coordinate_id = current_edge_target_coordinate_id;

            BOOST_ASSERT(m_edge_based_node_list.back().IsCompressed());
@@ -187,33 +190,34 @@ void EdgeBasedGraphFactory::InsertEdgeBasedNode(const NodeID node_u,
    }
    else
    {
-        BOOST_ASSERT(!m_geometry_compressor.HasEntryForID(edge_id_2));
+        BOOST_ASSERT(!m_compressed_edge_container.HasEntryForID(edge_id_2));

-        if (forward_data.edgeBasedNodeID != SPECIAL_NODEID)
+        if (forward_data.edge_id != SPECIAL_NODEID)
        {
-            BOOST_ASSERT(forward_data.forward);
+            BOOST_ASSERT(!forward_data.reversed);
        }
        else
        {
-            BOOST_ASSERT(!forward_data.forward);
+            BOOST_ASSERT(forward_data.reversed);
        }

-        if (reverse_data.edgeBasedNodeID != SPECIAL_NODEID)
+        if (reverse_data.edge_id != SPECIAL_NODEID)
        {
-            BOOST_ASSERT(reverse_data.forward);
+            BOOST_ASSERT(!reverse_data.reversed);
        }
        else
        {
-            BOOST_ASSERT(!reverse_data.forward);
+            BOOST_ASSERT(reverse_data.reversed);
        }

-        BOOST_ASSERT(forward_data.edgeBasedNodeID != SPECIAL_NODEID ||
-                     reverse_data.edgeBasedNodeID != SPECIAL_NODEID);
+        BOOST_ASSERT(forward_data.edge_id != SPECIAL_NODEID ||
+                     reverse_data.edge_id != SPECIAL_NODEID);

        m_edge_based_node_list.emplace_back(
-            forward_data.edgeBasedNodeID, reverse_data.edgeBasedNodeID, node_u, node_v,
-            forward_data.nameID, forward_data.distance, reverse_data.distance, 0, 0, SPECIAL_EDGEID,
-            component_id, 0, forward_data.travel_mode, reverse_data.travel_mode);
+            forward_data.edge_id, reverse_data.edge_id, node_u, node_v,
+            forward_data.name_id, forward_data.distance, reverse_data.distance, 0, 0, SPECIAL_EDGEID,
+            false, INVALID_COMPONENTID, 0, forward_data.travel_mode, reverse_data.travel_mode);
+        m_edge_based_node_is_startpoint.push_back(forward_data.startpoint || reverse_data.startpoint);
        BOOST_ASSERT(!m_edge_based_node_list.back().IsCompressed());
    }
 }
@@ -230,16 +234,23 @@ void EdgeBasedGraphFactory::FlushVectorToStream(
    original_edge_data_vector.clear();
 }

+#ifdef DEBUG_GEOMETRY
 void EdgeBasedGraphFactory::Run(const std::string &original_edge_data_filename,
-                                const std::string &geometry_filename,
-                                lua_State *lua_state)
+                                lua_State *lua_state,
+                                const std::string &edge_segment_lookup_filename,
+                                const std::string &edge_penalty_filename,
+                                const bool generate_edge_lookup,
+                                const std::string &debug_turns_path)
+#else
+void EdgeBasedGraphFactory::Run(const std::string &original_edge_data_filename,
+                                lua_State *lua_state,
+                                const std::string &edge_segment_lookup_filename,
+                                const std::string &edge_penalty_filename,
+                                const bool generate_edge_lookup)
+#endif
 {
-    TIMER_START(geometry);
-    CompressGeometry();
-    TIMER_STOP(geometry);
-
    TIMER_START(renumber);
-    RenumberEdges();
+    m_max_edge_id = RenumberEdges() - 1;
    TIMER_STOP(renumber);

    TIMER_START(generate_nodes);
@@ -247,196 +258,29 @@ void EdgeBasedGraphFactory::Run(const std::string &original_edge_data_filename,
    TIMER_STOP(generate_nodes);

    TIMER_START(generate_edges);
-    GenerateEdgeExpandedEdges(original_edge_data_filename, lua_state);
+#ifdef DEBUG_GEOMETRY
+    GenerateEdgeExpandedEdges(original_edge_data_filename, lua_state,
+            edge_segment_lookup_filename,edge_penalty_filename, 
+            generate_edge_lookup, debug_turns_path);
+#else
+    GenerateEdgeExpandedEdges(original_edge_data_filename, lua_state,
+            edge_segment_lookup_filename,edge_penalty_filename, 
+            generate_edge_lookup);
+#endif
+
    TIMER_STOP(generate_edges);

-    m_geometry_compressor.SerializeInternalVector(geometry_filename);
-
    SimpleLogger().Write() << "Timing statistics for edge-expanded graph:";
-    SimpleLogger().Write() << "Geometry compression: " << TIMER_SEC(geometry) << "s";
    SimpleLogger().Write() << "Renumbering edges: " << TIMER_SEC(renumber) << "s";
    SimpleLogger().Write() << "Generating nodes: " << TIMER_SEC(generate_nodes) << "s";
    SimpleLogger().Write() << "Generating edges: " << TIMER_SEC(generate_edges) << "s";
 }

-void EdgeBasedGraphFactory::CompressGeometry()
-{
-    SimpleLogger().Write() << "Removing graph geometry while preserving topology";

-    const unsigned original_number_of_nodes = m_node_based_graph->GetNumberOfNodes();
-    const unsigned original_number_of_edges = m_node_based_graph->GetNumberOfEdges();
-
-    Percent progress(original_number_of_nodes);
-
-    for (const NodeID node_v : osrm::irange(0u, original_number_of_nodes))
-    {
-        progress.printStatus(node_v);
-
-        // only contract degree 2 vertices
-        if (2 != m_node_based_graph->GetOutDegree(node_v))
-        {
-            continue;
-        }
-
-        // don't contract barrier node
-        if (m_barrier_nodes.end() != m_barrier_nodes.find(node_v))
-        {
-            continue;
-        }
-
-        // check if v is a via node for a turn restriction, i.e. a 'directed' barrier node
-        if (m_restriction_map->IsViaNode(node_v))
-        {
-            continue;
-        }
-
-        /*
-         *    reverse_e2   forward_e2
-         * u <---------- v -----------> w
-         *    ----------> <-----------
-         *    forward_e1   reverse_e1
-         *
-         * Will be compressed to:
-         *
-         *    reverse_e1
-         * u <---------- w
-         *    ---------->
-         *    forward_e1
-         *
-         * If the edges are compatible.
-         *
-         */
-
-        const bool reverse_edge_order =
-            !(m_node_based_graph->GetEdgeData(m_node_based_graph->BeginEdges(node_v)).forward);
-        const EdgeID forward_e2 = m_node_based_graph->BeginEdges(node_v) + reverse_edge_order;
-        BOOST_ASSERT(SPECIAL_EDGEID != forward_e2);
-        BOOST_ASSERT(forward_e2 >= m_node_based_graph->BeginEdges(node_v) &&
-                     forward_e2 < m_node_based_graph->EndEdges(node_v));
-        const EdgeID reverse_e2 = m_node_based_graph->BeginEdges(node_v) + 1 - reverse_edge_order;
-        BOOST_ASSERT(SPECIAL_EDGEID != reverse_e2);
-        BOOST_ASSERT(reverse_e2 >= m_node_based_graph->BeginEdges(node_v) &&
-                     reverse_e2 < m_node_based_graph->EndEdges(node_v));
-
-        const EdgeData &fwd_edge_data2 = m_node_based_graph->GetEdgeData(forward_e2);
-        const EdgeData &rev_edge_data2 = m_node_based_graph->GetEdgeData(reverse_e2);
-
-        const NodeID node_w = m_node_based_graph->GetTarget(forward_e2);
-        BOOST_ASSERT(SPECIAL_NODEID != node_w);
-        BOOST_ASSERT(node_v != node_w);
-        const NodeID node_u = m_node_based_graph->GetTarget(reverse_e2);
-        BOOST_ASSERT(SPECIAL_NODEID != node_u);
-        BOOST_ASSERT(node_u != node_v);
-
-        const EdgeID forward_e1 = m_node_based_graph->FindEdge(node_u, node_v);
-        BOOST_ASSERT(SPECIAL_EDGEID != forward_e1);
-        BOOST_ASSERT(node_v == m_node_based_graph->GetTarget(forward_e1));
-        const EdgeID reverse_e1 = m_node_based_graph->FindEdge(node_w, node_v);
-        BOOST_ASSERT(SPECIAL_EDGEID != reverse_e1);
-        BOOST_ASSERT(node_v == m_node_based_graph->GetTarget(reverse_e1));
-
-        const EdgeData &fwd_edge_data1 = m_node_based_graph->GetEdgeData(forward_e1);
-        const EdgeData &rev_edge_data1 = m_node_based_graph->GetEdgeData(reverse_e1);
-
-        if (m_node_based_graph->FindEdgeInEitherDirection(node_u, node_w) != SPECIAL_EDGEID)
-        {
-            continue;
-        }
-
-        // this case can happen if two ways with different names overlap
-        if (fwd_edge_data1.nameID != rev_edge_data1.nameID ||
-            fwd_edge_data2.nameID != rev_edge_data2.nameID)
-        {
-            continue;
-        }
-
-        if (fwd_edge_data1.IsCompatibleTo(fwd_edge_data2) && rev_edge_data1.IsCompatibleTo(rev_edge_data2))
-        {
-            BOOST_ASSERT(m_node_based_graph->GetEdgeData(forward_e1).nameID ==
-                         m_node_based_graph->GetEdgeData(reverse_e1).nameID);
-            BOOST_ASSERT(m_node_based_graph->GetEdgeData(forward_e2).nameID ==
-                         m_node_based_graph->GetEdgeData(reverse_e2).nameID);
-
-            // Get distances before graph is modified
-            const int forward_weight1 = m_node_based_graph->GetEdgeData(forward_e1).distance;
-            const int forward_weight2 = m_node_based_graph->GetEdgeData(forward_e2).distance;
-
-            BOOST_ASSERT(0 != forward_weight1);
-            BOOST_ASSERT(0 != forward_weight2);
-
-            const int reverse_weight1 = m_node_based_graph->GetEdgeData(reverse_e1).distance;
-            const int reverse_weight2 = m_node_based_graph->GetEdgeData(reverse_e2).distance;
-
-            BOOST_ASSERT(0 != reverse_weight1);
-            BOOST_ASSERT(0 != reverse_weight2);
-
-            const bool has_node_penalty = m_traffic_lights.find(node_v) != m_traffic_lights.end();
-
-            // add weight of e2's to e1
-            m_node_based_graph->GetEdgeData(forward_e1).distance += fwd_edge_data2.distance;
-            m_node_based_graph->GetEdgeData(reverse_e1).distance += rev_edge_data2.distance;
-            if (has_node_penalty)
-            {
-                m_node_based_graph->GetEdgeData(forward_e1).distance +=
-                    speed_profile.traffic_signal_penalty;
-                m_node_based_graph->GetEdgeData(reverse_e1).distance +=
-                    speed_profile.traffic_signal_penalty;
-            }
-
-            // extend e1's to targets of e2's
-            m_node_based_graph->SetTarget(forward_e1, node_w);
-            m_node_based_graph->SetTarget(reverse_e1, node_u);
-
-            // remove e2's (if bidir, otherwise only one)
-            m_node_based_graph->DeleteEdge(node_v, forward_e2);
-            m_node_based_graph->DeleteEdge(node_v, reverse_e2);
-
-            // update any involved turn restrictions
-            m_restriction_map->FixupStartingTurnRestriction(node_u, node_v, node_w);
-            m_restriction_map->FixupArrivingTurnRestriction(node_u, node_v, node_w,
-                                                            *m_node_based_graph);
-
-            m_restriction_map->FixupStartingTurnRestriction(node_w, node_v, node_u);
-            m_restriction_map->FixupArrivingTurnRestriction(node_w, node_v, node_u,
-                                                            *m_node_based_graph);
-
-            // store compressed geometry in container
-            m_geometry_compressor.CompressEdge(
-                forward_e1, forward_e2, node_v, node_w,
-                forward_weight1 + (has_node_penalty ? speed_profile.traffic_signal_penalty : 0),
-                forward_weight2);
-            m_geometry_compressor.CompressEdge(
-                reverse_e1, reverse_e2, node_v, node_u, reverse_weight1,
-                reverse_weight2 + (has_node_penalty ? speed_profile.traffic_signal_penalty : 0));
-            ++removed_node_count;
-
-
-        }
-    }
-    SimpleLogger().Write() << "removed " << removed_node_count << " nodes";
-    m_geometry_compressor.PrintStatistics();
-
-    unsigned new_node_count = 0;
-    unsigned new_edge_count = 0;
-
-    for (const auto i : osrm::irange(0u, m_node_based_graph->GetNumberOfNodes()))
-    {
-        if (m_node_based_graph->GetOutDegree(i) > 0)
-        {
-            ++new_node_count;
-            new_edge_count += (m_node_based_graph->EndEdges(i) - m_node_based_graph->BeginEdges(i));
-        }
-    }
-    SimpleLogger().Write() << "new nodes: " << new_node_count << ", edges " << new_edge_count;
-    SimpleLogger().Write() << "Node compression ratio: "
-                           << new_node_count / (double)original_number_of_nodes;
-    SimpleLogger().Write() << "Edge compression ratio: "
-                           << new_edge_count / (double)original_number_of_edges;
-}
-
-/// Renumbers all _forward_ edges and sets the edgeBasedNodeID.
+/// Renumbers all _forward_ edges and sets the edge_id.
 /// A specific numbering is not important. Any unique ID will do.
-void EdgeBasedGraphFactory::RenumberEdges()
+/// Returns the number of edge based nodes.
+unsigned EdgeBasedGraphFactory::RenumberEdges()
 {
    // renumber edge based node of outgoing edges
    unsigned numbered_edges_count = 0;
@@ -446,43 +290,26 @@ void EdgeBasedGraphFactory::RenumberEdges()
        {
            EdgeData &edge_data = m_node_based_graph->GetEdgeData(current_edge);

-            // this edge is an incoming edge
-            if (!edge_data.forward)
+            // only number incoming edges
+            if (edge_data.reversed)
            {
                continue;
            }

            BOOST_ASSERT(numbered_edges_count < m_node_based_graph->GetNumberOfEdges());
-            edge_data.edgeBasedNodeID = numbered_edges_count;
+            edge_data.edge_id = numbered_edges_count;
            ++numbered_edges_count;

-            BOOST_ASSERT(SPECIAL_NODEID != edge_data.edgeBasedNodeID);
+            BOOST_ASSERT(SPECIAL_NODEID != edge_data.edge_id);
        }
    }
-    m_number_of_edge_based_nodes = numbered_edges_count;
+
+    return numbered_edges_count;
 }

-/**
- * Creates the nodes in the edge expanded graph from edges in the node-based graph.
- */
+/// Creates the nodes in the edge expanded graph from edges in the node-based graph.
 void EdgeBasedGraphFactory::GenerateEdgeExpandedNodes()
 {
-    SimpleLogger().Write() << "Identifying components of the (compressed) road network";
-
-    // Run a BFS on the undirected graph and identify small components
-    TarjanSCC<NodeBasedDynamicGraph> component_explorer(m_node_based_graph, *m_restriction_map,
-                                                        m_barrier_nodes);
-
-    component_explorer.run();
-
-    SimpleLogger().Write() << "identified: "
-                           << component_explorer.get_number_of_components() - removed_node_count
-                           << " (compressed) components";
-    SimpleLogger().Write() << "identified "
-                           << component_explorer.get_size_one_count() - removed_node_count
-                           << " (compressed) SCCs of size 1";
-    SimpleLogger().Write() << "generating edge-expanded nodes";
-
    Percent progress(m_node_based_graph->GetNumberOfNodes());

    // loop over all edges and generate new set of nodes
@@ -507,47 +334,39 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedNodes()

            BOOST_ASSERT(node_u < node_v);

-            // Note: edges that end on barrier nodes or on a turn restriction
-            // may actually be in two distinct components. We choose the smallest
-            const unsigned size_of_component =
-                std::min(component_explorer.get_component_size(node_u),
-                         component_explorer.get_component_size(node_v));
-
-            const unsigned id_of_smaller_component = [node_u, node_v, &component_explorer]
+            // if we found a non-forward edge reverse and try again
+            if (edge_data.edge_id == SPECIAL_NODEID)
            {
-                if (component_explorer.get_component_size(node_u) <
-                    component_explorer.get_component_size(node_v))
-                {
-                    return component_explorer.get_component_id(node_u);
-                }
-                return component_explorer.get_component_id(node_v);
-            }();
-
-            const bool component_is_tiny = size_of_component < 1000;
-
-            // we only set edgeBasedNodeID for forward edges
-            if (edge_data.edgeBasedNodeID == SPECIAL_NODEID)
-            {
-                InsertEdgeBasedNode(node_v, node_u,
-                                    (component_is_tiny ? id_of_smaller_component + 1 : 0));
+                InsertEdgeBasedNode(node_v, node_u);
            }
            else
            {
-                InsertEdgeBasedNode(node_u, node_v,
-                                    (component_is_tiny ? id_of_smaller_component + 1 : 0));
+                InsertEdgeBasedNode(node_u, node_v);
            }
        }
    }

+    BOOST_ASSERT(m_edge_based_node_list.size() == m_edge_based_node_is_startpoint.size());
+
    SimpleLogger().Write() << "Generated " << m_edge_based_node_list.size()
                           << " nodes in edge-expanded graph";
 }

-/**
- * Actually it also generates OriginalEdgeData and serializes them...
- */
+/// Actually it also generates OriginalEdgeData and serializes them...
+#ifdef DEBUG_GEOMETRY
 void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
-    const std::string &original_edge_data_filename, lua_State *lua_state)
+    const std::string &original_edge_data_filename, lua_State *lua_state,
+    const std::string &edge_segment_lookup_filename,
+    const std::string &edge_fixed_penalties_filename,
+    const bool generate_edge_lookup, 
+    const std::string &debug_turns_path)
+#else
+void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
+    const std::string &original_edge_data_filename, lua_State *lua_state,
+    const std::string &edge_segment_lookup_filename,
+    const std::string &edge_fixed_penalties_filename,
+    const bool generate_edge_lookup)
+#endif
 {
    SimpleLogger().Write() << "generating edge-expanded edges";

@@ -555,6 +374,14 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
    unsigned original_edges_counter = 0;

    std::ofstream edge_data_file(original_edge_data_filename.c_str(), std::ios::binary);
+    std::ofstream edge_segment_file;
+    std::ofstream edge_penalty_file;
+
+    if (generate_edge_lookup)
+    {
+        edge_segment_file.open(edge_segment_lookup_filename.c_str(), std::ios::binary);
+        edge_penalty_file.open(edge_fixed_penalties_filename.c_str(), std::ios::binary);
+    }

    // writes a dummy value that is updated later
    edge_data_file.write((char *)&original_edges_counter, sizeof(unsigned));
@@ -572,12 +399,16 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(

    Percent progress(m_node_based_graph->GetNumberOfNodes());

+#ifdef DEBUG_GEOMETRY
+    DEBUG_TURNS_START(debug_turns_path);
+#endif
+
    for (const auto node_u : osrm::irange(0u, m_node_based_graph->GetNumberOfNodes()))
    {
-        progress.printStatus(node_u);
+        //progress.printStatus(node_u);
        for (const EdgeID e1 : m_node_based_graph->GetAdjacentEdgeRange(node_u))
        {
-            if (!m_node_based_graph->GetEdgeData(e1).forward)
+            if (m_node_based_graph->GetEdgeData(e1).reversed)
            {
                continue;
            }
@@ -590,7 +421,7 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(

            for (const EdgeID e2 : m_node_based_graph->GetAdjacentEdgeRange(node_v))
            {
-                if (!m_node_based_graph->GetEdgeData(e2).forward)
+                if (m_node_based_graph->GetEdgeData(e2).reversed)
                {
                    continue;
                }
@@ -614,10 +445,23 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
                }
                else
                {
-                    if ((node_u == node_w) && (m_node_based_graph->GetOutDegree(node_v) > 1))
+                    if (node_u == node_w && m_node_based_graph->GetOutDegree(node_v) > 1)
                    {
-                        ++skipped_uturns_counter;
-                        continue;
+                        auto number_of_emmiting_bidirectional_edges = 0;
+                        for (auto edge : m_node_based_graph->GetAdjacentEdgeRange(node_v))
+                        {
+                            auto target = m_node_based_graph->GetTarget(edge);
+                            auto reverse_edge = m_node_based_graph->FindEdge(target, node_v);
+                            if (!m_node_based_graph->GetEdgeData(reverse_edge).reversed)
+                            {
+                                ++number_of_emmiting_bidirectional_edges;
+                            }
+                        }
+                        if (number_of_emmiting_bidirectional_edges > 1)
+                        {
+                            ++skipped_uturns_counter;
+                            continue;
+                        }
                    }
                }

@@ -636,27 +480,29 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
                const EdgeData &edge_data1 = m_node_based_graph->GetEdgeData(e1);
                const EdgeData &edge_data2 = m_node_based_graph->GetEdgeData(e2);

-                BOOST_ASSERT(edge_data1.edgeBasedNodeID != edge_data2.edgeBasedNodeID);
-                BOOST_ASSERT(edge_data1.forward);
-                BOOST_ASSERT(edge_data2.forward);
+                BOOST_ASSERT(edge_data1.edge_id != edge_data2.edge_id);
+                BOOST_ASSERT(!edge_data1.reversed);
+                BOOST_ASSERT(!edge_data2.reversed);

                // the following is the core of the loop.
                unsigned distance = edge_data1.distance;
                if (m_traffic_lights.find(node_v) != m_traffic_lights.end())
                {
                    distance += speed_profile.traffic_signal_penalty;
+
+                    DEBUG_SIGNAL(node_v, m_node_info_list, speed_profile.traffic_signal_penalty);
                }

                // unpack last node of first segment if packed
                const auto first_coordinate =
-                    m_node_info_list[(m_geometry_compressor.HasEntryForID(e1)
-                                          ? m_geometry_compressor.GetLastNodeIDOfBucket(e1)
+                    m_node_info_list[(m_compressed_edge_container.HasEntryForID(e1)
+                                          ? m_compressed_edge_container.GetLastEdgeSourceID(e1)
                                          : node_u)];

                // unpack first node of second segment if packed
                const auto third_coordinate =
-                    m_node_info_list[(m_geometry_compressor.HasEntryForID(e2)
-                                          ? m_geometry_compressor.GetFirstNodeIDOfBucket(e2)
+                    m_node_info_list[(m_compressed_edge_container.HasEntryForID(e2)
+                                          ? m_compressed_edge_container.GetFirstEdgeTargetID(e2)
                                          : node_w)];

                const double turn_angle = ComputeAngle::OfThreeFixedPointCoordinates(
@@ -667,10 +513,15 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
                if (turn_instruction == TurnInstruction::UTurn)
                {
                    distance += speed_profile.u_turn_penalty;
-                }
+
+                    DEBUG_UTURN(node_v, m_node_info_list, speed_profile.u_turn_penalty);
+                } 
+
+                DEBUG_TURN(node_v, m_node_info_list, first_coordinate, turn_angle, turn_penalty);
+
                distance += turn_penalty;

-                const bool edge_is_compressed = m_geometry_compressor.HasEntryForID(e1);
+                const bool edge_is_compressed = m_compressed_edge_container.HasEntryForID(e1);

                if (edge_is_compressed)
                {
@@ -678,8 +529,8 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
                }

                original_edge_data_vector.emplace_back(
-                    (edge_is_compressed ? m_geometry_compressor.GetPositionForID(e1) : node_v),
-                    edge_data1.nameID, turn_instruction, edge_is_compressed,
+                    (edge_is_compressed ? m_compressed_edge_container.GetPositionForID(e1) : node_v),
+                    edge_data1.name_id, turn_instruction, edge_is_compressed,
                    edge_data2.travel_mode);

                ++original_edges_counter;
@@ -689,15 +540,73 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
                    FlushVectorToStream(edge_data_file, original_edge_data_vector);
                }

-                BOOST_ASSERT(SPECIAL_NODEID != edge_data1.edgeBasedNodeID);
-                BOOST_ASSERT(SPECIAL_NODEID != edge_data2.edgeBasedNodeID);
+                BOOST_ASSERT(SPECIAL_NODEID != edge_data1.edge_id);
+                BOOST_ASSERT(SPECIAL_NODEID != edge_data2.edge_id);

-                m_edge_based_edge_list.emplace_back(
-                    EdgeBasedEdge(edge_data1.edgeBasedNodeID, edge_data2.edgeBasedNodeID,
-                                  m_edge_based_edge_list.size(), distance, true, false));
+
+                // NOTE: potential overflow here if we hit 2^32 routable edges
+                BOOST_ASSERT(m_edge_based_edge_list.size() <= std::numeric_limits<NodeID>::max());
+                m_edge_based_edge_list.emplace_back(edge_data1.edge_id, edge_data2.edge_id,
+                                  m_edge_based_edge_list.size(), distance, true, false);
+
+
+                // Here is where we write out the mapping between the edge-expanded edges, and
+                // the node-based edges that are originally used to calculate the `distance`
+                // for the edge-expanded edges.  About 40 lines back, there is:
+                //
+                //                 unsigned distance = edge_data1.distance;
+                //
+                // This tells us that the weight for an edge-expanded-edge is based on the weight
+                // of the *source* node-based edge.  Therefore, we will look up the individual
+                // segments of the source node-based edge, and write out a mapping between
+                // those and the edge-based-edge ID.
+                // External programs can then use this mapping to quickly perform
+                // updates to the edge-expanded-edge based directly on its ID.
+                if (generate_edge_lookup)
+                {
+                    unsigned fixed_penalty = distance - edge_data1.distance;
+                    edge_penalty_file.write(reinterpret_cast<const char *>(&fixed_penalty), sizeof(fixed_penalty));
+                    if (edge_is_compressed)
+                    {
+                        const auto node_based_edges = m_compressed_edge_container.GetBucketReference(e1);
+                        NodeID previous = node_u;
+
+                        const unsigned node_count = node_based_edges.size()+1;
+                        edge_segment_file.write(reinterpret_cast<const char *>(&node_count), sizeof(node_count));
+                        const QueryNode &first_node = m_node_info_list[previous];
+                        edge_segment_file.write(reinterpret_cast<const char *>(&first_node.node_id), sizeof(first_node.node_id));
+
+                        for (auto target_node : node_based_edges)
+                        {
+                            const QueryNode &from = m_node_info_list[previous];
+                            const QueryNode &to = m_node_info_list[target_node.first];
+                            const double segment_length = coordinate_calculation::great_circle_distance(from.lat, from.lon, to.lat, to.lon);
+
+                            edge_segment_file.write(reinterpret_cast<const char *>(&to.node_id), sizeof(to.node_id));
+                            edge_segment_file.write(reinterpret_cast<const char *>(&segment_length), sizeof(segment_length));
+                            edge_segment_file.write(reinterpret_cast<const char *>(&target_node.second), sizeof(target_node.second));
+                            previous = target_node.first;
+                        }
+                    }
+                    else
+                    {
+                        static const unsigned node_count = 2;
+                        const QueryNode from = m_node_info_list[node_u];
+                        const QueryNode to = m_node_info_list[node_v];
+                        const double segment_length = coordinate_calculation::great_circle_distance(from.lat, from.lon, to.lat, to.lon);
+                        edge_segment_file.write(reinterpret_cast<const char *>(&node_count), sizeof(node_count));
+                        edge_segment_file.write(reinterpret_cast<const char *>(&from.node_id), sizeof(from.node_id));
+                        edge_segment_file.write(reinterpret_cast<const char *>(&to.node_id), sizeof(to.node_id));
+                        edge_segment_file.write(reinterpret_cast<const char *>(&segment_length), sizeof(segment_length));
+                        edge_segment_file.write(reinterpret_cast<const char *>(&edge_data1.distance), sizeof(edge_data1.distance));
+                    }
+                }
            }
        }
    }
+
+    DEBUG_TURNS_STOP();
+
    FlushVectorToStream(edge_data_file, original_edge_data_vector);

    edge_data_file.seekp(std::ios::beg);
@@ -723,7 +632,8 @@ int EdgeBasedGraphFactory::GetTurnPenalty(double angle, lua_State *lua_state) co
        try
        {
            // call lua profile to compute turn penalty
-            return luabind::call_function<int>(lua_state, "turn_function", 180. - angle);
+            double penalty = luabind::call_function<double>(lua_state, "turn_function", 180. - angle);
+            return static_cast<int>(penalty);
        }
        catch (const luabind::error &er)
        {
@@ -777,11 +687,11 @@ TurnInstruction EdgeBasedGraphFactory::AnalyzeTurn(const NodeID node_u,

    // If street names stay the same and if we are certain that it is not a
    // a segment of a roundabout, we skip it.
-    if (data1.nameID == data2.nameID)
+    if (data1.name_id == data2.name_id && data1.travel_mode == data2.travel_mode)
    {
        // TODO: Here we should also do a small graph exploration to check for
        //      more complex situations
-        if (0 != data1.nameID || m_node_based_graph->GetOutDegree(node_v) <= 2)
+        if (0 != data1.name_id || m_node_based_graph->GetOutDegree(node_v) <= 2)
        {
            return TurnInstruction::NoTurn;
        }
@@ -790,7 +700,3 @@ TurnInstruction EdgeBasedGraphFactory::AnalyzeTurn(const NodeID node_u,
    return TurnInstructionsClass::GetTurnDirectionOfInstruction(angle);
 }

-unsigned EdgeBasedGraphFactory::GetNumberOfEdgeBasedNodes() const
-{
-    return m_number_of_edge_based_nodes;
-}
@@ -30,8 +30,9 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef EDGE_BASED_GRAPH_FACTORY_HPP_
 #define EDGE_BASED_GRAPH_FACTORY_HPP_

-#include "geometry_compressor.hpp"
+#include "speed_profile.hpp"
 #include "../typedefs.h"
+#include "../data_structures/compressed_edge_container.hpp"
 #include "../data_structures/deallocating_vector.hpp"
 #include "../data_structures/edge_based_node.hpp"
 #include "../data_structures/original_edge_data.hpp"
@@ -49,6 +50,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <unordered_set>
 #include <vector>

+#include <boost/filesystem/fstream.hpp>
+
 struct lua_State;

 class EdgeBasedGraphFactory
@@ -57,73 +60,83 @@ class EdgeBasedGraphFactory
    EdgeBasedGraphFactory() = delete;
    EdgeBasedGraphFactory(const EdgeBasedGraphFactory &) = delete;

-    struct SpeedProfileProperties;
-
    explicit EdgeBasedGraphFactory(std::shared_ptr<NodeBasedDynamicGraph> node_based_graph,
-                                   std::shared_ptr<RestrictionMap> restricion_map,
-                                   std::unique_ptr<std::vector<NodeID>> barrier_node_list,
-                                   std::unique_ptr<std::vector<NodeID>> traffic_light_node_list,
+                                   const CompressedEdgeContainer &compressed_edge_container,
+                                   const std::unordered_set<NodeID> &barrier_nodes,
+                                   const std::unordered_set<NodeID> &traffic_lights,
+                                   std::shared_ptr<const RestrictionMap> restriction_map,
                                   const std::vector<QueryNode> &node_info_list,
-                                   const SpeedProfileProperties &speed_profile);
+                                   SpeedProfileProperties speed_profile);

+#ifdef DEBUG_GEOMETRY
    void Run(const std::string &original_edge_data_filename,
-             const std::string &geometry_filename,
-             lua_State *lua_state);
+             lua_State *lua_state,
+             const std::string &edge_segment_lookup_filename,
+             const std::string &edge_penalty_filename,
+             const bool generate_edge_lookup,
+             const std::string &debug_turns_path);
+#else
+    void Run(const std::string &original_edge_data_filename,
+             lua_State *lua_state,
+             const std::string &edge_segment_lookup_filename,
+             const std::string &edge_penalty_filename,
+             const bool generate_edge_lookup);
+#endif

    void GetEdgeBasedEdges(DeallocatingVector<EdgeBasedEdge> &edges);

    void GetEdgeBasedNodes(std::vector<EdgeBasedNode> &nodes);
+    void GetStartPointMarkers(std::vector<bool> &node_is_startpoint);
+
+    unsigned GetHighestEdgeID();

    TurnInstruction AnalyzeTurn(const NodeID u, const NodeID v, const NodeID w, const double angle) const;

    int GetTurnPenalty(double angle, lua_State *lua_state) const;

-    unsigned GetNumberOfEdgeBasedNodes() const;
-
-    struct SpeedProfileProperties
-    {
-        SpeedProfileProperties()
-            : traffic_signal_penalty(0), u_turn_penalty(0), has_turn_penalty_function(false)
-        {
-        }
-
-        int traffic_signal_penalty;
-        int u_turn_penalty;
-        bool has_turn_penalty_function;
-    } speed_profile;
-
  private:
    using EdgeData = NodeBasedDynamicGraph::EdgeData;

-    unsigned m_number_of_edge_based_nodes;
-
+    //! maps index from m_edge_based_node_list to ture/false if the node is an entry point to the graph
+    std::vector<bool> m_edge_based_node_is_startpoint;
+    //! list of edge based nodes (compressed segments)
    std::vector<EdgeBasedNode> m_edge_based_node_list;
    DeallocatingVector<EdgeBasedEdge> m_edge_based_edge_list;
+    unsigned m_max_edge_id;

    const std::vector<QueryNode>& m_node_info_list;
    std::shared_ptr<NodeBasedDynamicGraph> m_node_based_graph;
-    std::shared_ptr<RestrictionMap> m_restriction_map;
+    std::shared_ptr<RestrictionMap const> m_restriction_map;

-    std::unordered_set<NodeID> m_barrier_nodes;
-    std::unordered_set<NodeID> m_traffic_lights;
+    const std::unordered_set<NodeID>& m_barrier_nodes;
+    const std::unordered_set<NodeID>& m_traffic_lights;
+    const CompressedEdgeContainer& m_compressed_edge_container;

-
-    GeometryCompressor m_geometry_compressor;
+    SpeedProfileProperties speed_profile;

    void CompressGeometry();
-    void RenumberEdges();
+    unsigned RenumberEdges();
    void GenerateEdgeExpandedNodes();
+#ifdef DEBUG_GEOMETRY
    void GenerateEdgeExpandedEdges(const std::string &original_edge_data_filename,
-                                   lua_State *lua_state);
+                                   lua_State *lua_state,
+                                   const std::string &edge_segment_lookup_filename,
+                                   const std::string &edge_fixed_penalties_filename,
+                                   const bool generate_edge_lookup,
+                                   const std::string &debug_turns_path);
+#else
+    void GenerateEdgeExpandedEdges(const std::string &original_edge_data_filename,
+                                   lua_State *lua_state,
+                                   const std::string &edge_segment_lookup_filename,
+                                   const std::string &edge_fixed_penalties_filename,
+                                   const bool generate_edge_lookup);
+#endif 

-    void InsertEdgeBasedNode(const NodeID u, const NodeID v, const unsigned component_id);
+    void InsertEdgeBasedNode(const NodeID u, const NodeID v);

    void FlushVectorToStream(std::ofstream &edge_data_file,
                             std::vector<OriginalEdgeData> &original_edge_data_vector) const;

-    NodeID max_id;
-    std::size_t removed_node_count;
-
 };

 #endif /* EDGE_BASED_GRAPH_FACTORY_HPP_ */
@@ -28,7 +28,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "extraction_containers.hpp"
 #include "extraction_way.hpp"

-#include "../data_structures/coordinate_calculation.hpp"
+#include "../algorithms/coordinate_calculation.hpp"
 #include "../data_structures/node_id.hpp"
 #include "../data_structures/range_table.hpp"

@@ -36,21 +36,29 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "../util/simple_logger.hpp"
 #include "../util/timing_util.hpp"
 #include "../util/fingerprint.hpp"
+#include "../util/lua_util.hpp"

 #include <boost/assert.hpp>
 #include <boost/filesystem.hpp>
 #include <boost/filesystem/fstream.hpp>
+#include <boost/ref.hpp>
+#include <boost/numeric/conversion/cast.hpp>
+
+#include <luabind/luabind.hpp>

 #include <stxxl/sort>

 #include <chrono>
 #include <limits>

+static const int WRITE_BLOCK_BUFFER_SIZE = 8000;
+
 ExtractionContainers::ExtractionContainers()
 {
    // Check if stxxl can be instantiated
    stxxl::vector<unsigned> dummy_vector;
-    name_list.push_back("");
+    // Insert the empty string, it has no data and is zero length
+    name_lengths.push_back(0);
 }

 ExtractionContainers::~ExtractionContainers()
@@ -59,7 +67,8 @@ ExtractionContainers::~ExtractionContainers()
    used_node_id_list.clear();
    all_nodes_list.clear();
    all_edges_list.clear();
-    name_list.clear();
+    name_char_data.clear();
+    name_lengths.clear();
    restrictions_list.clear();
    way_start_end_id_list.clear();
 }
@@ -76,7 +85,8 @@ ExtractionContainers::~ExtractionContainers()
 */
 void ExtractionContainers::PrepareData(const std::string &output_file_name,
                                       const std::string &restrictions_file_name,
-                                       const std::string &name_file_name)
+                                       const std::string &name_file_name,
+                                       lua_State *segment_state)
 {
    try
    {
@@ -87,7 +97,7 @@ void ExtractionContainers::PrepareData(const std::string &output_file_name,

        PrepareNodes();
        WriteNodes(file_out_stream);
-        PrepareEdges();
+        PrepareEdges(segment_state);
        WriteEdges(file_out_stream);

        file_out_stream.close();
@@ -110,13 +120,10 @@ void ExtractionContainers::WriteNames(const std::string& names_file_name) const
    boost::filesystem::ofstream name_file_stream(names_file_name, std::ios::binary);

    unsigned total_length = 0;
-    std::vector<unsigned> name_lengths;
-    for (const std::string &temp_string : name_list)
+
+    for (const unsigned &name_length : name_lengths)
    {
-        const unsigned string_length =
-            std::min(static_cast<unsigned>(temp_string.length()), 255u);
-        name_lengths.push_back(string_length);
-        total_length += string_length;
+        total_length += name_length;
    }

    // builds and writes the index
@@ -124,14 +131,25 @@ void ExtractionContainers::WriteNames(const std::string& names_file_name) const
    name_file_stream << name_index_range;

    name_file_stream.write((char *)&total_length, sizeof(unsigned));
+
+
    // write all chars consecutively
-    for (const std::string &temp_string : name_list)
+    char write_buffer[WRITE_BLOCK_BUFFER_SIZE];
+    unsigned buffer_len = 0;
+
+    for (const char &c : name_char_data)
    {
-        const unsigned string_length =
-            std::min(static_cast<unsigned>(temp_string.length()), 255u);
-        name_file_stream.write(temp_string.c_str(), string_length);
+        write_buffer[buffer_len++] = c;
+
+        if (buffer_len >= WRITE_BLOCK_BUFFER_SIZE)
+        {
+            name_file_stream.write(write_buffer, WRITE_BLOCK_BUFFER_SIZE);
+            buffer_len = 0;
+        }
    }

+    name_file_stream.write(write_buffer, buffer_len);
+
    name_file_stream.close();
    TIMER_STOP(write_name_index);
    std::cout << "ok, after " << TIMER_SEC(write_name_index) << "s" << std::endl;
@@ -152,28 +170,60 @@ void ExtractionContainers::PrepareNodes()
    TIMER_STOP(erasing_dups);
    std::cout << "ok, after " << TIMER_SEC(erasing_dups) << "s" << std::endl;

-    std::cout << "[extractor] Building node id map      ... " << std::flush;
-    TIMER_START(id_map);
-    external_to_internal_node_id_map.reserve(used_node_id_list.size());
-    for (NodeID i = 0u; i < used_node_id_list.size(); ++i)
-        external_to_internal_node_id_map[used_node_id_list[i]] = i;
-    TIMER_STOP(id_map);
-    std::cout << "ok, after " << TIMER_SEC(id_map) << "s" << std::endl;
-
    std::cout << "[extractor] Sorting all nodes         ... " << std::flush;
    TIMER_START(sorting_nodes);
    stxxl::sort(all_nodes_list.begin(), all_nodes_list.end(), ExternalMemoryNodeSTXXLCompare(),
                stxxl_memory);
    TIMER_STOP(sorting_nodes);
    std::cout << "ok, after " << TIMER_SEC(sorting_nodes) << "s" << std::endl;
+
+    std::cout << "[extractor] Building node id map      ... " << std::flush;
+    TIMER_START(id_map);
+    external_to_internal_node_id_map.reserve(used_node_id_list.size());
+    auto node_iter = all_nodes_list.begin();
+    auto ref_iter = used_node_id_list.begin();
+    const auto all_nodes_list_end = all_nodes_list.end();
+    const auto used_node_id_list_end = used_node_id_list.end();
+    // Note: despite being able to handle 64 bit OSM node ids, we can't
+    // handle > uint32_t actual usable nodes.  This should be OK for a while
+    // because we usually route on a *lot* less than 2^32 of the OSM
+    // graph nodes.
+    std::size_t internal_id = 0;
+
+    // compute the intersection of nodes that were referenced and nodes we actually have
+    while (node_iter != all_nodes_list_end && ref_iter != used_node_id_list_end)
+    {
+        if (node_iter->node_id < *ref_iter)
+        {
+            node_iter++;
+            continue;
+        }
+        if (node_iter->node_id > *ref_iter)
+        {
+            ref_iter++;
+            continue;
+        }
+        BOOST_ASSERT(node_iter->node_id == *ref_iter);
+        external_to_internal_node_id_map[*ref_iter] = static_cast<NodeID>(internal_id++);
+        node_iter++;
+        ref_iter++;
+    }
+    if (internal_id > std::numeric_limits<NodeID>::max())
+    {
+        throw osrm::exception("There are too many nodes remaining after filtering, OSRM only supports 2^32 unique nodes");
+    }
+    max_internal_node_id = boost::numeric_cast<NodeID>(internal_id);
+    TIMER_STOP(id_map);
+    std::cout << "ok, after " << TIMER_SEC(id_map) << "s" << std::endl;
+
 }

-void ExtractionContainers::PrepareEdges()
+void ExtractionContainers::PrepareEdges(lua_State *segment_state)
 {
    // Sort edges by start.
    std::cout << "[extractor] Sorting edges by start    ... " << std::flush;
    TIMER_START(sort_edges_by_start);
-    stxxl::sort(all_edges_list.begin(), all_edges_list.end(), CmpEdgeByStartID(), stxxl_memory);
+    stxxl::sort(all_edges_list.begin(), all_edges_list.end(), CmpEdgeByOSMStartID(), stxxl_memory);
    TIMER_STOP(sort_edges_by_start);
    std::cout << "ok, after " << TIMER_SEC(sort_edges_by_start) << "s" << std::endl;

@@ -182,22 +232,27 @@ void ExtractionContainers::PrepareEdges()
    // Traverse list of edges and nodes in parallel and set start coord
    auto node_iterator = all_nodes_list.begin();
    auto edge_iterator = all_edges_list.begin();
-    while (edge_iterator != all_edges_list.end() && node_iterator != all_nodes_list.end())
+
+    const auto all_edges_list_end = all_edges_list.end();
+    const auto all_nodes_list_end = all_nodes_list.end();
+
+    while (edge_iterator != all_edges_list_end && node_iterator != all_nodes_list_end)
    {
-        if (edge_iterator->result.source < node_iterator->node_id)
+        if (edge_iterator->result.osm_source_id < node_iterator->node_id)
        {
+            SimpleLogger().Write(LogLevel::logWARNING) << "Found invalid node reference " << edge_iterator->result.source;
            edge_iterator->result.source = SPECIAL_NODEID;
            ++edge_iterator;
            continue;
        }
-        if (edge_iterator->result.source > node_iterator->node_id)
+        if (edge_iterator->result.osm_source_id > node_iterator->node_id)
        {
            node_iterator++;
            continue;
        }

        // remove loops
-        if (edge_iterator->result.source == edge_iterator->result.target)
+        if (edge_iterator->result.osm_source_id == edge_iterator->result.osm_target_id)
        {
            edge_iterator->result.source = SPECIAL_NODEID;
            edge_iterator->result.target = SPECIAL_NODEID;
@@ -205,7 +260,7 @@ void ExtractionContainers::PrepareEdges()
            continue;
        }

-        BOOST_ASSERT(edge_iterator->result.source == node_iterator->node_id);
+        BOOST_ASSERT(edge_iterator->result.osm_source_id == node_iterator->node_id);

        // assign new node id
        auto id_iter = external_to_internal_node_id_map.find(node_iterator->node_id);
@@ -216,13 +271,24 @@ void ExtractionContainers::PrepareEdges()
        edge_iterator->source_coordinate.lon = node_iterator->lon;
        ++edge_iterator;
    }
+
+    // Remove all remaining edges. They are invalid because there are no corresponding nodes for
+    // them. This happens when using osmosis with bbox or polygon to extract smaller areas.
+    auto markSourcesInvalid = [](InternalExtractorEdge &edge)
+    {
+        SimpleLogger().Write(LogLevel::logWARNING) << "Found invalid node reference "
+                                                   << edge.result.source;
+        edge.result.source = SPECIAL_NODEID;
+        edge.result.osm_source_id = SPECIAL_OSM_NODEID;
+    };
+    std::for_each(edge_iterator, all_edges_list_end, markSourcesInvalid);
    TIMER_STOP(set_start_coords);
    std::cout << "ok, after " << TIMER_SEC(set_start_coords) << "s" << std::endl;

    // Sort Edges by target
    std::cout << "[extractor] Sorting edges by target   ... " << std::flush;
    TIMER_START(sort_edges_by_target);
-    stxxl::sort(all_edges_list.begin(), all_edges_list.end(), CmpEdgeByTargetID(),
+    stxxl::sort(all_edges_list.begin(), all_edges_list.end(), CmpEdgeByOSMTargetID(),
                stxxl_memory);
    TIMER_STOP(sort_edges_by_target);
    std::cout << "ok, after " << TIMER_SEC(sort_edges_by_target) << "s" << std::endl;
@@ -232,7 +298,10 @@ void ExtractionContainers::PrepareEdges()
    TIMER_START(compute_weights);
    node_iterator = all_nodes_list.begin();
    edge_iterator = all_edges_list.begin();
-    while (edge_iterator != all_edges_list.end() && node_iterator != all_nodes_list.end())
+    const auto all_edges_list_end_ = all_edges_list.end();
+    const auto all_nodes_list_end_ = all_nodes_list.end();
+
+    while (edge_iterator != all_edges_list_end_ && node_iterator != all_nodes_list_end_)
    {
        // skip all invalid edges
        if (edge_iterator->result.source == SPECIAL_NODEID)
@@ -241,27 +310,38 @@ void ExtractionContainers::PrepareEdges()
            continue;
        }

-        if (edge_iterator->result.target < node_iterator->node_id)
+        if (edge_iterator->result.osm_target_id < node_iterator->node_id)
        {
+            SimpleLogger().Write(LogLevel::logWARNING) << "Found invalid node reference " << OSMNodeID_to_uint64_t(edge_iterator->result.osm_target_id);
            edge_iterator->result.target = SPECIAL_NODEID;
            ++edge_iterator;
            continue;
        }
-        if (edge_iterator->result.target > node_iterator->node_id)
+        if (edge_iterator->result.osm_target_id > node_iterator->node_id)
        {
            ++node_iterator;
            continue;
        }

-        BOOST_ASSERT(edge_iterator->result.target == node_iterator->node_id);
+        BOOST_ASSERT(edge_iterator->result.osm_target_id == node_iterator->node_id);
        BOOST_ASSERT(edge_iterator->weight_data.speed >= 0);
        BOOST_ASSERT(edge_iterator->source_coordinate.lat != std::numeric_limits<int>::min());
        BOOST_ASSERT(edge_iterator->source_coordinate.lon != std::numeric_limits<int>::min());

-        const double distance = coordinate_calculation::euclidean_distance(
+        const double distance = coordinate_calculation::great_circle_distance(
            edge_iterator->source_coordinate.lat, edge_iterator->source_coordinate.lon,
            node_iterator->lat, node_iterator->lon);

+        if (lua_function_exists(segment_state, "segment_function"))
+        {
+            luabind::call_function<void>(
+                segment_state, "segment_function",
+                boost::cref(edge_iterator->source_coordinate),
+                boost::cref(*node_iterator),
+                distance,
+                boost::ref(edge_iterator->weight_data));
+        }
+
        const double weight = [distance](const InternalExtractorEdge::WeightData& data) {
            switch (data.type)
            {
@@ -299,13 +379,23 @@ void ExtractionContainers::PrepareEdges()
        }
        ++edge_iterator;
    }
+
+    // Remove all remaining edges. They are invalid because there are no corresponding nodes for
+    // them. This happens when using osmosis with bbox or polygon to extract smaller areas.
+    auto markTargetsInvalid = [](InternalExtractorEdge &edge)
+    {
+        SimpleLogger().Write(LogLevel::logWARNING) << "Found invalid node reference "
+                                                   << edge.result.target;
+        edge.result.target = SPECIAL_NODEID;
+    };
+    std::for_each(edge_iterator, all_edges_list_end_, markTargetsInvalid);
    TIMER_STOP(compute_weights);
    std::cout << "ok, after " << TIMER_SEC(compute_weights) << "s" << std::endl;

    // Sort edges by start.
    std::cout << "[extractor] Sorting edges by renumbered start ... " << std::flush;
    TIMER_START(sort_edges_by_renumbered_start);
-    stxxl::sort(all_edges_list.begin(), all_edges_list.end(), CmpEdgeByStartThenTargetID(), stxxl_memory);
+    stxxl::sort(all_edges_list.begin(), all_edges_list.end(), CmpEdgeByInternalStartThenInternalTargetID(), stxxl_memory);
    TIMER_STOP(sort_edges_by_renumbered_start);
    std::cout << "ok, after " << TIMER_SEC(sort_edges_by_renumbered_start) << "s" << std::endl;

@@ -320,6 +410,7 @@ void ExtractionContainers::PrepareEdges()
        // skip invalid edges
        if (all_edges_list[i].result.target == SPECIAL_NODEID)
        {
+            ++i;
            continue;
        }

@@ -395,13 +486,14 @@ void ExtractionContainers::PrepareEdges()

 void ExtractionContainers::WriteEdges(std::ofstream& file_out_stream) const
 {
-    std::cout << "[extractor] Writing used egdes       ... " << std::flush;
+    std::cout << "[extractor] Writing used edges       ... " << std::flush;
    TIMER_START(write_edges);
    // Traverse list of edges and nodes in parallel and set target coord
-    unsigned number_of_used_edges = 0;
+    std::size_t used_edges_counter = 0;
+    unsigned used_edges_counter_buffer = 0;

    auto start_position = file_out_stream.tellp();
-    file_out_stream.write((char *)&number_of_used_edges, sizeof(unsigned));
+    file_out_stream.write((char *)&used_edges_counter_buffer, sizeof(unsigned));

    for (const auto& edge : all_edges_list)
    {
@@ -410,31 +502,47 @@ void ExtractionContainers::WriteEdges(std::ofstream& file_out_stream) const
            continue;
        }

-        file_out_stream.write((char*) &edge.result, sizeof(NodeBasedEdge));
-        number_of_used_edges++;
+        // IMPORTANT: here, we're using slicing to only write the data from the base
+        // class of NodeBasedEdgeWithOSM
+        NodeBasedEdge tmp = edge.result;
+        file_out_stream.write((char*) &tmp, sizeof(NodeBasedEdge));
+        used_edges_counter++;
+    }
+
+    if (used_edges_counter > std::numeric_limits<unsigned>::max())
+    {
+        throw osrm::exception("There are too many edges, OSRM only supports 2^32");
    }
    TIMER_STOP(write_edges);
    std::cout << "ok, after " << TIMER_SEC(write_edges) << "s" << std::endl;

    std::cout << "[extractor] setting number of edges   ... " << std::flush;
+
+    used_edges_counter_buffer = boost::numeric_cast<unsigned>(used_edges_counter);
+
    file_out_stream.seekp(start_position);
-    file_out_stream.write((char *)&number_of_used_edges, sizeof(unsigned));
+    file_out_stream.write((char *)&used_edges_counter_buffer, sizeof(unsigned));
    std::cout << "ok" << std::endl;

-    SimpleLogger().Write() << "Processed " << number_of_used_edges << " edges";
+    SimpleLogger().Write() << "Processed " << used_edges_counter << " edges";
 }

 void ExtractionContainers::WriteNodes(std::ofstream& file_out_stream) const
 {
-    unsigned number_of_used_nodes = 0;
    // write dummy value, will be overwritten later
-    file_out_stream.write((char *)&number_of_used_nodes, sizeof(unsigned));
+    std::cout << "[extractor] setting number of nodes   ... " << std::flush;
+    file_out_stream.write((char *)&max_internal_node_id, sizeof(unsigned));
+    std::cout << "ok" << std::endl;
+
    std::cout << "[extractor] Confirming/Writing used nodes     ... " << std::flush;
    TIMER_START(write_nodes);
    // identify all used nodes by a merging step of two sorted lists
    auto node_iterator = all_nodes_list.begin();
    auto node_id_iterator = used_node_id_list.begin();
-    while (node_id_iterator != used_node_id_list.end() && node_iterator != all_nodes_list.end())
+    const auto used_node_id_list_end = used_node_id_list.end();
+    const auto all_nodes_list_end = all_nodes_list.end();
+
+    while (node_id_iterator != used_node_id_list_end && node_iterator != all_nodes_list_end)
    {
        if (*node_id_iterator < node_iterator->node_id)
        {
@@ -450,21 +558,14 @@ void ExtractionContainers::WriteNodes(std::ofstream& file_out_stream) const

        file_out_stream.write((char *)&(*node_iterator), sizeof(ExternalMemoryNode));

-        ++number_of_used_nodes;
        ++node_id_iterator;
        ++node_iterator;
    }
    TIMER_STOP(write_nodes);
    std::cout << "ok, after " << TIMER_SEC(write_nodes) << "s" << std::endl;

-    std::cout << "[extractor] setting number of nodes   ... " << std::flush;
-    std::ios::pos_type previous_file_position = file_out_stream.tellp();
-    file_out_stream.seekp(std::ios::beg + sizeof(FingerPrint));
-    file_out_stream.write((char *)&number_of_used_nodes, sizeof(unsigned));
-    file_out_stream.seekp(previous_file_position);
-    std::cout << "ok" << std::endl;

-    SimpleLogger().Write() << "Processed " << number_of_used_nodes << " nodes";
+    SimpleLogger().Write() << "Processed " << max_internal_node_id << " nodes";
 }

 void ExtractionContainers::WriteRestrictions(const std::string& path) const
@@ -516,17 +617,19 @@ void ExtractionContainers::PrepareRestrictions()
    TIMER_START(fix_restriction_starts);
    auto restrictions_iterator = restrictions_list.begin();
    auto way_start_and_end_iterator = way_start_end_id_list.cbegin();
+    const auto restrictions_list_end = restrictions_list.end();
+    const auto way_start_end_id_list_end = way_start_end_id_list.cend();

-    while (way_start_and_end_iterator != way_start_end_id_list.cend() &&
-           restrictions_iterator != restrictions_list.end())
+    while (way_start_and_end_iterator != way_start_end_id_list_end &&
+           restrictions_iterator != restrictions_list_end)
    {
-        if (way_start_and_end_iterator->way_id < restrictions_iterator->restriction.from.way)
+        if (way_start_and_end_iterator->way_id < OSMWayID(restrictions_iterator->restriction.from.way))
        {
            ++way_start_and_end_iterator;
            continue;
        }

-        if (way_start_and_end_iterator->way_id > restrictions_iterator->restriction.from.way)
+        if (way_start_and_end_iterator->way_id > OSMWayID(restrictions_iterator->restriction.from.way))
        {
            SimpleLogger().Write(LogLevel::logDEBUG) << "Restriction references invalid way: " << restrictions_iterator->restriction.from.way;
            restrictions_iterator->restriction.from.node = SPECIAL_NODEID;
@@ -535,9 +638,9 @@ void ExtractionContainers::PrepareRestrictions()
        }

        BOOST_ASSERT(way_start_and_end_iterator->way_id ==
-                     restrictions_iterator->restriction.from.way);
+                     OSMWayID(restrictions_iterator->restriction.from.way));
        // we do not remap the via id yet, since we will need it for the to node as well
-        const NodeID via_node_id = restrictions_iterator->restriction.via.node;
+        const OSMNodeID via_node_id = OSMNodeID(restrictions_iterator->restriction.via.node);

        // check if via is actually valid, if not invalidate
        auto via_id_iter = external_to_internal_node_id_map.find(via_node_id);
@@ -549,19 +652,19 @@ void ExtractionContainers::PrepareRestrictions()
            continue;
        }

-        if (way_start_and_end_iterator->first_segment_source_id == via_node_id)
+        if (OSMNodeID(way_start_and_end_iterator->first_segment_source_id) == via_node_id)
        {
            // assign new from node id
            auto id_iter = external_to_internal_node_id_map.find(
-                    way_start_and_end_iterator->first_segment_target_id);
+                    OSMNodeID(way_start_and_end_iterator->first_segment_target_id));
            BOOST_ASSERT(id_iter != external_to_internal_node_id_map.end());
            restrictions_iterator->restriction.from.node = id_iter->second;
        }
-        else if (way_start_and_end_iterator->last_segment_target_id == via_node_id)
+        else if (OSMNodeID(way_start_and_end_iterator->last_segment_target_id) == via_node_id)
        {
            // assign new from node id
            auto id_iter = external_to_internal_node_id_map.find(
-                    way_start_and_end_iterator->last_segment_source_id);
+                    OSMNodeID(way_start_and_end_iterator->last_segment_source_id));
            BOOST_ASSERT(id_iter != external_to_internal_node_id_map.end());
            restrictions_iterator->restriction.from.node = id_iter->second;
        }
@@ -582,10 +685,13 @@ void ExtractionContainers::PrepareRestrictions()
    TIMER_START(fix_restriction_ends);
    restrictions_iterator = restrictions_list.begin();
    way_start_and_end_iterator = way_start_end_id_list.cbegin();
-    while (way_start_and_end_iterator != way_start_end_id_list.cend() &&
-           restrictions_iterator != restrictions_list.end())
+    const auto way_start_end_id_list_end_ = way_start_end_id_list.cend();
+    const auto restrictions_list_end_ = restrictions_list.end();
+
+    while (way_start_and_end_iterator != way_start_end_id_list_end_ &&
+           restrictions_iterator != restrictions_list_end_)
    {
-        if (way_start_and_end_iterator->way_id < restrictions_iterator->restriction.to.way)
+        if (way_start_and_end_iterator->way_id < OSMWayID(restrictions_iterator->restriction.to.way))
        {
            ++way_start_and_end_iterator;
            continue;
@@ -596,7 +702,7 @@ void ExtractionContainers::PrepareRestrictions()
            ++restrictions_iterator;
            continue;
        }
-        if (way_start_and_end_iterator->way_id > restrictions_iterator->restriction.to.way)
+        if (way_start_and_end_iterator->way_id > OSMWayID(restrictions_iterator->restriction.to.way))
        {
            SimpleLogger().Write(LogLevel::logDEBUG) << "Restriction references invalid way: " << restrictions_iterator->restriction.to.way;
            restrictions_iterator->restriction.to.way = SPECIAL_NODEID;
@@ -604,25 +710,25 @@ void ExtractionContainers::PrepareRestrictions()
            continue;
        }
        BOOST_ASSERT(way_start_and_end_iterator->way_id ==
-                     restrictions_iterator->restriction.to.way);
-        const NodeID via_node_id = restrictions_iterator->restriction.via.node;
+                     OSMWayID(restrictions_iterator->restriction.to.way));
+        const OSMNodeID via_node_id = OSMNodeID(restrictions_iterator->restriction.via.node);

        // assign new via node id
        auto via_id_iter = external_to_internal_node_id_map.find(via_node_id);
        BOOST_ASSERT(via_id_iter != external_to_internal_node_id_map.end());
        restrictions_iterator->restriction.via.node = via_id_iter->second;

-        if (way_start_and_end_iterator->first_segment_source_id == via_node_id)
+        if (OSMNodeID(way_start_and_end_iterator->first_segment_source_id) == via_node_id)
        {
            auto to_id_iter = external_to_internal_node_id_map.find(
-                    way_start_and_end_iterator->first_segment_target_id);
+                    OSMNodeID(way_start_and_end_iterator->first_segment_target_id));
            BOOST_ASSERT(to_id_iter != external_to_internal_node_id_map.end());
            restrictions_iterator->restriction.to.node = to_id_iter->second;
        }
-        else if (way_start_and_end_iterator->last_segment_target_id == via_node_id)
+        else if (OSMNodeID(way_start_and_end_iterator->last_segment_target_id) == via_node_id)
        {
            auto to_id_iter = external_to_internal_node_id_map.find(
-                    way_start_and_end_iterator->last_segment_source_id);
+                    OSMNodeID(way_start_and_end_iterator->last_segment_source_id));
            BOOST_ASSERT(to_id_iter != external_to_internal_node_id_map.end());
            restrictions_iterator->restriction.to.node = to_id_iter->second;
        }
@@ -30,6 +30,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 #include "internal_extractor_edge.hpp"
 #include "first_and_last_segment_of_way.hpp"
+#include "scripting_environment.hpp"
 #include "../data_structures/external_memory_node.hpp"
 #include "../data_structures/restriction.hpp"

@@ -53,27 +54,28 @@ class ExtractionContainers
 #endif
    void PrepareNodes();
    void PrepareRestrictions();
-    void PrepareEdges();
+    void PrepareEdges(lua_State *segment_state);

    void WriteNodes(std::ofstream& file_out_stream) const;
    void WriteRestrictions(const std::string& restrictions_file_name) const;
    void WriteEdges(std::ofstream& file_out_stream) const;
    void WriteNames(const std::string& names_file_name) const;
  public:
-    using STXXLNodeIDVector = stxxl::vector<NodeID>;
+    using STXXLNodeIDVector = stxxl::vector<OSMNodeID>;
    using STXXLNodeVector = stxxl::vector<ExternalMemoryNode>;
    using STXXLEdgeVector = stxxl::vector<InternalExtractorEdge>;
-    using STXXLStringVector = stxxl::vector<std::string>;
    using STXXLRestrictionsVector = stxxl::vector<InputRestrictionContainer>;
    using STXXLWayIDStartEndVector = stxxl::vector<FirstAndLastSegmentOfWay>;

    STXXLNodeIDVector used_node_id_list;
    STXXLNodeVector all_nodes_list;
    STXXLEdgeVector all_edges_list;
-    STXXLStringVector name_list;
+    stxxl::vector<char> name_char_data;
+    stxxl::vector<unsigned> name_lengths;
    STXXLRestrictionsVector restrictions_list;
    STXXLWayIDStartEndVector way_start_end_id_list;
-    std::unordered_map<NodeID, NodeID> external_to_internal_node_id_map;
+    std::unordered_map<OSMNodeID, NodeID> external_to_internal_node_id_map;
+    unsigned max_internal_node_id;

    ExtractionContainers();

@@ -81,7 +83,8 @@ class ExtractionContainers

    void PrepareData(const std::string &output_file_name,
                     const std::string &restrictions_file_name,
-                     const std::string &names_file_name);
+                     const std::string &names_file_name,
+                     lua_State *segment_state);
 };

 #endif /* EXTRACTION_CONTAINERS_HPP */
@@ -37,6 +37,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <boost/regex.hpp>

 #include <limits>
+#include <string>

 bool simple_duration_is_valid(const std::string &s)
 {
@@ -89,18 +90,18 @@ unsigned parseDuration(const std::string &s)
        {
            if (1 == result.size())
            {
-                minutes = cast::string_to_int(result[0]);
+                minutes = std::stoul(result[0]);
            }
            if (2 == result.size())
            {
-                minutes = cast::string_to_int(result[1]);
-                hours = cast::string_to_int(result[0]);
+                minutes = std::stoul(result[1]);
+                hours = std::stoul(result[0]);
            }
            if (3 == result.size())
            {
-                seconds = cast::string_to_int(result[2]);
-                minutes = cast::string_to_int(result[1]);
-                hours = cast::string_to_int(result[0]);
+                seconds = std::stoul(result[2]);
+                minutes = std::stoul(result[1]);
+                hours = std::stoul(result[0]);
            }
            return (3600 * hours + 60 * minutes + seconds);
        }
@@ -50,8 +50,8 @@ struct ExtractionWay
        backward_speed = -1;
        duration = -1;
        roundabout = false;
+        is_startpoint = true;
        is_access_restricted = false;
-        ignore_in_grid = false;
        name.clear();
        forward_travel_mode = TRAVEL_MODE_DEFAULT;
        backward_travel_mode = TRAVEL_MODE_DEFAULT;
@@ -121,7 +121,7 @@ struct ExtractionWay
    std::string name;
    bool roundabout;
    bool is_access_restricted;
-    bool ignore_in_grid;
+    bool is_startpoint;
    TravelMode forward_travel_mode : 4;
    TravelMode backward_travel_mode : 4;
 };
@@ -34,15 +34,26 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "restriction_parser.hpp"
 #include "scripting_environment.hpp"

-#include "../util/git_sha.hpp"
+#include "../data_structures/raster_source.hpp"
 #include "../util/make_unique.hpp"
 #include "../util/simple_logger.hpp"
 #include "../util/timing_util.hpp"
+#include "../util/lua_util.hpp"
+#include "../util/graph_loader.hpp"

 #include "../typedefs.h"

+#include "../data_structures/static_graph.hpp"
+#include "../data_structures/static_rtree.hpp"
+#include "../data_structures/restriction_map.hpp"
+#include "../data_structures/compressed_edge_container.hpp"
+
+#include "../algorithms/tarjan_scc.hpp"
+#include "../algorithms/crc32_processor.hpp"
+
 #include <boost/filesystem.hpp>
 #include <boost/filesystem/fstream.hpp>
+#include <boost/optional/optional.hpp>

 #include <luabind/luabind.hpp>

@@ -51,8 +62,6 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <tbb/parallel_for.h>
 #include <tbb/task_scheduler_init.h>

-#include <variant/optional.hpp>
-
 #include <cstdlib>

 #include <algorithm>
@@ -79,7 +88,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 * The result of this process are the following files:
 *  .names : Names of all streets, stored as long consecutive string with prefix sum based index
 *  .osrm  : Nodes and edges in a intermediate format that easy to digest for osrm-prepare
- *  .restrictions : Turn restrictions that are used my osrm-prepare to construct the edge-expanded graph
+ *  .restrictions : Turn restrictions that are used my osrm-prepare to construct the edge-expanded
+ * graph
 *
 */
 int extractor::run()
@@ -116,6 +126,17 @@ int extractor::run()
        SimpleLogger().Write() << "Parsing in progress..";
        TIMER_START(parsing);

+        lua_State *segment_state = scripting_environment.get_lua_state();
+
+        if (lua_function_exists(segment_state, "source_function"))
+        {
+            // bind a single instance of SourceContainer class to relevant lua state
+            SourceContainer sources;
+            luabind::globals(segment_state)["sources"] = sources;
+
+            luabind::call_function<void>(segment_state, "source_function");
+        }
+
        std::string generator = header.get("generator");
        if (generator.empty())
        {
@@ -138,8 +159,7 @@ int extractor::run()
        // initialize vectors holding parsed objects
        tbb::concurrent_vector<std::pair<std::size_t, ExtractionNode>> resulting_nodes;
        tbb::concurrent_vector<std::pair<std::size_t, ExtractionWay>> resulting_ways;
-        tbb::concurrent_vector<mapbox::util::optional<InputRestrictionContainer>>
-            resulting_restrictions;
+        tbb::concurrent_vector<boost::optional<InputRestrictionContainer>> resulting_restrictions;

        // setup restriction parser
        const RestrictionParser restriction_parser(scripting_environment.get_lua_state());
@@ -148,7 +168,7 @@ int extractor::run()
        {
            // create a vector of iterators into the buffer
            std::vector<osmium::memory::Buffer::const_iterator> osm_elements;
-            for (auto iter = std::begin(buffer); iter != std::end(buffer); ++iter)
+            for (auto iter = std::begin(buffer), end = std::end(buffer); iter != end; ++iter)
            {
                osm_elements.push_back(iter);
            }
@@ -167,7 +187,7 @@ int extractor::run()
                    ExtractionWay result_way;
                    lua_State *local_state = scripting_environment.get_lua_state();

-                    for (auto x = range.begin(); x != range.end(); ++x)
+                    for (auto x = range.begin(), end = range.end(); x != end; ++x)
                    {
                        const auto entity = osm_elements[x];

@@ -236,19 +256,383 @@ int extractor::run()
            return 1;
        }

-        extraction_containers.PrepareData(config.output_file_name,
-                                          config.restriction_file_name,
-                                          config.names_file_name);
+        extraction_containers.PrepareData(config.output_file_name, config.restriction_file_name,
+                                          config.names_file_name, segment_state);
+
        TIMER_STOP(extracting);
        SimpleLogger().Write() << "extraction finished after " << TIMER_SEC(extracting) << "s";
-        SimpleLogger().Write() << "To prepare the data for routing, run: "
-                               << "./osrm-prepare " << config.output_file_name
-                               << std::endl;
    }
-    catch (std::exception &e)
+    catch (const std::exception &e)
    {
        SimpleLogger().Write(logWARNING) << e.what();
        return 1;
    }
+
+    try
+    {
+        // Transform the node-based graph that OSM is based on into an edge-based graph
+        // that is better for routing.  Every edge becomes a node, and every valid
+        // movement (e.g. turn from A->B, and B->A) becomes an edge
+        //
+        //
+        //    // Create a new lua state
+
+        SimpleLogger().Write() << "Generating edge-expanded graph representation";
+
+        TIMER_START(expansion);
+
+        std::vector<EdgeBasedNode> node_based_edge_list;
+        DeallocatingVector<EdgeBasedEdge> edge_based_edge_list;
+        std::vector<bool> node_is_startpoint;
+        std::vector<QueryNode> internal_to_external_node_map;
+        auto graph_size =
+            BuildEdgeExpandedGraph(internal_to_external_node_map, node_based_edge_list,
+                                   node_is_startpoint, edge_based_edge_list);
+
+        auto number_of_node_based_nodes = graph_size.first;
+        auto max_edge_id = graph_size.second;
+
+        TIMER_STOP(expansion);
+
+        SimpleLogger().Write() << "building r-tree ...";
+        TIMER_START(rtree);
+
+        FindComponents(max_edge_id, edge_based_edge_list, node_based_edge_list);
+
+        BuildRTree(std::move(node_based_edge_list), std::move(node_is_startpoint),
+                   internal_to_external_node_map);
+
+        TIMER_STOP(rtree);
+
+        SimpleLogger().Write() << "writing node map ...";
+        WriteNodeMapping(internal_to_external_node_map);
+
+        WriteEdgeBasedGraph(config.edge_graph_output_path, max_edge_id, edge_based_edge_list);
+
+        SimpleLogger().Write() << "Expansion  : "
+                               << (number_of_node_based_nodes / TIMER_SEC(expansion))
+                               << " nodes/sec and " << ((max_edge_id + 1) / TIMER_SEC(expansion))
+                               << " edges/sec";
+        SimpleLogger().Write() << "To prepare the data for routing, run: "
+                               << "./osrm-prepare " << config.output_file_name << std::endl;
+    }
+    catch (const std::exception &e)
+    {
+        SimpleLogger().Write(logWARNING) << e.what();
+        return 1;
+    }
+
    return 0;
 }
+
+/**
+    \brief Setups scripting environment (lua-scripting)
+    Also initializes speed profile.
+*/
+void extractor::SetupScriptingEnvironment(lua_State *lua_state,
+                                          SpeedProfileProperties &speed_profile)
+{
+    // open utility libraries string library;
+    luaL_openlibs(lua_state);
+
+    // adjust lua load path
+    luaAddScriptFolderToLoadPath(lua_state, config.profile_path.string().c_str());
+
+    // Now call our function in a lua script
+    if (0 != luaL_dofile(lua_state, config.profile_path.string().c_str()))
+    {
+        std::stringstream msg;
+        msg << lua_tostring(lua_state, -1) << " occured in scripting block";
+        throw osrm::exception(msg.str());
+    }
+
+    if (0 != luaL_dostring(lua_state, "return traffic_signal_penalty\n"))
+    {
+        std::stringstream msg;
+        msg << lua_tostring(lua_state, -1) << " occured in scripting block";
+        throw osrm::exception(msg.str());
+    }
+    speed_profile.traffic_signal_penalty = 10 * lua_tointeger(lua_state, -1);
+    SimpleLogger().Write(logDEBUG) << "traffic_signal_penalty: "
+                                   << speed_profile.traffic_signal_penalty;
+
+    if (0 != luaL_dostring(lua_state, "return u_turn_penalty\n"))
+    {
+        std::stringstream msg;
+        msg << lua_tostring(lua_state, -1) << " occured in scripting block";
+        throw osrm::exception(msg.str());
+    }
+
+    speed_profile.u_turn_penalty = 10 * lua_tointeger(lua_state, -1);
+    speed_profile.has_turn_penalty_function = lua_function_exists(lua_state, "turn_function");
+}
+
+void extractor::FindComponents(unsigned max_edge_id,
+                               const DeallocatingVector<EdgeBasedEdge> &input_edge_list,
+                               std::vector<EdgeBasedNode> &input_nodes) const
+{
+    struct UncontractedEdgeData
+    {
+    };
+    struct InputEdge
+    {
+        unsigned source;
+        unsigned target;
+        UncontractedEdgeData data;
+
+        bool operator<(const InputEdge &rhs) const
+        {
+            return source < rhs.source || (source == rhs.source && target < rhs.target);
+        }
+
+        bool operator==(const InputEdge &rhs) const
+        {
+            return source == rhs.source && target == rhs.target;
+        }
+    };
+    using UncontractedGraph = StaticGraph<UncontractedEdgeData>;
+    std::vector<InputEdge> edges;
+    edges.reserve(input_edge_list.size() * 2);
+
+    for (const auto &edge : input_edge_list)
+    {
+        BOOST_ASSERT_MSG(static_cast<unsigned int>(std::max(edge.weight, 1)) > 0,
+                         "edge distance < 1");
+        if (edge.forward)
+        {
+            edges.push_back({edge.source, edge.target, {}});
+        }
+
+        if (edge.backward)
+        {
+            edges.push_back({edge.target, edge.source, {}});
+        }
+    }
+
+    // connect forward and backward nodes of each edge
+    for (const auto &node : input_nodes)
+    {
+        if (node.reverse_edge_based_node_id != SPECIAL_NODEID)
+        {
+            edges.push_back({node.forward_edge_based_node_id, node.reverse_edge_based_node_id, {}});
+            edges.push_back({node.reverse_edge_based_node_id, node.forward_edge_based_node_id, {}});
+        }
+    }
+
+    tbb::parallel_sort(edges.begin(), edges.end());
+    auto new_end = std::unique(edges.begin(), edges.end());
+    edges.resize(new_end - edges.begin());
+
+    auto uncontractor_graph = std::make_shared<UncontractedGraph>(max_edge_id + 1, edges);
+
+    TarjanSCC<UncontractedGraph> component_search(
+        std::const_pointer_cast<const UncontractedGraph>(uncontractor_graph));
+    component_search.run();
+
+    for (auto &node : input_nodes)
+    {
+        auto forward_component = component_search.get_component_id(node.forward_edge_based_node_id);
+        BOOST_ASSERT(node.reverse_edge_based_node_id == SPECIAL_EDGEID ||
+                     forward_component ==
+                         component_search.get_component_id(node.reverse_edge_based_node_id));
+
+        const unsigned component_size = component_search.get_component_size(forward_component);
+        node.component.is_tiny = component_size < config.small_component_size;
+        node.component.id = 1 + forward_component;
+    }
+}
+
+/**
+  \brief Build load restrictions from .restriction file
+  */
+std::shared_ptr<RestrictionMap> extractor::LoadRestrictionMap()
+{
+    boost::filesystem::ifstream input_stream(config.restriction_file_name,
+                                             std::ios::in | std::ios::binary);
+
+    std::vector<TurnRestriction> restriction_list;
+    loadRestrictionsFromFile(input_stream, restriction_list);
+
+    SimpleLogger().Write() << " - " << restriction_list.size() << " restrictions.";
+
+    return std::make_shared<RestrictionMap>(restriction_list);
+}
+
+/**
+  \brief Load node based graph from .osrm file
+  */
+std::shared_ptr<NodeBasedDynamicGraph>
+extractor::LoadNodeBasedGraph(std::unordered_set<NodeID> &barrier_nodes,
+                              std::unordered_set<NodeID> &traffic_lights,
+                              std::vector<QueryNode> &internal_to_external_node_map)
+{
+    std::vector<NodeBasedEdge> edge_list;
+
+    boost::filesystem::ifstream input_stream(config.output_file_name,
+                                             std::ios::in | std::ios::binary);
+
+    std::vector<NodeID> barrier_list;
+    std::vector<NodeID> traffic_light_list;
+    NodeID number_of_node_based_nodes = loadNodesFromFile(
+        input_stream, barrier_list, traffic_light_list, internal_to_external_node_map);
+
+    SimpleLogger().Write() << " - " << barrier_list.size() << " bollard nodes, "
+                           << traffic_light_list.size() << " traffic lights";
+
+    // insert into unordered sets for fast lookup
+    barrier_nodes.insert(barrier_list.begin(), barrier_list.end());
+    traffic_lights.insert(traffic_light_list.begin(), traffic_light_list.end());
+
+    barrier_list.clear();
+    barrier_list.shrink_to_fit();
+    traffic_light_list.clear();
+    traffic_light_list.shrink_to_fit();
+
+    loadEdgesFromFile(input_stream, edge_list);
+
+    if (edge_list.empty())
+    {
+        SimpleLogger().Write(logWARNING) << "The input data is empty, exiting.";
+        return std::shared_ptr<NodeBasedDynamicGraph>();
+    }
+
+    return NodeBasedDynamicGraphFromEdges(number_of_node_based_nodes, edge_list);
+}
+
+/**
+ \brief Building an edge-expanded graph from node-based input and turn restrictions
+*/
+std::pair<std::size_t, std::size_t>
+extractor::BuildEdgeExpandedGraph(std::vector<QueryNode> &internal_to_external_node_map,
+                                  std::vector<EdgeBasedNode> &node_based_edge_list,
+                                  std::vector<bool> &node_is_startpoint,
+                                  DeallocatingVector<EdgeBasedEdge> &edge_based_edge_list)
+{
+    lua_State *lua_state = luaL_newstate();
+    luabind::open(lua_state);
+
+    SpeedProfileProperties speed_profile;
+    SetupScriptingEnvironment(lua_state, speed_profile);
+
+    std::unordered_set<NodeID> barrier_nodes;
+    std::unordered_set<NodeID> traffic_lights;
+
+    auto restriction_map = LoadRestrictionMap();
+    auto node_based_graph =
+        LoadNodeBasedGraph(barrier_nodes, traffic_lights, internal_to_external_node_map);
+
+    CompressedEdgeContainer compressed_edge_container;
+    GraphCompressor graph_compressor(speed_profile);
+    graph_compressor.Compress(barrier_nodes, traffic_lights, *restriction_map, *node_based_graph,
+                              compressed_edge_container);
+
+    EdgeBasedGraphFactory edge_based_graph_factory(
+        node_based_graph, compressed_edge_container, barrier_nodes, traffic_lights,
+        std::const_pointer_cast<RestrictionMap const>(restriction_map),
+        internal_to_external_node_map, speed_profile);
+
+    compressed_edge_container.SerializeInternalVector(config.geometry_output_path);
+
+    edge_based_graph_factory.Run(config.edge_output_path, lua_state,
+                                 config.edge_segment_lookup_path, config.edge_penalty_path,
+                                 config.generate_edge_lookup
+#ifdef DEBUG_GEOMETRY
+                                 ,
+                                 config.debug_turns_path
+#endif
+                                 );
+    lua_close(lua_state);
+
+    edge_based_graph_factory.GetEdgeBasedEdges(edge_based_edge_list);
+    edge_based_graph_factory.GetEdgeBasedNodes(node_based_edge_list);
+    edge_based_graph_factory.GetStartPointMarkers(node_is_startpoint);
+    auto max_edge_id = edge_based_graph_factory.GetHighestEdgeID();
+
+    const std::size_t number_of_node_based_nodes = node_based_graph->GetNumberOfNodes();
+    return std::make_pair(number_of_node_based_nodes, max_edge_id);
+}
+
+/**
+  \brief Writing info on original (node-based) nodes
+ */
+void extractor::WriteNodeMapping(const std::vector<QueryNode> &internal_to_external_node_map)
+{
+    boost::filesystem::ofstream node_stream(config.node_output_path, std::ios::binary);
+    const unsigned size_of_mapping = internal_to_external_node_map.size();
+    node_stream.write((char *)&size_of_mapping, sizeof(unsigned));
+    if (size_of_mapping > 0)
+    {
+        node_stream.write((char *)internal_to_external_node_map.data(),
+                          size_of_mapping * sizeof(QueryNode));
+    }
+    node_stream.close();
+}
+
+/**
+    \brief Building rtree-based nearest-neighbor data structure
+
+    Saves tree into '.ramIndex' and leaves into '.fileIndex'.
+ */
+void extractor::BuildRTree(std::vector<EdgeBasedNode> node_based_edge_list,
+                           std::vector<bool> node_is_startpoint,
+                           const std::vector<QueryNode> &internal_to_external_node_map)
+{
+    SimpleLogger().Write() << "constructing r-tree of " << node_based_edge_list.size()
+                           << " edge elements build on-top of "
+                           << internal_to_external_node_map.size() << " coordinates";
+
+    BOOST_ASSERT(node_is_startpoint.size() == node_based_edge_list.size());
+
+    // Filter node based edges based on startpoint
+    auto out_iter = node_based_edge_list.begin();
+    auto in_iter = node_based_edge_list.begin();
+    for (auto index : osrm::irange<std::size_t>(0, node_is_startpoint.size()))
+    {
+        BOOST_ASSERT(in_iter != node_based_edge_list.end());
+        if (node_is_startpoint[index])
+        {
+            *out_iter = *in_iter;
+            out_iter++;
+        }
+        in_iter++;
+    }
+    auto new_size = out_iter - node_based_edge_list.begin();
+    node_based_edge_list.resize(new_size);
+
+    TIMER_START(construction);
+    StaticRTree<EdgeBasedNode>(node_based_edge_list, config.rtree_nodes_output_path,
+                               config.rtree_leafs_output_path, internal_to_external_node_map);
+
+    TIMER_STOP(construction);
+    SimpleLogger().Write() << "finished r-tree construction in " << TIMER_SEC(construction)
+                           << " seconds";
+}
+
+void extractor::WriteEdgeBasedGraph(std::string const &output_file_filename,
+                                    size_t const max_edge_id,
+                                    DeallocatingVector<EdgeBasedEdge> const &edge_based_edge_list)
+{
+
+    std::ofstream file_out_stream;
+    file_out_stream.open(output_file_filename.c_str(), std::ios::binary);
+    const FingerPrint fingerprint = FingerPrint::GetValid();
+    file_out_stream.write((char *)&fingerprint, sizeof(FingerPrint));
+
+    std::cout << "[extractor] Writing edge-based-graph egdes       ... " << std::flush;
+    TIMER_START(write_edges);
+
+    size_t number_of_used_edges = edge_based_edge_list.size();
+    file_out_stream.write((char *)&number_of_used_edges, sizeof(size_t));
+    file_out_stream.write((char *)&max_edge_id, sizeof(size_t));
+
+    for (const auto &edge : edge_based_edge_list)
+    {
+        file_out_stream.write((char *)&edge, sizeof(EdgeBasedEdge));
+    }
+
+    TIMER_STOP(write_edges);
+    std::cout << "ok, after " << TIMER_SEC(write_edges) << "s" << std::endl;
+
+    SimpleLogger().Write() << "Processed " << number_of_used_edges << " edges";
+    file_out_stream.close();
+}
@@ -29,14 +29,38 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define EXTRACTOR_HPP

 #include "extractor_options.hpp"
+#include "edge_based_graph_factory.hpp"
+#include "../algorithms/graph_compressor.hpp"

 class extractor
 {
-public:
-    extractor(const ExtractorConfig &extractor_config)
-        : config(extractor_config) {}
+  public:
+    extractor(ExtractorConfig extractor_config) : config(std::move(extractor_config)) {}
    int run();
-private:
-   ExtractorConfig config;
+
+  private:
+    ExtractorConfig config;
+    void SetupScriptingEnvironment(lua_State *myLuaState, SpeedProfileProperties &speed_profile);
+    std::pair<std::size_t, std::size_t>
+    BuildEdgeExpandedGraph(std::vector<QueryNode> &internal_to_external_node_map,
+                           std::vector<EdgeBasedNode> &node_based_edge_list,
+                           std::vector<bool> &node_is_startpoint,
+                           DeallocatingVector<EdgeBasedEdge> &edge_based_edge_list);
+    void WriteNodeMapping(const std::vector<QueryNode> &internal_to_external_node_map);
+    void FindComponents(unsigned max_edge_id,
+                        const DeallocatingVector<EdgeBasedEdge> &edges,
+                        std::vector<EdgeBasedNode> &nodes) const;
+    void BuildRTree(std::vector<EdgeBasedNode> node_based_edge_list,
+                    std::vector<bool> node_is_startpoint,
+                    const std::vector<QueryNode> &internal_to_external_node_map);
+    std::shared_ptr<RestrictionMap> LoadRestrictionMap();
+    std::shared_ptr<NodeBasedDynamicGraph>
+    LoadNodeBasedGraph(std::unordered_set<NodeID> &barrier_nodes,
+                       std::unordered_set<NodeID> &traffic_lights,
+                       std::vector<QueryNode> &internal_to_external_node_map);
+
+    void WriteEdgeBasedGraph(std::string const &output_file_filename,
+                             size_t const max_edge_id,
+                             DeallocatingVector<EdgeBasedEdge> const &edge_based_edge_list);
 };
 #endif /* EXTRACTOR_HPP */
@@ -35,6 +35,10 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "../util/container.hpp"
 #include "../util/simple_logger.hpp"

+#include <boost/optional/optional.hpp>
+
+#include <osmium/osm.hpp>
+
 #include <osrm/coordinate.hpp>

 #include <limits>
@@ -59,13 +63,13 @@ void ExtractorCallbacks::ProcessNode(const osmium::Node &input_node,
    external_memory.all_nodes_list.push_back(
        {static_cast<int>(input_node.location().lat() * COORDINATE_PRECISION),
         static_cast<int>(input_node.location().lon() * COORDINATE_PRECISION),
-         static_cast<NodeID>(input_node.id()),
+         OSMNodeID(input_node.id()),
         result_node.barrier,
         result_node.traffic_lights});
 }

 void ExtractorCallbacks::ProcessRestriction(
-    const mapbox::util::optional<InputRestrictionContainer> &restriction)
+    const boost::optional<InputRestrictionContainer> &restriction)
 {
    if (restriction)
    {
@@ -140,8 +144,8 @@ void ExtractorCallbacks::ProcessWay(const osmium::Way &input_way, const Extracti
        }
    }

-    if (forward_weight_data.type == InternalExtractorEdge::WeightType::INVALID
-     && backward_weight_data.type == InternalExtractorEdge::WeightType::INVALID)
+    if (forward_weight_data.type == InternalExtractorEdge::WeightType::INVALID &&
+        backward_weight_data.type == InternalExtractorEdge::WeightType::INVALID)
    {
        SimpleLogger().Write(logDEBUG) << "found way with bogus speed, id: " << input_way.id();
        return;
@@ -149,10 +153,12 @@ void ExtractorCallbacks::ProcessWay(const osmium::Way &input_way, const Extracti

    // Get the unique identifier for the street name
    const auto &string_map_iterator = string_map.find(parsed_way.name);
-    unsigned name_id = external_memory.name_list.size();
+    unsigned name_id = external_memory.name_lengths.size();
    if (string_map.end() == string_map_iterator)
    {
-        external_memory.name_list.push_back(parsed_way.name);
+        auto name_length = std::min<unsigned>(255u, parsed_way.name.size());
+        std::copy(parsed_way.name.c_str(), parsed_way.name.c_str() + name_length, std::back_inserter(external_memory.name_char_data));
+        external_memory.name_lengths.push_back(name_length);
        string_map.insert(std::make_pair(parsed_way.name, name_id));
    }
    else
@@ -167,76 +173,69 @@ void ExtractorCallbacks::ProcessWay(const osmium::Way &input_way, const Extracti
                            ((parsed_way.forward_speed != parsed_way.backward_speed) ||
                             (parsed_way.forward_travel_mode != parsed_way.backward_travel_mode));

-    // lambda to add edge to container
-    auto pair_wise_segment_split_forward =
-        [&](const osmium::NodeRef &first_node, const osmium::NodeRef &last_node)
-    {
-        const bool forward_only = split_edge || TRAVEL_MODE_INACCESSIBLE == parsed_way.backward_travel_mode;
-        external_memory.all_edges_list.push_back(InternalExtractorEdge(
-            first_node.ref(), last_node.ref(), name_id, forward_weight_data,
-            true, !forward_only, parsed_way.roundabout, parsed_way.ignore_in_grid,
-            parsed_way.is_access_restricted, parsed_way.forward_travel_mode, split_edge));
-        external_memory.used_node_id_list.push_back(first_node.ref());
-    };
+    std::transform(input_way.nodes().begin(), input_way.nodes().end(),
+                   std::back_inserter(external_memory.used_node_id_list),
+                   [](const osmium::NodeRef &ref)
+                   {
+                       return OSMNodeID(ref.ref());
+                   });

    const bool is_opposite_way = TRAVEL_MODE_INACCESSIBLE == parsed_way.forward_travel_mode;
+
    // traverse way in reverse in this case
    if (is_opposite_way)
    {
-        // why don't we have to swap the parsed_way.forward/backward speed here as well
-        const_cast<ExtractionWay &>(parsed_way).forward_travel_mode =
-            parsed_way.backward_travel_mode;
-        const_cast<ExtractionWay &>(parsed_way).backward_travel_mode = TRAVEL_MODE_INACCESSIBLE;
+        BOOST_ASSERT(split_edge == false);
+        BOOST_ASSERT(parsed_way.backward_travel_mode != TRAVEL_MODE_INACCESSIBLE);
        osrm::for_each_pair(input_way.nodes().crbegin(), input_way.nodes().crend(),
-                            pair_wise_segment_split_forward);
-        external_memory.used_node_id_list.push_back(input_way.nodes().front().ref());
+                            [&](const osmium::NodeRef &first_node, const osmium::NodeRef &last_node)
+                            {
+                                external_memory.all_edges_list.push_back(InternalExtractorEdge(
+                                    OSMNodeID(first_node.ref()), OSMNodeID(last_node.ref()), name_id,
+                                    backward_weight_data, true, false, parsed_way.roundabout,
+                                    parsed_way.is_access_restricted, parsed_way.is_startpoint,
+                                    parsed_way.backward_travel_mode, false));
+                            });
+
+        external_memory.way_start_end_id_list.push_back(
+            {OSMWayID(input_way.id()),
+             OSMNodeID(input_way.nodes().back().ref()),
+             OSMNodeID(input_way.nodes()[input_way.nodes().size() - 2].ref()),
+             OSMNodeID(input_way.nodes()[1].ref()),
+             OSMNodeID(input_way.nodes()[0].ref())});
    }
    else
    {
+        const bool forward_only =
+            split_edge || TRAVEL_MODE_INACCESSIBLE == parsed_way.backward_travel_mode;
        osrm::for_each_pair(input_way.nodes().cbegin(), input_way.nodes().cend(),
-                            pair_wise_segment_split_forward);
-        external_memory.used_node_id_list.push_back(input_way.nodes().back().ref());
-    }
-
-    // The following information is needed to identify start and end segments of restrictions
-    external_memory.way_start_end_id_list.push_back(
-        {(EdgeID)input_way.id(),
-         (NodeID)input_way.nodes()[0].ref(),
-         (NodeID)input_way.nodes()[1].ref(),
-         (NodeID)input_way.nodes()[input_way.nodes().size() - 2].ref(),
-         (NodeID)input_way.nodes().back().ref()});
-
-    if (split_edge)
-    { // Only true if the way should be split
-        BOOST_ASSERT(parsed_way.backward_travel_mode != TRAVEL_MODE_INACCESSIBLE);
-        auto pair_wise_segment_split_2 =
-            [&](const osmium::NodeRef &first_node, const osmium::NodeRef &last_node)
+                            [&](const osmium::NodeRef &first_node, const osmium::NodeRef &last_node)
+                            {
+                                external_memory.all_edges_list.push_back(InternalExtractorEdge(
+                                    OSMNodeID(first_node.ref()), OSMNodeID(last_node.ref()), name_id, forward_weight_data,
+                                    true, !forward_only, parsed_way.roundabout,
+                                    parsed_way.is_access_restricted, parsed_way.is_startpoint, parsed_way.forward_travel_mode,
+                                    split_edge));
+                            });
+        if (split_edge)
        {
-            external_memory.all_edges_list.push_back(InternalExtractorEdge(
-                last_node.ref(), first_node.ref(), name_id, backward_weight_data,
-                true, false, parsed_way.roundabout, parsed_way.ignore_in_grid,
-                parsed_way.is_access_restricted, parsed_way.backward_travel_mode, split_edge));
-            external_memory.used_node_id_list.push_back(last_node.ref());
-        };
-
-        if (is_opposite_way)
-        {
-            osrm::for_each_pair(input_way.nodes().crbegin(), input_way.nodes().crend(),
-                                pair_wise_segment_split_2);
-            external_memory.used_node_id_list.push_back(input_way.nodes().front().ref());
-        }
-        else
-        {
-            osrm::for_each_pair(input_way.nodes().cbegin(), input_way.nodes().cend(),
-                                pair_wise_segment_split_2);
-            external_memory.used_node_id_list.push_back(input_way.nodes().front().ref());
+            BOOST_ASSERT(parsed_way.backward_travel_mode != TRAVEL_MODE_INACCESSIBLE);
+            osrm::for_each_pair(
+                input_way.nodes().cbegin(), input_way.nodes().cend(),
+                [&](const osmium::NodeRef &first_node, const osmium::NodeRef &last_node)
+                {
+                    external_memory.all_edges_list.push_back(InternalExtractorEdge(
+                        OSMNodeID(first_node.ref()), OSMNodeID(last_node.ref()), name_id, backward_weight_data, false,
+                        true, parsed_way.roundabout, parsed_way.is_access_restricted,
+                        parsed_way.is_startpoint, parsed_way.backward_travel_mode, true));
+                });
        }

        external_memory.way_start_end_id_list.push_back(
-            {(EdgeID)input_way.id(),
-             (NodeID)input_way.nodes()[1].ref(),
-             (NodeID)input_way.nodes()[0].ref(),
-             (NodeID)input_way.nodes().back().ref(),
-             (NodeID)input_way.nodes()[input_way.nodes().size() - 2].ref()});
+            {OSMWayID(input_way.id()),
+             OSMNodeID(input_way.nodes().back().ref()),
+             OSMNodeID(input_way.nodes()[input_way.nodes().size() - 2].ref()),
+             OSMNodeID(input_way.nodes()[1].ref()),
+             OSMNodeID(input_way.nodes()[0].ref())});
    }
 }
@@ -28,12 +28,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef EXTRACTOR_CALLBACKS_HPP
 #define EXTRACTOR_CALLBACKS_HPP

-#include "extraction_way.hpp"
 #include "../typedefs.h"
-
-#include <osmium/osm.hpp>
-
-#include <variant/optional.hpp>
+#include <boost/optional/optional_fwd.hpp>

 #include <string>
 #include <unordered_map>
@@ -42,6 +38,12 @@ struct ExternalMemoryNode;
 class ExtractionContainers;
 struct InputRestrictionContainer;
 struct ExtractionNode;
+struct ExtractionWay;
+namespace osmium
+{
+class Node;
+class Way;
+}

 /**
 * This class is uses by the extractor with the results of the
@@ -66,7 +68,7 @@ class ExtractorCallbacks
    void ProcessNode(const osmium::Node &current_node, const ExtractionNode &result_node);

    // warning: caller needs to take care of synchronization!
-    void ProcessRestriction(const mapbox::util::optional<InputRestrictionContainer> &restriction);
+    void ProcessRestriction(const boost::optional<InputRestrictionContainer> &restriction);

    // warning: caller needs to take care of synchronization!
    void ProcessWay(const osmium::Way &current_way, const ExtractionWay &result_way);
@@ -27,7 +27,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 #include "extractor_options.hpp"

-#include "../util/git_sha.hpp"
+#include "util/version.hpp"
 #include "../util/ini_file.hpp"
 #include "../util/simple_logger.hpp"

@@ -42,6 +42,12 @@ ExtractorOptions::ParseArguments(int argc, char *argv[], ExtractorConfig &extrac
    // declare a group of options that will be allowed only on command line
    boost::program_options::options_description generic_options("Options");
    generic_options.add_options()("version,v", "Show version")("help,h", "Show this help message")(
+        /*
+         * TODO: re-enable this
+        "restrictions,r",
+        boost::program_options::value<boost::filesystem::path>(&extractor_config.restrictions_path),
+        "Restrictions file in .osrm.restrictions format")(
+        */
        "config,c", boost::program_options::value<boost::filesystem::path>(
                        &extractor_config.config_file_path)->default_value("extractor.ini"),
        "Path to a configuration file.");
@@ -55,7 +61,20 @@ ExtractorOptions::ParseArguments(int argc, char *argv[], ExtractorConfig &extrac
        "threads,t",
        boost::program_options::value<unsigned int>(&extractor_config.requested_num_threads)
            ->default_value(tbb::task_scheduler_init::default_num_threads()),
-        "Number of threads to use");
+        "Number of threads to use")(
+            "generate-edge-lookup",boost::program_options::value<bool>(
+                                                &extractor_config.generate_edge_lookup)->implicit_value(true)->default_value(false),
+                                 "Generate a lookup table for internal edge-expanded-edge IDs to OSM node pairs")(
+        "small-component-size",
+        boost::program_options::value<unsigned int>(&extractor_config.small_component_size)
+            ->default_value(1000),
+        "Number of nodes required before a strongly-connected-componennt is considered big (affects nearest neighbor snapping)");
+
+#ifdef DEBUG_GEOMETRY
+        config_options.add_options()("debug-turns",
+            boost::program_options::value<std::string>(&extractor_config.debug_turns_path),
+            "Write out GeoJSON with turn penalty data");
+#endif // DEBUG_GEOMETRY

    // hidden options, will be allowed both on command line and in config file, but will not be
    // shown to the user
@@ -64,6 +83,7 @@ ExtractorOptions::ParseArguments(int argc, char *argv[], ExtractorConfig &extrac
                                                &extractor_config.input_path),
                                 "Input file in .osm, .osm.bz2 or .osm.pbf format");

+
    // positional option
    boost::program_options::positional_options_description positional_options;
    positional_options.add("input", 1);
@@ -90,7 +110,7 @@ ExtractorOptions::ParseArguments(int argc, char *argv[], ExtractorConfig &extrac
                                      option_variables);
        if (option_variables.count("version"))
        {
-            SimpleLogger().Write() << g_GIT_DESCRIPTION;
+            SimpleLogger().Write() << OSRM_VERSION;
            return return_code::exit;
        }

@@ -137,6 +157,14 @@ void ExtractorOptions::GenerateOutputFilesNames(ExtractorConfig &extractor_confi
    extractor_config.restriction_file_name = input_path.string();
    extractor_config.names_file_name = input_path.string();
    extractor_config.timestamp_file_name = input_path.string();
+    extractor_config.geometry_output_path = input_path.string();
+    extractor_config.edge_output_path = input_path.string();
+    extractor_config.edge_graph_output_path = input_path.string();
+    extractor_config.node_output_path = input_path.string();
+    extractor_config.rtree_nodes_output_path = input_path.string();
+    extractor_config.rtree_leafs_output_path = input_path.string();
+    extractor_config.edge_segment_lookup_path = input_path.string();
+    extractor_config.edge_penalty_path = input_path.string();
    std::string::size_type pos = extractor_config.output_file_name.find(".osm.bz2");
    if (pos == std::string::npos)
    {
@@ -159,6 +187,14 @@ void ExtractorOptions::GenerateOutputFilesNames(ExtractorConfig &extractor_confi
            extractor_config.restriction_file_name.append(".osrm.restrictions");
            extractor_config.names_file_name.append(".osrm.names");
            extractor_config.timestamp_file_name.append(".osrm.timestamp");
+            extractor_config.geometry_output_path.append(".osrm.geometry");
+            extractor_config.node_output_path.append(".osrm.nodes");
+            extractor_config.edge_output_path.append(".osrm.edges");
+            extractor_config.edge_graph_output_path.append(".osrm.ebg");
+            extractor_config.rtree_nodes_output_path.append(".osrm.ramIndex");
+            extractor_config.rtree_leafs_output_path.append(".osrm.fileIndex");
+            extractor_config.edge_segment_lookup_path.append(".osrm.edge_segment_lookup");
+            extractor_config.edge_penalty_path.append(".osrm.edge_penalties");
        }
        else
        {
@@ -166,6 +202,14 @@ void ExtractorOptions::GenerateOutputFilesNames(ExtractorConfig &extractor_confi
            extractor_config.restriction_file_name.replace(pos, 5, ".osrm.restrictions");
            extractor_config.names_file_name.replace(pos, 5, ".osrm.names");
            extractor_config.timestamp_file_name.replace(pos, 5, ".osrm.timestamp");
+            extractor_config.geometry_output_path.replace(pos, 5, ".osrm.geometry");
+            extractor_config.node_output_path.replace(pos, 5, ".osrm.nodes");
+            extractor_config.edge_output_path.replace(pos, 5, ".osrm.edges");
+            extractor_config.edge_graph_output_path.replace(pos, 5, ".osrm.ebg");
+            extractor_config.rtree_nodes_output_path.replace(pos, 5, ".osrm.ramIndex");
+            extractor_config.rtree_leafs_output_path.replace(pos, 5, ".osrm.fileIndex");
+            extractor_config.edge_segment_lookup_path.replace(pos,5, ".osrm.edge_segment_lookup");
+            extractor_config.edge_penalty_path.replace(pos,5, ".osrm.edge_penalties");
        }
    }
    else
@@ -174,5 +218,13 @@ void ExtractorOptions::GenerateOutputFilesNames(ExtractorConfig &extractor_confi
        extractor_config.restriction_file_name.replace(pos, 8, ".osrm.restrictions");
        extractor_config.names_file_name.replace(pos, 8, ".osrm.names");
        extractor_config.timestamp_file_name.replace(pos, 8, ".osrm.timestamp");
+        extractor_config.geometry_output_path.replace(pos, 8, ".osrm.geometry");
+        extractor_config.node_output_path.replace(pos, 8, ".osrm.nodes");
+        extractor_config.edge_output_path.replace(pos, 8, ".osrm.edges");
+        extractor_config.edge_graph_output_path.replace(pos, 8, ".osrm.ebg");
+        extractor_config.rtree_nodes_output_path.replace(pos, 8, ".osrm.ramIndex");
+        extractor_config.rtree_leafs_output_path.replace(pos, 8, ".osrm.fileIndex");
+        extractor_config.edge_segment_lookup_path.replace(pos,8, ".osrm.edge_segment_lookup");
+        extractor_config.edge_penalty_path.replace(pos,8, ".osrm.edge_penalties");
    }
 }
@@ -50,8 +50,22 @@ struct ExtractorConfig
    std::string restriction_file_name;
    std::string names_file_name;
    std::string timestamp_file_name;
+    std::string geometry_output_path;
+    std::string edge_output_path;
+    std::string edge_graph_output_path;
+    std::string node_output_path;
+    std::string rtree_nodes_output_path;
+    std::string rtree_leafs_output_path;

    unsigned requested_num_threads;
+    unsigned small_component_size;
+
+    bool generate_edge_lookup;
+    std::string edge_penalty_path;
+    std::string edge_segment_lookup_path;
+#ifdef DEBUG_GEOMETRY
+    std::string debug_turns_path;
+#endif
 };

 struct ExtractorOptions
@@ -36,21 +36,22 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 struct FirstAndLastSegmentOfWay
 {
-    EdgeID way_id;
-    NodeID first_segment_source_id;
-    NodeID first_segment_target_id;
-    NodeID last_segment_source_id;
-    NodeID last_segment_target_id;
+    OSMWayID way_id;
+    OSMNodeID first_segment_source_id;
+    OSMNodeID first_segment_target_id;
+    OSMNodeID last_segment_source_id;
+    OSMNodeID last_segment_target_id;
+
    FirstAndLastSegmentOfWay()
-        : way_id(std::numeric_limits<EdgeID>::max()),
-          first_segment_source_id(std::numeric_limits<NodeID>::max()),
-          first_segment_target_id(std::numeric_limits<NodeID>::max()),
-          last_segment_source_id(std::numeric_limits<NodeID>::max()),
-          last_segment_target_id(std::numeric_limits<NodeID>::max())
+        : way_id(SPECIAL_OSM_WAYID),
+          first_segment_source_id(SPECIAL_OSM_NODEID),
+          first_segment_target_id(SPECIAL_OSM_NODEID),
+          last_segment_source_id(SPECIAL_OSM_NODEID),
+          last_segment_target_id(SPECIAL_OSM_NODEID)
    {
    }

-    FirstAndLastSegmentOfWay(EdgeID w, NodeID fs, NodeID ft, NodeID ls, NodeID lt)
+    FirstAndLastSegmentOfWay(OSMWayID w, OSMNodeID fs, OSMNodeID ft, OSMNodeID ls, OSMNodeID lt)
        : way_id(w), first_segment_source_id(fs), first_segment_target_id(ft),
          last_segment_source_id(ls), last_segment_target_id(lt)
    {
@@ -58,19 +59,19 @@ struct FirstAndLastSegmentOfWay

    static FirstAndLastSegmentOfWay min_value()
    {
-        return {std::numeric_limits<EdgeID>::min(),
-                std::numeric_limits<NodeID>::min(),
-                std::numeric_limits<NodeID>::min(),
-                std::numeric_limits<NodeID>::min(),
-                std::numeric_limits<NodeID>::min()};
+        return {MIN_OSM_WAYID,
+                MIN_OSM_NODEID,
+                MIN_OSM_NODEID,
+                MIN_OSM_NODEID,
+                MIN_OSM_NODEID};
    }
    static FirstAndLastSegmentOfWay max_value()
    {
-        return {std::numeric_limits<EdgeID>::max(),
-                std::numeric_limits<NodeID>::max(),
-                std::numeric_limits<NodeID>::max(),
-                std::numeric_limits<NodeID>::max(),
-                std::numeric_limits<NodeID>::max()};
+        return {MAX_OSM_WAYID,
+                MAX_OSM_NODEID,
+                MAX_OSM_NODEID,
+                MAX_OSM_NODEID,
+                MAX_OSM_NODEID};
    }
 };

@@ -35,6 +35,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <boost/assert.hpp>

 #include <osrm/coordinate.hpp>
+#include <utility>

 struct InternalExtractorEdge
 {
@@ -62,30 +63,39 @@ struct InternalExtractorEdge
    };

    explicit InternalExtractorEdge()
-        : result(0, 0, 0, 0, false, false, false, false, false,
+        : result(MIN_OSM_NODEID, MIN_OSM_NODEID, 0, 0, false, false, false, false, true,
                TRAVEL_MODE_INACCESSIBLE, false)
    {
    }

-    explicit InternalExtractorEdge(NodeID source,
-                           NodeID target,
-                           NodeID name_id,
-                           const WeightData& weight_data,
-                           bool forward,
-                           bool backward,
-                           bool roundabout,
-                           bool in_tiny_cc,
-                           bool access_restricted,
-                           TravelMode travel_mode,
-                           bool is_split)
-        : result(source, target, name_id, 0, forward, backward, roundabout,
-                 in_tiny_cc, access_restricted, travel_mode, is_split),
-          weight_data(weight_data)
+    explicit InternalExtractorEdge(OSMNodeID source,
+                                   OSMNodeID target,
+                                   NodeID name_id,
+                                   WeightData weight_data,
+                                   bool forward,
+                                   bool backward,
+                                   bool roundabout,
+                                   bool access_restricted,
+                                   bool startpoint,
+                                   TravelMode travel_mode,
+                                   bool is_split)
+        : result(OSMNodeID(source),
+                 OSMNodeID(target),
+                 name_id,
+                 0,
+                 forward,
+                 backward,
+                 roundabout,
+                 access_restricted,
+                 startpoint,
+                 travel_mode,
+                 is_split),
+          weight_data(std::move(weight_data))
    {
    }

    // data that will be written to disk
-    NodeBasedEdge result;
+    NodeBasedEdgeWithOSM result;
    // intermediate edge weight
    WeightData weight_data;
    // coordinate of the source node
@@ -93,19 +103,35 @@ struct InternalExtractorEdge


    // necessary static util functions for stxxl's sorting
-    static InternalExtractorEdge min_value()
+    static InternalExtractorEdge min_osm_value()
    {
-        return InternalExtractorEdge(0, 0, 0, WeightData(), false, false, false,
-                                     false, false, TRAVEL_MODE_INACCESSIBLE, false);
+        return InternalExtractorEdge(MIN_OSM_NODEID, MIN_OSM_NODEID, 0, WeightData(), false, false, false,
+                                     false, true, TRAVEL_MODE_INACCESSIBLE, false);
    }
-    static InternalExtractorEdge max_value()
+    static InternalExtractorEdge max_osm_value()
    {
-        return InternalExtractorEdge(SPECIAL_NODEID, SPECIAL_NODEID, 0, WeightData(), false, false,
-                                     false, false, false, TRAVEL_MODE_INACCESSIBLE, false);
+        return InternalExtractorEdge(MAX_OSM_NODEID, MAX_OSM_NODEID, 0, WeightData(), false,
+                                     false, false, false, true, TRAVEL_MODE_INACCESSIBLE, false);
    }
+
+    static InternalExtractorEdge min_internal_value()
+    {
+        auto v = min_osm_value();
+        v.result.source = 0;
+        v.result.target = 0;
+        return v;
+    }
+    static InternalExtractorEdge max_internal_value()
+    {
+        auto v = max_osm_value();
+        v.result.source = std::numeric_limits<NodeID>::max();
+        v.result.target = std::numeric_limits<NodeID>::max();
+        return v;
+    }
+
 };

-struct CmpEdgeByStartThenTargetID
+struct CmpEdgeByInternalStartThenInternalTargetID
 {
    using value_type = InternalExtractorEdge;
    bool operator()(const InternalExtractorEdge &lhs, const InternalExtractorEdge &rhs) const
@@ -115,32 +141,32 @@ struct CmpEdgeByStartThenTargetID
               (lhs.result.target <  rhs.result.target));
    }

-    value_type max_value() { return InternalExtractorEdge::max_value(); }
-    value_type min_value() { return InternalExtractorEdge::min_value(); }
+    value_type max_value() { return InternalExtractorEdge::max_internal_value(); }
+    value_type min_value() { return InternalExtractorEdge::min_internal_value(); }
 };

-struct CmpEdgeByStartID
+struct CmpEdgeByOSMStartID
 {
    using value_type = InternalExtractorEdge;
    bool operator()(const InternalExtractorEdge &lhs, const InternalExtractorEdge &rhs) const
    {
-        return lhs.result.source < rhs.result.source;
+        return lhs.result.osm_source_id < rhs.result.osm_source_id;
    }

-    value_type max_value() { return InternalExtractorEdge::max_value(); }
-    value_type min_value() { return InternalExtractorEdge::min_value(); }
+    value_type max_value() { return InternalExtractorEdge::max_osm_value(); }
+    value_type min_value() { return InternalExtractorEdge::min_osm_value(); }
 };

-struct CmpEdgeByTargetID
+struct CmpEdgeByOSMTargetID
 {
    using value_type = InternalExtractorEdge;
    bool operator()(const InternalExtractorEdge &lhs, const InternalExtractorEdge &rhs) const
    {
-        return lhs.result.target < rhs.result.target;
+        return lhs.result.osm_target_id < rhs.result.osm_target_id;
    }

-    value_type max_value() { return InternalExtractorEdge::max_value(); }
-    value_type min_value() { return InternalExtractorEdge::min_value(); }
+    value_type max_value() { return InternalExtractorEdge::max_osm_value(); }
+    value_type min_value() { return InternalExtractorEdge::min_osm_value(); }
 };

 #endif // INTERNAL_EXTRACTOR_EDGE_HPP
@@ -35,24 +35,27 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 #include <boost/algorithm/string.hpp>
 #include <boost/algorithm/string/regex.hpp>
+#include <boost/algorithm/string/predicate.hpp>
 #include <boost/ref.hpp>
 #include <boost/regex.hpp>
+#include <boost/optional/optional.hpp>
+
+#include <osmium/osm.hpp>
+#include <osmium/tags/regex_filter.hpp>

 #include <algorithm>
+#include <iterator>

 namespace
 {
 int lua_error_callback(lua_State *lua_state)
 {
    std::string error_msg = lua_tostring(lua_state, -1);
-    std::ostringstream error_stream;
-    error_stream << error_msg;
-    throw osrm::exception("ERROR occured in profile script:\n" + error_stream.str());
+    throw osrm::exception("ERROR occured in profile script:\n" + error_msg);
 }
 }

-RestrictionParser::RestrictionParser(lua_State *lua_state)
-    : use_turn_restrictions(true)
+RestrictionParser::RestrictionParser(lua_State *lua_state) : use_turn_restrictions(true)
 {
    ReadUseRestrictionsSetting(lua_state);

@@ -104,18 +107,18 @@ void RestrictionParser::ReadRestrictionExceptions(lua_State *lua_state)

 /**
 * Tries to parse an relation as turn restriction. This can fail for a number of
- * reasons, this the return type is a mapbox::util::optional<>.
+ * reasons, this the return type is a boost::optional<T>.
 *
 * Some restrictions can also be ignored: See the ```get_exceptions``` function
 * in the corresponding profile.
 */
-mapbox::util::optional<InputRestrictionContainer>
+boost::optional<InputRestrictionContainer>
 RestrictionParser::TryParse(const osmium::Relation &relation) const
 {
    // return if turn restrictions should be ignored
    if (!use_turn_restrictions)
    {
-        return mapbox::util::optional<InputRestrictionContainer>();
+        return {};
    }

    osmium::tags::KeyPrefixFilter filter(false);
@@ -129,28 +132,42 @@ RestrictionParser::TryParse(const osmium::Relation &relation) const
    // if it's a restriction, continue;
    if (std::distance(fi_begin, fi_end) == 0)
    {
-        return mapbox::util::optional<InputRestrictionContainer>();
+        return {};
    }

    // check if the restriction should be ignored
    const char *except = relation.get_value_by_key("except");
    if (except != nullptr && ShouldIgnoreRestriction(except))
    {
-        return mapbox::util::optional<InputRestrictionContainer>();
+        return {};
    }

    bool is_only_restriction = false;

-    for (auto iter = fi_begin; iter != fi_end; ++iter)
+    for (; fi_begin != fi_end; ++fi_begin)
    {
-        if (std::string("restriction") == iter->key() ||
-            std::string("restriction::hgv") == iter->key())
-        {
-            const std::string restriction_value(iter->value());
+        const std::string key(fi_begin->key());
+        const std::string value(fi_begin->value());

-            if (restriction_value.find("only_") == 0)
+        if (value.find("only_") == 0)
+        {
+            is_only_restriction = true;
+        }
+
+        // if the "restriction*" key is longer than 11 chars, it is a conditional exception (i.e.
+        // "restriction:<transportation_type>")
+        if (key.size() > 11)
+        {
+            const auto ex_suffix = [&](const std::string &exception)
            {
-                is_only_restriction = true;
+                return boost::algorithm::ends_with(key, exception);
+            };
+            bool is_actually_restricted =
+                std::any_of(begin(restriction_exceptions), end(restriction_exceptions), ex_suffix);
+
+            if (!is_actually_restricted)
+            {
+                return {};
            }
        }
    }
@@ -204,7 +221,7 @@ RestrictionParser::TryParse(const osmium::Relation &relation) const
            break;
        }
    }
-    return mapbox::util::optional<InputRestrictionContainer>(restriction_container);
+    return boost::make_optional(std::move(restriction_container));
 }

 bool RestrictionParser::ShouldIgnoreRestriction(const std::string &except_tag_string) const
@@ -30,16 +30,16 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 #include "../data_structures/restriction.hpp"

-#include <osmium/osm.hpp>
-#include <osmium/tags/regex_filter.hpp>
-
-#include <variant/optional.hpp>
+#include <boost/optional/optional.hpp>

 #include <string>
 #include <vector>

 struct lua_State;
-class ScriptingEnvironment;
+namespace osmium
+{
+class Relation;
+}

 /**
 * Parses the relations that represents turn restrictions.
@@ -63,8 +63,7 @@ class RestrictionParser
 {
  public:
    RestrictionParser(lua_State *lua_state);
-    mapbox::util::optional<InputRestrictionContainer>
-    TryParse(const osmium::Relation &relation) const;
+    boost::optional<InputRestrictionContainer> TryParse(const osmium::Relation &relation) const;

  private:
    void ReadUseRestrictionsSetting(lua_State *lua_state);
@@ -30,13 +30,16 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "extraction_helper_functions.hpp"
 #include "extraction_node.hpp"
 #include "extraction_way.hpp"
+#include "internal_extractor_edge.hpp"
 #include "../data_structures/external_memory_node.hpp"
+#include "../data_structures/raster_source.hpp"
 #include "../util/lua_util.hpp"
 #include "../util/osrm_exception.hpp"
 #include "../util/simple_logger.hpp"
 #include "../typedefs.h"

 #include <luabind/tag_function.hpp>
+#include <luabind/operator.hpp>

 #include <osmium/osm.hpp>

@@ -80,6 +83,13 @@ void ScriptingEnvironment::init_lua_state(lua_State *lua_state)
        luabind::def("print", LUA_print<std::string>),
        luabind::def("durationIsValid", durationIsValid),
        luabind::def("parseDuration", parseDuration),
+        luabind::class_<SourceContainer>("sources")
+            .def(luabind::constructor<>())
+            .def("load", &SourceContainer::loadRasterSource)
+            .def("query", &SourceContainer::getRasterDataFromSource)
+            .def("interpolate", &SourceContainer::getRasterInterpolateFromSource),
+        luabind::class_<const float>("constants")
+            .enum_("enums")[luabind::value("precision", COORDINATE_PRECISION)],

        luabind::class_<std::vector<std::string>>("vector")
            .def("Add", static_cast<void (std::vector<std::string>::*)(const std::string &)>(
@@ -107,7 +117,7 @@ void ScriptingEnvironment::init_lua_state(lua_State *lua_state)
            .def_readwrite("name", &ExtractionWay::name)
            .def_readwrite("roundabout", &ExtractionWay::roundabout)
            .def_readwrite("is_access_restricted", &ExtractionWay::is_access_restricted)
-            .def_readwrite("ignore_in_index", &ExtractionWay::ignore_in_grid)
+            .def_readwrite("is_startpoint", &ExtractionWay::is_startpoint)
            .def_readwrite("duration", &ExtractionWay::duration)
            .property("forward_mode", &ExtractionWay::get_forward_mode,
                      &ExtractionWay::set_forward_mode)
@@ -122,7 +132,21 @@ void ScriptingEnvironment::init_lua_state(lua_State *lua_state)
        luabind::class_<osmium::Way>("Way")
            .def("get_value_by_key", &osmium::Way::get_value_by_key)
            .def("get_value_by_key", &get_value_by_key<osmium::Way>)
-            .def("id", &osmium::Way::id)
+            .def("id", &osmium::Way::id),
+        luabind::class_<InternalExtractorEdge>("EdgeSource")
+            .property("source_coordinate", &InternalExtractorEdge::source_coordinate)
+            .property("weight_data", &InternalExtractorEdge::weight_data),
+        luabind::class_<InternalExtractorEdge::WeightData>("WeightData")
+            .def_readwrite("speed", &InternalExtractorEdge::WeightData::speed),
+        luabind::class_<ExternalMemoryNode>("EdgeTarget")
+            .property("lat", &ExternalMemoryNode::lat)
+            .property("lon", &ExternalMemoryNode::lon),
+        luabind::class_<FixedPointCoordinate>("Coordinate")
+            .property("lat", &FixedPointCoordinate::lat)
+            .property("lon", &FixedPointCoordinate::lon),
+        luabind::class_<RasterDatum>("RasterDatum")
+            .property("datum", &RasterDatum::datum)
+            .def("invalid_data", &RasterDatum::get_invalid)
    ];

    if (0 != luaL_dofile(lua_state, file_name.c_str()))
@@ -0,0 +1,16 @@
+#ifndef SPEED_PROFILE_PROPERTIES_HPP
+#define SPEED_PROFILE_PROPERTIES_HPP
+
+struct SpeedProfileProperties
+{
+  SpeedProfileProperties()
+    : traffic_signal_penalty(0), u_turn_penalty(0), has_turn_penalty_function(false)
+  {
+  }
+
+  int traffic_signal_penalty;
+  int u_turn_penalty;
+  bool has_turn_penalty_function;
+};
+
+#endif
@@ -19,6 +19,7 @@ Feature: Barriers
            | wall           |       |
            | fence          |       |
            | some_tag       |       |
+            | block          | x     |

    Scenario: Bike - Access tag trumphs barriers
        Then routability should be
@@ -42,6 +42,6 @@ Feature: Bicycle - Handle movable bridge
        When I route I should get
            | from | to | route       | modes | speed   |
            | a    | g  | abc,cde,efg | 1,5,1 | 5 km/h |
-            | b    | f  | abc,cde,efg | 1,5,1 | 3 km/h |
+            | b    | f  | abc,cde,efg | 1,5,1 | 4 km/h |
            | c    | e  | cde         | 5     | 2 km/h |
            | e    | c  | cde         | 5     | 2 km/h |
@@ -125,13 +125,15 @@ Feature: Car - Restricted access

    Scenario: Car - Access combinations
        Then routability should be
-            | highway     | accesss      | vehicle    | motor_vehicle | motorcar   | bothw |
-            | runway      | private      |            |               | permissive | x     |
-            | primary     | forestry     |            | yes           |            | x     |
-            | cycleway    |              |            | designated    |            | x     |
-            | residential |              | yes        | no            |            |       |
-            | motorway    | yes          | permissive |               | private    |       |
-            | trunk       | agricultural | designated | permissive    | no         |       |
+            | highway     | accesss      | vehicle    | motor_vehicle | motorcar    | bothw |
+            | runway      | private      |            |               | permissive  | x     |
+            | primary     | forestry     |            | yes           |             | x     |
+            | cycleway    |              |            | designated    |             | x     |
+            | residential |              | yes        | no            |             |       |
+            | motorway    | yes          | permissive |               | private     |       |
+            | trunk       | agricultural | designated | permissive    | no          |       |
+            | pedestrian  |              |            |               |             |       |
+            | pedestrian  |              |            |               | destination | x     |

    Scenario: Car - Ignore access tags for other modes
        Then routability should be
--- a/Show More
+++ b/Show More