POC of one-to-many bidirectional routing in map-matching

2024-07-30 17:44:48 +02:00 · 2024-07-30 17:29:12 +02:00 · 2024-07-30 17:11:52 +02:00 · 2024-07-30 15:35:36 +02:00 · 2024-07-30 15:23:52 +02:00 · 2024-07-30 13:19:06 +02:00
824 changed files with 52487 additions and 100748 deletions
@@ -17,6 +17,7 @@ Checks: >
    -bugprone-incorrect-enable-if,
    -bugprone-switch-missing-default-case,
    -bugprone-empty-catch,
+    -bugprone-unchecked-optional-access,
    -clang-analyzer-*,
    -clang-diagnostic-deprecated-declarations,
    -clang-diagnostic-constant-conversion,
@@ -177,39 +177,41 @@ jobs:
  #           CXXCOMPILER: g++-13
  #           ENABLE_COVERAGE: ON

-  #         - name: clang-15-debug-asan-ubsan
+  #         - name: clang-18-debug-asan-ubsan
  #           continue-on-error: false
  #           node: 20
-  #           runs-on: ubuntu-22.04
+  #           runs-on: ubuntu-24.04
  #           BUILD_TOOLS: ON
  #           BUILD_TYPE: Debug
-  #           CCOMPILER: clang-15
+  #           CCOMPILER: clang-18
  #           CUCUMBER_TIMEOUT: 20000
-  #           CXXCOMPILER: clang++-15
+  #           CXXCOMPILER: clang++-18
  #           ENABLE_SANITIZER: ON
  #           TARGET_ARCH: x86_64-asan-ubsan
  #           OSRM_CONNECTION_RETRIES: 10
  #           OSRM_CONNECTION_EXP_BACKOFF_COEF: 1.5

-  #         - name: clang-15-release
+  #         - name: clang-18-release
  #           continue-on-error: false
  #           node: 18
-  #           runs-on: ubuntu-22.04
+  #           runs-on: ubuntu-24.04
  #           BUILD_TOOLS: ON
  #           BUILD_TYPE: Release
-  #           CCOMPILER: clang-15
-  #           CXXCOMPILER: clang++-15
+  #           CCOMPILER: clang-18
+  #           CXXCOMPILER: clang++-18
  #           CUCUMBER_TIMEOUT: 60000
+  #           ENABLE_LTO: OFF

-  #         - name: clang-15-debug
+  #         - name: clang-18-debug
  #           continue-on-error: false
  #           node: 18
-  #           runs-on: ubuntu-22.04
+  #           runs-on: ubuntu-24.04
  #           BUILD_TOOLS: ON
  #           BUILD_TYPE: Debug
-  #           CCOMPILER: clang-15
-  #           CXXCOMPILER: clang++-15
+  #           CCOMPILER: clang-18
+  #           CXXCOMPILER: clang++-18
  #           CUCUMBER_TIMEOUT: 60000
+  #           ENABLE_LTO: OFF

  #         - name: clang-18-debug-clang-tidy
  #           continue-on-error: false
@@ -223,46 +225,50 @@ jobs:
  #           ENABLE_CLANG_TIDY: ON


-  #         - name: clang-14-release
+  #         - name: clang-17-release
  #           continue-on-error: false
  #           node: 18
-  #           runs-on: ubuntu-22.04
+  #           runs-on: ubuntu-24.04
  #           BUILD_TOOLS: ON
  #           BUILD_TYPE: Release
-  #           CCOMPILER: clang-14
-  #           CXXCOMPILER: clang++-14
+  #           CCOMPILER: clang-17
+  #           CXXCOMPILER: clang++-17
  #           CUCUMBER_TIMEOUT: 60000
+  #           ENABLE_LTO: OFF

-  #         - name: clang-13-release
+  #         - name: clang-16-release
  #           continue-on-error: false
  #           node: 18
-  #           runs-on: ubuntu-22.04
+  #           runs-on: ubuntu-24.04
  #           BUILD_TOOLS: ON
  #           BUILD_TYPE: Release
-  #           CCOMPILER: clang-13
-  #           CXXCOMPILER: clang++-13
+  #           CCOMPILER: clang-16
+  #           CXXCOMPILER: clang++-16
  #           CUCUMBER_TIMEOUT: 60000
+  #           ENABLE_LTO: OFF

  #         - name: conan-linux-debug-asan-ubsan
  #           continue-on-error: false
  #           node: 18
-  #           runs-on: ubuntu-22.04
+  #           runs-on: ubuntu-24.04
  #           BUILD_TOOLS: ON
  #           BUILD_TYPE: Release
-  #           CCOMPILER: clang-15
-  #           CXXCOMPILER: clang++-15
+  #           CCOMPILER: clang-18
+  #           CXXCOMPILER: clang++-18
  #           ENABLE_CONAN: ON
  #           ENABLE_SANITIZER: ON
+  #           ENABLE_LTO: OFF

  #         - name: conan-linux-release
  #           continue-on-error: false
  #           node: 18
-  #           runs-on: ubuntu-22.04
+  #           runs-on: ubuntu-24.04
  #           BUILD_TOOLS: ON
  #           BUILD_TYPE: Release
-  #           CCOMPILER: clang-15
-  #           CXXCOMPILER: clang++-15
+  #           CCOMPILER: clang-18
+  #           CXXCOMPILER: clang++-18
  #           ENABLE_CONAN: ON
+  #           ENABLE_LTO: OFF

  #         - name: gcc-14-release
  #           continue-on-error: false
@@ -298,10 +304,10 @@ jobs:
  #           build_node_package: true
  #           continue-on-error: false
  #           node: 20
-  #           runs-on: ubuntu-22.04
+  #           runs-on: ubuntu-24.04
  #           BUILD_TYPE: Release
-  #           CCOMPILER: clang-13
-  #           CXXCOMPILER: clang++-13
+  #           CCOMPILER: clang-16
+  #           CXXCOMPILER: clang++-16
  #           ENABLE_CONAN: ON
  #           NODE_PACKAGE_TESTS_ONLY: ON

@@ -309,10 +315,10 @@ jobs:
  #           build_node_package: true
  #           continue-on-error: false
  #           node: 20
-  #           runs-on: ubuntu-22.04
+  #           runs-on: ubuntu-24.04
  #           BUILD_TYPE: Debug
-  #           CCOMPILER: clang-13
-  #           CXXCOMPILER: clang++-13
+  #           CCOMPILER: clang-16
+  #           CXXCOMPILER: clang++-16
  #           ENABLE_CONAN: ON
  #           NODE_PACKAGE_TESTS_ONLY: ON

@@ -361,6 +367,7 @@ jobs:
  #     TARGET_ARCH: ${{ matrix.TARGET_ARCH }}
  #     OSRM_CONNECTION_RETRIES: ${{ matrix.OSRM_CONNECTION_RETRIES }}
  #     OSRM_CONNECTION_EXP_BACKOFF_COEF: ${{ matrix.OSRM_CONNECTION_EXP_BACKOFF_COEF }}
+  #     ENABLE_LTO: ${{ matrix.ENABLE_LTO }}
  #   steps:
  #   - uses: actions/checkout@v4
  #   - name: Build machine architecture
@@ -488,6 +495,13 @@ jobs:
  #       tar zxvf onetbb.tgz
  #       sudo cp -a oneapi-tbb-${TBB_VERSION}/lib/. /usr/local/lib/
  #       sudo cp -a oneapi-tbb-${TBB_VERSION}/include/. /usr/local/include/
+  #   - name: Add Clang 18 to list of Conan compilers # workaround for the issue that Conan 1.x doesn't know about Clang 18
+  #     if: ${{ matrix.ENABLE_CONAN == 'ON' && matrix.CCOMPILER == 'clang-18' }}
+  #     run: |
+  #       sudo wget https://github.com/mikefarah/yq/releases/download/v4.9.6/yq_linux_amd64 -O /usr/bin/yq && sudo chmod +x /usr/bin/yq
+
+  #       conan config init
+  #       yq eval '.compiler.clang.version += ["18"]' -i "$HOME/.conan/settings.yml"
  #   - name: Prepare build
  #     run: |
  #       mkdir ${OSRM_BUILD_DIR}
@@ -521,6 +535,7 @@ jobs:
  #                -DENABLE_SANITIZER=${ENABLE_SANITIZER:-OFF} \
  #                -DBUILD_TOOLS=${BUILD_TOOLS:-OFF} \
  #                -DENABLE_CCACHE=ON \
+  #                -DENABLE_LTO=${ENABLE_LTO:-ON} \
  #                -DCMAKE_INSTALL_PREFIX=${OSRM_INSTALL_DIR}
  #       make --jobs=${JOBS}

@@ -638,48 +653,28 @@ jobs:
  benchmarks:
    if: github.event_name == 'pull_request'
   # needs: [format-taginfo-docs]
-    runs-on: ubuntu-22.04
+    runs-on: self-hosted
    env:
-      CCOMPILER: clang-13
-      CXXCOMPILER: clang++-13
-      CC: clang-13
-      CXX: clang++-13
+      CCOMPILER: clang-16
+      CXXCOMPILER: clang++-16
+      CC: clang-16
+      CXX: clang++-16
      GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
      PR_NUMBER: ${{ github.event.pull_request.number }}
      GITHUB_REPOSITORY: ${{ github.repository }}
      RUN_BIG_BENCHMARK: ${{ contains(github.event.pull_request.labels.*.name, 'Performance') }}
    steps: 
-      - name: Enable data.osm.pbf cache
-        if: ${{ ! env.RUN_BIG_BENCHMARK }}        
-        uses: actions/cache@v4
-        with:
-          path: ~/data.osm.pbf
-          key: v1-data-osm-pbf
-          restore-keys: |
-            v1-data-osm-pbf
-      - name: Enable compiler cache
-        uses: actions/cache@v4
-        with:
-          path: ~/.ccache
-          key: v1-ccache-benchmarks-${{ github.sha }}
-          restore-keys: |
-            v1-ccache-benchmarks-
-      - name: Enable Conan cache
-        uses: actions/cache@v4
-        with:
-          path: ~/.conan
-          key: v1-conan-benchmarks-${{ github.sha }}
-          restore-keys: |
-            v1-conan-benchmarks-
      - name: Checkout PR Branch
        uses: actions/checkout@v4
        with:
          ref: ${{ github.head_ref }}
          path: pr
-      - name: Install dependencies
-        run: | 
-          python3 -m pip install "conan<2.0.0" "requests==2.31.0" "numpy==1.26.4" 
-          sudo apt-get update -y && sudo apt-get install ccache
+      - name: Activate virtualenv
+        run: |
+          python3 -m venv .venv
+          source .venv/bin/activate
+          echo PATH=$PATH >> $GITHUB_ENV
+          pip install "conan<2.0.0" "requests==2.31.0" "numpy==1.26.4" 
      - name: Prepare data
        run: |
          if [ "$RUN_BIG_BENCHMARK" = "true" ]; then
@@ -707,57 +702,85 @@ jobs:
          path: base
      - name: Build Base Branch
        run: |
+          cd base
+          npm ci --ignore-scripts
+          cd ..
          mkdir base/build
          cd base/build
-          cmake -DENABLE_CONAN=ON -DCMAKE_BUILD_TYPE=Release ..
+          cmake -DENABLE_CONAN=ON -DCMAKE_BUILD_TYPE=Release -DENABLE_NODE_BINDINGS=ON ..
          make -j$(nproc)
          make -j$(nproc) benchmarks
          cd ..
          make -C test/data 
-      # - name: Build PR Branch
-      #   run: |
-      #     mkdir -p pr/build
-      #     cd pr/build
-      #     cmake -DENABLE_CONAN=ON -DCMAKE_BUILD_TYPE=Release ..
-      #     make -j$(nproc) 
-      #     make -j$(nproc) benchmarks
-      #     cd ..
-      #     make -C test/data 
+      - name: Build PR Branch
+        run: |
+          cd pr
+          npm ci --ignore-scripts
+          cd ..
+          mkdir -p pr/build
+          cd pr/build
+          cmake -DENABLE_CONAN=ON -DCMAKE_BUILD_TYPE=Release -DENABLE_NODE_BINDINGS=ON ..
+          make -j$(nproc) 
+          make -j$(nproc) benchmarks
+          cd ..
+          make -C test/data 
      # we run benchmarks in tmpfs to avoid impact of disk IO
      - name: Create folder for tmpfs 
-        run: mkdir -p /opt/benchmarks
-      # - name: Run PR Benchmarks 
-      #   run: |
-      #     sudo mount -t tmpfs -o size=4g none /opt/benchmarks
-      #     cp -rf pr/build /opt/benchmarks/build
-      #     mkdir -p /opt/benchmarks/test
-      #     cp -rf pr/test/data /opt/benchmarks/test/data
-      #     cp -rf pr/profiles /opt/benchmarks/profiles
+        run: |
+          # if by any chance it was mounted before(e.g. due to previous job failed), unmount it
+          sudo umount ~/benchmarks | true
+          rm -rf ~/benchmarks 
+          mkdir -p ~/benchmarks

-      #     ./pr/scripts/ci/run_benchmarks.sh -f /opt/benchmarks -r $(pwd)/pr_results -s $(pwd)/pr -b /opt/benchmarks/build -o ~/data.osm.pbf -g ~/gps_traces.csv
-      #     sudo umount /opt/benchmarks
+          SHIELD=bench
+          sudo cset shield --reset | true
+      # see https://llvm.org/docs/Benchmarking.html
+      - name: Run PR Benchmarks 
+        run: |
+          SHIELD=bench
+          sudo cset shield -c 2-3 -k on
+          sudo mount -t tmpfs -o size=4g none ~/benchmarks
+          cp -rf pr/build ~/benchmarks/build
+          cp -rf pr/lib ~/benchmarks/lib
+          mkdir -p ~/benchmarks/test
+          cp -rf pr/test/data ~/benchmarks/test/data
+          cp -rf pr/profiles ~/benchmarks/profiles
+
+          sudo cset shield --exec -- ./pr/scripts/ci/run_benchmarks.sh -f ~/benchmarks -r $(pwd)/pr_results -s $(pwd)/pr -b ~/benchmarks/build -o ~/data.osm.pbf -g ~/gps_traces.csv
+          sudo umount ~/benchmarks
+
+          sleep 5
+          # sudo cset shield --move --cpu=0-1
+          sudo cset shield --reset
      - name: Run Base Benchmarks
        run: |
-          sudo mount -t tmpfs -o size=4g none /opt/benchmarks
-          cp -rf base/build /opt/benchmarks/build
-          mkdir -p /opt/benchmarks/test
-          cp -rf base/test/data /opt/benchmarks/test/data
-          cp -rf base/profiles /opt/benchmarks/profiles
+          SHIELD=bench
+          sudo cset shield -c 2-3 -k on
+          sudo mount -t tmpfs -o size=4g none ~/benchmarks
+          cp -rf base/build ~/benchmarks/build
+          cp -rf base/lib ~/benchmarks/lib
+          mkdir -p ~/benchmarks/test
+          cp -rf base/test/data ~/benchmarks/test/data
+          cp -rf base/profiles ~/benchmarks/profiles

          # TODO: remove it when base branch will have this file at needed location
-          if [ ! -f /opt/benchmarks/test/data/portugal_to_korea.json ]; then
-            cp base/src/benchmarks/portugal_to_korea.json /opt/benchmarks/test/data/portugal_to_korea.json
+          if [ ! -f ~/benchmarks/test/data/portugal_to_korea.json ]; then
+            cp base/src/benchmarks/portugal_to_korea.json ~/benchmarks/test/data/portugal_to_korea.json
          fi
          # we intentionally use scripts from PR branch to be able to update them and see results in the same PR
-          ./pr/scripts/ci/run_benchmarks.sh -f /opt/benchmarks -r $(pwd)/base_results -s $(pwd)/pr -b /opt/benchmarks/build -o ~/data.osm.pbf -g ~/gps_traces.csv
-          sudo umount /opt/benchmarks
-      # - name: Post Benchmark Results
-      #   run: |
-      #     python3 pr/scripts/ci/post_benchmark_results.py base_results pr_results
-      # - name: Show CCache statistics
-      #   run: |
-      #     ccache -p
-      #     ccache -s
+          sudo cset shield --exec -- ./pr/scripts/ci/run_benchmarks.sh -f ~/benchmarks -r $(pwd)/base_results -s $(pwd)/pr -b ~/benchmarks/build -o ~/data.osm.pbf -g ~/gps_traces.csv
+          sudo umount ~/benchmarks
+
+          sleep 5
+          # sudo cset shield --move --cpu=0-1
+          sudo cset shield --reset
+      - name: Post Benchmark Results
+        run: |
+          python3 pr/scripts/ci/post_benchmark_results.py base_results pr_results
+      - name: Show CCache statistics
+        run: |
+          ccache -p
+          ccache -s

  # ci-complete:
  #   runs-on: ubuntu-22.04
@@ -1,5 +1,9 @@
 name: 'Close stale issues'
 on:
+  # NOTE: uncomment if you want to test changes to this file in PRs CI
+  # pull_request:
+  #   branches:
+  #     - master
  schedule:
    - cron: '30 1 * * *' # every day at 1:30am
 permissions:
@@ -12,6 +16,7 @@ jobs:
    steps:
      - uses: actions/stale@v9
        with:
+          operations-per-run: 3000
          stale-issue-message: 'This issue seems to be stale. It will be closed in 30 days if no further activity occurs.'
          stale-pr-message: 'This PR seems to be stale. Is it still relevant?'
          days-before-issue-stale: 180 # 6 months
@@ -46,7 +46,6 @@ Thumbs.db
 /example/build/
 /test/data/monaco.osrm*
 /test/data/ch
-/test/data/corech
 /test/data/mld
 /cmake/postinst

@@ -1,6 +1,7 @@
 # Unreleased
  - Changes from 5.27.1
    - Features
+      - ADDED: Route pedestrians over highway=platform [#6993](https://github.com/Project-OSRM/osrm-backend/pull/6993)
      - REMOVED: Remove all core-CH left-overs [#6920](https://github.com/Project-OSRM/osrm-backend/pull/6920)
      - ADDED: Add support for a keepalive_timeout flag. [#6674](https://github.com/Project-OSRM/osrm-backend/pull/6674)
      - ADDED: Add support for a default_radius flag. [#6575](https://github.com/Project-OSRM/osrm-backend/pull/6575)
@@ -24,6 +25,14 @@
    - NodeJS:
      - CHANGED: Use node-api instead of NAN. [#6452](https://github.com/Project-OSRM/osrm-backend/pull/6452)
    - Misc:
+      - CHANGED: Use thread_local instead of boost::thread_specific_ptr. [#6991](https://github.com/Project-OSRM/osrm-backend/pull/6991)
+      - CHANGED: Bump flatbuffers to v24.3.25 version. [#6988](https://github.com/Project-OSRM/osrm-backend/pull/6988)
+      - CHANGED: Add .reserve(...) to assembleGeometry function. [#6983](https://github.com/Project-OSRM/osrm-backend/pull/6983)
+      - CHANGED: Get rid of boost::optional leftovers. [#6977](https://github.com/Project-OSRM/osrm-backend/pull/6977)
+      - CHANGED: Use Link Time Optimisation whenever possible. [#6967](https://github.com/Project-OSRM/osrm-backend/pull/6967)
+      - CHANGED: Use struct instead of tuple to define UnpackedPath. [#6974](https://github.com/Project-OSRM/osrm-backend/pull/6974)
+      - CHANGED: Micro performance optimisation in map matching. [#6976](https://github.com/Project-OSRM/osrm-backend/pull/6976)
+      - CHANGED: Re-use priority queue in StaticRTree. [#6952](https://github.com/Project-OSRM/osrm-backend/pull/6952)
      - CHANGED: Optimise encodePolyline function. [#6940](https://github.com/Project-OSRM/osrm-backend/pull/6940)
      - CHANGED: Avoid reallocations in base64 encoding. [#6951](https://github.com/Project-OSRM/osrm-backend/pull/6951)
      - CHANGED: Get rid of unused Boost dependencies. [#6960](https://github.com/Project-OSRM/osrm-backend/pull/6960)
@@ -31,11 +31,12 @@ option(ENABLE_ASSERTIONS "Use assertions in release mode" OFF)
 option(ENABLE_DEBUG_LOGGING "Use debug logging in release mode" OFF)
 option(ENABLE_COVERAGE "Build with coverage instrumentalisation" OFF)
 option(ENABLE_SANITIZER "Use memory sanitizer for Debug build" OFF)
-option(ENABLE_LTO "Use LTO if available" OFF)
+option(ENABLE_LTO "Use Link Time Optimisation" ON)
 option(ENABLE_FUZZING "Fuzz testing using LLVM's libFuzzer" OFF)
 option(ENABLE_NODE_BINDINGS "Build NodeJs bindings" OFF)
 option(ENABLE_CLANG_TIDY "Enables clang-tidy checks" OFF)

+
 if (ENABLE_CLANG_TIDY)
  find_program(CLANG_TIDY_COMMAND NAMES clang-tidy)
  if(NOT CLANG_TIDY_COMMAND)
@@ -57,6 +58,18 @@ if (POLICY CMP0074)
 endif()
 project(OSRM C CXX)

+
+if(ENABLE_LTO AND (CMAKE_BUILD_TYPE MATCHES Release OR CMAKE_BUILD_TYPE MATCHES MinRelSize OR CMAKE_BUILD_TYPE MATCHES RelWithDebInfo))
+  include(CheckIPOSupported)
+  check_ipo_supported(RESULT LTO_SUPPORTED OUTPUT error)
+  if(LTO_SUPPORTED)
+      message(STATUS "IPO / LTO enabled")
+      set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
+  else()
+      message(FATAL_ERROR "IPO / LTO not supported: <${error}>")
+  endif()
+endif()
+
 # add @loader_path/$ORIGIN to rpath to make binaries relocatable
 if (APPLE)
  set(CMAKE_BUILD_RPATH "@loader_path")
@@ -120,6 +133,7 @@ endif()

 include_directories(BEFORE ${CMAKE_CURRENT_BINARY_DIR}/include/)
 include_directories(BEFORE ${CMAKE_CURRENT_SOURCE_DIR}/include/)
+include_directories(SYSTEM ${CMAKE_CURRENT_SOURCE_DIR}/generated/include/)
 include_directories(SYSTEM ${CMAKE_CURRENT_SOURCE_DIR}/third_party/sol2/include)

 set(BOOST_COMPONENTS date_time iostreams program_options thread unit_test_framework)
@@ -208,17 +222,6 @@ if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
  set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Og -ggdb")
 endif()

-if(ENABLE_LTO AND (CMAKE_BUILD_TYPE MATCHES Release OR CMAKE_BUILD_TYPE MATCHES MinRelSize OR CMAKE_BUILD_TYPE MATCHES RelWithDebInfo))
-  include(CheckIPOSupported)
-  check_ipo_supported(RESULT LTO_SUPPORTED OUTPUT error)
-  if(LTO_SUPPORTED)
-      message(STATUS "IPO / LTO enabled")
-      set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
-  else()
-      message(WARNING "IPO / LTO not supported: <${error}>")
-  endif()
-endif()
-
 set(MAYBE_COVERAGE_LIBRARIES "")
 if (ENABLE_COVERAGE)
  if (NOT CMAKE_BUILD_TYPE MATCHES "Debug")
@@ -290,6 +293,7 @@ include_directories(SYSTEM ${MICROTAR_INCLUDE_DIR})

 add_library(MICROTAR OBJECT "${CMAKE_CURRENT_SOURCE_DIR}/third_party/microtar/src/microtar.c")
 set_property(TARGET MICROTAR PROPERTY POSITION_INDEPENDENT_CODE ON)
+
 target_no_warning(MICROTAR unused-variable)
 target_no_warning(MICROTAR format)

@@ -64,7 +64,6 @@ add_warning(init-self)
 add_warning(bool-compare)
 add_warning(logical-not-parentheses)
 add_warning(logical-op)
-add_warning(maybe-uninitialized)
 add_warning(misleading-indentation)
 # `no-` prefix is part of warning name(i.e. doesn't mean we are disabling it)
 add_warning(no-return-local-addr)
@@ -84,3 +83,6 @@ no_warning(comma-subscript)
 no_warning(ambiguous-reversed-operator)
 no_warning(restrict)
 no_warning(free-nonheap-object)
+if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
+  no_warning(stringop-overflow)
+endif()
@@ -31,7 +31,7 @@ RUN NPROC=${BUILD_CONCURRENCY:-$(nproc)} && \
    case ${DOCKER_TAG} in *"-debug"*) BUILD_TYPE="Debug";; esac && \
    case ${DOCKER_TAG} in *"-assertions"*) BUILD_TYPE="RelWithDebInfo" && ENABLE_ASSERTIONS="On" && BUILD_TOOLS="On";; esac && \
    echo "Building ${BUILD_TYPE} with ENABLE_ASSERTIONS=${ENABLE_ASSERTIONS} BUILD_TOOLS=${BUILD_TOOLS}" && \
-    cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DENABLE_ASSERTIONS=${ENABLE_ASSERTIONS} -DBUILD_TOOLS=${BUILD_TOOLS} -DENABLE_LTO=On && \
+    cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DENABLE_ASSERTIONS=${ENABLE_ASSERTIONS} -DBUILD_TOOLS=${BUILD_TOOLS} -DENABLE_LTO=OFF && \
    make -j${NPROC} install && \
    cd ../profiles && \
    cp -r * /opt && \
@@ -21,7 +21,7 @@ COPY . /src
 WORKDIR /src

 RUN NPROC=${BUILD_CONCURRENCY:-$(nproc)} && \
-    export CXXFLAGS="-Wno-array-bounds -Wno-uninitialized" && \
+    export CXXFLAGS="-Wno-array-bounds -Wno-uninitialized -Wno-stringop-overflow" && \
    echo "Building OSRM ${DOCKER_TAG}" && \
    git show --format="%H" | head -n1 > /opt/OSRM_GITSHA && \
    echo "Building OSRM gitsha $(cat /opt/OSRM_GITSHA)" && \
@@ -26,7 +26,15 @@ Feature: Foot - Access tags on ways
            | motorway | no     |      |       |
            | motorway | no     | yes  | x     |
            | motorway | no     | no   |       |
-
+            | platform |        |      | x     |
+            | platform |        | yes  | x     |
+            | platform |        | no   |       |
+            | platform | yes    |      | x     |
+            | platform | yes    | yes  | x     |
+            | platform | yes    | no   |       |
+            | platform | no     |      |       |
+            | platform | no     | yes  | x     |
+            | platform | no     | no   |       |

    Scenario: Foot - Overwriting implied acccess on ways
        Then routability should be
@@ -1061,7 +1061,7 @@ Feature: Collapse
        #    i
        #    """

-        And the node locations
+        Given the node locations
          | node |         lat |         lon |        #id |
          | a    | -33.9644254 | 151.1378673 |   33226063 |
          | b    | -33.9644373 | 151.1377172 | 1072787030 |
@@ -9,7 +9,7 @@ Feature: Basic Roundabout
            """

    Scenario: Roundabout exit counting for left sided driving
-        And a grid size of 10 meters
+        Given a grid size of 10 meters
        And the node map
            """
                a
@@ -33,7 +33,7 @@ Feature: Basic Roundabout
           | a,h       | ab,gh,gh | depart,roundabout turn right exit-3,arrive    |

    Scenario: Mixed Entry and Exit
-        And a grid size of 10 meters
+        Given a grid size of 10 meters
        And the node map
           """
             c   a
@@ -1,44 +0,0 @@
-@prepare @options @help
-Feature: osrm-contract command line options: help
-
-    Scenario: osrm-contract - Help should be shown when no options are passed
-        When I try to run "osrm-contract"
-        Then stderr should be empty
-        And stdout should contain /osrm-contract(.exe)? <input.osrm> \[options\]:/
-        And stdout should contain "Options:"
-        And stdout should contain "--version"
-        And stdout should contain "--help"
-        And stdout should contain "--verbosity"
-        And stdout should contain "Configuration:"
-        And stdout should contain "--threads"
-        And stdout should contain "--core"
-        And stdout should contain "--segment-speed-file"
-        And it should exit with an error
-
-    Scenario: osrm-contract - Help, short
-        When I run "osrm-contract -h"
-        Then stderr should be empty
-        And stdout should contain /osrm-contract(.exe)? <input.osrm> \[options\]:/
-        And stdout should contain "Options:"
-        And stdout should contain "--version"
-        And stdout should contain "--help"
-        And stdout should contain "--verbosity"
-        And stdout should contain "Configuration:"
-        And stdout should contain "--threads"
-        And stdout should contain "--core"
-        And stdout should contain "--segment-speed-file"
-        And it should exit successfully
-
-    Scenario: osrm-contract - Help, long
-        When I run "osrm-contract --help"
-        Then stderr should be empty
-        And stdout should contain /osrm-contract(.exe)? <input.osrm> \[options\]:/
-        And stdout should contain "Options:"
-        And stdout should contain "--version"
-        And stdout should contain "--help"
-        And stdout should contain "--verbosity"
-        And stdout should contain "Configuration:"
-        And stdout should contain "--threads"
-        And stdout should contain "--core"
-        And stdout should contain "--segment-speed-file"
-        And it should exit successfully
@@ -1,38 +0,0 @@
-@contract @options @help
-Feature: osrm-customize command line options: help
-
-    Scenario: osrm-customize - Help should be shown when no options are passed
-        When I try to run "osrm-customize"
-        Then stderr should be empty
-        And stdout should contain /osrm-customize(.exe)? <input.osrm> \[options\]:/
-        And stdout should contain "Options:"
-        And stdout should contain "--version"
-        And stdout should contain "--help"
-        And stdout should contain "--verbosity"
-        And stdout should contain "Configuration:"
-        And stdout should contain "--threads"
-        And it should exit with an error
-
-    Scenario: osrm-customize - Help, short
-        When I run "osrm-customize -h"
-        Then stderr should be empty
-        And stdout should contain /osrm-customize(.exe)? <input.osrm> \[options\]:/
-        And stdout should contain "Options:"
-        And stdout should contain "--version"
-        And stdout should contain "--help"
-        And stdout should contain "--verbosity"
-        And stdout should contain "Configuration:"
-        And stdout should contain "--threads"
-        And it should exit successfully
-
-    Scenario: osrm-customize - Help, long
-        When I run "osrm-customize --help"
-        Then stderr should be empty
-        And stdout should contain /osrm-customize(.exe)? <input.osrm> \[options\]:/
-        And stdout should contain "Options:"
-        And stdout should contain "--version"
-        And stdout should contain "--help"
-        And stdout should contain "--verbosity"
-        And stdout should contain "Configuration:"
-        And stdout should contain "--threads"
-        And it should exit successfully
@@ -33,10 +33,6 @@ Feature: osrm-datastore command line options
        When I try to run "osrm-datastore {processed_file} --dataset-name cucumber/only_metric_test --only-metric"
        Then it should exit successfully

-    Scenario: osrm-datastore - Displaying help should work
-        When I try to run "osrm-datastore {processed_file} --help"
-        Then it should exit successfully
-
    Scenario: osrm-datastore - Errors on invalid path
        When I try to run "osrm-datastore invalid_path.osrm"
        Then stderr should contain "[error] Config contains invalid file paths."
@@ -1,47 +0,0 @@
-@extract @options @help
-Feature: osrm-extract command line options: help
-
-    Background:
-        Given the profile "testbot"
-
-    Scenario: osrm-extract - Help should be shown when no options are passed
-        When I run "osrm-extract"
-        Then stderr should be empty
-        And stdout should contain /osrm-extract(.exe)? <input.osm/.osm.bz2/.osm.pbf> \[options\]:/
-        And stdout should contain "Options:"
-        And stdout should contain "--version"
-        And stdout should contain "--help"
-        And stdout should contain "--verbosity"
-        And stdout should contain "Configuration:"
-        And stdout should contain "--profile"
-        And stdout should contain "--threads"
-        And stdout should contain "--small-component-size"
-        And it should exit successfully
-
-    Scenario: osrm-extract - Help, short
-        When I run "osrm-extract -h"
-        Then stderr should be empty
-        And stdout should contain /osrm-extract(.exe)? <input.osm/.osm.bz2/.osm.pbf> \[options\]:/
-        And stdout should contain "Options:"
-        And stdout should contain "--version"
-        And stdout should contain "--help"
-        And stdout should contain "--verbosity"
-        And stdout should contain "Configuration:"
-        And stdout should contain "--profile"
-        And stdout should contain "--threads"
-        And stdout should contain "--small-component-size"
-        And it should exit successfully
-
-    Scenario: osrm-extract - Help, long
-        When I run "osrm-extract --help"
-        Then stderr should be empty
-        And stdout should contain /osrm-extract(.exe)? <input.osm/.osm.bz2/.osm.pbf> \[options\]:/
-        And stdout should contain "Options:"
-        And stdout should contain "--version"
-        And stdout should contain "--help"
-        And stdout should contain "--verbosity"
-        And stdout should contain "Configuration:"
-        And stdout should contain "--profile"
-        And stdout should contain "--threads"
-        And stdout should contain "--small-component-size"
-        And it should exit successfully
@@ -1,53 +0,0 @@
-@partition @options @help
-Feature: osrm-partition command line options: help
-
-    Scenario: osrm-partition - Help should be shown when no options are passed
-        When I try to run "osrm-partition"
-        Then stderr should be empty
-        And stdout should contain /osrm-partition(.exe)? <input.osrm> \[options\]:/
-        And stdout should contain "Options:"
-        And stdout should contain "--version"
-        And stdout should contain "--help"
-        And stdout should contain "--verbosity"
-        And stdout should contain "Configuration:"
-        And stdout should contain "--threads"
-        And stdout should contain "--balance"
-        And stdout should contain "--boundary"
-        And stdout should contain "--optimizing-cuts"
-        And stdout should contain "--small-component-size"
-        And stdout should contain "--max-cell-sizes"
-        And it should exit with an error
-
-    Scenario: osrm-partition - Help, short
-        When I run "osrm-partition -h"
-        Then stderr should be empty
-        And stdout should contain /osrm-partition(.exe)? <input.osrm> \[options\]:/
-        And stdout should contain "Options:"
-        And stdout should contain "--version"
-        And stdout should contain "--help"
-        And stdout should contain "--verbosity"
-        And stdout should contain "Configuration:"
-        And stdout should contain "--threads"
-        And stdout should contain "--balance"
-        And stdout should contain "--boundary"
-        And stdout should contain "--optimizing-cuts"
-        And stdout should contain "--small-component-size"
-        And stdout should contain "--max-cell-sizes"
-        And it should exit successfully
-
-    Scenario: osrm-partition - Help, long
-        When I run "osrm-partition --help"
-        Then stderr should be empty
-        And stdout should contain /osrm-partition(.exe)? <input.osrm> \[options\]:/
-        And stdout should contain "Options:"
-        And stdout should contain "--version"
-        And stdout should contain "--help"
-        And stdout should contain "--verbosity"
-        And stdout should contain "Configuration:"
-        And stdout should contain "--threads"
-        And stdout should contain "--balance"
-        And stdout should contain "--boundary"
-        And stdout should contain "--optimizing-cuts"
-        And stdout should contain "--small-component-size"
-        And stdout should contain "--max-cell-sizes"
-        And it should exit successfully
@@ -1,71 +0,0 @@
-@routed @options @help
-Feature: osrm-routed command line options: help
-
-    Background:
-        Given the profile "testbot"
-
-    Scenario: osrm-routed - Help should be shown when no options are passed
-        When I run "osrm-routed"
-        Then stderr should be empty
-        And stdout should contain /osrm-routed(.exe)? <base.osrm> \[<options>\]:/
-        And stdout should contain "Options:"
-        And stdout should contain "--version"
-        And stdout should contain "--help"
-        And stdout should contain "--verbosity"
-        And stdout should contain "--trial"
-        And stdout should contain "Configuration:"
-        And stdout should contain "--ip"
-        And stdout should contain "--port"
-        And stdout should contain "--threads"
-        And stdout should contain "--shared-memory"
-        And stdout should contain "--max-viaroute-size"
-        And stdout should contain "--max-trip-size"
-        And stdout should contain "--max-table-size"
-        And stdout should contain "--max-matching-size"
-        And stdout should contain "--default-radius"
-        And stdout should contain "--keepalive-timeout"
-        And it should exit successfully
-
-    Scenario: osrm-routed - Help, short
-        When I run "osrm-routed -h"
-        Then stderr should be empty
-        And stdout should contain /osrm-routed(.exe)? <base.osrm> \[<options>\]:/
-        And stdout should contain "Options:"
-        And stdout should contain "--version"
-        And stdout should contain "--help"
-        And stdout should contain "--verbosity"
-        And stdout should contain "--trial"
-        And stdout should contain "Configuration:"
-        And stdout should contain "--ip"
-        And stdout should contain "--port"
-        And stdout should contain "--threads"
-        And stdout should contain "--shared-memory"
-        And stdout should contain "--max-viaroute-size"
-        And stdout should contain "--max-trip-size"
-        And stdout should contain "--max-table-size"
-        And stdout should contain "--max-matching-size"
-        And stdout should contain "--default-radius"
-        And stdout should contain "--keepalive-timeout"
-        And it should exit successfully
-
-    Scenario: osrm-routed - Help, long
-        When I run "osrm-routed --help"
-        Then stderr should be empty
-        And stdout should contain /osrm-routed(.exe)? <base.osrm> \[<options>\]:/
-        And stdout should contain "Options:"
-        And stdout should contain "--version"
-        And stdout should contain "--help"
-        And stdout should contain "--verbosity"
-        And stdout should contain "--trial"
-        And stdout should contain "Configuration:"
-        And stdout should contain "--ip"
-        And stdout should contain "--port"
-        And stdout should contain "--threads"
-        And stdout should contain "--shared-memory"
-        And stdout should contain "--max-trip-size"
-        And stdout should contain "--max-table-size"
-        And stdout should contain "--max-table-size"
-        And stdout should contain "--max-matching-size"
-        And stdout should contain "--default-radius"
-        And stdout should contain "--keepalive-timeout"
-        And it should exit successfully
@@ -75,7 +75,7 @@ Feature: Avoid weird loops caused by rounding errors

    @412 @via
    Scenario: Avoid weird loops 3
-        And the node map
+        Given the node map
            """
            a
            b e
@@ -136,22 +136,6 @@ Feature: Basic Map Matching
            | trace | matchings |
            | abcbd | abbd      |

-    Scenario: Testbot - Map matching with core factor
-        Given the contract extra arguments "--core 0.8"
-        Given the node map
-            """
-            a b c d
-                e
-            """
-
-        And the ways
-            | nodes | oneway |
-            | abcd  | no     |
-
-        When I match I should get
-            | trace | timestamps | matchings |
-            | abcd  | 0 1 2 3    | abcd      |
-
    Scenario: Testbot - Map matching with small distortion
        Given the node map
            """
@@ -401,12 +401,12 @@ Feature: Snapping at intersections
        Given the extract extra arguments "--small-component-size=4"

        And the ways
-            | nodes | oneway |
-            | ab    | no     |
-            | bc    | no     |
-            | cd    | no     |
-            | fed   | no     |
-            | bg    | yes    | # small SCC
+            | nodes | oneway | # comment  |
+            | ab    | no     |            |
+            | bc    | no     |            |
+            | cd    | no     |            |
+            | fed   | no     |            |
+            | bg    | yes    | small SCC  |

        And the relations
            | type        | way:from | way:to | node:via | restriction   |
@@ -437,14 +437,14 @@ Feature: Snapping at intersections
        Given the extract extra arguments "--small-component-size=4"

        And the ways
-            | nodes | oneway |
-            | ab    | no     |
-            | bc    | no     |
-            | cd    | no     |
-            | fed   | no     |
-            | ghi   | no     |
-            | jkl   | no     |
-            | bm    | yes    | # small SCC
+            | nodes | oneway | # comment |
+            | ab    | no     |           |
+            | bc    | no     |           |
+            | cd    | no     |           |
+            | fed   | no     |           |
+            | ghi   | no     |           |
+            | jkl   | no     |           |
+            | bm    | yes    | small SCC |

        And the relations
            | type        | way:from | way:to | node:via | restriction   |
@@ -65,32 +65,6 @@ Feature: Via points
            | waypoints | route          | turns                                                      |
            | 1,2,3     | cd,ac,ab,bd,cd | depart,new name right,new name right,new name right,arrive |

-    Scenario: Simple via point with core factor
-        Given the contract extra arguments "--core 0.8"
-        Given the node map
-            """
-            a b c d
-              e f g
-                h i
-                  j
-            """
-
-        And the ways
-            | nodes |
-            | abcd  |
-            | efg   |
-            | hi    |
-            | be    |
-            | cfh   |
-            | dgij  |
-
-        When I route I should get
-            | waypoints | route               |
-            | a,b,c     | abcd,abcd,abcd,abcd |
-            | c,b,a     | abcd,abcd,abcd,abcd |
-            | a,d,j     | abcd,abcd,dgij,dgij |
-            | j,d,a     | dgij,dgij,abcd,abcd |
-
    Scenario: Via point at a dead end
        Given the node map
            """
@@ -0,0 +1,249 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+
+#ifndef FLATBUFFERS_GENERATED_FBRESULT_OSRM_ENGINE_API_FBRESULT_H_
+#define FLATBUFFERS_GENERATED_FBRESULT_OSRM_ENGINE_API_FBRESULT_H_
+
+#include "flatbuffers/flatbuffers.h"
+
+// Ensure the included flatbuffers.h is the same version as when this file was
+// generated, otherwise it may not be compatible.
+static_assert(FLATBUFFERS_VERSION_MAJOR == 24 &&
+              FLATBUFFERS_VERSION_MINOR == 3 &&
+              FLATBUFFERS_VERSION_REVISION == 25,
+             "Non-compatible flatbuffers version included");
+
+#include "route_generated.h"
+#include "table_generated.h"
+
+namespace osrm {
+namespace engine {
+namespace api {
+namespace fbresult {
+
+struct Error;
+struct ErrorBuilder;
+
+struct FBResult;
+struct FBResultBuilder;
+
+struct Error FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef ErrorBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_CODE = 4,
+    VT_MESSAGE = 6
+  };
+  const ::flatbuffers::String *code() const {
+    return GetPointer<const ::flatbuffers::String *>(VT_CODE);
+  }
+  const ::flatbuffers::String *message() const {
+    return GetPointer<const ::flatbuffers::String *>(VT_MESSAGE);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_CODE) &&
+           verifier.VerifyString(code()) &&
+           VerifyOffset(verifier, VT_MESSAGE) &&
+           verifier.VerifyString(message()) &&
+           verifier.EndTable();
+  }
+};
+
+struct ErrorBuilder {
+  typedef Error Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_code(::flatbuffers::Offset<::flatbuffers::String> code) {
+    fbb_.AddOffset(Error::VT_CODE, code);
+  }
+  void add_message(::flatbuffers::Offset<::flatbuffers::String> message) {
+    fbb_.AddOffset(Error::VT_MESSAGE, message);
+  }
+  explicit ErrorBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<Error> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<Error>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<Error> CreateError(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<::flatbuffers::String> code = 0,
+    ::flatbuffers::Offset<::flatbuffers::String> message = 0) {
+  ErrorBuilder builder_(_fbb);
+  builder_.add_message(message);
+  builder_.add_code(code);
+  return builder_.Finish();
+}
+
+inline ::flatbuffers::Offset<Error> CreateErrorDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    const char *code = nullptr,
+    const char *message = nullptr) {
+  auto code__ = code ? _fbb.CreateString(code) : 0;
+  auto message__ = message ? _fbb.CreateString(message) : 0;
+  return osrm::engine::api::fbresult::CreateError(
+      _fbb,
+      code__,
+      message__);
+}
+
+struct FBResult FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef FBResultBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_ERROR = 4,
+    VT_CODE = 6,
+    VT_DATA_VERSION = 8,
+    VT_WAYPOINTS = 10,
+    VT_ROUTES = 12,
+    VT_TABLE = 14
+  };
+  bool error() const {
+    return GetField<uint8_t>(VT_ERROR, 0) != 0;
+  }
+  const osrm::engine::api::fbresult::Error *code() const {
+    return GetPointer<const osrm::engine::api::fbresult::Error *>(VT_CODE);
+  }
+  const ::flatbuffers::String *data_version() const {
+    return GetPointer<const ::flatbuffers::String *>(VT_DATA_VERSION);
+  }
+  const ::flatbuffers::Vector<::flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *waypoints() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *>(VT_WAYPOINTS);
+  }
+  const ::flatbuffers::Vector<::flatbuffers::Offset<osrm::engine::api::fbresult::RouteObject>> *routes() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<osrm::engine::api::fbresult::RouteObject>> *>(VT_ROUTES);
+  }
+  const osrm::engine::api::fbresult::TableResult *table() const {
+    return GetPointer<const osrm::engine::api::fbresult::TableResult *>(VT_TABLE);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<uint8_t>(verifier, VT_ERROR, 1) &&
+           VerifyOffset(verifier, VT_CODE) &&
+           verifier.VerifyTable(code()) &&
+           VerifyOffset(verifier, VT_DATA_VERSION) &&
+           verifier.VerifyString(data_version()) &&
+           VerifyOffset(verifier, VT_WAYPOINTS) &&
+           verifier.VerifyVector(waypoints()) &&
+           verifier.VerifyVectorOfTables(waypoints()) &&
+           VerifyOffset(verifier, VT_ROUTES) &&
+           verifier.VerifyVector(routes()) &&
+           verifier.VerifyVectorOfTables(routes()) &&
+           VerifyOffset(verifier, VT_TABLE) &&
+           verifier.VerifyTable(table()) &&
+           verifier.EndTable();
+  }
+};
+
+struct FBResultBuilder {
+  typedef FBResult Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_error(bool error) {
+    fbb_.AddElement<uint8_t>(FBResult::VT_ERROR, static_cast<uint8_t>(error), 0);
+  }
+  void add_code(::flatbuffers::Offset<osrm::engine::api::fbresult::Error> code) {
+    fbb_.AddOffset(FBResult::VT_CODE, code);
+  }
+  void add_data_version(::flatbuffers::Offset<::flatbuffers::String> data_version) {
+    fbb_.AddOffset(FBResult::VT_DATA_VERSION, data_version);
+  }
+  void add_waypoints(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>> waypoints) {
+    fbb_.AddOffset(FBResult::VT_WAYPOINTS, waypoints);
+  }
+  void add_routes(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<osrm::engine::api::fbresult::RouteObject>>> routes) {
+    fbb_.AddOffset(FBResult::VT_ROUTES, routes);
+  }
+  void add_table(::flatbuffers::Offset<osrm::engine::api::fbresult::TableResult> table) {
+    fbb_.AddOffset(FBResult::VT_TABLE, table);
+  }
+  explicit FBResultBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<FBResult> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<FBResult>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<FBResult> CreateFBResult(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    bool error = false,
+    ::flatbuffers::Offset<osrm::engine::api::fbresult::Error> code = 0,
+    ::flatbuffers::Offset<::flatbuffers::String> data_version = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>> waypoints = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<osrm::engine::api::fbresult::RouteObject>>> routes = 0,
+    ::flatbuffers::Offset<osrm::engine::api::fbresult::TableResult> table = 0) {
+  FBResultBuilder builder_(_fbb);
+  builder_.add_table(table);
+  builder_.add_routes(routes);
+  builder_.add_waypoints(waypoints);
+  builder_.add_data_version(data_version);
+  builder_.add_code(code);
+  builder_.add_error(error);
+  return builder_.Finish();
+}
+
+inline ::flatbuffers::Offset<FBResult> CreateFBResultDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    bool error = false,
+    ::flatbuffers::Offset<osrm::engine::api::fbresult::Error> code = 0,
+    const char *data_version = nullptr,
+    const std::vector<::flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *waypoints = nullptr,
+    const std::vector<::flatbuffers::Offset<osrm::engine::api::fbresult::RouteObject>> *routes = nullptr,
+    ::flatbuffers::Offset<osrm::engine::api::fbresult::TableResult> table = 0) {
+  auto data_version__ = data_version ? _fbb.CreateString(data_version) : 0;
+  auto waypoints__ = waypoints ? _fbb.CreateVector<::flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>(*waypoints) : 0;
+  auto routes__ = routes ? _fbb.CreateVector<::flatbuffers::Offset<osrm::engine::api::fbresult::RouteObject>>(*routes) : 0;
+  return osrm::engine::api::fbresult::CreateFBResult(
+      _fbb,
+      error,
+      code,
+      data_version__,
+      waypoints__,
+      routes__,
+      table);
+}
+
+inline const osrm::engine::api::fbresult::FBResult *GetFBResult(const void *buf) {
+  return ::flatbuffers::GetRoot<osrm::engine::api::fbresult::FBResult>(buf);
+}
+
+inline const osrm::engine::api::fbresult::FBResult *GetSizePrefixedFBResult(const void *buf) {
+  return ::flatbuffers::GetSizePrefixedRoot<osrm::engine::api::fbresult::FBResult>(buf);
+}
+
+inline bool VerifyFBResultBuffer(
+    ::flatbuffers::Verifier &verifier) {
+  return verifier.VerifyBuffer<osrm::engine::api::fbresult::FBResult>(nullptr);
+}
+
+inline bool VerifySizePrefixedFBResultBuffer(
+    ::flatbuffers::Verifier &verifier) {
+  return verifier.VerifySizePrefixedBuffer<osrm::engine::api::fbresult::FBResult>(nullptr);
+}
+
+inline void FinishFBResultBuffer(
+    ::flatbuffers::FlatBufferBuilder &fbb,
+    ::flatbuffers::Offset<osrm::engine::api::fbresult::FBResult> root) {
+  fbb.Finish(root);
+}
+
+inline void FinishSizePrefixedFBResultBuffer(
+    ::flatbuffers::FlatBufferBuilder &fbb,
+    ::flatbuffers::Offset<osrm::engine::api::fbresult::FBResult> root) {
+  fbb.FinishSizePrefixed(root);
+}
+
+}  // namespace fbresult
+}  // namespace api
+}  // namespace engine
+}  // namespace osrm
+
+#endif  // FLATBUFFERS_GENERATED_FBRESULT_OSRM_ENGINE_API_FBRESULT_H_
@@ -0,0 +1,51 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+
+#ifndef FLATBUFFERS_GENERATED_POSITION_OSRM_ENGINE_API_FBRESULT_H_
+#define FLATBUFFERS_GENERATED_POSITION_OSRM_ENGINE_API_FBRESULT_H_
+
+#include "flatbuffers/flatbuffers.h"
+
+// Ensure the included flatbuffers.h is the same version as when this file was
+// generated, otherwise it may not be compatible.
+static_assert(FLATBUFFERS_VERSION_MAJOR == 24 &&
+              FLATBUFFERS_VERSION_MINOR == 3 &&
+              FLATBUFFERS_VERSION_REVISION == 25,
+             "Non-compatible flatbuffers version included");
+
+namespace osrm {
+namespace engine {
+namespace api {
+namespace fbresult {
+
+struct Position;
+
+FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Position FLATBUFFERS_FINAL_CLASS {
+ private:
+  float longitude_;
+  float latitude_;
+
+ public:
+  Position()
+      : longitude_(0),
+        latitude_(0) {
+  }
+  Position(float _longitude, float _latitude)
+      : longitude_(::flatbuffers::EndianScalar(_longitude)),
+        latitude_(::flatbuffers::EndianScalar(_latitude)) {
+  }
+  float longitude() const {
+    return ::flatbuffers::EndianScalar(longitude_);
+  }
+  float latitude() const {
+    return ::flatbuffers::EndianScalar(latitude_);
+  }
+};
+FLATBUFFERS_STRUCT_END(Position, 8);
+
+}  // namespace fbresult
+}  // namespace api
+}  // namespace engine
+}  // namespace osrm
+
+#endif  // FLATBUFFERS_GENERATED_POSITION_OSRM_ENGINE_API_FBRESULT_H_
@@ -0,0 +1,149 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+
+#ifndef FLATBUFFERS_GENERATED_TABLE_OSRM_ENGINE_API_FBRESULT_H_
+#define FLATBUFFERS_GENERATED_TABLE_OSRM_ENGINE_API_FBRESULT_H_
+
+#include "flatbuffers/flatbuffers.h"
+
+// Ensure the included flatbuffers.h is the same version as when this file was
+// generated, otherwise it may not be compatible.
+static_assert(FLATBUFFERS_VERSION_MAJOR == 24 &&
+              FLATBUFFERS_VERSION_MINOR == 3 &&
+              FLATBUFFERS_VERSION_REVISION == 25,
+             "Non-compatible flatbuffers version included");
+
+#include "waypoint_generated.h"
+
+namespace osrm {
+namespace engine {
+namespace api {
+namespace fbresult {
+
+struct TableResult;
+struct TableResultBuilder;
+
+struct TableResult FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef TableResultBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_DURATIONS = 4,
+    VT_ROWS = 6,
+    VT_COLS = 8,
+    VT_DISTANCES = 10,
+    VT_DESTINATIONS = 12,
+    VT_FALLBACK_SPEED_CELLS = 14
+  };
+  const ::flatbuffers::Vector<float> *durations() const {
+    return GetPointer<const ::flatbuffers::Vector<float> *>(VT_DURATIONS);
+  }
+  uint16_t rows() const {
+    return GetField<uint16_t>(VT_ROWS, 0);
+  }
+  uint16_t cols() const {
+    return GetField<uint16_t>(VT_COLS, 0);
+  }
+  const ::flatbuffers::Vector<float> *distances() const {
+    return GetPointer<const ::flatbuffers::Vector<float> *>(VT_DISTANCES);
+  }
+  const ::flatbuffers::Vector<::flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *destinations() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *>(VT_DESTINATIONS);
+  }
+  const ::flatbuffers::Vector<uint32_t> *fallback_speed_cells() const {
+    return GetPointer<const ::flatbuffers::Vector<uint32_t> *>(VT_FALLBACK_SPEED_CELLS);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_DURATIONS) &&
+           verifier.VerifyVector(durations()) &&
+           VerifyField<uint16_t>(verifier, VT_ROWS, 2) &&
+           VerifyField<uint16_t>(verifier, VT_COLS, 2) &&
+           VerifyOffset(verifier, VT_DISTANCES) &&
+           verifier.VerifyVector(distances()) &&
+           VerifyOffset(verifier, VT_DESTINATIONS) &&
+           verifier.VerifyVector(destinations()) &&
+           verifier.VerifyVectorOfTables(destinations()) &&
+           VerifyOffset(verifier, VT_FALLBACK_SPEED_CELLS) &&
+           verifier.VerifyVector(fallback_speed_cells()) &&
+           verifier.EndTable();
+  }
+};
+
+struct TableResultBuilder {
+  typedef TableResult Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_durations(::flatbuffers::Offset<::flatbuffers::Vector<float>> durations) {
+    fbb_.AddOffset(TableResult::VT_DURATIONS, durations);
+  }
+  void add_rows(uint16_t rows) {
+    fbb_.AddElement<uint16_t>(TableResult::VT_ROWS, rows, 0);
+  }
+  void add_cols(uint16_t cols) {
+    fbb_.AddElement<uint16_t>(TableResult::VT_COLS, cols, 0);
+  }
+  void add_distances(::flatbuffers::Offset<::flatbuffers::Vector<float>> distances) {
+    fbb_.AddOffset(TableResult::VT_DISTANCES, distances);
+  }
+  void add_destinations(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>> destinations) {
+    fbb_.AddOffset(TableResult::VT_DESTINATIONS, destinations);
+  }
+  void add_fallback_speed_cells(::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> fallback_speed_cells) {
+    fbb_.AddOffset(TableResult::VT_FALLBACK_SPEED_CELLS, fallback_speed_cells);
+  }
+  explicit TableResultBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<TableResult> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<TableResult>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<TableResult> CreateTableResult(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<::flatbuffers::Vector<float>> durations = 0,
+    uint16_t rows = 0,
+    uint16_t cols = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<float>> distances = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>> destinations = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> fallback_speed_cells = 0) {
+  TableResultBuilder builder_(_fbb);
+  builder_.add_fallback_speed_cells(fallback_speed_cells);
+  builder_.add_destinations(destinations);
+  builder_.add_distances(distances);
+  builder_.add_durations(durations);
+  builder_.add_cols(cols);
+  builder_.add_rows(rows);
+  return builder_.Finish();
+}
+
+inline ::flatbuffers::Offset<TableResult> CreateTableResultDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    const std::vector<float> *durations = nullptr,
+    uint16_t rows = 0,
+    uint16_t cols = 0,
+    const std::vector<float> *distances = nullptr,
+    const std::vector<::flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *destinations = nullptr,
+    const std::vector<uint32_t> *fallback_speed_cells = nullptr) {
+  auto durations__ = durations ? _fbb.CreateVector<float>(*durations) : 0;
+  auto distances__ = distances ? _fbb.CreateVector<float>(*distances) : 0;
+  auto destinations__ = destinations ? _fbb.CreateVector<::flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>(*destinations) : 0;
+  auto fallback_speed_cells__ = fallback_speed_cells ? _fbb.CreateVector<uint32_t>(*fallback_speed_cells) : 0;
+  return osrm::engine::api::fbresult::CreateTableResult(
+      _fbb,
+      durations__,
+      rows,
+      cols,
+      distances__,
+      destinations__,
+      fallback_speed_cells__);
+}
+
+}  // namespace fbresult
+}  // namespace api
+}  // namespace engine
+}  // namespace osrm
+
+#endif  // FLATBUFFERS_GENERATED_TABLE_OSRM_ENGINE_API_FBRESULT_H_
@@ -0,0 +1,205 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+
+#ifndef FLATBUFFERS_GENERATED_WAYPOINT_OSRM_ENGINE_API_FBRESULT_H_
+#define FLATBUFFERS_GENERATED_WAYPOINT_OSRM_ENGINE_API_FBRESULT_H_
+
+#include "flatbuffers/flatbuffers.h"
+
+// Ensure the included flatbuffers.h is the same version as when this file was
+// generated, otherwise it may not be compatible.
+static_assert(FLATBUFFERS_VERSION_MAJOR == 24 &&
+              FLATBUFFERS_VERSION_MINOR == 3 &&
+              FLATBUFFERS_VERSION_REVISION == 25,
+             "Non-compatible flatbuffers version included");
+
+#include "position_generated.h"
+
+namespace osrm {
+namespace engine {
+namespace api {
+namespace fbresult {
+
+struct Uint64Pair;
+
+struct Waypoint;
+struct WaypointBuilder;
+
+FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Uint64Pair FLATBUFFERS_FINAL_CLASS {
+ private:
+  uint64_t first_;
+  uint64_t second_;
+
+ public:
+  Uint64Pair()
+      : first_(0),
+        second_(0) {
+  }
+  Uint64Pair(uint64_t _first, uint64_t _second)
+      : first_(::flatbuffers::EndianScalar(_first)),
+        second_(::flatbuffers::EndianScalar(_second)) {
+  }
+  uint64_t first() const {
+    return ::flatbuffers::EndianScalar(first_);
+  }
+  uint64_t second() const {
+    return ::flatbuffers::EndianScalar(second_);
+  }
+};
+FLATBUFFERS_STRUCT_END(Uint64Pair, 16);
+
+struct Waypoint FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef WaypointBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_HINT = 4,
+    VT_DISTANCE = 6,
+    VT_NAME = 8,
+    VT_LOCATION = 10,
+    VT_NODES = 12,
+    VT_MATCHINGS_INDEX = 14,
+    VT_WAYPOINT_INDEX = 16,
+    VT_ALTERNATIVES_COUNT = 18,
+    VT_TRIPS_INDEX = 20
+  };
+  const ::flatbuffers::String *hint() const {
+    return GetPointer<const ::flatbuffers::String *>(VT_HINT);
+  }
+  float distance() const {
+    return GetField<float>(VT_DISTANCE, 0.0f);
+  }
+  const ::flatbuffers::String *name() const {
+    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
+  }
+  const osrm::engine::api::fbresult::Position *location() const {
+    return GetStruct<const osrm::engine::api::fbresult::Position *>(VT_LOCATION);
+  }
+  const osrm::engine::api::fbresult::Uint64Pair *nodes() const {
+    return GetStruct<const osrm::engine::api::fbresult::Uint64Pair *>(VT_NODES);
+  }
+  uint32_t matchings_index() const {
+    return GetField<uint32_t>(VT_MATCHINGS_INDEX, 0);
+  }
+  uint32_t waypoint_index() const {
+    return GetField<uint32_t>(VT_WAYPOINT_INDEX, 0);
+  }
+  uint32_t alternatives_count() const {
+    return GetField<uint32_t>(VT_ALTERNATIVES_COUNT, 0);
+  }
+  uint32_t trips_index() const {
+    return GetField<uint32_t>(VT_TRIPS_INDEX, 0);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_HINT) &&
+           verifier.VerifyString(hint()) &&
+           VerifyField<float>(verifier, VT_DISTANCE, 4) &&
+           VerifyOffset(verifier, VT_NAME) &&
+           verifier.VerifyString(name()) &&
+           VerifyField<osrm::engine::api::fbresult::Position>(verifier, VT_LOCATION, 4) &&
+           VerifyField<osrm::engine::api::fbresult::Uint64Pair>(verifier, VT_NODES, 8) &&
+           VerifyField<uint32_t>(verifier, VT_MATCHINGS_INDEX, 4) &&
+           VerifyField<uint32_t>(verifier, VT_WAYPOINT_INDEX, 4) &&
+           VerifyField<uint32_t>(verifier, VT_ALTERNATIVES_COUNT, 4) &&
+           VerifyField<uint32_t>(verifier, VT_TRIPS_INDEX, 4) &&
+           verifier.EndTable();
+  }
+};
+
+struct WaypointBuilder {
+  typedef Waypoint Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_hint(::flatbuffers::Offset<::flatbuffers::String> hint) {
+    fbb_.AddOffset(Waypoint::VT_HINT, hint);
+  }
+  void add_distance(float distance) {
+    fbb_.AddElement<float>(Waypoint::VT_DISTANCE, distance, 0.0f);
+  }
+  void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
+    fbb_.AddOffset(Waypoint::VT_NAME, name);
+  }
+  void add_location(const osrm::engine::api::fbresult::Position *location) {
+    fbb_.AddStruct(Waypoint::VT_LOCATION, location);
+  }
+  void add_nodes(const osrm::engine::api::fbresult::Uint64Pair *nodes) {
+    fbb_.AddStruct(Waypoint::VT_NODES, nodes);
+  }
+  void add_matchings_index(uint32_t matchings_index) {
+    fbb_.AddElement<uint32_t>(Waypoint::VT_MATCHINGS_INDEX, matchings_index, 0);
+  }
+  void add_waypoint_index(uint32_t waypoint_index) {
+    fbb_.AddElement<uint32_t>(Waypoint::VT_WAYPOINT_INDEX, waypoint_index, 0);
+  }
+  void add_alternatives_count(uint32_t alternatives_count) {
+    fbb_.AddElement<uint32_t>(Waypoint::VT_ALTERNATIVES_COUNT, alternatives_count, 0);
+  }
+  void add_trips_index(uint32_t trips_index) {
+    fbb_.AddElement<uint32_t>(Waypoint::VT_TRIPS_INDEX, trips_index, 0);
+  }
+  explicit WaypointBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<Waypoint> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<Waypoint>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<Waypoint> CreateWaypoint(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<::flatbuffers::String> hint = 0,
+    float distance = 0.0f,
+    ::flatbuffers::Offset<::flatbuffers::String> name = 0,
+    const osrm::engine::api::fbresult::Position *location = nullptr,
+    const osrm::engine::api::fbresult::Uint64Pair *nodes = nullptr,
+    uint32_t matchings_index = 0,
+    uint32_t waypoint_index = 0,
+    uint32_t alternatives_count = 0,
+    uint32_t trips_index = 0) {
+  WaypointBuilder builder_(_fbb);
+  builder_.add_trips_index(trips_index);
+  builder_.add_alternatives_count(alternatives_count);
+  builder_.add_waypoint_index(waypoint_index);
+  builder_.add_matchings_index(matchings_index);
+  builder_.add_nodes(nodes);
+  builder_.add_location(location);
+  builder_.add_name(name);
+  builder_.add_distance(distance);
+  builder_.add_hint(hint);
+  return builder_.Finish();
+}
+
+inline ::flatbuffers::Offset<Waypoint> CreateWaypointDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    const char *hint = nullptr,
+    float distance = 0.0f,
+    const char *name = nullptr,
+    const osrm::engine::api::fbresult::Position *location = nullptr,
+    const osrm::engine::api::fbresult::Uint64Pair *nodes = nullptr,
+    uint32_t matchings_index = 0,
+    uint32_t waypoint_index = 0,
+    uint32_t alternatives_count = 0,
+    uint32_t trips_index = 0) {
+  auto hint__ = hint ? _fbb.CreateString(hint) : 0;
+  auto name__ = name ? _fbb.CreateString(name) : 0;
+  return osrm::engine::api::fbresult::CreateWaypoint(
+      _fbb,
+      hint__,
+      distance,
+      name__,
+      location,
+      nodes,
+      matchings_index,
+      waypoint_index,
+      alternatives_count,
+      trips_index);
+}
+
+}  // namespace fbresult
+}  // namespace api
+}  // namespace engine
+}  // namespace osrm
+
+#endif  // FLATBUFFERS_GENERATED_WAYPOINT_OSRM_ENGINE_API_FBRESULT_H_
@@ -33,7 +33,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "engine/hint.hpp"
 #include "util/coordinate.hpp"

-#include <boost/optional.hpp>
+#include <optional>

 #include <algorithm>
 #include <vector>
@@ -74,12 +74,12 @@ struct BaseParameters
    };

    std::vector<util::Coordinate> coordinates;
-    std::vector<boost::optional<Hint>> hints;
-    std::vector<boost::optional<double>> radiuses;
-    std::vector<boost::optional<Bearing>> bearings;
-    std::vector<boost::optional<Approach>> approaches;
+    std::vector<std::optional<Hint>> hints;
+    std::vector<std::optional<double>> radiuses;
+    std::vector<std::optional<Bearing>> bearings;
+    std::vector<std::optional<Approach>> approaches;
    std::vector<std::string> exclude;
-    boost::optional<OutputFormatType> format = OutputFormatType::JSON;
+    std::optional<OutputFormatType> format = OutputFormatType::JSON;

    // Adds hints to response which can be included in subsequent requests, see `hints` above.
    bool generate_hints = true;
@@ -90,10 +90,10 @@ struct BaseParameters
    SnappingType snapping = SnappingType::Default;

    BaseParameters(std::vector<util::Coordinate> coordinates_ = {},
-                   std::vector<boost::optional<Hint>> hints_ = {},
-                   std::vector<boost::optional<double>> radiuses_ = {},
-                   std::vector<boost::optional<Bearing>> bearings_ = {},
-                   std::vector<boost::optional<Approach>> approaches_ = {},
+                   std::vector<std::optional<Hint>> hints_ = {},
+                   std::vector<std::optional<double>> radiuses_ = {},
+                   std::vector<std::optional<Bearing>> bearings_ = {},
+                   std::vector<std::optional<Approach>> approaches_ = {},
                   bool generate_hints_ = true,
                   std::vector<std::string> exclude = {},
                   const SnappingType snapping_ = SnappingType::Default)
@@ -112,7 +112,7 @@ struct BaseParameters
               (approaches.empty() || approaches.size() == coordinates.size()) &&
               std::all_of(bearings.begin(),
                           bearings.end(),
-                           [](const boost::optional<Bearing> &bearing_and_range)
+                           [](const std::optional<Bearing> &bearing_and_range)
                           {
                               if (bearing_and_range)
                               {
@@ -14,7 +14,7 @@ table FBResult {
    data_version: string;
    waypoints: [Waypoint]; //Used as 'sources' waypoints for a 'Table' service
    routes: [RouteObject];
-    table: Table;
+    table: TableResult;
 }

 root_type FBResult;
@@ -1,7 +1,7 @@
 include "waypoint.fbs";
 namespace osrm.engine.api.fbresult;

-table Table {
+table TableResult {
    durations: [float];
    rows: ushort;
    cols: ushort;
@@ -12,7 +12,7 @@
 #include "util/coordinate.hpp"
 #include "util/json_container.hpp"

-#include <boost/optional.hpp>
+#include <optional>

 #include <algorithm>
 #include <iterator>
@@ -90,7 +90,7 @@ util::json::Object makeRouteStep(guidance::RouteStep step, util::json::Value geo

 util::json::Object makeRoute(const guidance::Route &route,
                             util::json::Array legs,
-                             boost::optional<util::json::Value> geometry,
+                             std::optional<util::json::Value> geometry,
                             const char *weight_name);

 // Creates a Waypoint without Hint, see the Hint overload below
@@ -45,7 +45,7 @@ class NearestAPI final : public BaseAPI
                      flatbuffers::FlatBufferBuilder &fb_result) const
    {
        auto data_timestamp = facade.GetTimestamp();
-        boost::optional<flatbuffers::Offset<flatbuffers::String>> data_version_string = boost::none;
+        std::optional<flatbuffers::Offset<flatbuffers::String>> data_version_string = std::nullopt;
        if (!data_timestamp.empty())
        {
            data_version_string = fb_result.CreateString(data_timestamp);
@@ -184,10 +184,10 @@ class RouteAPI : public BaseAPI
        return builder.CreateVectorOfStructs(coordinates);
    }

-    boost::optional<util::json::Value>
-    MakeGeometry(boost::optional<std::vector<Coordinate>> &&annotations) const
+    std::optional<util::json::Value>
+    MakeGeometry(std::optional<std::vector<Coordinate>> &&annotations) const
    {
-        boost::optional<util::json::Value> json_geometry;
+        std::optional<util::json::Value> json_geometry;
        if (annotations)
        {
            auto begin = annotations->begin();
@@ -720,8 +720,7 @@ class RouteAPI : public BaseAPI
        std::vector<guidance::LegGeometry> &leg_geometries = legs_info.second;

        auto route = guidance::assembleRoute(legs);
-        boost::optional<util::json::Value> json_overview =
-            MakeGeometry(MakeOverview(leg_geometries));
+        std::optional<util::json::Value> json_overview = MakeGeometry(MakeOverview(leg_geometries));

        std::vector<util::json::Value> step_geometries;
        const auto total_step_count =
@@ -997,10 +996,10 @@ class RouteAPI : public BaseAPI
        return result;
    }

-    boost::optional<std::vector<Coordinate>>
+    std::optional<std::vector<Coordinate>>
    MakeOverview(const std::vector<guidance::LegGeometry> &leg_geometries) const
    {
-        boost::optional<std::vector<Coordinate>> overview;
+        std::optional<std::vector<Coordinate>> overview;
        if (parameters.overview != RouteParameters::OverviewType::False)
        {
            const auto use_simplification =
@@ -82,7 +82,7 @@ struct RouteParameters : public BaseParameters
                    const bool alternatives_,
                    const GeometriesType geometries_,
                    const OverviewType overview_,
-                    const boost::optional<bool> continue_straight_,
+                    const std::optional<bool> continue_straight_,
                    Args &&...args_)
        // Once we perfectly-forward `args` (see #2990) this constructor can delegate to the one
        // below.
@@ -100,7 +100,7 @@ struct RouteParameters : public BaseParameters
                    const bool annotations_,
                    const GeometriesType geometries_,
                    const OverviewType overview_,
-                    const boost::optional<bool> continue_straight_,
+                    const std::optional<bool> continue_straight_,
                    Args &&...args_)
        : BaseParameters{std::forward<Args>(args_)...}, steps{steps_}, alternatives{alternatives_},
          number_of_alternatives{alternatives_ ? 1u : 0u}, annotations{annotations_},
@@ -118,7 +118,7 @@ struct RouteParameters : public BaseParameters
                    const AnnotationsType annotations_,
                    const GeometriesType geometries_,
                    const OverviewType overview_,
-                    const boost::optional<bool> continue_straight_,
+                    const std::optional<bool> continue_straight_,
                    Args &&...args_)
        : BaseParameters{std::forward<Args>(args_)...}, steps{steps_}, alternatives{alternatives_},
          number_of_alternatives{alternatives_ ? 1u : 0u},
@@ -135,7 +135,7 @@ struct RouteParameters : public BaseParameters
                    const bool annotations_,
                    const GeometriesType geometries_,
                    const OverviewType overview_,
-                    const boost::optional<bool> continue_straight_,
+                    const std::optional<bool> continue_straight_,
                    std::vector<std::size_t> waypoints_,
                    const Args &&...args_)
        : BaseParameters{std::forward<Args>(args_)...}, steps{steps_}, alternatives{alternatives_},
@@ -153,7 +153,7 @@ struct RouteParameters : public BaseParameters
                    const AnnotationsType annotations_,
                    const GeometriesType geometries_,
                    const OverviewType overview_,
-                    const boost::optional<bool> continue_straight_,
+                    const std::optional<bool> continue_straight_,
                    std::vector<std::size_t> waypoints_,
                    Args &&...args_)
        : BaseParameters{std::forward<Args>(args_)...}, steps{steps_}, alternatives{alternatives_},
@@ -172,7 +172,7 @@ struct RouteParameters : public BaseParameters
    AnnotationsType annotations_type = AnnotationsType::None;
    GeometriesType geometries = GeometriesType::Polyline;
    OverviewType overview = OverviewType::Simplified;
-    boost::optional<bool> continue_straight;
+    std::optional<bool> continue_straight;
    std::vector<std::size_t> waypoints;

    bool IsValid() const
@@ -137,7 +137,7 @@ class TableAPI final : public BaseAPI
            speed_cells = MakeEstimatesTable(fb_result, fallback_speed_cells);
        }

-        fbresult::TableBuilder table(fb_result);
+        fbresult::TableResultBuilder table(fb_result);
        table.add_destinations(destinations);
        table.add_rows(number_of_sources);
        table.add_cols(number_of_destinations);
@@ -30,7 +30,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 #include "engine/api/route_parameters.hpp"

-#include <boost/optional.hpp>
+#include <optional>
 #include <vector>

 namespace osrm::engine::api
@@ -369,7 +369,7 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
    std::vector<PhantomNodeWithDistance>
    NearestPhantomNodesInRange(const util::Coordinate input_coordinate,
                               const double max_distance,
-                               const boost::optional<Bearing> bearing,
+                               const std::optional<Bearing> bearing,
                               const Approach approach,
                               const bool use_all_edges) const override final
    {
@@ -382,20 +382,20 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
    std::vector<PhantomNodeWithDistance>
    NearestPhantomNodes(const util::Coordinate input_coordinate,
                        const size_t max_results,
-                        const boost::optional<double> max_distance,
-                        const boost::optional<Bearing> bearing,
+                        const std::optional<double> max_distance,
+                        const std::optional<Bearing> bearing,
                        const Approach approach) const override final
    {
        BOOST_ASSERT(m_geospatial_query.get());

        return m_geospatial_query->NearestPhantomNodes(
-            input_coordinate, approach, max_results, max_distance, bearing, boost::none);
+            input_coordinate, approach, max_results, max_distance, bearing, std::nullopt);
    }

    PhantomCandidateAlternatives
    NearestCandidatesWithAlternativeFromBigComponent(const util::Coordinate input_coordinate,
-                                                     const boost::optional<double> max_distance,
-                                                     const boost::optional<Bearing> bearing,
+                                                     const std::optional<double> max_distance,
+                                                     const std::optional<Bearing> bearing,
                                                     const Approach approach,
                                                     const bool use_all_edges) const override final
    {
@@ -35,6 +35,7 @@
 #include <cstddef>

 #include <engine/bearing.hpp>
+#include <optional>
 #include <string>
 #include <string_view>
 #include <utility>
@@ -126,21 +127,21 @@ class BaseDataFacade
    virtual std::vector<PhantomNodeWithDistance>
    NearestPhantomNodesInRange(const util::Coordinate input_coordinate,
                               const double max_distance,
-                               const boost::optional<Bearing> bearing,
+                               const std::optional<Bearing> bearing,
                               const Approach approach,
                               const bool use_all_edges) const = 0;

    virtual std::vector<PhantomNodeWithDistance>
    NearestPhantomNodes(const util::Coordinate input_coordinate,
                        const size_t max_results,
-                        const boost::optional<double> max_distance,
-                        const boost::optional<Bearing> bearing,
+                        const std::optional<double> max_distance,
+                        const std::optional<Bearing> bearing,
                        const Approach approach) const = 0;

    virtual PhantomCandidateAlternatives
    NearestCandidatesWithAlternativeFromBigComponent(const util::Coordinate input_coordinate,
-                                                     const boost::optional<double> max_distance,
-                                                     const boost::optional<Bearing> bearing,
+                                                     const std::optional<double> max_distance,
+                                                     const std::optional<Bearing> bearing,
                                                     const Approach approach,
                                                     const bool use_all_edges) const = 0;

@@ -79,7 +79,7 @@ struct EngineConfig final
    int max_locations_map_matching = -1;
    double max_radius_map_matching = -1.0;
    int max_results_nearest = -1;
-    boost::optional<double> default_radius = -1.0;
+    double default_radius = -1.0;
    int max_alternatives = 3; // set an arbitrary upper bound; can be adjusted by user
    bool use_shared_memory = true;
    std::filesystem::path memory_file;
@@ -12,7 +12,7 @@

 #include "osrm/coordinate.hpp"

-#include <boost/optional.hpp>
+#include <optional>

 #include <algorithm>
 #include <cmath>
@@ -53,8 +53,8 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
    NearestPhantomNodes(const util::Coordinate input_coordinate,
                        const Approach approach,
                        const double max_distance,
-                        const boost::optional<Bearing> bearing_with_range,
-                        const boost::optional<bool> use_all_edges) const
+                        const std::optional<Bearing> bearing_with_range,
+                        const std::optional<bool> use_all_edges) const
    {
        auto results = rtree.SearchInRange(
            input_coordinate,
@@ -85,9 +85,9 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
    NearestPhantomNodes(const util::Coordinate input_coordinate,
                        const Approach approach,
                        const size_t max_results,
-                        const boost::optional<double> max_distance,
-                        const boost::optional<Bearing> bearing_with_range,
-                        const boost::optional<bool> use_all_edges) const
+                        const std::optional<double> max_distance,
+                        const std::optional<Bearing> bearing_with_range,
+                        const std::optional<bool> use_all_edges) const
    {
        auto results = rtree.Nearest(
            input_coordinate,
@@ -121,9 +121,9 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
    PhantomCandidateAlternatives NearestCandidatesWithAlternativeFromBigComponent(
        const util::Coordinate input_coordinate,
        const Approach approach,
-        const boost::optional<double> max_distance,
-        const boost::optional<Bearing> bearing_with_range,
-        const boost::optional<bool> use_all_edges) const
+        const std::optional<double> max_distance,
+        const std::optional<Bearing> bearing_with_range,
+        const std::optional<bool> use_all_edges) const
    {
        bool has_nearest = false;
        bool has_big_component = false;
@@ -37,6 +37,14 @@ inline LegGeometry assembleGeometry(const datafacade::BaseDataFacade &facade,
 {
    LegGeometry geometry;

+    // each container will at most have `leg_data.size()` + 1/2 elements in it
+    // these additional 1/2 elements come from processing of very first and very last segment
+    geometry.locations.reserve(leg_data.size() + 2);
+    geometry.segment_distances.reserve(leg_data.size() + 1);
+    geometry.segment_offsets.reserve(leg_data.size() + 1);
+    geometry.annotations.reserve(leg_data.size() + 1);
+    geometry.node_ids.reserve(leg_data.size() + 2);
+
    // segment 0 first and last
    geometry.segment_offsets.push_back(0);
    geometry.locations.push_back(source_node.location);
@@ -17,9 +17,9 @@
 #include "util/guidance/turn_lanes.hpp"
 #include "util/typedefs.hpp"

-#include <boost/optional.hpp>
 #include <cstddef>
 #include <guidance/turn_bearing.hpp>
+#include <optional>
 #include <vector>

 namespace osrm::engine::guidance
@@ -3,7 +3,7 @@

 #include "engine/guidance/route_step.hpp"

-#include <boost/optional.hpp>
+#include <optional>

 #include <string>
 #include <vector>
@@ -15,7 +15,7 @@
 #include "util/integer_range.hpp"
 #include "util/typedefs.hpp"

-#include <boost/optional.hpp>
+#include <optional>
 #include <vector>

 namespace osrm::engine
@@ -42,7 +42,7 @@ struct PathData
    // Source of the speed value on this road segment
    DatasourceID datasource_id;
    // If segment precedes a turn, ID of the turn itself
-    boost::optional<EdgeID> turn_edge;
+    std::optional<EdgeID> turn_edge;
 };

 struct InternalRouteResult
@@ -22,7 +22,7 @@ class MatchPlugin : public BasePlugin

    MatchPlugin(const int max_locations_map_matching,
                const double max_radius_map_matching,
-                const boost::optional<double> default_radius)
+                const std::optional<double> default_radius)
        : BasePlugin(default_radius), max_locations_map_matching(max_locations_map_matching),
          max_radius_map_matching(max_radius_map_matching)
    {
@@ -13,7 +13,7 @@ namespace osrm::engine::plugins
 class NearestPlugin final : public BasePlugin
 {
  public:
-    explicit NearestPlugin(const int max_results, const boost::optional<double> default_radius);
+    explicit NearestPlugin(const int max_results, const std::optional<double> default_radius);

    Status HandleRequest(const RoutingAlgorithmsInterface &algorithms,
                         const api::NearestParameters &params,
@@ -29,7 +29,7 @@ class BasePlugin
  protected:
    BasePlugin() = default;

-    BasePlugin(const boost::optional<double> default_radius_) : default_radius(default_radius_) {}
+    BasePlugin(const std::optional<double> default_radius_) : default_radius(default_radius_) {}

    bool CheckAllCoordinates(const std::vector<util::Coordinate> &coordinates) const
    {
@@ -200,8 +200,8 @@ class BasePlugin
            phantom_nodes[i] = facade.NearestPhantomNodesInRange(
                parameters.coordinates[i],
                radiuses[i],
-                use_bearings ? parameters.bearings[i] : boost::none,
-                use_approaches && parameters.approaches[i] ? parameters.approaches[i].get()
+                use_bearings ? parameters.bearings[i] : std::nullopt,
+                use_approaches && parameters.approaches[i] ? parameters.approaches[i].value()
                                                           : engine::Approach::UNRESTRICTED,
                use_all_edges);
        }
@@ -242,8 +242,8 @@ class BasePlugin
                parameters.coordinates[i],
                number_of_results,
                use_radiuses ? parameters.radiuses[i] : default_radius,
-                use_bearings ? parameters.bearings[i] : boost::none,
-                use_approaches && parameters.approaches[i] ? parameters.approaches[i].get()
+                use_bearings ? parameters.bearings[i] : std::nullopt,
+                use_approaches && parameters.approaches[i] ? parameters.approaches[i].value()
                                                           : engine::Approach::UNRESTRICTED);

            // we didn't find a fitting node, return error
@@ -284,8 +284,8 @@ class BasePlugin
            alternatives[i] = facade.NearestCandidatesWithAlternativeFromBigComponent(
                parameters.coordinates[i],
                use_radiuses ? parameters.radiuses[i] : default_radius,
-                use_bearings ? parameters.bearings[i] : boost::none,
-                use_approaches && parameters.approaches[i] ? parameters.approaches[i].get()
+                use_bearings ? parameters.bearings[i] : std::nullopt,
+                use_approaches && parameters.approaches[i] ? parameters.approaches[i].value()
                                                           : engine::Approach::UNRESTRICTED,
                use_all_edges);

@@ -325,7 +325,7 @@ class BasePlugin
               std::to_string(missing_index);
    }

-    const boost::optional<double> default_radius;
+    const std::optional<double> default_radius;
 };
 } // namespace osrm::engine::plugins

@@ -15,7 +15,7 @@ class TablePlugin final : public BasePlugin
 {
  public:
    explicit TablePlugin(const int max_locations_distance_table,
-                         const boost::optional<double> default_radius);
+                         const std::optional<double> default_radius);

    Status HandleRequest(const RoutingAlgorithmsInterface &algorithms,
                         const api::TableParameters &params,
@@ -32,7 +32,7 @@ class TripPlugin final : public BasePlugin
                                     const bool roundtrip) const;

  public:
-    explicit TripPlugin(const int max_locations_trip_, boost::optional<double> default_radius)
+    explicit TripPlugin(const int max_locations_trip_, std::optional<double> default_radius)
        : BasePlugin(default_radius), max_locations_trip(max_locations_trip_)
    {
    }
@@ -27,7 +27,7 @@ class ViaRoutePlugin final : public BasePlugin
  public:
    explicit ViaRoutePlugin(int max_locations_viaroute,
                            int max_alternatives,
-                            boost::optional<double> default_radius);
+                            std::optional<double> default_radius);

    Status HandleRequest(const RoutingAlgorithmsInterface &algorithms,
                         const api::RouteParameters &route_parameters,
@@ -25,7 +25,7 @@ class RoutingAlgorithmsInterface

    virtual InternalRouteResult
    ShortestPathSearch(const std::vector<PhantomNodeCandidates> &waypoint_candidates,
-                       const boost::optional<bool> continue_straight_at_waypoint) const = 0;
+                       const std::optional<bool> continue_straight_at_waypoint) const = 0;

    virtual InternalRouteResult
    DirectShortestPathSearch(const PhantomEndpointCandidates &endpoint_candidates) const = 0;
@@ -40,7 +40,7 @@ class RoutingAlgorithmsInterface
    MapMatching(const routing_algorithms::CandidateLists &candidates_list,
                const std::vector<util::Coordinate> &trace_coordinates,
                const std::vector<unsigned> &trace_timestamps,
-                const std::vector<boost::optional<double>> &trace_gps_precision,
+                const std::vector<std::optional<double>> &trace_gps_precision,
                const bool allow_splitting) const = 0;

    virtual std::vector<routing_algorithms::TurnData>
@@ -78,7 +78,7 @@ template <typename Algorithm> class RoutingAlgorithms final : public RoutingAlgo

    InternalRouteResult ShortestPathSearch(
        const std::vector<PhantomNodeCandidates> &waypoint_candidates,
-        const boost::optional<bool> continue_straight_at_waypoint) const final override;
+        const std::optional<bool> continue_straight_at_waypoint) const final override;

    InternalRouteResult DirectShortestPathSearch(
        const PhantomEndpointCandidates &endpoint_candidates) const final override;
@@ -93,7 +93,7 @@ template <typename Algorithm> class RoutingAlgorithms final : public RoutingAlgo
    MapMatching(const routing_algorithms::CandidateLists &candidates_list,
                const std::vector<util::Coordinate> &trace_coordinates,
                const std::vector<unsigned> &trace_timestamps,
-                const std::vector<boost::optional<double>> &trace_gps_precision,
+                const std::vector<std::optional<double>> &trace_gps_precision,
                const bool allow_splitting) const final override;

    std::vector<routing_algorithms::TurnData>
@@ -160,7 +160,7 @@ InternalManyRoutesResult RoutingAlgorithms<Algorithm>::AlternativePathSearch(
 template <typename Algorithm>
 InternalRouteResult RoutingAlgorithms<Algorithm>::ShortestPathSearch(
    const std::vector<PhantomNodeCandidates> &waypoint_candidates,
-    const boost::optional<bool> continue_straight_at_waypoint) const
+    const std::optional<bool> continue_straight_at_waypoint) const
 {
    return routing_algorithms::shortestPathSearch(
        heaps, *facade, waypoint_candidates, continue_straight_at_waypoint);
@@ -178,7 +178,7 @@ inline routing_algorithms::SubMatchingList RoutingAlgorithms<Algorithm>::MapMatc
    const routing_algorithms::CandidateLists &candidates_list,
    const std::vector<util::Coordinate> &trace_coordinates,
    const std::vector<unsigned> &trace_timestamps,
-    const std::vector<boost::optional<double>> &trace_gps_precision,
+    const std::vector<std::optional<double>> &trace_gps_precision,
    const bool allow_splitting) const
 {
    return routing_algorithms::mapMatching(heaps,
@@ -24,7 +24,7 @@ SubMatchingList mapMatching(SearchEngineData<Algorithm> &engine_working_data,
                            const CandidateLists &candidates_list,
                            const std::vector<util::Coordinate> &trace_coordinates,
                            const std::vector<unsigned> &trace_timestamps,
-                            const std::vector<boost::optional<double>> &trace_gps_precision,
+                            const std::vector<std::optional<double>> &trace_gps_precision,
                            const bool allow_splitting);

 } // namespace osrm::engine::routing_algorithms
@@ -258,7 +258,7 @@ void annotatePath(const FacadeT &facade,
                                             alias_cast<EdgeDuration>(duration_vector[segment_idx]),
                                             {0},
                                             datasource_vector[segment_idx],
-                                             boost::none});
+                                             std::nullopt});
        }
        BOOST_ASSERT(!unpacked_path.empty());

@@ -315,7 +315,7 @@ void annotatePath(const FacadeT &facade,
                     alias_cast<EdgeDuration>(duration_vector[segment_idx]),
                     {0},
                     datasource_vector[segment_idx],
-                     boost::none});
+                     std::nullopt});
    }

    if (!unpacked_path.empty())
@@ -460,6 +460,19 @@ void search(SearchEngineData<Algorithm> &engine_working_data,
                  duration_upper_bound);
 }

+inline std::vector<double> getNetworkDistances(
+    SearchEngineData<Algorithm> &,
+    const DataFacade<ch::Algorithm> &,
+    SearchEngineData<Algorithm>::QueryHeap &,
+    const std::vector<std::unique_ptr<typename SearchEngineData<Algorithm>::QueryHeap>> &,
+    const PhantomNode &,
+    const std::vector<PhantomNode> &,
+    EdgeWeight /*duration_upper_bound*/ = INVALID_EDGE_WEIGHT)
+{
+    std::vector<double> distances;
+    return distances;
+}
+
 // Requires the heaps for be empty
 // If heaps should be adjusted to be initialized outside of this function,
 // the addition of force_step parameters might be required
@@ -38,10 +38,13 @@ inline LevelID getNodeQueryLevel(const MultiLevelPartition &partition,
        return INVALID_LEVEL_ID;
    };

-    return std::min(std::min(level(source.forward_segment_id, target.forward_segment_id),
-                             level(source.forward_segment_id, target.reverse_segment_id)),
-                    std::min(level(source.reverse_segment_id, target.forward_segment_id),
-                             level(source.reverse_segment_id, target.reverse_segment_id)));
+    auto res = std::min(std::min(level(source.forward_segment_id, target.forward_segment_id),
+                                 level(source.forward_segment_id, target.reverse_segment_id)),
+                        std::min(level(source.reverse_segment_id, target.forward_segment_id),
+                                 level(source.reverse_segment_id, target.reverse_segment_id)));
+
+    //   std::cerr << "OLD!!! " << (int)res << std::endl;
+    return res;
 }

 template <typename MultiLevelPartition>
@@ -92,6 +95,7 @@ inline LevelID getNodeQueryLevel(const MultiLevelPartition &partition,
                                        getNodeQueryLevel(partition, node, source, target));
                                }));
        });
+    // std::cerr << "NEW " << (int)min_level << std::endl;
    return min_level;
 }

@@ -140,6 +144,8 @@ inline LevelID getNodeQueryLevel(const MultiLevelPartition &partition,
                                         highest_different_level(phantom_node.reverse_segment_id));
                            return std::min(current_level, highest_level);
                        });
+
+    //     std::cerr << "NEW!!! " << (int)node_level << std::endl;
    return node_level;
 }

@@ -300,7 +306,6 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
    const auto &metric = facade.GetCellMetric();

    const auto level = getNodeQueryLevel(partition, heapNode.node, args...);
-
    static constexpr auto IS_MAP_MATCHING =
        std::is_same_v<typename SearchEngineData<mld::Algorithm>::MapMatchingQueryHeap, Heap>;

@@ -457,6 +462,15 @@ void routingStep(const DataFacade<Algorithm> &facade,

    BOOST_ASSERT(!facade.ExcludeNode(heapNode.node));

+    if (DIRECTION == FORWARD_DIRECTION)
+    {
+        //    std::cerr << "FORWARDO " << heapNode.node << std::endl;
+    }
+    else
+    {
+        // std::cerr << "REVERSEO " << heapNode.node << std::endl;
+    }
+
    // Upper bound for the path source -> target with
    // weight(source -> node) = weight weight(to -> target) ≤ reverse_weight
    // is weight + reverse_weight
@@ -487,7 +501,13 @@ void routingStep(const DataFacade<Algorithm> &facade,

 using UnpackedNodes = std::vector<NodeID>;
 using UnpackedEdges = std::vector<EdgeID>;
-using UnpackedPath = std::tuple<EdgeWeight, UnpackedNodes, UnpackedEdges>;
+
+struct UnpackedPath
+{
+    EdgeWeight weight;
+    UnpackedNodes nodes;
+    UnpackedEdges edges;
+};

 template <typename Algorithm, typename Heap, typename... Args>
 std::optional<std::pair<NodeID, EdgeWeight>> runSearch(const DataFacade<Algorithm> &facade,
@@ -551,7 +571,7 @@ UnpackedPath search(SearchEngineData<Algorithm> &engine_working_data,
        facade, forward_heap, reverse_heap, force_step_nodes, weight_upper_bound, args...);
    if (!searchResult)
    {
-        return std::make_tuple(INVALID_EDGE_WEIGHT, std::vector<NodeID>(), std::vector<EdgeID>());
+        return {INVALID_EDGE_WEIGHT, std::vector<NodeID>(), std::vector<EdgeID>()};
    }

    auto [middle, weight] = *searchResult;
@@ -595,25 +615,27 @@ UnpackedPath search(SearchEngineData<Algorithm> &engine_working_data,
            forward_heap.Insert(source, {0}, {source});
            reverse_heap.Insert(target, {0}, {target});

-            auto [subpath_weight, subpath_nodes, subpath_edges] = search(engine_working_data,
-                                                                         facade,
-                                                                         forward_heap,
-                                                                         reverse_heap,
-                                                                         force_step_nodes,
-                                                                         INVALID_EDGE_WEIGHT,
-                                                                         sublevel,
-                                                                         parent_cell_id);
-            BOOST_ASSERT(!subpath_edges.empty());
-            BOOST_ASSERT(subpath_nodes.size() > 1);
-            BOOST_ASSERT(subpath_nodes.front() == source);
-            BOOST_ASSERT(subpath_nodes.back() == target);
-            unpacked_nodes.insert(
-                unpacked_nodes.end(), std::next(subpath_nodes.begin()), subpath_nodes.end());
-            unpacked_edges.insert(unpacked_edges.end(), subpath_edges.begin(), subpath_edges.end());
+            auto unpacked_subpath = search(engine_working_data,
+                                           facade,
+                                           forward_heap,
+                                           reverse_heap,
+                                           force_step_nodes,
+                                           INVALID_EDGE_WEIGHT,
+                                           sublevel,
+                                           parent_cell_id);
+            BOOST_ASSERT(!unpacked_subpath.edges.empty());
+            BOOST_ASSERT(unpacked_subpath.nodes.size() > 1);
+            BOOST_ASSERT(unpacked_subpath.nodes.front() == source);
+            BOOST_ASSERT(unpacked_subpath.nodes.back() == target);
+            unpacked_nodes.insert(unpacked_nodes.end(),
+                                  std::next(unpacked_subpath.nodes.begin()),
+                                  unpacked_subpath.nodes.end());
+            unpacked_edges.insert(
+                unpacked_edges.end(), unpacked_subpath.edges.begin(), unpacked_subpath.edges.end());
        }
    }

-    return std::make_tuple(weight, std::move(unpacked_nodes), std::move(unpacked_edges));
+    return {weight, std::move(unpacked_nodes), std::move(unpacked_edges)};
 }

 template <typename Algorithm, typename... Args>
@@ -636,6 +658,7 @@ searchDistance(SearchEngineData<Algorithm> &,

    auto [middle, _] = *searchResult;

+    //   std::cerr << "old " << middle << std::endl;
    auto distance = forward_heap.GetData(middle).distance + reverse_heap.GetData(middle).distance;

    return distance;
@@ -654,13 +677,15 @@ inline void search(SearchEngineData<Algorithm> &engine_working_data,
                   const EdgeWeight weight_upper_bound = INVALID_EDGE_WEIGHT)
 {
    // TODO: change search calling interface to use unpacked_edges result
-    std::tie(weight, unpacked_nodes, std::ignore) = search(engine_working_data,
-                                                           facade,
-                                                           forward_heap,
-                                                           reverse_heap,
-                                                           force_step_nodes,
-                                                           weight_upper_bound,
-                                                           endpoints);
+    auto unpacked_path = search(engine_working_data,
+                                facade,
+                                forward_heap,
+                                reverse_heap,
+                                force_step_nodes,
+                                weight_upper_bound,
+                                endpoints);
+    weight = unpacked_path.weight;
+    unpacked_nodes = std::move(unpacked_path.nodes);
 }

 // TODO: refactor CH-related stub to use unpacked_edges
@@ -753,6 +778,307 @@ double getNetworkDistance(SearchEngineData<Algorithm> &engine_working_data,
    return from_alias<double>(distance);
 }

+
+template <typename Algorithm, typename Heap>
+std::vector<NodeID>
+runSearch2(const DataFacade<Algorithm> &facade,
+           Heap &forward_heap,
+           const std::vector<std::unique_ptr<Heap>> &reverse_heap,
+           size_t candidatesCount,
+           const std::vector<NodeID> &force_step_nodes,
+           EdgeWeight weight_upper_bound,
+           const PhantomEndpointCandidates &candidates)
+{
+    // if (forward_heap.Empty() || reverse_heap.Empty())
+    // {
+    //     return {};
+    // }
+
+    // BOOST_ASSERT(!forward_heap.Empty() && forward_heap.MinKey() < INVALID_EDGE_WEIGHT);
+    // BOOST_ASSERT(!reverse_heap.Empty() && reverse_heap.MinKey() < INVALID_EDGE_WEIGHT);
+
+    std::vector<NodeID> middles;
+    std::vector<EdgeWeight> weights;
+
+    middles.resize(candidatesCount, SPECIAL_NODEID);
+    weights.resize(candidatesCount, weight_upper_bound);
+
+    // run two-Target Dijkstra routing step.
+    EdgeWeight forward_heap_min = forward_heap.MinKey();
+    std::vector<EdgeWeight> reverse_heap_mins;
+    for (size_t i = 0; i < candidatesCount; ++i)
+    {
+        reverse_heap_mins.push_back(reverse_heap[i]->MinKey());
+    }
+
+    auto shouldContinue = [&]()
+    {
+        bool cont = false;
+        for (size_t i = 0; i < candidatesCount; ++i)
+        {
+            if ((forward_heap.Size() + reverse_heap[i]->Size() > 0) &&
+                (forward_heap_min + reverse_heap_mins[i]) < weights[i])
+            {
+                cont = true;
+                break;
+            }
+        }
+        return cont;
+    };
+
+    bool cont = shouldContinue();
+    while (cont)
+    {
+        if (!forward_heap.Empty())
+        {
+            const auto heapNode = forward_heap.DeleteMinGetHeapNode();
+            //  std::cerr << "FORWARDN " << heapNode.node << std::endl;
+            // auto heapNode = routingStep2<FORWARD_DIRECTION>(facade, forward_heap, args...);
+
+            for (size_t i = 0; i < candidatesCount; ++i)
+            {
+                auto &rh = reverse_heap[i];
+                const auto reverseHeapNode = rh->GetHeapNodeIfWasInserted(heapNode.node);
+                if (reverseHeapNode)
+                {
+                    auto reverse_weight = reverseHeapNode->weight;
+                    auto path_weight = heapNode.weight + reverse_weight;
+
+                    if (!shouldForceStep(force_step_nodes, heapNode, *reverseHeapNode) &&
+                        (path_weight >= EdgeWeight{0}) && (path_weight < weights[i]))
+                    {
+                        middles[i] = heapNode.node;
+                        weights[i] = path_weight;
+
+                        //                                             auto distance =
+                        // forward_heap.GetData(middles[i]).distance +
+                        // reverse_heap[i]->GetData(middles[i]).distance;
+                        //    std::cerr << "RFOUNDN " << i <<" " << distance << std::endl;
+                    }
+                }
+            }
+
+            relaxOutgoingEdges<FORWARD_DIRECTION>(facade, forward_heap, heapNode, candidates);
+
+            if (!forward_heap.Empty())
+                forward_heap_min = forward_heap.MinKey();
+        }
+
+        cont = false;
+        for (size_t i = 0; i < candidatesCount; ++i)
+        {
+             if ((forward_heap.Size() + reverse_heap[i]->Size() > 0) &&
+                (forward_heap_min + reverse_heap_mins[i]) < weights[i])
+            {
+                cont = true;
+            }
+            if (!reverse_heap[i]->Empty() && (forward_heap_min + reverse_heap_mins[i]) < weights[i])
+            {
+                const auto heapNode = reverse_heap[i]->DeleteMinGetHeapNode();
+                // std::cerr << "REVERSEN " << i << " " << heapNode.node << std::endl;
+
+                const auto reverseHeapNode = forward_heap.GetHeapNodeIfWasInserted(heapNode.node);
+                if (reverseHeapNode)
+                {
+                    auto reverse_weight = reverseHeapNode->weight;
+                    auto path_weight = heapNode.weight + reverse_weight;
+
+                    if (!shouldForceStep(force_step_nodes, heapNode, *reverseHeapNode) &&
+                        (path_weight >= EdgeWeight{0}) && (path_weight < weights[i]))
+                    {
+
+                        middles[i] = heapNode.node;
+                        weights[i] = path_weight;
+
+                        //                     auto distance =
+                        // forward_heap.GetData(middles[i]).distance +
+                        // reverse_heap[i]->GetData(middles[i]).distance;
+                        //     std::cerr << "FFOUNDN " << i << " " << distance << std::endl;
+                    }
+                }
+                relaxOutgoingEdges<REVERSE_DIRECTION>(
+                    facade, *reverse_heap[i], heapNode, candidates);
+
+                if (!reverse_heap[i]->Empty())
+                    reverse_heap_mins[i] = reverse_heap[i]->MinKey();
+            }
+        }
+    };
+
+return middles;
+    // std::vector<std::optional<std::pair<NodeID, EdgeWeight>>> results;
+    // results.reserve(candidatesCount);
+    // for (size_t i = 0; i < candidatesCount; ++i)
+    // {
+    //     if (weights[i] >= weight_upper_bound || SPECIAL_NODEID == middles[i])
+    //     {
+    //         results.push_back({});
+    //     }
+    //     else
+    //     {
+    //         results.push_back({{middles[i], weights[i]}});
+    //     }
+    // }
+    // return results;
+
+    // // run two-Target Dijkstra routing step.
+    // NodeID middle = SPECIAL_NODEID;
+    // EdgeWeight weight = weight_upper_bound;
+    // EdgeWeight forward_heap_min = forward_heap.MinKey();
+    // EdgeWeight reverse_heap_min = reverse_heap.MinKey();
+    // while (forward_heap.Size() + reverse_heap.Size() > 0 &&
+    //        forward_heap_min + reverse_heap_min < weight)
+    // {
+    //     if (!forward_heap.Empty())
+    //     {
+    //         routingStep<FORWARD_DIRECTION>(
+    //             facade, forward_heap, reverse_heap, middle, weight, force_step_nodes, args...);
+    //         if (!forward_heap.Empty())
+    //             forward_heap_min = forward_heap.MinKey();
+    //     }
+    //     if (!reverse_heap.Empty())
+    //     {
+    //         routingStep<REVERSE_DIRECTION>(
+    //             facade, reverse_heap, forward_heap, middle, weight, force_step_nodes, args...);
+    //         if (!reverse_heap.Empty())
+    //             reverse_heap_min = reverse_heap.MinKey();
+    //     }
+    // };
+
+    // // No path found for both target nodes?
+    // if (weight >= weight_upper_bound || SPECIAL_NODEID == middle)
+    // {
+    //     return {};
+    // }
+
+    // return {{middle, weight}};
+}
+
+template <typename Algorithm>
+std::vector<double> searchDistance2(
+    SearchEngineData<Algorithm> &,
+    const DataFacade<Algorithm> &facade,
+    typename SearchEngineData<Algorithm>::MapMatchingQueryHeap &forward_heap,
+    const std::vector<std::unique_ptr<typename SearchEngineData<Algorithm>::MapMatchingQueryHeap>>
+        &reverse_heaps,
+    size_t candidatesCount,
+    const std::vector<NodeID> &force_step_nodes,
+    EdgeWeight weight_upper_bound,
+    const PhantomEndpointCandidates &candidates)
+{
+    auto searchResults = runSearch2(facade,
+                                    forward_heap,
+                                    reverse_heaps,
+                                    candidatesCount,
+                                    force_step_nodes,
+                                    weight_upper_bound,
+                                    candidates);
+    std::vector<double> res;
+    res.reserve(candidatesCount);
+    for (size_t i = 0; i < searchResults.size(); ++i)
+    {
+        if (searchResults[i] == SPECIAL_NODEID)
+        {
+            res.push_back(std::numeric_limits<double>::max());
+        }
+        else
+        {
+            auto middle = searchResults[i];
+
+            // std::cerr << "new " << i << " " << middle << std::endl;
+
+            auto distance =
+                forward_heap.GetData(middle).distance + reverse_heaps[i]->GetData(middle).distance;
+            res.push_back(from_alias<double>(distance));
+        }
+    }
+    return res;
+}
+template <typename Algorithm>
+std::vector<double> getNetworkDistances(
+    SearchEngineData<Algorithm> &engine_working_data,
+    const DataFacade<Algorithm> &facade,
+    typename SearchEngineData<Algorithm>::MapMatchingQueryHeap &forward_heap,
+    const std::vector<std::unique_ptr<typename SearchEngineData<Algorithm>::MapMatchingQueryHeap>>
+        &reverse_heaps,
+    const PhantomNode &source_phantom,
+    const std::vector<PhantomNode> &target_phantoms,
+    EdgeWeight weight_upper_bound = INVALID_EDGE_WEIGHT)
+{
+    forward_heap.Clear();
+    for (const auto &heap : reverse_heaps)
+    {
+        heap->Clear();
+    }
+    // std::vector<std::unique_ptr<Heap>> reverse_heaps;
+    // const auto nodes_number = facade.GetNumberOfNodes();
+    // const auto border_nodes_number = facade.GetMaxBorderNodeID() + 1;
+    // for (const auto &target_phantom : target_phantoms)
+    // {
+    //     (void)target_phantom;
+    //     reverse_heaps.emplace_back(std::make_unique<Heap>(nodes_number, border_nodes_number));
+    // }
+
+    if (source_phantom.IsValidForwardSource())
+    {
+        forward_heap.Insert(source_phantom.forward_segment_id.id,
+                            EdgeWeight{0} - source_phantom.GetForwardWeightPlusOffset(),
+                            {source_phantom.forward_segment_id.id,
+                             false,
+                             EdgeDistance{0} - source_phantom.GetForwardDistance()});
+    }
+
+    if (source_phantom.IsValidReverseSource())
+    {
+        forward_heap.Insert(source_phantom.reverse_segment_id.id,
+                            EdgeWeight{0} - source_phantom.GetReverseWeightPlusOffset(),
+                            {source_phantom.reverse_segment_id.id,
+                             false,
+                             EdgeDistance{0} - source_phantom.GetReverseDistance()});
+    }
+
+    for (size_t i = 0; i < target_phantoms.size(); ++i)
+    {
+        auto &reverse_heap = *reverse_heaps[i];
+        const auto &target_phantom = target_phantoms[i];
+        if (target_phantom.IsValidForwardTarget())
+        {
+            reverse_heap.Insert(
+                target_phantom.forward_segment_id.id,
+                target_phantom.GetForwardWeightPlusOffset(),
+                {target_phantom.forward_segment_id.id, false, target_phantom.GetForwardDistance()});
+        }
+
+        if (target_phantom.IsValidReverseTarget())
+        {
+            reverse_heap.Insert(
+                target_phantom.reverse_segment_id.id,
+                target_phantom.GetReverseWeightPlusOffset(),
+                {target_phantom.reverse_segment_id.id, false, target_phantom.GetReverseDistance()});
+        }
+    }
+
+    // PhantomEndpoints endpoints{};
+    // endpoints.push_back(source_phantom);
+    // for (const auto &target_phantom : target_phantoms)
+    // {
+    //     endpoints.push_back(target_phantom);
+    // }
+    std::vector<PhantomNode> source_phantomes;
+    source_phantomes.push_back(source_phantom);
+    PhantomEndpointCandidates phantom_candidates{source_phantomes, target_phantoms};
+
+    auto distances = searchDistance2(engine_working_data,
+                                      facade,
+                                      forward_heap,
+                                      reverse_heaps,
+                                      target_phantoms.size(),
+                                      {},
+                                      weight_upper_bound,
+                                      phantom_candidates);
+    return distances;
+}
+
 } // namespace osrm::engine::routing_algorithms::mld

 #endif // OSRM_ENGINE_ROUTING_BASE_MLD_HPP
@@ -14,7 +14,7 @@ InternalRouteResult
 shortestPathSearch(SearchEngineData<Algorithm> &engine_working_data,
                   const DataFacade<Algorithm> &facade,
                   const std::vector<PhantomNodeCandidates> &waypoint_candidates,
-                   const boost::optional<bool> continue_straight_at_waypoint);
+                   const std::optional<bool> continue_straight_at_waypoint);

 } // namespace osrm::engine::routing_algorithms

@@ -4,7 +4,7 @@
 #include "engine/routing_algorithms/shortest_path.hpp"

 #include <boost/assert.hpp>
-#include <boost/optional.hpp>
+#include <optional>

 namespace osrm::engine::routing_algorithms
 {
@@ -339,10 +339,10 @@ struct leg_connections
 {
    // X_to_Y = i can be read as
    // sources[i].X is the source of the shortest leg path to target.Y
-    boost::optional<size_t> forward_to_forward;
-    boost::optional<size_t> reverse_to_forward;
-    boost::optional<size_t> forward_to_reverse;
-    boost::optional<size_t> reverse_to_reverse;
+    std::optional<size_t> forward_to_forward;
+    std::optional<size_t> reverse_to_forward;
+    std::optional<size_t> forward_to_reverse;
+    std::optional<size_t> reverse_to_reverse;
 };

 // Identify which of the source candidates segments is being used for paths to the
@@ -771,7 +771,7 @@ InternalRouteResult
 shortestPathSearch(SearchEngineData<Algorithm> &engine_working_data,
                   const DataFacade<Algorithm> &facade,
                   const std::vector<PhantomNodeCandidates> &waypoint_candidates,
-                   const boost::optional<bool> continue_straight_at_waypoint)
+                   const std::optional<bool> continue_straight_at_waypoint)
 {
    const bool allow_uturn_at_waypoint =
        !(continue_straight_at_waypoint ? *continue_straight_at_waypoint
@@ -5,8 +5,6 @@
 #include "util/query_heap.hpp"
 #include "util/typedefs.hpp"

-#include <boost/thread/tss.hpp>
-
 namespace osrm::engine
 {

@@ -45,19 +43,20 @@ template <> struct SearchEngineData<routing_algorithms::ch::Algorithm>
                                                ManyToManyHeapData,
                                                util::UnorderedMapStorage<NodeID, int>>;

-    using SearchEngineHeapPtr = boost::thread_specific_ptr<QueryHeap>;
+    using SearchEngineHeapPtr = std::unique_ptr<QueryHeap>;

-    using ManyToManyHeapPtr = boost::thread_specific_ptr<ManyToManyQueryHeap>;
+    using ManyToManyHeapPtr = std::unique_ptr<ManyToManyQueryHeap>;

-    static SearchEngineHeapPtr forward_heap_1;
-    static SearchEngineHeapPtr reverse_heap_1;
-    static SearchEngineHeapPtr forward_heap_2;
-    static SearchEngineHeapPtr reverse_heap_2;
-    static SearchEngineHeapPtr forward_heap_3;
-    static SearchEngineHeapPtr reverse_heap_3;
-    static ManyToManyHeapPtr many_to_many_heap;
-    static SearchEngineHeapPtr map_matching_forward_heap_1;
-    static SearchEngineHeapPtr map_matching_reverse_heap_1;
+    static thread_local SearchEngineHeapPtr forward_heap_1;
+    static thread_local SearchEngineHeapPtr reverse_heap_1;
+    static thread_local SearchEngineHeapPtr forward_heap_2;
+    static thread_local SearchEngineHeapPtr reverse_heap_2;
+    static thread_local SearchEngineHeapPtr forward_heap_3;
+    static thread_local SearchEngineHeapPtr reverse_heap_3;
+    static thread_local ManyToManyHeapPtr many_to_many_heap;
+    static thread_local SearchEngineHeapPtr map_matching_forward_heap_1;
+    static thread_local SearchEngineHeapPtr map_matching_reverse_heap_1;
+    static thread_local std::vector<SearchEngineHeapPtr> map_matching_reverse_heaps;

    void InitializeOrClearMapMatchingThreadLocalStorage(unsigned number_of_nodes);

@@ -127,25 +126,27 @@ template <> struct SearchEngineData<routing_algorithms::mld::Algorithm>
                                                 MapMatchingMultiLayerDijkstraHeapData,
                                                 util::TwoLevelStorage<NodeID, int>>;

-    using SearchEngineHeapPtr = boost::thread_specific_ptr<QueryHeap>;
-    using ManyToManyHeapPtr = boost::thread_specific_ptr<ManyToManyQueryHeap>;
-    using MapMatchingHeapPtr = boost::thread_specific_ptr<MapMatchingQueryHeap>;
+    using SearchEngineHeapPtr = std::unique_ptr<QueryHeap>;
+    using ManyToManyHeapPtr = std::unique_ptr<ManyToManyQueryHeap>;
+    using MapMatchingHeapPtr = std::unique_ptr<MapMatchingQueryHeap>;

-    static SearchEngineHeapPtr forward_heap_1;
-    static SearchEngineHeapPtr reverse_heap_1;
-    static MapMatchingHeapPtr map_matching_forward_heap_1;
-    static MapMatchingHeapPtr map_matching_reverse_heap_1;
+    static thread_local SearchEngineHeapPtr forward_heap_1;
+    static thread_local SearchEngineHeapPtr reverse_heap_1;
+    static thread_local MapMatchingHeapPtr map_matching_forward_heap_1;
+    static thread_local MapMatchingHeapPtr map_matching_reverse_heap_1;
+    static thread_local std::vector<MapMatchingHeapPtr> map_matching_reverse_heaps;

-    static ManyToManyHeapPtr many_to_many_heap;
+    static thread_local ManyToManyHeapPtr many_to_many_heap;

    void InitializeOrClearFirstThreadLocalStorage(unsigned number_of_nodes,
                                                  unsigned number_of_boundary_nodes);
    void InitializeOrClearMapMatchingThreadLocalStorage(unsigned number_of_nodes,
-                                                        unsigned number_of_boundary_nodes);
+                                                        unsigned number_of_boundary_nodes,
+                                                        size_t max_candidates);

    void InitializeOrClearManyToManyThreadLocalStorage(unsigned number_of_nodes,
                                                       unsigned number_of_boundary_nodes);
 };
 } // namespace osrm::engine

-#endif // SEARCH_ENGINE_DATA_HPP
+#endif // SEARCH_ENGINE_DATA_HPP
@@ -21,7 +21,7 @@
 #include <napi.h>

 #include <boost/assert.hpp>
-#include <boost/optional.hpp>
+#include <optional>

 #include <algorithm>
 #include <iterator>
@@ -395,11 +395,11 @@ inline engine_config_ptr argumentsToEngineConfig(const Napi::CallbackInfo &args)
    return engine_config;
 }

-inline boost::optional<std::vector<osrm::Coordinate>>
+inline std::optional<std::vector<osrm::Coordinate>>
 parseCoordinateArray(const Napi::Array &coordinates_array)
 {
    Napi::HandleScope scope(coordinates_array.Env());
-    boost::optional<std::vector<osrm::Coordinate>> resulting_coordinates;
+    std::optional<std::vector<osrm::Coordinate>> resulting_coordinates;
    std::vector<osrm::Coordinate> temp_coordinates;

    for (uint32_t i = 0; i < coordinates_array.Length(); ++i)
@@ -450,7 +450,7 @@ parseCoordinateArray(const Napi::Array &coordinates_array)
                                      osrm::util::FloatLatitude{std::move(lat)});
    }

-    resulting_coordinates = boost::make_optional(std::move(temp_coordinates));
+    resulting_coordinates = std::make_optional(std::move(temp_coordinates));
    return resulting_coordinates;
 }

@@ -1023,7 +1023,7 @@ inline bool parseCommonParameters(const Napi::Object &obj, ParamType &params)

 inline PluginParameters argumentsToPluginParameters(
    const Napi::CallbackInfo &args,
-    const boost::optional<osrm::engine::api::BaseParameters::OutputFormatType> &output_format = {})
+    const std::optional<osrm::engine::api::BaseParameters::OutputFormatType> &output_format = {})
 {
    if (args.Length() < 3 || !args[1].IsObject())
    {
@@ -7,9 +7,9 @@
 #include "engine/hint.hpp"
 #include "engine/polyline_compressor.hpp"

-#include <boost/optional.hpp>
 #include <boost/phoenix.hpp>
 #include <boost/spirit/include/qi.hpp>
+#include <optional>

 #include <limits>
 #include <string>
@@ -88,7 +88,7 @@ struct BaseParametersGrammar : boost::spirit::qi::grammar<Iterator, Signature>
            }
            else
            {
-                base_parameters.hints.emplace_back(boost::none);
+                base_parameters.hints.emplace_back(std::nullopt);
            }
        };

@@ -96,13 +96,24 @@ struct BaseParametersGrammar : boost::spirit::qi::grammar<Iterator, Signature>
            [](engine::api::BaseParameters &base_parameters,
               boost::optional<boost::fusion::vector2<short, short>> bearing_range)
        {
-            boost::optional<engine::Bearing> bearing;
+            std::optional<engine::Bearing> bearing;
            if (bearing_range)
            {
                bearing = engine::Bearing{boost::fusion::at_c<0>(*bearing_range),
                                          boost::fusion::at_c<1>(*bearing_range)};
            }
-            base_parameters.bearings.push_back(std::move(bearing));
+            base_parameters.bearings.push_back(bearing);
+        };
+
+        const auto add_approach = [](engine::api::BaseParameters &base_parameters,
+                                     boost::optional<osrm::engine::Approach> approach) {
+            base_parameters.approaches.push_back(approach ? std::make_optional(*approach)
+                                                          : std::nullopt);
+        };
+
+        const auto add_radius = [](engine::api::BaseParameters &base_parameters,
+                                   boost::optional<double> radius) {
+            base_parameters.radiuses.push_back(radius ? std::make_optional(*radius) : std::nullopt);
        };

        polyline_chars = qi::char_("a-zA-Z0-9_.--[]{}@?|\\%~`^");
@@ -144,9 +155,9 @@ struct BaseParametersGrammar : boost::spirit::qi::grammar<Iterator, Signature>
            ((location_rule % ';') | polyline_rule |
             polyline6_rule)[ph::bind(&engine::api::BaseParameters::coordinates, qi::_r1) = qi::_1];

-        radiuses_rule = qi::lit("radiuses=") >
-                        (-(qi::double_ | unlimited_rule) %
-                         ';')[ph::bind(&engine::api::BaseParameters::radiuses, qi::_r1) = qi::_1];
+        radiuses_rule =
+            qi::lit("radiuses=") >
+            (-(qi::double_ | unlimited_rule))[ph::bind(add_radius, qi::_r1, qi::_1)] % ';';

        hints_rule =
            qi::lit("hints=") >
@@ -170,8 +181,7 @@ struct BaseParametersGrammar : boost::spirit::qi::grammar<Iterator, Signature>
            "curb", engine::Approach::CURB)("opposite", engine::Approach::OPPOSITE);

        approach_rule = qi::lit("approaches=") >
-                        (-approach_type %
-                         ';')[ph::bind(&engine::api::BaseParameters::approaches, qi::_r1) = qi::_1];
+                        (-approach_type)[ph::bind(add_approach, qi::_r1, qi::_1)] % ';';

        snapping_type.add("default", engine::api::BaseParameters::SnappingType::Default)(
            "any", engine::api::BaseParameters::SnappingType::Any);
@@ -26,13 +26,13 @@ using is_parameter_t =
 // Starts parsing and iter and modifies it until iter == end or parsing failed
 template <typename ParameterT,
          typename std::enable_if<detail::is_parameter_t<ParameterT>::value, int>::type = 0>
-boost::optional<ParameterT> parseParameters(std::string::iterator &iter,
-                                            const std::string::iterator end);
+std::optional<ParameterT> parseParameters(std::string::iterator &iter,
+                                          const std::string::iterator end);

 // Copy on purpose because we need mutability
 template <typename ParameterT,
          typename std::enable_if<detail::is_parameter_t<ParameterT>::value, int>::type = 0>
-boost::optional<ParameterT> parseParameters(std::string options_string)
+std::optional<ParameterT> parseParameters(std::string options_string)
 {
    auto first = options_string.begin();
    const auto last = options_string.end();
@@ -3,7 +3,7 @@

 #include "server/api/parsed_url.hpp"

-#include <boost/optional.hpp>
+#include <optional>

 #include <string>

@@ -11,9 +11,9 @@ namespace osrm::server::api
 {

 // Starts parsing and iter and modifies it until iter == end or parsing failed
-boost::optional<ParsedURL> parseURL(std::string::iterator &iter, const std::string::iterator end);
+std::optional<ParsedURL> parseURL(std::string::iterator &iter, const std::string::iterator end);

-inline boost::optional<ParsedURL> parseURL(std::string url_string)
+inline std::optional<ParsedURL> parseURL(std::string url_string)
 {
    auto iter = url_string.begin();
    return parseURL(iter, url_string.end());
@@ -0,0 +1,40 @@
+#pragma once
+#include <algorithm>
+#include <boost/assert.hpp>
+#include <vector>
+
+namespace osrm::util
+{
+
+// in its essence it is std::priority_queue, but with `clear` method
+template <typename T> class BinaryHeap
+{
+  public:
+    bool empty() const { return heap_.empty(); }
+
+    const T &top() const
+    {
+        BOOST_ASSERT(!heap_.empty());
+        return heap_.front();
+    }
+
+    void pop()
+    {
+        BOOST_ASSERT(!heap_.empty());
+        std::pop_heap(heap_.begin(), heap_.end());
+        heap_.pop_back();
+    }
+
+    template <typename... Args> void emplace(Args &&...args)
+    {
+        heap_.emplace_back(std::forward<Args>(args)...);
+        std::push_heap(heap_.begin(), heap_.end());
+    }
+
+    void clear() { heap_.clear(); }
+
+  private:
+    std::vector<T> heap_;
+};
+
+} // namespace osrm::util
@@ -2,6 +2,7 @@
 #define MEMINFO_HPP

 #include "util/log.hpp"
+#include <cstddef>

 #ifndef _WIN32
 #include <sys/resource.h>
@@ -10,22 +11,31 @@
 namespace osrm::util
 {

-inline void DumpMemoryStats()
+inline size_t PeakRAMUsedInBytes()
 {
 #ifndef _WIN32
    rusage usage;
    getrusage(RUSAGE_SELF, &usage);
 #ifdef __linux__
    // Under linux, ru.maxrss is in kb
-    util::Log() << "RAM: peak bytes used: " << usage.ru_maxrss * 1024;
+    return usage.ru_maxrss * 1024;
 #else  // __linux__
    // Under BSD systems (OSX), it's in bytes
-    util::Log() << "RAM: peak bytes used: " << usage.ru_maxrss;
+    return usage.ru_maxrss;
 #endif // __linux__
+#else  // _WIN32
+    return 0;
+#endif // _WIN32
+}
+
+inline void DumpMemoryStats()
+{
+#ifndef _WIN32
+    util::Log() << "RAM: peak bytes used: " << PeakRAMUsedInBytes();
 #else  // _WIN32
    util::Log() << "RAM: peak bytes used: <not implemented on Windows>";
 #endif // _WIN32
 }
 } // namespace osrm::util

-#endif
+#endif
@@ -15,48 +15,6 @@
 namespace osrm::util
 {

-template <typename NodeID, typename Key> class GenerationArrayStorage
-{
-    using GenerationCounter = std::uint16_t;
-
-  public:
-    explicit GenerationArrayStorage(std::size_t size)
-        : positions(size, 0), generation(1), generations(size, 0)
-    {
-    }
-
-    Key &operator[](NodeID node)
-    {
-        generation[node] = generation;
-        return positions[node];
-    }
-
-    Key peek_index(const NodeID node) const
-    {
-        if (generations[node] < generation)
-        {
-            return std::numeric_limits<Key>::max();
-        }
-        return positions[node];
-    }
-
-    void Clear()
-    {
-        generation++;
-        // if generation overflows we end up at 0 again and need to clear the vector
-        if (generation == 0)
-        {
-            generation = 1;
-            std::fill(generations.begin(), generations.end(), 0);
-        }
-    }
-
-  private:
-    GenerationCounter generation;
-    std::vector<GenerationCounter> generations;
-    std::vector<Key> positions;
-};
-
 template <typename NodeID, typename Key> class ArrayStorage
 {
  public:
@@ -72,29 +30,6 @@ template <typename NodeID, typename Key> class ArrayStorage
    std::vector<Key> positions;
 };

-template <typename NodeID, typename Key> class MapStorage
-{
-  public:
-    explicit MapStorage(std::size_t) {}
-
-    Key &operator[](NodeID node) { return nodes[node]; }
-
-    void Clear() { nodes.clear(); }
-
-    Key peek_index(const NodeID node) const
-    {
-        const auto iter = nodes.find(node);
-        if (nodes.end() != iter)
-        {
-            return iter->second;
-        }
-        return std::numeric_limits<Key>::max();
-    }
-
-  private:
-    std::map<NodeID, Key> nodes;
-};
-
 template <typename NodeID, typename Key> class UnorderedMapStorage
 {
  public:
@@ -2,7 +2,9 @@
 #define STATIC_RTREE_HPP

 #include "storage/tar_fwd.hpp"
+#include "osrm/coordinate.hpp"
 #include "util/bearing.hpp"
+#include "util/binary_heap.hpp"
 #include "util/coordinate_calculation.hpp"
 #include "util/deallocating_vector.hpp"
 #include "util/exception.hpp"
@@ -15,8 +17,6 @@
 #include "util/vector_view.hpp"
 #include "util/web_mercator.hpp"

-#include "osrm/coordinate.hpp"
-
 #include "storage/shared_memory_ownership.hpp"

 #include <boost/assert.hpp>
@@ -554,9 +554,12 @@ class StaticRTree
        auto projected_coordinate = web_mercator::fromWGS84(input_coordinate);
        Coordinate fixed_projected_coordinate{projected_coordinate};

+        // we re-use queue for each query to avoid re-allocating memory
+        static thread_local util::BinaryHeap<QueryCandidate> traversal_queue;
+
+        traversal_queue.clear();
        // initialize queue with root element
-        std::priority_queue<QueryCandidate> traversal_queue;
-        traversal_queue.push(QueryCandidate{0, TreeIndex{}});
+        traversal_queue.emplace(QueryCandidate{0, TreeIndex{}});

        while (!traversal_queue.empty())
        {
@@ -710,10 +713,11 @@ class StaticRTree
            // distance must be non-negative
            BOOST_ASSERT(0. <= squared_distance);
            BOOST_ASSERT(i < std::numeric_limits<std::uint32_t>::max());
-            traversal_queue.push(QueryCandidate{squared_distance,
-                                                leaf_id,
-                                                static_cast<std::uint32_t>(i),
-                                                Coordinate{projected_nearest}});
+
+            traversal_queue.emplace(QueryCandidate{squared_distance,
+                                                   leaf_id,
+                                                   static_cast<std::uint32_t>(i),
+                                                   Coordinate{projected_nearest}});
        }
    }

@@ -742,7 +746,7 @@ class StaticRTree
                child.minimum_bounding_rectangle.GetMinSquaredDist(
                    fixed_projected_input_coordinate);

-            traversal_queue.push(QueryCandidate{
+            traversal_queue.emplace(QueryCandidate{
                squared_lower_bound_to_element,
                TreeIndex(parent.level + 1, child_index - m_tree_level_starts[parent.level + 1])});
        }
@@ -10,7 +10,8 @@
      "hasInstallScript": true,
      "license": "BSD-2-Clause",
      "dependencies": {
-        "@mapbox/node-pre-gyp": "^1.0.11"
+        "@mapbox/node-pre-gyp": "^1.0.11",
+        "seedrandom": "^3.0.5"
      },
      "devDependencies": {
        "@babel/cli": "^7.18.10",
@@ -14652,6 +14653,11 @@
      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
      "devOptional": true
    },
+    "node_modules/seedrandom": {
+      "version": "3.0.5",
+      "resolved": "https://registry.npmjs.org/seedrandom/-/seedrandom-3.0.5.tgz",
+      "integrity": "sha512-8OwmbklUNzwezjGInmZ+2clQmExQPvomqjL7LFqOYqtmuxRgQYqOD3mHaU+MvZn5FLUeVxVfQjwLZW/n/JFuqg=="
+    },
    "node_modules/semver": {
      "version": "5.7.2",
      "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.2.tgz",
@@ -30296,6 +30302,11 @@
      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
      "devOptional": true
    },
+    "seedrandom": {
+      "version": "3.0.5",
+      "resolved": "https://registry.npmjs.org/seedrandom/-/seedrandom-3.0.5.tgz",
+      "integrity": "sha512-8OwmbklUNzwezjGInmZ+2clQmExQPvomqjL7LFqOYqtmuxRgQYqOD3mHaU+MvZn5FLUeVxVfQjwLZW/n/JFuqg=="
+    },
    "semver": {
      "version": "5.7.2",
      "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.2.tgz",
@@ -4,7 +4,8 @@
  "private": false,
  "description": "The Open Source Routing Machine is a high performance routing engine written in C++ designed to run on OpenStreetMap data.",
  "dependencies": {
-    "@mapbox/node-pre-gyp": "^1.0.11"
+    "@mapbox/node-pre-gyp": "^1.0.11",
+    "seedrandom": "^3.0.5"
  },
  "browserify": {
    "transform": [
@@ -57,6 +58,7 @@
    "jsonpath": "^1.1.1",
    "mkdirp": "^0.5.6",
    "node-addon-api": "^5.0.0",
+    "node-cmake": "^2.5.1",
    "node-timeout": "0.0.4",
    "polyline": "^0.2.0",
    "request": "^2.88.2",
@@ -64,12 +66,13 @@
    "tape": "^4.16.0",
    "turf": "^3.0.14",
    "uglify-js": "^3.17.0",
-    "xmlbuilder": "^4.2.1",
-    "node-cmake": "^2.5.1"
+    "xmlbuilder": "^4.2.1"
  },
  "main": "lib/index.js",
  "binary": {
-    "napi_versions": [8],
+    "napi_versions": [
+      8
+    ],
    "module_name": "node_osrm",
    "module_path": "./lib/binding_napi_v{napi_build_version}/",
    "host": "https://github.com",
@@ -90,6 +90,7 @@ function setup()
        path            = walking_speed,
        steps           = walking_speed,
        pedestrian      = walking_speed,
+        platform        = walking_speed,
        footway         = walking_speed,
        pier            = walking_speed,
      },
@@ -0,0 +1,211 @@
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const seedrandom = require('seedrandom');
+
+
+let RNG;
+
+class GPSData {
+    constructor(gpsTracesFilePath) {
+        this.tracks = {};
+        this.coordinates = [];
+        this.trackIds = [];
+        this._loadGPSTraces(gpsTracesFilePath);
+    }
+
+    _loadGPSTraces(gpsTracesFilePath) {
+        const expandedPath = path.resolve(gpsTracesFilePath);
+        const data = fs.readFileSync(expandedPath, 'utf-8');
+        const lines = data.split('\n');
+        const headers = lines[0].split(',');
+
+        const latitudeIndex = headers.indexOf('Latitude');
+        const longitudeIndex = headers.indexOf('Longitude');
+        const trackIdIndex = headers.indexOf('TrackID');
+
+        for (let i = 1; i < lines.length; i++) {
+            if (lines[i].trim() === '') continue;
+            const row = lines[i].split(',');
+
+            const latitude = parseFloat(row[latitudeIndex]);
+            const longitude = parseFloat(row[longitudeIndex]);
+            const trackId = row[trackIdIndex];
+
+            const coord = [longitude, latitude];
+            this.coordinates.push(coord);
+
+            if (!this.tracks[trackId]) {
+                this.tracks[trackId] = [];
+            }
+            this.tracks[trackId].push(coord);
+        }
+
+        this.trackIds = Object.keys(this.tracks);
+    }
+
+    getRandomCoordinate() {
+        const randomIndex = Math.floor(RNG() * this.coordinates.length);
+        return this.coordinates[randomIndex];
+    }
+
+    getRandomTrack() {
+        const randomIndex = Math.floor(RNG() * this.trackIds.length);
+        const trackId = this.trackIds[randomIndex];
+        return this.tracks[trackId];
+    }
+};
+
+async function runOSRMMethod(osrm, method, coordinates) {
+    const time = await new Promise((resolve, reject) => {
+        const startTime = process.hrtime();
+        osrm[method]({coordinates}, (err, result) => {
+            if (err) {
+                if (['NoSegment', 'NoMatch', 'NoRoute', 'NoTrips'].includes(err.message)) {
+                    resolve(null);
+                } else {
+
+                reject(err);
+                }
+            } else {
+                const endTime = process.hrtime(startTime);
+                resolve(endTime[0] + endTime[1] / 1e9);
+            }
+        });
+    });
+    return time;
+}
+
+async function nearest(osrm, gpsData) {
+    const times = [];
+    for (let i = 0; i < 1000; i++) {
+        const coord = gpsData.getRandomCoordinate();
+        times.push(await runOSRMMethod(osrm, 'nearest', [coord]));
+    }
+    return times;
+}
+
+async function route(osrm, gpsData) {
+    const times = [];
+    for (let i = 0; i < 1000; i++) {
+        const from = gpsData.getRandomCoordinate();
+        const to = gpsData.getRandomCoordinate();
+
+        
+        times.push(await runOSRMMethod(osrm, 'route', [from, to]));
+    }
+    return times;
+}
+
+async function table(osrm, gpsData) {
+    const times = [];
+    for (let i = 0; i < 250; i++) {
+        const numPoints = Math.floor(RNG() * 3) + 15;
+        const coordinates = [];
+        for (let i = 0; i < numPoints; i++) {
+            coordinates.push(gpsData.getRandomCoordinate());
+        }
+
+        
+        times.push(await runOSRMMethod(osrm, 'table', coordinates));
+    }
+    return times;
+}
+
+async function match(osrm, gpsData) {
+    const times = [];
+    for (let i = 0; i < 1000; i++) {
+        const numPoints = Math.floor(RNG() * 50) + 50;
+        const coordinates = gpsData.getRandomTrack().slice(0, numPoints);
+
+        
+        times.push(await runOSRMMethod(osrm, 'match', coordinates));
+    }
+    return times;
+}
+
+async function trip(osrm, gpsData) {
+    const times = [];
+    for (let i = 0; i < 250; i++) {
+        const numPoints = Math.floor(RNG() * 2) + 5;
+        const coordinates = [];
+        for (let i = 0; i < numPoints; i++) {
+            coordinates.push(gpsData.getRandomCoordinate());
+        }
+
+        
+        times.push(await runOSRMMethod(osrm, 'trip', coordinates));
+    }
+    return times;
+}
+
+function bootstrapConfidenceInterval(data, numSamples = 1000, confidenceLevel = 0.95) {
+    let means = [];
+    let dataLength = data.length;
+
+    for (let i = 0; i < numSamples; i++) {
+        let sample = [];
+        for (let j = 0; j < dataLength; j++) {
+            let randomIndex = Math.floor(RNG() * dataLength);
+            sample.push(data[randomIndex]);
+        }
+        let sampleMean = sample.reduce((a, b) => a + b, 0) / sample.length;
+        means.push(sampleMean);
+    }
+
+    means.sort((a, b) => a - b);
+    let lowerBoundIndex = Math.floor((1 - confidenceLevel) / 2 * numSamples);
+    let upperBoundIndex = Math.floor((1 + confidenceLevel) / 2 * numSamples);
+    let mean = means.reduce((a, b) => a + b, 0) / means.length;
+    let lowerBound = means[lowerBoundIndex];
+    let upperBound = means[upperBoundIndex];
+
+    return { mean: mean, lowerBound: lowerBound, upperBound: upperBound };
+}
+
+function calculateConfidenceInterval(data) {
+    let { mean, lowerBound, upperBound } = bootstrapConfidenceInterval(data);
+    let bestValue = Math.max(...data);
+    let errorMargin = (upperBound - lowerBound) / 2;
+
+    return { mean, errorMargin, bestValue };
+}
+
+async function main() {
+    const args = process.argv.slice(2);
+
+    const {OSRM} = require(args[0]);
+    const path = args[1];
+    const algorithm = args[2].toUpperCase();
+    const method = args[3];
+    const gpsTracesFilePath = args[4];
+    const iterations = parseInt(args[5]);
+
+    const gpsData = new GPSData(gpsTracesFilePath);
+    const osrm = new OSRM({path, algorithm});
+
+
+    const functions = {
+        route: route,
+        table: table,
+        nearest: nearest,
+        match: match,
+        trip: trip
+    };
+    const func = functions[method];
+    if (!func) {
+        throw new Error('Unknown method');
+    }
+    const allTimes = [];
+    for (let i = 0; i < iterations; i++) {
+        RNG = seedrandom(42);
+        allTimes.push((await func(osrm, gpsData)).filter(t => t !== null));
+    }
+
+    const opsPerSec = allTimes.map(times => times.length / times.reduce((a, b) => a + b, 0));
+    const { mean, errorMargin, bestValue } = calculateConfidenceInterval(opsPerSec);
+    console.log(`Ops: ${mean.toFixed(1)} ± ${errorMargin.toFixed(1)} ops/s. Best: ${bestValue.toFixed(1)} ops/s`);
+
+}
+
+main();
@@ -86,9 +86,9 @@ def bootstrap_confidence_interval(data, num_samples=1000, confidence_level=0.95)
    mean = np.mean(means)
    return mean, lower_bound, upper_bound

-def calculate_confidence_interval(data):
+def calculate_confidence_interval(data, min_is_best=True):
    mean, lower, upper = bootstrap_confidence_interval(data)
-    min_value = np.min(data)
+    min_value = np.min(data) if min_is_best else np.max(data)
    return mean, (upper - lower) / 2, min_value


@@ -117,7 +117,7 @@ def main():


    total_time, total_ci, total_best = calculate_confidence_interval(np.sum(all_times, axis=1))
-    ops_per_sec, ops_per_sec_ci, ops_per_sec_best = calculate_confidence_interval(float(all_times.shape[1]) / np.sum(all_times / 1000, axis=1))
+    ops_per_sec, ops_per_sec_ci, ops_per_sec_best = calculate_confidence_interval(float(all_times.shape[1]) / np.sum(all_times / 1000, axis=1), min_is_best=False)
    min_time, min_ci, _ = calculate_confidence_interval(np.min(all_times, axis=1))
    mean_time, mean_ci, _ = calculate_confidence_interval(np.mean(all_times, axis=1))
    median_time, median_ci, _ = calculate_confidence_interval(np.median(all_times, axis=1))
@@ -50,11 +50,13 @@ function measure_peak_ram_and_time {
 }

 function run_benchmarks_for_folder {
+    rm -rf $RESULTS_FOLDER
    mkdir -p $RESULTS_FOLDER

    BENCHMARKS_FOLDER="$BINARIES_FOLDER/src/benchmarks"
-    echo "Running match-bench MLD"
-    perf stat -r 1 $BENCHMARKS_FOLDER/match-bench "$FOLDER/test/data/mld/monaco.osrm" mld #> "$RESULTS_FOLDER/match_mld.bench"
+
+    # echo "Running match-bench MLD"
+    # $BENCHMARKS_FOLDER/match-bench "$FOLDER/test/data/mld/monaco.osrm" mld > "$RESULTS_FOLDER/match_mld.bench"
    # echo "Running match-bench CH"
    # $BENCHMARKS_FOLDER/match-bench "$FOLDER/test/data/ch/monaco.osrm" ch > "$RESULTS_FOLDER/match_ch.bench"
    # echo "Running route-bench MLD"
@@ -70,28 +72,40 @@ function run_benchmarks_for_folder {
    # echo "Running rtree-bench"
    # $BENCHMARKS_FOLDER/rtree-bench "$FOLDER/test/data/monaco.osrm.ramIndex" "$FOLDER/test/data/monaco.osrm.fileIndex" "$FOLDER/test/data/monaco.osrm.nbg_nodes" > "$RESULTS_FOLDER/rtree.bench"

-    # cp -rf $OSM_PBF $FOLDER/data.osm.pbf
+    cp -rf $OSM_PBF $FOLDER/data.osm.pbf
+
+    echo "Running osrm-extract"
+    measure_peak_ram_and_time "$BINARIES_FOLDER/osrm-extract -p $FOLDER/profiles/car.lua $FOLDER/data.osm.pbf" "$RESULTS_FOLDER/osrm_extract.bench"
+    echo "Running osrm-partition"
+    measure_peak_ram_and_time "$BINARIES_FOLDER/osrm-partition $FOLDER/data.osrm" "$RESULTS_FOLDER/osrm_partition.bench"
+    echo "Running osrm-customize"
+    measure_peak_ram_and_time "$BINARIES_FOLDER/osrm-customize $FOLDER/data.osrm" "$RESULTS_FOLDER/osrm_customize.bench"
+    echo "Running osrm-contract"
+    measure_peak_ram_and_time "$BINARIES_FOLDER/osrm-contract $FOLDER/data.osrm" "$RESULTS_FOLDER/osrm_contract.bench"

-    # echo "Running osrm-extract"
-    # measure_peak_ram_and_time "$BINARIES_FOLDER/osrm-extract -p $FOLDER/profiles/car.lua $FOLDER/data.osm.pbf" "$RESULTS_FOLDER/osrm_extract.bench"
-    # echo "Running osrm-partition"
-    # measure_peak_ram_and_time "$BINARIES_FOLDER/osrm-partition $FOLDER/data.osrm" "$RESULTS_FOLDER/osrm_partition.bench"
-    # echo "Running osrm-customize"
-    # measure_peak_ram_and_time "$BINARIES_FOLDER/osrm-customize $FOLDER/data.osrm" "$RESULTS_FOLDER/osrm_customize.bench"
-    # echo "Running osrm-contract"
-    # measure_peak_ram_and_time "$BINARIES_FOLDER/osrm-contract $FOLDER/data.osrm" "$RESULTS_FOLDER/osrm_contract.bench"

    # for ALGORITHM in ch mld; do
    #     for BENCH in nearest table trip route match; do
-    #         echo "Running random $BENCH $ALGORITHM"
+    #         echo "Running node $BENCH $ALGORITHM"
    #         START=$(date +%s.%N)
-    #         $BENCHMARKS_FOLDER/bench "$FOLDER/data.osrm" $ALGORITHM $GPS_TRACES ${BENCH} > "$RESULTS_FOLDER/random_${BENCH}_${ALGORITHM}.bench" 5 || true
+    #         node $SCRIPTS_FOLDER/scripts/ci/bench.js $FOLDER/lib/binding/node_osrm.node $FOLDER/data.osrm $ALGORITHM $BENCH $GPS_TRACES > "$RESULTS_FOLDER/node_${BENCH}_${ALGORITHM}.bench" 5
    #         END=$(date +%s.%N)
    #         DIFF=$(echo "$END - $START" | bc)
    #         echo "Took: ${DIFF}s"
    #     done
    # done

+    for ALGORITHM in mld; do
+        for BENCH in match; do
+            echo "Running random $BENCH $ALGORITHM"
+            START=$(date +%s.%N)
+            $BENCHMARKS_FOLDER/bench "$FOLDER/data.osrm" $ALGORITHM $GPS_TRACES ${BENCH} > "$RESULTS_FOLDER/random_${BENCH}_${ALGORITHM}.bench" 5 || true
+            END=$(date +%s.%N)
+            DIFF=$(echo "$END - $START" | bc)
+            echo "Took: ${DIFF}s"
+        done
+    done
+

    # for ALGORITHM in ch mld; do
    #     $BINARIES_FOLDER/osrm-routed --algorithm $ALGORITHM $FOLDER/data.osrm > /dev/null 2>&1 &
@@ -59,28 +59,22 @@ IF %ERRORLEVEL% NEQ 0 GOTO ERROR

 SET test_region=monaco
 SET test_region_ch=ch\monaco
-SET test_region_corech=corech\monaco
 SET test_region_mld=mld\monaco
 SET test_osm=%test_region%.osm.pbf
-COPY %PROJECT_DIR%\test\data\%test_region%.osm.pbf %test_osm% 
+COPY %PROJECT_DIR%\test\data\%test_region%.osm.pbf %test_osm%
 %CONFIGURATION%\osrm-extract.exe -p %PROJECT_DIR%\profiles\car.lua %test_osm%
 IF %ERRORLEVEL% NEQ 0 GOTO ERROR

 MKDIR ch
 XCOPY %test_region%.osrm.* ch\
 XCOPY %test_region%.osrm ch\
-MKDIR corech
-XCOPY %test_region%.osrm.* corech\
-XCOPY %test_region%.osrm corech\
 MKDIR mld
 XCOPY %test_region%.osrm.* mld\
 XCOPY %test_region%.osrm mld\
 %CONFIGURATION%\osrm-contract.exe %test_region_ch%.osrm
-%CONFIGURATION%\osrm-contract.exe --core 0.8 %test_region_corech%.osrm
 %CONFIGURATION%\osrm-partition.exe %test_region_mld%.osrm
 %CONFIGURATION%\osrm-customize.exe %test_region_mld%.osrm
 XCOPY /Y ch\*.* ..\test\data\ch\
-XCOPY /Y corech\*.* ..\test\data\corech\
 XCOPY /Y mld\*.* ..\test\data\mld\
 unit_tests\%CONFIGURATION%\library-tests.exe
 IF %ERRORLEVEL% NEQ 0 GOTO ERROR
@@ -30,6 +30,9 @@ VTZERO_TAG=v1.1.0
 FMT_PATH="fmtlib/fmt"
 FMT_TAG=v10.2.1

+FLATBUFFERS_PATH="google/flatbuffers"
+FLATBUFFERS_TAG=v24.3.25
+
 function update_subtree () {
    name=$(echo "$1" | tr '[:lower:]' '[:upper:]')
    path=$(tmpvar=${name}_PATH && echo ${!tmpvar})
@@ -53,6 +56,6 @@ function update_subtree () {
 }

 ## Update dependencies
-for dep in osmium sol rapidjson microtar protozero vtzero fmt; do
+for dep in osmium sol rapidjson microtar protozero vtzero fmt flatbuffers; do
    update_subtree $dep
 done
@@ -16,8 +16,8 @@
 #include "osrm/osrm.hpp"
 #include "osrm/status.hpp"

+#include "util/meminfo.hpp"
 #include <boost/assert.hpp>
-
 #include <boost/optional/optional.hpp>
 #include <cstdlib>
 #include <exception>
@@ -134,6 +134,7 @@ struct ConfidenceInterval
    double mean;
    double confidence;
    double min;
+    double max;
 };

 // Helper function to calculate the bootstrap confidence interval
@@ -161,8 +162,10 @@ ConfidenceInterval confidenceInterval(const std::vector<double> &data,
    double upper_bound = means[(int)((1 + confidence_level) / 2 * num_samples)];
    double mean = std::accumulate(means.begin(), means.end(), 0.0) / means.size();

-    ConfidenceInterval ci = {
-        mean, (upper_bound - lower_bound) / 2, *std::min_element(data.begin(), data.end())};
+    ConfidenceInterval ci = {mean,
+                             (upper_bound - lower_bound) / 2,
+                             *std::min_element(data.begin(), data.end()),
+                             *std::max_element(data.begin(), data.end())};
    return ci;
 }

@@ -260,7 +263,7 @@ std::ostream &operator<<(std::ostream &os, Statistics &statistics)
    ConfidenceInterval ops_ci = statistics.ops_per_sec();

    os << "ops: " << ops_ci.mean << " ± " << ops_ci.confidence << " ops/s. "
-       << "best: " << ops_ci.min << "ops/s." << std::endl;
+       << "best: " << ops_ci.max << "ops/s." << std::endl;
    os << "total: " << total_ci.mean << " ± " << total_ci.confidence << "ms. "
       << "best: " << total_ci.min << "ms." << std::endl;
    os << "avg: " << mean_ci.mean << " ± " << mean_ci.confidence << "ms" << std::endl;
@@ -357,8 +360,8 @@ void runRouteBenchmark(const OSRM &osrm, const GPSTraces &gpsTraces, int iterati

                      if (benchmark.radius)
                      {
-                          params.radiuses = std::vector<boost::optional<double>>(
-                              params.coordinates.size(), boost::make_optional(*benchmark.radius));
+                          params.radiuses = std::vector<std::optional<double>>(
+                              params.coordinates.size(), std::make_optional(*benchmark.radius));
                      }

                      engine::api::ResultT result = json::Object();
@@ -652,6 +655,12 @@ try
        std::cerr << "Unknown benchmark: " << benchmarkToRun << std::endl;
        return EXIT_FAILURE;
    }
+
+    std::cout << "Peak RAM: " << std::setprecision(3)
+              << static_cast<double>(osrm::util::PeakRAMUsedInBytes()) /
+                     static_cast<double>((1024 * 1024))
+              << "MB" << std::endl;
+
    return EXIT_SUCCESS;
 }
 catch (const std::exception &e)
@@ -66,8 +66,8 @@ try

        if (benchmark.radius)
        {
-            params.radiuses = std::vector<boost::optional<double>>(
-                params.coordinates.size(), boost::make_optional(*benchmark.radius));
+            params.radiuses = std::vector<std::optional<double>>(
+                params.coordinates.size(), std::make_optional(*benchmark.radius));
        }

        TIMER_START(routes);
@@ -11,7 +11,7 @@
 #include "util/typedefs.hpp"

 #include <boost/assert.hpp>
-#include <boost/optional.hpp>
+#include <optional>

 #include <algorithm>
 #include <iterator>
@@ -215,7 +215,7 @@ util::json::Object makeRouteStep(guidance::RouteStep step, util::json::Value geo

 util::json::Object makeRoute(const guidance::Route &route,
                             util::json::Array legs,
-                             boost::optional<util::json::Value> geometry,
+                             std::optional<util::json::Value> geometry,
                             const char *weight_name)
 {
    util::json::Object json_route;
@@ -12,15 +12,13 @@ bool EngineConfig::IsValid() const
    const auto unlimited_or_more_than = [](const auto v, const auto limit)
    { return v == -1 || v > limit; };

-    const bool limits_valid =
-        unlimited_or_more_than(max_locations_distance_table, 2) &&
-        unlimited_or_more_than(max_locations_map_matching, 2) &&
-        unlimited_or_more_than(max_radius_map_matching, 0) &&
-        unlimited_or_more_than(max_locations_trip, 2) &&
-        unlimited_or_more_than(max_locations_viaroute, 2) &&
-        unlimited_or_more_than(max_results_nearest, 0) &&
-        (!default_radius.has_value() || unlimited_or_more_than(*default_radius, 0)) &&
-        max_alternatives >= 0;
+    const bool limits_valid = unlimited_or_more_than(max_locations_distance_table, 2) &&
+                              unlimited_or_more_than(max_locations_map_matching, 2) &&
+                              unlimited_or_more_than(max_radius_map_matching, 0) &&
+                              unlimited_or_more_than(max_locations_trip, 2) &&
+                              unlimited_or_more_than(max_locations_viaroute, 2) &&
+                              unlimited_or_more_than(max_results_nearest, 0) &&
+                              unlimited_or_more_than(default_radius, 0) && max_alternatives >= 0;

    return ((use_shared_memory && all_path_are_empty) || (use_mmap && storage_config.IsValid()) ||
            storage_config.IsValid()) &&
@@ -194,7 +194,7 @@ Status MatchPlugin::HandleRequest(const RoutingAlgorithmsInterface &algorithms,
            tidied.parameters.radiuses.begin(),
            tidied.parameters.radiuses.end(),
            search_radiuses.begin(),
-            [default_radius = this->default_radius](const boost::optional<double> &maybe_radius)
+            [default_radius = this->default_radius](const std::optional<double> &maybe_radius)
            {
                if (maybe_radius)
                {
@@ -10,7 +10,7 @@
 namespace osrm::engine::plugins
 {

-NearestPlugin::NearestPlugin(const int max_results_, const boost::optional<double> default_radius_)
+NearestPlugin::NearestPlugin(const int max_results_, const std::optional<double> default_radius_)
    : BasePlugin(default_radius_), max_results{max_results_}
 {
 }
@@ -15,7 +15,7 @@ namespace osrm::engine::plugins
 {

 TablePlugin::TablePlugin(const int max_locations_distance_table,
-                         const boost::optional<double> default_radius)
+                         const std::optional<double> default_radius)
    : BasePlugin(default_radius), max_locations_distance_table(max_locations_distance_table)
 {
 }
@@ -17,7 +17,7 @@ namespace osrm::engine::plugins

 ViaRoutePlugin::ViaRoutePlugin(int max_locations_viaroute,
                               int max_alternatives,
-                               boost::optional<double> default_radius)
+                               std::optional<double> default_radius)
    : BasePlugin(default_radius), max_locations_viaroute(max_locations_viaroute),
      max_alternatives(max_alternatives)
 {
@@ -621,27 +621,24 @@ void unpackPackedPaths(InputIt first,
                BOOST_ASSERT(!facade.ExcludeNode(source));
                BOOST_ASSERT(!facade.ExcludeNode(target));

-                // TODO: when structured bindings will be allowed change to
-                // auto [subpath_weight, subpath_source, subpath_target, subpath] = ...
-                EdgeWeight subpath_weight;
-                std::vector<NodeID> subpath_nodes;
-                std::vector<EdgeID> subpath_edges;
-                std::tie(subpath_weight, subpath_nodes, subpath_edges) = search(search_engine_data,
-                                                                                facade,
-                                                                                forward_heap,
-                                                                                reverse_heap,
-                                                                                {},
-                                                                                INVALID_EDGE_WEIGHT,
-                                                                                sublevel,
-                                                                                parent_cell_id);
-                BOOST_ASSERT(!subpath_edges.empty());
-                BOOST_ASSERT(subpath_nodes.size() > 1);
-                BOOST_ASSERT(subpath_nodes.front() == source);
-                BOOST_ASSERT(subpath_nodes.back() == target);
-                unpacked_nodes.insert(
-                    unpacked_nodes.end(), std::next(subpath_nodes.begin()), subpath_nodes.end());
-                unpacked_edges.insert(
-                    unpacked_edges.end(), subpath_edges.begin(), subpath_edges.end());
+                auto unpacked_subpath = search(search_engine_data,
+                                               facade,
+                                               forward_heap,
+                                               reverse_heap,
+                                               {},
+                                               INVALID_EDGE_WEIGHT,
+                                               sublevel,
+                                               parent_cell_id);
+                BOOST_ASSERT(!unpacked_subpath.edges.empty());
+                BOOST_ASSERT(unpacked_subpath.nodes.size() > 1);
+                BOOST_ASSERT(unpacked_subpath.nodes.front() == source);
+                BOOST_ASSERT(unpacked_subpath.nodes.back() == target);
+                unpacked_nodes.insert(unpacked_nodes.end(),
+                                      std::next(unpacked_subpath.nodes.begin()),
+                                      unpacked_subpath.nodes.end());
+                unpacked_edges.insert(unpacked_edges.end(),
+                                      unpacked_subpath.edges.begin(),
+                                      unpacked_subpath.edges.end());
            }
        }

@@ -70,20 +70,19 @@ InternalRouteResult directShortestPathSearch(SearchEngineData<mld::Algorithm> &e
    auto &reverse_heap = *engine_working_data.reverse_heap_1;
    insertNodesInHeaps(forward_heap, reverse_heap, endpoint_candidates);

-    // TODO: when structured bindings will be allowed change to
-    // auto [weight, source_node, target_node, unpacked_edges] = ...
-    EdgeWeight weight = INVALID_EDGE_WEIGHT;
-    std::vector<NodeID> unpacked_nodes;
-    std::vector<EdgeID> unpacked_edges;
-    std::tie(weight, unpacked_nodes, unpacked_edges) = mld::search(engine_working_data,
-                                                                   facade,
-                                                                   forward_heap,
-                                                                   reverse_heap,
-                                                                   {},
-                                                                   INVALID_EDGE_WEIGHT,
-                                                                   endpoint_candidates);
+    auto unpacked_path = mld::search(engine_working_data,
+                                     facade,
+                                     forward_heap,
+                                     reverse_heap,
+                                     {},
+                                     INVALID_EDGE_WEIGHT,
+                                     endpoint_candidates);

-    return extractRoute(facade, weight, endpoint_candidates, unpacked_nodes, unpacked_edges);
+    return extractRoute(facade,
+                        unpacked_path.weight,
+                        endpoint_candidates,
+                        unpacked_path.nodes,
+                        unpacked_path.edges);
 }

 } // namespace osrm::engine::routing_algorithms
@@ -45,7 +45,8 @@ unsigned getMedianSampleTime(const std::vector<unsigned> &timestamps)

 template <typename Algorithm>
 inline void initializeHeap(SearchEngineData<Algorithm> &engine_working_data,
-                           const DataFacade<Algorithm> &facade)
+                           const DataFacade<Algorithm> &facade,
+                           size_t)
 {

    const auto nodes_number = facade.GetNumberOfNodes();
@@ -54,14 +55,92 @@ inline void initializeHeap(SearchEngineData<Algorithm> &engine_working_data,

 template <>
 inline void initializeHeap<mld::Algorithm>(SearchEngineData<mld::Algorithm> &engine_working_data,
-                                           const DataFacade<mld::Algorithm> &facade)
+                                           const DataFacade<mld::Algorithm> &facade,
+                                           size_t max_candidates)
 {

    const auto nodes_number = facade.GetNumberOfNodes();
    const auto border_nodes_number = facade.GetMaxBorderNodeID() + 1;
-    engine_working_data.InitializeOrClearMapMatchingThreadLocalStorage(nodes_number,
-                                                                       border_nodes_number);
+    engine_working_data.InitializeOrClearMapMatchingThreadLocalStorage(
+        nodes_number, border_nodes_number, max_candidates);
 }
+
+#include <fstream>
+#include <iostream>
+
+template <typename T> void saveVectorToFile(const std::vector<T> &data, const std::string &filename)
+{
+    std::ofstream outFile(filename, std::ios::binary);
+    if (!outFile)
+    {
+        std::cerr << "Error opening file for writing: " << filename << std::endl;
+        return;
+    }
+    size_t size = data.size();
+    outFile.write(reinterpret_cast<const char *>(&size), sizeof(size));
+    outFile.write(reinterpret_cast<const char *>(data.data()), size * sizeof(T));
+    outFile.close();
+    if (!outFile.good())
+    {
+        std::cerr << "Error occurred at writing time!" << std::endl;
+    }
+}
+
+template <typename T> bool loadVectorFromFile(std::vector<T> &data, const std::string &filename)
+{
+    std::ifstream inFile(filename, std::ios::binary);
+    if (!inFile)
+    {
+        std::cerr << "Error opening file for reading: " << filename << std::endl;
+        return false;
+    }
+    size_t size;
+    inFile.read(reinterpret_cast<char *>(&size), sizeof(size));
+    data.resize(size);
+    inFile.read(reinterpret_cast<char *>(data.data()), size * sizeof(T));
+    inFile.close();
+    if (!inFile.good())
+    {
+        std::cerr << "Error occurred at reading time!" << std::endl;
+        return false;
+    }
+    return true;
+}
+
+template <typename T> void saveStructToFile(const T &data, const std::string &filename)
+{
+    std::ofstream outFile(filename, std::ios::binary);
+    if (!outFile)
+    {
+        std::cerr << "Error opening file for writing: " << filename << std::endl;
+        return;
+    }
+    outFile.write(reinterpret_cast<const char *>(&data), sizeof(T));
+    outFile.close();
+    if (!outFile.good())
+    {
+        std::cerr << "Error occurred at writing time!" << std::endl;
+    }
+}
+
+template <typename T> bool loadStructFromFile(T &data, const std::string &filename)
+{
+    std::ifstream inFile(filename, std::ios::binary);
+    if (!inFile)
+    {
+        std::cerr << "Error opening file for reading: " << filename << std::endl;
+        return false;
+    }
+    inFile.read(reinterpret_cast<char *>(&data), sizeof(T));
+    inFile.close();
+    if (!inFile.good())
+    {
+        std::cerr << "Error occurred at reading time!" << std::endl;
+        return false;
+    }
+    return true;
+}
+
 } // namespace

 template <typename Algorithm>
@@ -70,7 +149,7 @@ SubMatchingList mapMatching(SearchEngineData<Algorithm> &engine_working_data,
                            const CandidateLists &candidates_list,
                            const std::vector<util::Coordinate> &trace_coordinates,
                            const std::vector<unsigned> &trace_timestamps,
-                            const std::vector<boost::optional<double>> &trace_gps_precision,
+                            const std::vector<std::optional<double>> &trace_gps_precision,
                            const bool allow_splitting)
 {
    map_matching::MatchingConfidence confidence;
@@ -144,9 +223,16 @@ SubMatchingList mapMatching(SearchEngineData<Algorithm> &engine_working_data,
        return sub_matchings;
    }

-    initializeHeap(engine_working_data, facade);
+    size_t max_candidates = 0;
+    for (const auto &candidates : candidates_list)
+    {
+        max_candidates = std::max(max_candidates, candidates.size());
+    }
+
+    initializeHeap(engine_working_data, facade, max_candidates);
    auto &forward_heap = *engine_working_data.map_matching_forward_heap_1;
    auto &reverse_heap = *engine_working_data.map_matching_reverse_heap_1;
+    const auto &reverse_heaps = engine_working_data.map_matching_reverse_heaps;

    std::size_t breakage_begin = map_matching::INVALID_STATE;
    std::vector<std::size_t> split_points;
@@ -225,6 +311,108 @@ SubMatchingList mapMatching(SearchEngineData<Algorithm> &engine_working_data,
                    continue;
                }

+                //    PhantomNode source;
+                //   loadStructFromFile<PhantomNode>(source, "source.bin");
+                std::vector<PhantomNode> target_phantom_nodes;
+                //      loadVectorFromFile(target_phantom_nodes, "target.bin");
+                //      target_phantom_nodes.erase(target_phantom_nodes.begin());
+                //      target_phantom_nodes.erase(target_phantom_nodes.begin());
+                //      target_phantom_nodes.erase(target_phantom_nodes.begin());
+                //      target_phantom_nodes.erase(target_phantom_nodes.begin());
+                //      target_phantom_nodes.pop_back();
+                //      target_phantom_nodes.pop_back();
+                //      target_phantom_nodes.erase(target_phantom_nodes.begin() + 1);
+
+                //                target_phantom_nodes.push_back(target);
+                for (const auto s_prime : util::irange<std::size_t>(0UL, current_viterbi.size()))
+                {
+                    const double emission_pr = emission_log_probabilities[t][s_prime];
+                    double new_value = prev_viterbi[s] + emission_pr;
+                    if (current_viterbi[s_prime] > new_value)
+                    {
+                        continue;
+                    }
+                    target_phantom_nodes.push_back(current_timestamps_list[s_prime].phantom_node);
+                }
+
+// TIMER_START(NEW_DIST);
+
+#define MODE 1
+
+#if MODE == 0
+                auto new_distances =
+                    getNetworkDistances(engine_working_data,
+                                        facade,
+                                        forward_heap,
+                                        reverse_heaps,
+                                        prev_unbroken_timestamps_list[s].phantom_node,
+                                        target_phantom_nodes,
+                                        weight_upper_bound);
+               std::vector<double> old_distances;
+
+                for (const auto &pn : target_phantom_nodes)
+                {
+                    double network_distance =
+                        getNetworkDistance(engine_working_data,
+                                           facade,
+                                           forward_heap,
+                                           reverse_heap,
+                                           prev_unbroken_timestamps_list[s].phantom_node,
+                                           pn,
+                                           weight_upper_bound);
+                    old_distances.push_back(network_distance);
+                }
+
+                 for (size_t i = 0; i < old_distances.size(); ++i)
+                {
+                    if (std::abs(old_distances[i] - new_distances[i]) > 0.01)
+                    {
+                        // saveStructToFile(prev_unbroken_timestamps_list[s].phantom_node,
+                       // "source.bin");
+                        // saveVectorToFile(target_phantom_nodes, "target.bin");
+                        std::cerr << "OOPS " << old_distances[i] << " " << new_distances[i]
+                                  << std::endl;
+                       // std::exit(1);
+                    }
+                }
+
+                auto distances = old_distances;
+#elif MODE == 1 
+               (void)reverse_heap;
+                auto distances =
+                    getNetworkDistances(engine_working_data,
+                                        facade,
+                                        forward_heap,
+                                        reverse_heaps,
+                                        prev_unbroken_timestamps_list[s].phantom_node,
+                                        target_phantom_nodes,
+                                        weight_upper_bound);
+                // TIMER_STOP(NEW_DIST);
+#else
+                // TIMER_START(OLD_DIST);
+                (void)reverse_heaps;
+                std::vector<double> distances;
+
+                for (const auto &pn : target_phantom_nodes)
+                {
+                    double network_distance =
+                        getNetworkDistance(engine_working_data,
+                                           facade,
+                                           forward_heap,
+                                           reverse_heap,
+                                           prev_unbroken_timestamps_list[s].phantom_node,
+                                           pn,
+                                           weight_upper_bound);
+                    distances.push_back(network_distance);
+                }
+#endif
+                // TIMER_STOP(OLD_DIST);
+
+                // std::cerr << "Old: " << TIMER_MSEC(OLD_DIST) << " New: " << TIMER_MSEC(NEW_DIST)
+                //           << std::endl;
+
+               
+                size_t distance_index = 0;
                for (const auto s_prime : util::irange<std::size_t>(0UL, current_viterbi.size()))
                {
                    const double emission_pr = emission_log_probabilities[t][s_prime];
@@ -234,14 +422,16 @@ SubMatchingList mapMatching(SearchEngineData<Algorithm> &engine_working_data,
                        continue;
                    }

-                    double network_distance =
-                        getNetworkDistance(engine_working_data,
-                                           facade,
-                                           forward_heap,
-                                           reverse_heap,
-                                           prev_unbroken_timestamps_list[s].phantom_node,
-                                           current_timestamps_list[s_prime].phantom_node,
-                                           weight_upper_bound);
+                    double network_distance = distances[distance_index];
+                    ++distance_index;
+                    // double network_distance =
+                    //     getNetworkDistance(engine_working_data,
+                    //                        facade,
+                    //                        forward_heap,
+                    //                        reverse_heap,
+                    //                        prev_unbroken_timestamps_list[s].phantom_node,
+                    //                        current_timestamps_list[s_prime].phantom_node,
+                    //                        weight_upper_bound);

                    // get distance diff between loc1/2 and locs/s_prime
                    const auto d_t = std::abs(network_distance - haversine_distance);
@@ -401,6 +591,7 @@ SubMatchingList mapMatching(SearchEngineData<Algorithm> &engine_working_data,
        auto trace_distance = 0.0;
        matching.nodes.reserve(reconstructed_indices.size());
        matching.indices.reserve(reconstructed_indices.size());
+        matching.alternatives_count.reserve(reconstructed_indices.size());
        for (const auto &idx : reconstructed_indices)
        {
            const auto timestamp_index = idx.first;
@@ -428,7 +619,7 @@ SubMatchingList mapMatching(SearchEngineData<Algorithm> &engine_working_data,

        matching.confidence = confidence(trace_distance, matching_distance);

-        sub_matchings.push_back(matching);
+        sub_matchings.emplace_back(std::move(matching));
        sub_matching_begin = sub_matching_end;
    }

@@ -436,24 +627,22 @@ SubMatchingList mapMatching(SearchEngineData<Algorithm> &engine_working_data,
 }

 // CH
-template SubMatchingList
-mapMatching(SearchEngineData<ch::Algorithm> &engine_working_data,
-            const DataFacade<ch::Algorithm> &facade,
-            const CandidateLists &candidates_list,
-            const std::vector<util::Coordinate> &trace_coordinates,
-            const std::vector<unsigned> &trace_timestamps,
-            const std::vector<boost::optional<double>> &trace_gps_precision,
-            const bool allow_splitting);
+template SubMatchingList mapMatching(SearchEngineData<ch::Algorithm> &engine_working_data,
+                                     const DataFacade<ch::Algorithm> &facade,
+                                     const CandidateLists &candidates_list,
+                                     const std::vector<util::Coordinate> &trace_coordinates,
+                                     const std::vector<unsigned> &trace_timestamps,
+                                     const std::vector<std::optional<double>> &trace_gps_precision,
+                                     const bool allow_splitting);

 // MLD
-template SubMatchingList
-mapMatching(SearchEngineData<mld::Algorithm> &engine_working_data,
-            const DataFacade<mld::Algorithm> &facade,
-            const CandidateLists &candidates_list,
-            const std::vector<util::Coordinate> &trace_coordinates,
-            const std::vector<unsigned> &trace_timestamps,
-            const std::vector<boost::optional<double>> &trace_gps_precision,
-            const bool allow_splitting);
+template SubMatchingList mapMatching(SearchEngineData<mld::Algorithm> &engine_working_data,
+                                     const DataFacade<mld::Algorithm> &facade,
+                                     const CandidateLists &candidates_list,
+                                     const std::vector<util::Coordinate> &trace_coordinates,
+                                     const std::vector<unsigned> &trace_timestamps,
+                                     const std::vector<std::optional<double>> &trace_gps_precision,
+                                     const bool allow_splitting);

 } // namespace osrm::engine::routing_algorithms

@@ -9,12 +9,12 @@ template InternalRouteResult
 shortestPathSearch(SearchEngineData<ch::Algorithm> &engine_working_data,
                   const DataFacade<ch::Algorithm> &facade,
                   const std::vector<PhantomNodeCandidates> &waypoint_candidates,
-                   const boost::optional<bool> continue_straight_at_waypoint);
+                   const std::optional<bool> continue_straight_at_waypoint);

 template InternalRouteResult
 shortestPathSearch(SearchEngineData<mld::Algorithm> &engine_working_data,
                   const DataFacade<mld::Algorithm> &facade,
                   const std::vector<PhantomNodeCandidates> &waypoint_candidates,
-                   const boost::optional<bool> continue_straight_at_waypoint);
+                   const std::optional<bool> continue_straight_at_waypoint);

 } // namespace osrm::engine::routing_algorithms
@@ -5,16 +5,20 @@ namespace osrm::engine

 // CH heaps
 using CH = routing_algorithms::ch::Algorithm;
-SearchEngineData<CH>::SearchEngineHeapPtr SearchEngineData<CH>::forward_heap_1;
-SearchEngineData<CH>::SearchEngineHeapPtr SearchEngineData<CH>::reverse_heap_1;
-SearchEngineData<CH>::SearchEngineHeapPtr SearchEngineData<CH>::forward_heap_2;
-SearchEngineData<CH>::SearchEngineHeapPtr SearchEngineData<CH>::reverse_heap_2;
-SearchEngineData<CH>::SearchEngineHeapPtr SearchEngineData<CH>::forward_heap_3;
-SearchEngineData<CH>::SearchEngineHeapPtr SearchEngineData<CH>::reverse_heap_3;
-SearchEngineData<CH>::SearchEngineHeapPtr SearchEngineData<CH>::map_matching_forward_heap_1;
-SearchEngineData<CH>::SearchEngineHeapPtr SearchEngineData<CH>::map_matching_reverse_heap_1;
+thread_local SearchEngineData<CH>::SearchEngineHeapPtr SearchEngineData<CH>::forward_heap_1;
+thread_local SearchEngineData<CH>::SearchEngineHeapPtr SearchEngineData<CH>::reverse_heap_1;
+thread_local SearchEngineData<CH>::SearchEngineHeapPtr SearchEngineData<CH>::forward_heap_2;
+thread_local SearchEngineData<CH>::SearchEngineHeapPtr SearchEngineData<CH>::reverse_heap_2;
+thread_local SearchEngineData<CH>::SearchEngineHeapPtr SearchEngineData<CH>::forward_heap_3;
+thread_local SearchEngineData<CH>::SearchEngineHeapPtr SearchEngineData<CH>::reverse_heap_3;
+thread_local SearchEngineData<CH>::SearchEngineHeapPtr
+    SearchEngineData<CH>::map_matching_forward_heap_1;
+thread_local SearchEngineData<CH>::SearchEngineHeapPtr
+    SearchEngineData<CH>::map_matching_reverse_heap_1;
+thread_local std::vector<typename SearchEngineData<CH>::SearchEngineHeapPtr>
+    SearchEngineData<CH>::map_matching_reverse_heaps;

-SearchEngineData<CH>::ManyToManyHeapPtr SearchEngineData<CH>::many_to_many_heap;
+thread_local SearchEngineData<CH>::ManyToManyHeapPtr SearchEngineData<CH>::many_to_many_heap;

 void SearchEngineData<CH>::InitializeOrClearMapMatchingThreadLocalStorage(unsigned number_of_nodes)
 {
@@ -114,14 +118,18 @@ void SearchEngineData<CH>::InitializeOrClearManyToManyThreadLocalStorage(unsigne

 // MLD
 using MLD = routing_algorithms::mld::Algorithm;
-SearchEngineData<MLD>::SearchEngineHeapPtr SearchEngineData<MLD>::forward_heap_1;
-SearchEngineData<MLD>::SearchEngineHeapPtr SearchEngineData<MLD>::reverse_heap_1;
-SearchEngineData<MLD>::MapMatchingHeapPtr SearchEngineData<MLD>::map_matching_forward_heap_1;
-SearchEngineData<MLD>::MapMatchingHeapPtr SearchEngineData<MLD>::map_matching_reverse_heap_1;
-SearchEngineData<MLD>::ManyToManyHeapPtr SearchEngineData<MLD>::many_to_many_heap;
+thread_local SearchEngineData<MLD>::SearchEngineHeapPtr SearchEngineData<MLD>::forward_heap_1;
+thread_local SearchEngineData<MLD>::SearchEngineHeapPtr SearchEngineData<MLD>::reverse_heap_1;
+thread_local SearchEngineData<MLD>::MapMatchingHeapPtr
+    SearchEngineData<MLD>::map_matching_forward_heap_1;
+thread_local SearchEngineData<MLD>::MapMatchingHeapPtr
+    SearchEngineData<MLD>::map_matching_reverse_heap_1;
+thread_local SearchEngineData<MLD>::ManyToManyHeapPtr SearchEngineData<MLD>::many_to_many_heap;
+thread_local std::vector<typename SearchEngineData<MLD>::MapMatchingHeapPtr>
+    SearchEngineData<MLD>::map_matching_reverse_heaps;

 void SearchEngineData<MLD>::InitializeOrClearMapMatchingThreadLocalStorage(
-    unsigned number_of_nodes, unsigned number_of_boundary_nodes)
+    unsigned number_of_nodes, unsigned number_of_boundary_nodes, size_t max_candidates)
 {
    if (map_matching_forward_heap_1.get())
    {
@@ -142,6 +150,16 @@ void SearchEngineData<MLD>::InitializeOrClearMapMatchingThreadLocalStorage(
        map_matching_reverse_heap_1.reset(
            new MapMatchingQueryHeap(number_of_nodes, number_of_boundary_nodes));
    }
+
+    if (max_candidates > map_matching_reverse_heaps.size())
+    {
+        size_t to_add = max_candidates - map_matching_reverse_heaps.size();
+        for (unsigned i = 0; i < to_add; ++i)
+        {
+            map_matching_reverse_heaps.emplace_back(
+                new MapMatchingQueryHeap(number_of_nodes, number_of_boundary_nodes));
+        }
+    }
 }

 void SearchEngineData<MLD>::InitializeOrClearFirstThreadLocalStorage(
@@ -178,4 +196,4 @@ void SearchEngineData<MLD>::InitializeOrClearManyToManyThreadLocalStorage(
        many_to_many_heap.reset(new ManyToManyQueryHeap(number_of_nodes, number_of_boundary_nodes));
    }
 }
-} // namespace osrm::engine
+} // namespace osrm::engine
@@ -23,8 +23,6 @@
 #include <vector>

 #ifdef _MSC_VER
-#if (_MSC_VER >= 1928)
-#ifdef _DEBUG
 namespace osrm
 {
 namespace extractor
@@ -37,8 +35,6 @@ const ByEdgeOrByMeterValue::ValueByMeter ByEdgeOrByMeterValue::by_meter;
 } // namespace extractor
 } // namespace osrm
 #endif
-#endif
-#endif

 namespace osrm::extractor
 {
@@ -28,8 +28,8 @@ template <typename ParameterT,
          typename GrammarT,
          typename std::enable_if<detail::is_parameter_t<ParameterT>::value, int>::type = 0,
          typename std::enable_if<detail::is_grammar_t<GrammarT>::value, int>::type = 0>
-boost::optional<ParameterT> parseParameters(std::string::iterator &iter,
-                                            const std::string::iterator end)
+std::optional<ParameterT> parseParameters(std::string::iterator &iter,
+                                          const std::string::iterator end)
 {
    using It = std::decay<decltype(iter)>::type;

@@ -56,52 +56,52 @@ boost::optional<ParameterT> parseParameters(std::string::iterator &iter,
        // as normal parser error
    }

-    return boost::none;
+    return std::nullopt;
 }
 } // namespace detail

 template <>
-boost::optional<engine::api::RouteParameters> parseParameters(std::string::iterator &iter,
-                                                              const std::string::iterator end)
+std::optional<engine::api::RouteParameters> parseParameters(std::string::iterator &iter,
+                                                            const std::string::iterator end)
 {
    return detail::parseParameters<engine::api::RouteParameters, RouteParametersGrammar<>>(iter,
                                                                                           end);
 }

 template <>
-boost::optional<engine::api::TableParameters> parseParameters(std::string::iterator &iter,
-                                                              const std::string::iterator end)
+std::optional<engine::api::TableParameters> parseParameters(std::string::iterator &iter,
+                                                            const std::string::iterator end)
 {
    return detail::parseParameters<engine::api::TableParameters, TableParametersGrammar<>>(iter,
                                                                                           end);
 }

 template <>
-boost::optional<engine::api::NearestParameters> parseParameters(std::string::iterator &iter,
-                                                                const std::string::iterator end)
+std::optional<engine::api::NearestParameters> parseParameters(std::string::iterator &iter,
+                                                              const std::string::iterator end)
 {
    return detail::parseParameters<engine::api::NearestParameters, NearestParametersGrammar<>>(iter,
                                                                                               end);
 }

 template <>
-boost::optional<engine::api::TripParameters> parseParameters(std::string::iterator &iter,
-                                                             const std::string::iterator end)
+std::optional<engine::api::TripParameters> parseParameters(std::string::iterator &iter,
+                                                           const std::string::iterator end)
 {
    return detail::parseParameters<engine::api::TripParameters, TripParametersGrammar<>>(iter, end);
 }

 template <>
-boost::optional<engine::api::MatchParameters> parseParameters(std::string::iterator &iter,
-                                                              const std::string::iterator end)
+std::optional<engine::api::MatchParameters> parseParameters(std::string::iterator &iter,
+                                                            const std::string::iterator end)
 {
    return detail::parseParameters<engine::api::MatchParameters, MatchParametersGrammar<>>(iter,
                                                                                           end);
 }

 template <>
-boost::optional<engine::api::TileParameters> parseParameters(std::string::iterator &iter,
-                                                             const std::string::iterator end)
+std::optional<engine::api::TileParameters> parseParameters(std::string::iterator &iter,
+                                                           const std::string::iterator end)
 {
    return detail::parseParameters<engine::api::TileParameters, TileParametersGrammar<>>(iter, end);
 }
@@ -65,7 +65,7 @@ struct URLParser final : qi::grammar<Iterator, Into>
 namespace osrm::server::api
 {

-boost::optional<ParsedURL> parseURL(std::string::iterator &iter, const std::string::iterator end)
+std::optional<ParsedURL> parseURL(std::string::iterator &iter, const std::string::iterator end)
 {
    using It = std::decay<decltype(iter)>::type;

@@ -77,7 +77,7 @@ boost::optional<ParsedURL> parseURL(std::string::iterator &iter, const std::stri
        const auto ok = boost::spirit::qi::parse(iter, end, parser(boost::phoenix::val(iter)), out);

        if (ok && iter == end)
-            return boost::make_optional(out);
+            return std::make_optional(out);
    }
    catch (const qi::expectation_failure<It> &failure)
    {
@@ -86,7 +86,7 @@ boost::optional<ParsedURL> parseURL(std::string::iterator &iter, const std::stri
        iter = failure.first;
    }

-    return boost::none;
+    return std::nullopt;
 }

 } // namespace osrm::server::api
@@ -46,25 +46,16 @@ return_code parseArguments(int argc,
        boost::program_options::value<unsigned int>(&contractor_config.requested_num_threads)
            ->default_value(std::thread::hardware_concurrency()),
        "Number of threads to use")(
-        "core,k",
-        boost::program_options::value<double>(&contractor_config.core_factor)->default_value(1.0),
-        "DEPRECATED: Will always be 1.0. Percentage of the graph (in vertices) to contract "
-        "[0..1].")("segment-speed-file",
-                   boost::program_options::value<std::vector<std::string>>(
-                       &contractor_config.updater_config.segment_speed_lookup_paths)
-                       ->composing(),
-                   "Lookup files containing nodeA, nodeB, speed data to adjust edge weights")(
+        "segment-speed-file",
+        boost::program_options::value<std::vector<std::string>>(
+            &contractor_config.updater_config.segment_speed_lookup_paths)
+            ->composing(),
+        "Lookup files containing nodeA, nodeB, speed data to adjust edge weights")(
        "turn-penalty-file",
        boost::program_options::value<std::vector<std::string>>(
            &contractor_config.updater_config.turn_penalty_lookup_paths)
            ->composing(),
        "Lookup files containing from_, to_, via_nodes, and turn penalties to adjust turn weights")(
-        "level-cache,o",
-        boost::program_options::bool_switch(&contractor_config.use_cached_priority)
-            ->default_value(false),
-        "DEPRECATED: Will always be false. Use .level file to retain the contraction level for "
-        "each "
-        "node from the last run.")(
        "edge-weight-updates-over-factor",
        boost::program_options::value<double>(
            &contractor_config.updater_config.log_edge_updates_factor)
@@ -186,7 +186,7 @@ inline unsigned generateServerProgramOptions(const int argc,
         value<double>(&config.max_radius_map_matching)->default_value(-1.0),
         "Max. radius size supported in map matching query. Default: unlimited.") //
        ("default-radius",
-         value<boost::optional<double>>(&config.default_radius)->default_value(-1.0),
+         value<double>(&config.default_radius)->default_value(-1.0),
         "Default radius size for queries. Default: unlimited.");

    // hidden options, will be allowed on command line, but will not be shown to the user
@@ -1,41 +0,0 @@
-:: Copyright 2018 Google Inc. All rights reserved.
-::
-:: Licensed under the Apache License, Version 2.0 (the "License");
-:: you may not use this file except in compliance with the License.
-:: You may obtain a copy of the License at
-::
-::     http://www.apache.org/licenses/LICENSE-2.0
-::
-:: Unless required by applicable law or agreed to in writing, software
-:: distributed under the License is distributed on an "AS IS" BASIS,
-:: WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-:: See the License for the specific language governing permissions and
-:: limitations under the License.
-set buildtype=Release
-if "%1"=="-b" set buildtype=%2
-
-cd tests
-call generate_code.bat -b %buildtype% || goto FAIL
-
-:: TODO: Release and Debug builds produce differences here for some reason.
-git checkout HEAD -- monster_test.bfbs
-git checkout HEAD -- arrays_test.bfbs
-
-git -c core.autocrlf=true diff --exit-code --quiet || goto :DIFFFOUND
-goto SUCCESS
-
-:DIFFFOUND
-@echo "" >&2
-@echo "ERROR: ********************************************************" >&2
-@echo "ERROR: The following differences were found after running the" >&2
-@echo "ERROR: tests/generate_code.sh script.  Maybe you forgot to run" >&2
-@echo "ERROR: it after making changes in a generator or schema?" >&2
-@echo "ERROR: ********************************************************" >&2
-@echo "" >&2
-@git -c core.autocrlf=true --no-pager diff --binary
-
-:FAIL
-set EXITCODE=1
-:SUCCESS
-cd ..
-EXIT /B %EXITCODE%
@@ -1,18 +1,38 @@
 ---
 buildifier: latest
+bazel: 6.4.0
 platforms:
-  ubuntu1604:
-    build_targets:
-    - "..."
-    test_targets:
-    - "..."
  ubuntu1804:
+    environment:
+      CC: clang
+      SWIFT_VERSION: "5.5.3"
+      SWIFT_HOME: "$HOME/swift-$SWIFT_VERSION"
+      PATH: "$PATH:$SWIFT_HOME/usr/bin"
+    shell_commands:
+      - "echo --- Downloading and extracting Swift $SWIFT_VERSION to $SWIFT_HOME"
+      - "mkdir $SWIFT_HOME"
+      - "curl https://download.swift.org/swift-${SWIFT_VERSION}-release/ubuntu1804/swift-${SWIFT_VERSION}-RELEASE/swift-${SWIFT_VERSION}-RELEASE-ubuntu18.04.tar.gz | tar xvz --strip-components=1 -C $SWIFT_HOME"
    build_targets:
-    - "..."
+    - "//..."
    test_targets:
-    - "..."
+    - "//..."
+  ubuntu2004:
+    environment:
+      CC: clang
+      SWIFT_VERSION: "5.5.3"
+      SWIFT_HOME: "$HOME/swift-$SWIFT_VERSION"
+      PATH: "$PATH:$SWIFT_HOME/usr/bin"
+    shell_commands:
+      - "echo --- Downloading and extracting Swift $SWIFT_VERSION to $SWIFT_HOME"
+      - "mkdir $SWIFT_HOME"
+      - "curl https://download.swift.org/swift-${SWIFT_VERSION}-release/ubuntu2004/swift-${SWIFT_VERSION}-RELEASE/swift-${SWIFT_VERSION}-RELEASE-ubuntu20.04.tar.gz | tar xvz --strip-components=1 -C $SWIFT_HOME"
+    build_targets:
+    - "//..."
+    test_targets:
+    - "//..."
  macos:
+    xcode_version: "14.2"
    build_targets:
-    - "..."
+    - "//..."
    test_targets:
-    - "..."
+    - "//..."
@@ -0,0 +1 @@
+node_modules
@@ -0,0 +1,4 @@
+# We cannot use "common" here because the "version" command doesn't support
+# --deleted_packages. We need to specify it for both build and query instead.
+build --deleted_packages=tests/ts/bazel_repository_test_dir
+query --deleted_packages=tests/ts/bazel_repository_test_dir
@@ -0,0 +1,347 @@
+---
+FormatStyle: "file"
+WarningsAsErrors: "*"
+HeaderFilterRegex: ".*"
+Checks: "google-build-explicit-make-pair,
+         google-build-namespaces,
+         google-build-using-namespace,
+         google-default-arguments,
+         google-explicit-constructor,
+         google-global-names-in-headers,
+         google-objc-avoid-nsobject-new,
+         google-objc-avoid-throwing-exception,
+         google-objc-function-naming,
+         google-objc-global-variable-declaration,
+         google-readability-avoid-underscore-in-googletest-name,
+         google-readability-braces-around-statements,
+         google-readability-casting,
+         google-readability-function-size,
+         google-readability-namespace-comments,
+         google-runtime-int,
+         google-runtime-operator,
+         google-upgrade-googletest-case,
+         clang-analyzer-apiModeling.StdCLibraryFunctions,
+         clang-analyzer-apiModeling.TrustNonnull,
+         clang-analyzer-apiModeling.google.GTest,
+         clang-analyzer-apiModeling.llvm.CastValue,
+         clang-analyzer-apiModeling.llvm.ReturnValue,
+         clang-analyzer-core.CallAndMessage,
+         clang-analyzer-core.CallAndMessageModeling,
+         clang-analyzer-core.DivideZero,
+         clang-analyzer-core.DynamicTypePropagation,
+         clang-analyzer-core.NonNullParamChecker,
+         clang-analyzer-core.NonnilStringConstants,
+         clang-analyzer-core.NullDereference,
+         clang-analyzer-core.StackAddrEscapeBase,
+         clang-analyzer-core.StackAddressEscape,
+         clang-analyzer-core.UndefinedBinaryOperatorResult,
+         clang-analyzer-core.VLASize,
+         clang-analyzer-core.builtin.BuiltinFunctions,
+         clang-analyzer-core.builtin.NoReturnFunctions,
+         clang-analyzer-core.uninitialized.ArraySubscript,
+         clang-analyzer-core.uninitialized.Assign,
+         clang-analyzer-core.uninitialized.Branch,
+         clang-analyzer-core.uninitialized.CapturedBlockVariable,
+         clang-analyzer-core.uninitialized.UndefReturn,
+         clang-analyzer-cplusplus.InnerPointer,
+         clang-analyzer-cplusplus.Move,
+         clang-analyzer-cplusplus.NewDelete,
+         clang-analyzer-cplusplus.NewDeleteLeaks,
+         clang-analyzer-cplusplus.PlacementNew,
+         clang-analyzer-cplusplus.PureVirtualCall,
+         clang-analyzer-cplusplus.SelfAssignment,
+         clang-analyzer-cplusplus.SmartPtrModeling,
+         clang-analyzer-cplusplus.StringChecker,
+         clang-analyzer-cplusplus.VirtualCallModeling,
+         clang-analyzer-deadcode.DeadStores,
+         clang-analyzer-fuchsia.HandleChecker,
+         clang-analyzer-nullability.NullPassedToNonnull,
+         clang-analyzer-nullability.NullReturnedFromNonnull,
+         clang-analyzer-nullability.NullabilityBase,
+         clang-analyzer-nullability.NullableDereferenced,
+         clang-analyzer-nullability.NullablePassedToNonnull,
+         clang-analyzer-nullability.NullableReturnedFromNonnull,
+         clang-analyzer-optin.cplusplus.UninitializedObject,
+         clang-analyzer-optin.cplusplus.VirtualCall,
+         clang-analyzer-optin.mpi.MPI-Checker,
+         clang-analyzer-optin.osx.OSObjectCStyleCast,
+         clang-analyzer-optin.osx.cocoa.localizability.EmptyLocalizationContextChecker,
+         clang-analyzer-optin.osx.cocoa.localizability.NonLocalizedStringChecker,
+         clang-analyzer-optin.performance.GCDAntipattern,
+         clang-analyzer-optin.performance.Padding,
+         clang-analyzer-optin.portability.UnixAPI,
+         clang-analyzer-osx.API,
+         clang-analyzer-osx.MIG,
+         clang-analyzer-osx.NSOrCFErrorDerefChecker,
+         clang-analyzer-osx.NumberObjectConversion,
+         clang-analyzer-osx.OSObjectRetainCount,
+         clang-analyzer-osx.ObjCProperty,
+         clang-analyzer-osx.SecKeychainAPI,
+         clang-analyzer-osx.cocoa.AtSync,
+         clang-analyzer-osx.cocoa.AutoreleaseWrite,
+         clang-analyzer-osx.cocoa.ClassRelease,
+         clang-analyzer-osx.cocoa.Dealloc,
+         clang-analyzer-osx.cocoa.IncompatibleMethodTypes,
+         clang-analyzer-osx.cocoa.Loops,
+         clang-analyzer-osx.cocoa.MissingSuperCall,
+         clang-analyzer-osx.cocoa.NSAutoreleasePool,
+         clang-analyzer-osx.cocoa.NSError,
+         clang-analyzer-osx.cocoa.NilArg,
+         clang-analyzer-osx.cocoa.NonNilReturnValue,
+         clang-analyzer-osx.cocoa.ObjCGenerics,
+         clang-analyzer-osx.cocoa.RetainCount,
+         clang-analyzer-osx.cocoa.RetainCountBase,
+         clang-analyzer-osx.cocoa.RunLoopAutoreleaseLeak,
+         clang-analyzer-osx.cocoa.SelfInit,
+         clang-analyzer-osx.cocoa.SuperDealloc,
+         clang-analyzer-osx.cocoa.UnusedIvars,
+         clang-analyzer-osx.cocoa.VariadicMethodTypes,
+         clang-analyzer-osx.coreFoundation.CFError,
+         clang-analyzer-osx.coreFoundation.CFNumber,
+         clang-analyzer-osx.coreFoundation.CFRetainRelease,
+         clang-analyzer-osx.coreFoundation.containers.OutOfBounds,
+         clang-analyzer-osx.coreFoundation.containers.PointerSizedValues,
+         clang-analyzer-security.FloatLoopCounter,
+         clang-analyzer-security.insecureAPI.DeprecatedOrUnsafeBufferHandling,
+         clang-analyzer-security.insecureAPI.SecuritySyntaxChecker,
+         clang-analyzer-security.insecureAPI.UncheckedReturn,
+         clang-analyzer-security.insecureAPI.bcmp,
+         clang-analyzer-security.insecureAPI.bcopy,
+         clang-analyzer-security.insecureAPI.bzero,
+         clang-analyzer-security.insecureAPI.decodeValueOfObjCType,
+         clang-analyzer-security.insecureAPI.getpw,
+         clang-analyzer-security.insecureAPI.gets,
+         clang-analyzer-security.insecureAPI.mkstemp,
+         clang-analyzer-security.insecureAPI.mktemp,
+         clang-analyzer-security.insecureAPI.rand,
+         clang-analyzer-security.insecureAPI.strcpy,
+         clang-analyzer-security.insecureAPI.vfork,
+         clang-analyzer-unix.API,
+         clang-analyzer-unix.DynamicMemoryModeling,
+         clang-analyzer-unix.Malloc,
+         clang-analyzer-unix.MallocSizeof,
+         clang-analyzer-unix.MismatchedDeallocator,
+         clang-analyzer-unix.Vfork,
+         clang-analyzer-unix.cstring.BadSizeArg,
+         clang-analyzer-unix.cstring.CStringModeling,
+         clang-analyzer-unix.cstring.NullArg,
+         clang-analyzer-valist.CopyToSelf,
+         clang-analyzer-valist.Uninitialized,
+         clang-analyzer-valist.Unterminated,
+         clang-analyzer-valist.ValistBase,
+         clang-analyzer-webkit.NoUncountedMemberChecker,
+         clang-analyzer-webkit.RefCntblBaseVirtualDtor,
+         clang-analyzer-webkit.UncountedLambdaCapturesChecker,
+
+################################################ Optional checks ################################################
+
+         #google-readability-todo,
+         #bugprone-argument-comment,
+         #bugprone-assert-side-effect,
+         #bugprone-bad-signal-to-kill-thread,
+         #bugprone-bool-pointer-implicit-conversion,
+         #bugprone-branch-clone,
+         #bugprone-copy-constructor-init,
+         #bugprone-dangling-handle,
+         #bugprone-dynamic-static-initializers,
+         #bugprone-easily-swappable-parameters,
+         #bugprone-exception-escape,
+         #bugprone-fold-init-type,
+         #bugprone-forward-declaration-namespace,
+         #bugprone-forwarding-reference-overload,
+         #bugprone-implicit-widening-of-multiplication-result,
+         #bugprone-inaccurate-erase,
+         #bugprone-incorrect-roundings,
+         #bugprone-infinite-loop,
+         #bugprone-integer-division,
+         #bugprone-lambda-function-name,
+         #bugprone-macro-parentheses,
+         #bugprone-macro-repeated-side-effects,
+         #bugprone-misplaced-operator-in-strlen-in-alloc,
+         #bugprone-misplaced-pointer-arithmetic-in-alloc,
+         #bugprone-misplaced-widening-cast,
+         #bugprone-move-forwarding-reference,
+         #bugprone-multiple-statement-macro,
+         #bugprone-narrowing-conversions,
+         #bugprone-no-escape,
+         #bugprone-not-null-terminated-result,
+         #bugprone-parent-virtual-call,
+         #bugprone-posix-return,
+         #bugprone-redundant-branch-condition,
+         #bugprone-reserved-identifier,
+         #bugprone-signal-handler,
+         #bugprone-signed-char-misuse,
+         #bugprone-sizeof-container,
+         #bugprone-sizeof-expression,
+         #bugprone-spuriously-wake-up-functions,
+         #bugprone-string-constructor,
+         #bugprone-string-integer-assignment,
+         #bugprone-string-literal-with-embedded-nul,
+         #bugprone-stringview-nullptr,
+         #bugprone-suspicious-enum-usage,
+         #bugprone-suspicious-include,
+         #bugprone-suspicious-memory-comparison,
+         #bugprone-suspicious-memset-usage,
+         #bugprone-suspicious-missing-comma,
+         #bugprone-suspicious-semicolon,
+         #bugprone-suspicious-string-compare,
+         #bugprone-swapped-arguments,
+         #bugprone-terminating-continue,
+         #bugprone-throw-keyword-missing,
+         #bugprone-too-small-loop-variable,
+         #bugprone-undefined-memory-manipulation,
+         #bugprone-undelegated-constructor,
+         #bugprone-unhandled-exception-at-new,
+         #bugprone-unhandled-self-assignment,
+         #bugprone-unused-raii,
+         #bugprone-unused-return-value,
+         #bugprone-use-after-move,
+         #bugprone-virtual-near-miss,
+         #cppcoreguidelines-avoid-c-arrays,
+         #cppcoreguidelines-avoid-goto,
+         #cppcoreguidelines-avoid-magic-numbers,
+         #cppcoreguidelines-avoid-non-const-global-variables,
+         #cppcoreguidelines-c-copy-assignment-signature,
+         #cppcoreguidelines-explicit-virtual-functions,
+         #cppcoreguidelines-init-variables,
+         #cppcoreguidelines-interfaces-global-init,
+         #cppcoreguidelines-macro-usage,
+         #cppcoreguidelines-narrowing-conversions,
+         #cppcoreguidelines-no-malloc,
+         #cppcoreguidelines-non-private-member-variables-in-classes,
+         #cppcoreguidelines-owning-memory,
+         #cppcoreguidelines-prefer-member-initializer,
+         #cppcoreguidelines-pro-bounds-array-to-pointer-decay,
+         #cppcoreguidelines-pro-bounds-constant-array-index,
+         #cppcoreguidelines-pro-bounds-pointer-arithmetic,
+         #cppcoreguidelines-pro-type-const-cast,
+         #cppcoreguidelines-pro-type-cstyle-cast,
+         #cppcoreguidelines-pro-type-member-init,
+         #cppcoreguidelines-pro-type-reinterpret-cast,
+         #cppcoreguidelines-pro-type-static-cast-downcast,
+         #cppcoreguidelines-pro-type-union-access,
+         #cppcoreguidelines-pro-type-vararg,
+         #cppcoreguidelines-slicing,
+         #cppcoreguidelines-special-member-functions,
+         #cppcoreguidelines-virtual-class-destructor,
+         #hicpp-avoid-c-arrays,
+         #hicpp-avoid-goto,
+         #hicpp-braces-around-statements,
+         #hicpp-deprecated-headers,
+         #hicpp-exception-baseclass,
+         #hicpp-explicit-conversions,
+         #hicpp-function-size,
+         #hicpp-invalid-access-moved,
+         #hicpp-member-init,
+         #hicpp-move-const-arg,
+         #hicpp-multiway-paths-covered,
+         #hicpp-named-parameter,
+         #hicpp-new-delete-operators,
+         #hicpp-no-array-decay,
+         #hicpp-no-assembler,
+         #hicpp-no-malloc,
+         #hicpp-noexcept-move,
+         #hicpp-signed-bitwise,
+         #hicpp-special-member-functions,
+         #hicpp-static-assert,
+         #hicpp-undelegated-constructor,
+         #hicpp-uppercase-literal-suffix,
+         #hicpp-use-auto,
+         #hicpp-use-emplace,
+         #hicpp-use-equals-default,
+         #hicpp-use-equals-delete,
+         #hicpp-use-noexcept,
+         #hicpp-use-nullptr,
+         #hicpp-use-override,
+         #hicpp-vararg,
+         #modernize-avoid-bind,
+         #modernize-avoid-c-arrays,
+         #modernize-concat-nested-namespaces,
+         #modernize-deprecated-headers,
+         #modernize-deprecated-ios-base-aliases,
+         #modernize-loop-convert,
+         #modernize-make-shared,
+         #modernize-make-unique,
+         #modernize-pass-by-value,
+         #modernize-raw-string-literal,
+         #modernize-redundant-void-arg,
+         #modernize-replace-auto-ptr,
+         #modernize-replace-disallow-copy-and-assign-macro,
+         #modernize-replace-random-shuffle,
+         #modernize-return-braced-init-list,
+         #modernize-shrink-to-fit,
+         #modernize-unary-static-assert,
+         #modernize-use-auto,
+         #modernize-use-bool-literals,
+         #modernize-use-default-member-init,
+         #modernize-use-emplace,
+         #modernize-use-equals-default,
+         #modernize-use-equals-delete,
+         #modernize-use-nodiscard,
+         #modernize-use-noexcept,
+         #modernize-use-nullptr,
+         #modernize-use-override,
+         #modernize-use-trailing-return-type,
+         #modernize-use-transparent-functors,
+         #modernize-use-uncaught-exceptions,
+         #modernize-use-using,
+         #performance-faster-string-find,
+         #performance-for-range-copy,
+         #performance-implicit-conversion-in-loop,
+         #performance-inefficient-algorithm,
+         #performance-inefficient-string-concatenation,
+         #performance-inefficient-vector-operation,
+         #performance-move-const-arg,
+         #performance-move-constructor-init,
+         #performance-no-automatic-move,
+         #performance-no-int-to-ptr,
+         #performance-noexcept-move-constructor,
+         #performance-trivially-destructible,
+         #performance-type-promotion-in-math-fn,
+         #performance-unnecessary-copy-initialization,
+         #performance-unnecessary-value-param,
+         #portability-restrict-system-includes,
+         #portability-simd-intrinsics,
+         #readability-avoid-const-params-in-decls,
+         #readability-braces-around-statements,
+         #readability-const-return-type,
+         #readability-container-contains,
+         #readability-container-data-pointer,
+         #readability-container-size-empty,
+         #readability-convert-member-functions-to-static,
+         #readability-delete-null-pointer,
+         #readability-duplicate-include,
+         #readability-else-after-return,
+         #readability-function-cognitive-complexity,
+         #readability-function-size,
+         #readability-identifier-length,
+         #readability-identifier-naming,
+         #readability-implicit-bool-conversion,
+         #readability-inconsistent-declaration-parameter-name,
+         #readability-isolate-declaration,
+         #readability-magic-numbers,
+         #readability-make-member-function-const,
+         #readability-misleading-indentation,
+         #readability-misplaced-array-index,
+         #readability-named-parameter,
+         #readability-non-const-parameter,
+         #readability-qualified-auto,
+         #readability-redundant-access-specifiers,
+         #readability-redundant-control-flow,
+         #readability-redundant-declaration,
+         #readability-redundant-function-ptr-dereference,
+         #readability-redundant-member-init,
+         #readability-redundant-preprocessor,
+         #readability-redundant-smartptr-get,
+         #readability-redundant-string-cstr,
+         #readability-redundant-string-init,
+         #readability-simplify-boolean-expr,
+         #readability-simplify-subscript-expr,
+         #readability-static-accessed-through-instance,
+         #readability-static-definition-in-anonymous-namespace,
+         #readability-string-compare,
+         #readability-suspicious-call-argument,
+         #readability-uniqueptr-delete-release,
+         #readability-uppercase-literal-suffix,
+         #readability-use-anyofallof
+         "
@@ -5,3 +5,4 @@ root = true
 indent_style = space
 indent_size = 2
 insert_final_newline = true
+trim_trailing_whitespace = true
@@ -0,0 +1,13 @@
+/* eslint-env node */
+
+module.exports = {
+    root: true,
+    parser: '@typescript-eslint/parser',
+    plugins: [
+        '@typescript-eslint',
+    ],
+    extends: [
+        'eslint:recommended',
+        'plugin:@typescript-eslint/recommended',
+    ]
+};
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Siarhei Fedartsou	a8e52b6af9	POC of one-to-many bidirectional routing in map-matching	2024-07-30 17:44:48 +02:00
Siarhei Fedartsou	edd9dcca47	POC of one-to-many bidirectional routing in map-matching	2024-07-30 17:29:12 +02:00
Siarhei Fedartsou	ecbaabc15f	POC of one-to-many bidirectional routing in map-matching	2024-07-30 17:11:52 +02:00
Siarhei Fedartsou	f909d89381	POC of one-to-many bidirectional routing in map-matching	2024-07-30 15:35:36 +02:00
Siarhei Fedartsou	36d91d61d7	POC of one-to-many bidirectional routing in map-matching	2024-07-30 15:23:52 +02:00
Siarhei Fedartsou	5769d0d46e	POC of one-to-many bidirectional routing in map-matching	2024-07-30 13:19:06 +02:00
Siarhei Fedartsou	da6d08e759	POC of one-to-many bidirectional routing in map-matching	2024-07-30 12:27:35 +02:00
Siarhei Fedartsou	44056eda0b	POC of one-to-many bidirectional routing in map-matching	2024-07-29 21:21:28 +02:00
Siarhei Fedartsou	d76d5e7d5f	POC of one-to-many bidirectional routing in map-matching	2024-07-29 20:59:26 +02:00
Siarhei Fedartsou	ed49564e27	POC of one-to-many bidirectional routing in map-matching	2024-07-29 20:46:00 +02:00
Siarhei Fedartsou	fe339b385c	POC of one-to-many bidirectional routing in map-matching	2024-07-29 20:17:59 +02:00
Siarhei Fedartsou	5fc269c50a	POC of one-to-many bidirectional routing in map-matching	2024-07-29 20:11:24 +02:00
Siarhei Fedartsou	6f2b8f44d0	POC of one-to-many bidirectional routing in map-matching	2024-07-29 19:55:39 +02:00
Siarhei Fedartsou	2e2ce1d421	POC of one-to-many bidirectional routing in map-matching	2024-07-29 19:53:44 +02:00
Siarhei Fedartsou	4a34c86544	wip	2024-07-28 18:55:57 +02:00
Siarhei Fedartsou	2b38c936d5	somehow works	2024-07-28 13:31:33 +02:00
Siarhei Fedartsou	b577558980	wip	2024-07-28 12:14:08 +02:00
Siarhei Fedartsou	f1ce2e6384	wip	2024-07-28 12:04:19 +02:00
Siarhei Fedartsou	e5e25a1aca	Configure self-hosted runner for benchmarks job (#6975 )	2024-07-26 21:19:47 +02:00
Siarhei Fedartsou	84f12c7c6d	Add NodeJs bindings benchmarks (#7004 )	2024-07-26 19:36:43 +02:00
Siarhei Fedartsou	7802f86bd6	Measure peak RAM in benchmarks (#6995 )	2024-07-25 21:27:37 +02:00
Siarhei Fedartsou	43afec3b39	Move flatbuffers non-generated files back to include/engine/api/flatbuffers/ (#6996 )	2024-07-13 13:43:56 +02:00
Dennis Luxen	2da7ca5338	Route pedestrians over highway=platform (#6993 )	2024-07-12 20:12:19 +02:00
Dennis Luxen	8ae9abaa63	Fix parsing on feature files on other gherkin parser (#6992 )	2024-07-12 17:35:44 +02:00
Siarhei Fedartsou	d3638ace59	Use thread_local instead of boost::thread_specific_ptr (#6991 )	2024-07-11 23:53:22 +02:00
Siarhei Fedartsou	c2f877eb9d	Remove unused MapStorage and GenerationArrayStorage (#6990 )	2024-07-11 23:10:14 +02:00
Siarhei Fedartsou	825132eec7	Bump flatbuffers to v24.3.25 version (#6968 )	2024-07-10 20:44:36 +02:00
Dennis Luxen	7436835244	Remove corech options, redundant tests (#6989 ) * Remove corech options, redundant tests * Small fix	2024-07-10 16:28:07 +02:00
Siarhei Fedartsou	5e6fdda16b	Add NOTE: label to comment in stale.yml (#6987 )	2024-07-09 21:27:46 +02:00
Siarhei Fedartsou	f5598efcff	Add .reserve(...) to assembleGeometry function (#6983 )	2024-07-09 20:12:47 +02:00
Siarhei Fedartsou	ab771c6142	Do not trigger stale bot on each PR (#6986 )	2024-07-09 19:58:03 +02:00
Siarhei Fedartsou	f1510b758d	Increase number of GitHub operations allowed in stale bot (#6985 )	2024-07-09 19:32:03 +02:00
Siarhei Fedartsou	4930d2ef05	Use clang 18/17/16 instead of 15/14/13 (#6978 )	2024-07-03 20:02:44 +02:00
Siarhei Fedartsou	57b792c768	Get rid of boost::optional leftovers (#6977 )	2024-07-02 22:37:09 +02:00
Siarhei Fedartsou	d0ed29adb7	Use Link Time Optimisation whenever possible (#6967 )	2024-06-30 21:07:49 +02:00
Siarhei Fedartsou	bdc6ed8a53	Use struct instead of tuple to define UnpackedPath (#6974 )	2024-06-29 21:34:43 +02:00
Siarhei Fedartsou	93c0e1dab3	Micro performance optimisation in map matching (#6976 )	2024-06-29 19:59:08 +02:00
Siarhei Fedartsou	cacb1b23f9	Fix calculation of best ops/sec in benchmarks (#6973 )	2024-06-29 10:31:23 +02:00
Siarhei Fedartsou	0e17869e21	Re-use priority queue in StaticRTree (#6952 )	2024-06-25 18:58:48 +02:00