Try to add Conan debug builds

2024-05-13 15:52:21 +02:00
1822 changed files with 147700 additions and 71099 deletions
--- a/.clang-tidy
+++ b/.clang-tidy
@ -13,11 +13,6 @@ Checks: >
    -bugprone-forward-declaration-namespace,
    -bugprone-sizeof-expression,
    -bugprone-throw-keyword-missing,
    -bugprone-chained-comparison,
    -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,
@ -54,13 +49,11 @@ Checks: >
    -misc-misplaced-const,
    -misc-definitions-in-headers,
    -misc-unused-parameters,
    -misc-include-cleaner,
    modernize-concat-nested-namespaces,
    modernize-use-using,
    performance-*,
    -performance-noexcept-move-constructor,
    -performance-no-int-to-ptr,
    -performance-enum-size,
    -performance-avoid-endl,
    readability-*,
    -readability-avoid-const-params-in-decls,
    -readability-braces-around-statements,
@ -89,10 +82,6 @@ Checks: >
    -readability-make-member-function-const,
    -readability-redundant-string-init,
    -readability-non-const-parameter,
    -readability-redundant-inline-specifier,
    -readability-avoid-nested-conditional-operator,
    -readability-avoid-return-with-void-value,
    -readability-redundant-casting,
    -readability-static-accessed-through-instance
 WarningsAsErrors: '*'
--- a/.gitea/workflows/publish-container.yaml
+++ b/.gitea/workflows/publish-container.yaml
@ -1,65 +0,0 @@
 name: Build and Publish Docker Image
 on:
  release:
    types: [published, prereleased]
 env:
  IMAGE_NAME: openharbor/osrm-backend
 jobs:
  publish:
    strategy:
      matrix:
        docker-base-image: ["debian", "alpine"]
    runs-on: ubuntu-latest
    steps:
      - name: Check out the repo
        uses: actions/checkout@v3
      - name: Set up QEMU
        uses: docker/setup-qemu-action@v2
      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v2
      - name: Docker meta
        id: meta
        uses: docker/metadata-action@v4
        with:
          images: ${{ env.IMAGE_NAME }}
      - name: Docker meta - debug
        id: metadebug
        uses: docker/metadata-action@v4
        with:
          images: ${{ env.IMAGE_NAME }}
          flavor: |
            latest=true
            suffix=-debug,onlatest=true
      - name: Log in to DockerHub
        uses: docker/login-action@v2
        with:
          username: ${{ secrets.DOCKERHUB_USERNAME }}
          password: ${{ secrets.DOCKERHUB_ACCESS_TOKEN }}
      - name: Build and push debug image
        uses: docker/build-push-action@v4
        with:
          push: true
          platforms: linux/amd64,linux/arm64,linux/ppc64le,linux/riscv64
          file: ./docker/Dockerfile-${{ matrix.docker-base-image }}
          tags: ${{ steps.metadebug.outputs.tags }}
          build-args: |
            DOCKER_TAG=${{ join(steps.metadebug.outputs.tags) }}-${{ matrix.docker-base-image }}
      - name: Build and push normal image
        uses: docker/build-push-action@v4
        with:
          push: true
          platforms: linux/amd64,linux/arm64,linux/ppc64le,linux/riscv64
          file: ./docker/Dockerfile-${{ matrix.docker-base-image }}
          tags: ${{ steps.meta.outputs.tags }}
          build-args: |
            DOCKER_TAG=${{ join(steps.meta.outputs.tags) }}-${{ matrix.docker-base-image }}
--- a/.github/workflows/osrm-backend-docker.yml
+++ b/.github/workflows/osrm-backend-docker.yml
@ -6,9 +6,6 @@ on:
 jobs:
  publish:
    strategy:
      matrix:
        docker-base-image: ["debian", "alpine"]
    runs-on: ubuntu-latest
    steps:       
      - name: Check out the repo
@ -56,10 +53,10 @@ jobs:
        with:
          push: true
          platforms: linux/amd64,linux/arm64
-          file: ./docker/Dockerfile-${{ matrix.docker-base-image }}
+          file: ./docker/Dockerfile
          tags: ${{ steps.metadebug.outputs.tags  }}
          build-args: |
-            DOCKER_TAG=${{ join(steps.metadebug.outputs.tags ) }}-${{ matrix.docker-base-image }}
+            DOCKER_TAG=${{ join(steps.metadebug.outputs.tags ) }}
      - name: Build container image - assertions
@ -67,10 +64,10 @@ jobs:
        with:
          push: true
          platforms: linux/amd64,linux/arm64
-          file: ./docker/Dockerfile-${{ matrix.docker-base-image }}
+          file: ./docker/Dockerfile
          tags: ${{ steps.metaassertions.outputs.tags  }}
          build-args: |
-            DOCKER_TAG=${{ join(steps.metaassertions.outputs.tags ) }}-${{ matrix.docker-base-image }}
+            DOCKER_TAG=${{ join(steps.metaassertions.outputs.tags ) }}
      # build and publish "normal" image as last to get it listed on top
      - name: Build container image - normal
@ -78,7 +75,10 @@ jobs:
        with:
          push: true
          platforms: linux/amd64,linux/arm64
-          file: ./docker/Dockerfile-${{ matrix.docker-base-image }}
+          file: ./docker/Dockerfile
-          tags: ${{ steps.meta.outputs.tags  }}
+          tags:  ${{ steps.meta.outputs.tags  }}
          build-args: |
-            DOCKER_TAG=${{ join(steps.meta.outputs.tags ) }}-${{ matrix.docker-base-image }}
+            DOCKER_TAG=${{ join(steps.meta.outputs.tags ) }}            
--- a/.github/workflows/osrm-backend.yml
+++ b/.github/workflows/osrm-backend.yml
@ -15,6 +15,7 @@ env:
  CCACHE_TEMPDIR: /tmp/.ccache-temp
  CCACHE_COMPRESS: 1
  CASHER_TIME_OUT: 599 # one second less than 10m to avoid 10m timeout error: https://github.com/Project-OSRM/osrm-backend/issues/2742
  CCACHE_VERSION: 3.3.1
  CMAKE_VERSION: 3.21.2
  ENABLE_NODE_BINDINGS: "ON"
@ -30,11 +31,11 @@ jobs:
    env:
      BUILD_TYPE: Release
    steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v3
    - run: pip install "conan<2.0.0"
    - run: conan --version
    - run: cmake --version
-    - uses: actions/setup-node@v4
+    - uses: actions/setup-node@v3
      with:
        node-version: 18
    - run: node --version
@ -46,32 +47,15 @@ jobs:
        echo PUBLISH=$([[ "${GITHUB_REF:-}" == "refs/tags/v${PACKAGE_JSON_VERSION}" ]] && echo "On" || echo "Off") >> $GITHUB_ENV
    - run: npm install --ignore-scripts
    - run: npm link --ignore-scripts
    - uses: microsoft/setup-msbuild@v1.1
    - name: Build
      run: |
        .\scripts\ci\windows-build.bat
    - name: Run node tests
      shell: bash
      run: |
-        mkdir build
+        ./lib/binding/osrm-datastore.exe test/data/ch/monaco.osrm
-        cd build
+        node test/nodejs/index.js
        cmake -DCMAKE_BUILD_TYPE=Release -DENABLE_CONAN=ON -DENABLE_NODE_BINDINGS=ON ..
        cmake --build . --config Release
    # TODO: MSVC goes out of memory when building our tests
    # - name: Run tests
    #   shell: bash
    #   run: |
    #     cd build
    #     cmake --build . --config Release --target tests
    #     # TODO: run tests
    # - name: Run node tests
    #   shell: bash
    #   run: |
    #     ./lib/binding/osrm-extract.exe -p profiles/car.lua test/data/monaco.osm.pbf
    #     mkdir -p test/data/ch
    #     cp test/data/monaco.osrm* test/data/ch/
    #     ./lib/binding/osrm-contract.exe test/data/ch/monaco.osrm
    #     ./lib/binding/osrm-datastore.exe test/data/ch/monaco.osrm
    #     node test/nodejs/index.js
    - name: Build Node package
      shell: bash
      run: ./scripts/ci/node_package.sh
@ -92,13 +76,13 @@ jobs:
  format-taginfo-docs:
    runs-on: ubuntu-22.04
    steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v3
    - name: Use Node.js
-      uses: actions/setup-node@v4
+      uses: actions/setup-node@v3
      with:
        node-version: 18
    - name: Enable Node.js cache
-      uses: actions/cache@v4
+      uses: actions/cache@v3
      with:
        path: ~/.npm
        key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
@ -116,18 +100,15 @@ jobs:
        npm run docs && ./scripts/error_on_dirty.sh
        npm audit --production
-  docker-image-matrix:
+  docker-image:
    strategy:
      matrix:
        docker-base-image: ["debian", "alpine"]
    needs: format-taginfo-docs
    runs-on: ubuntu-22.04
    continue-on-error: false
    steps:
      - name: Check out the repo
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
      - name: Enable osm.pbf cache
-        uses: actions/cache@v4
+        uses: actions/cache@v3
        with:
          path: berlin-latest.osm.pbf
          key: v1-berlin-osm-pbf
@ -135,7 +116,7 @@ jobs:
            v1-berlin-osm-pbf
      - name: Docker build
        run: |
-          docker build -t osrm-backend-local -f docker/Dockerfile-${{ matrix.docker-base-image }} .
+          docker build -t osrm-backend-local -f docker/Dockerfile .
      - name: Test Docker image
        run: |
          if [ ! -f "${PWD}/berlin-latest.osm.pbf" ]; then
@ -152,6 +133,7 @@ jobs:
            >&2 echo "No berlin-latest.geojson found"
            exit 1
          fi
          # removing `.osrm.nbg` to check that whole pipeline works without it
          rm -rf "${PWD}/berlin-latest.osrm.nbg"
@ -169,7 +151,7 @@ jobs:
          - name: gcc-13-debug-cov
            continue-on-error: false
            node: 20
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-22.04
            BUILD_TOOLS: ON
            BUILD_TYPE: Debug
            CCOMPILER: gcc-13
@ -177,117 +159,111 @@ jobs:
            CXXCOMPILER: g++-13
            ENABLE_COVERAGE: ON
-          - name: clang-18-debug-asan-ubsan
+          - name: clang-15-debug-asan-ubsan
            continue-on-error: false
            node: 20
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-22.04
            BUILD_TOOLS: ON
            BUILD_TYPE: Debug
-            CCOMPILER: clang-18
+            CCOMPILER: clang-15
            CUCUMBER_TIMEOUT: 20000
-            CXXCOMPILER: clang++-18
+            CXXCOMPILER: clang++-15
            ENABLE_SANITIZER: ON
            TARGET_ARCH: x86_64-asan-ubsan
            OSRM_CONNECTION_RETRIES: 10
            OSRM_CONNECTION_EXP_BACKOFF_COEF: 1.5
-          - name: clang-18-release
+          - name: clang-15-release
            continue-on-error: false
            node: 18
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-22.04
            BUILD_TOOLS: ON
            BUILD_TYPE: Release
-            CCOMPILER: clang-18
+            CCOMPILER: clang-15
-            CXXCOMPILER: clang++-18
+            CXXCOMPILER: clang++-15
            CUCUMBER_TIMEOUT: 60000
            ENABLE_LTO: OFF
-          - name: clang-18-debug
+          - name: clang-15-debug
            continue-on-error: false
            node: 18
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-22.04
            BUILD_TOOLS: ON
            BUILD_TYPE: Debug
-            CCOMPILER: clang-18
+            CCOMPILER: clang-15
-            CXXCOMPILER: clang++-18
+            CXXCOMPILER: clang++-15
            CUCUMBER_TIMEOUT: 60000
            ENABLE_LTO: OFF
-          - name: clang-18-debug-clang-tidy
+          - name: clang-15-debug-clang-tidy
            continue-on-error: false
            node: 18
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-22.04
            BUILD_TOOLS: ON
            BUILD_TYPE: Debug
-            CCOMPILER: clang-18
+            CCOMPILER: clang-15
-            CXXCOMPILER: clang++-18
+            CXXCOMPILER: clang++-15
            CUCUMBER_TIMEOUT: 60000
            ENABLE_CLANG_TIDY: ON
-
+          - name: clang-14-release
          - name: clang-17-release
            continue-on-error: false
            node: 18
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-22.04
            BUILD_TOOLS: ON
            BUILD_TYPE: Release
-            CCOMPILER: clang-17
+            CCOMPILER: clang-14
-            CXXCOMPILER: clang++-17
+            CXXCOMPILER: clang++-14
            CUCUMBER_TIMEOUT: 60000
            ENABLE_LTO: OFF
-          - name: clang-16-release
+          - name: clang-13-release
            continue-on-error: false
            node: 18
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-22.04
            BUILD_TOOLS: ON
            BUILD_TYPE: Release
-            CCOMPILER: clang-16
+            CCOMPILER: clang-13
-            CXXCOMPILER: clang++-16
+            CXXCOMPILER: clang++-13
            CUCUMBER_TIMEOUT: 60000
            ENABLE_LTO: OFF
          - name: conan-linux-debug-asan-ubsan
            continue-on-error: false
            node: 18
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-22.04
            BUILD_TOOLS: ON
-            BUILD_TYPE: Release
+            BUILD_TYPE: Debug
-            CCOMPILER: clang-18
+            CCOMPILER: clang-15
-            CXXCOMPILER: clang++-18
+            CXXCOMPILER: clang++-15
            ENABLE_CONAN: ON
            ENABLE_SANITIZER: ON
            ENABLE_LTO: OFF
          - name: conan-linux-release
            continue-on-error: false
            node: 18
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-22.04
            BUILD_TOOLS: ON
            BUILD_TYPE: Release
-            CCOMPILER: clang-18
+            CCOMPILER: clang-15
-            CXXCOMPILER: clang++-18
+            CXXCOMPILER: clang++-15
            ENABLE_CONAN: ON
            ENABLE_LTO: OFF
-          - name: gcc-14-release
+          - name: conan-linux-debug
            continue-on-error: false
-            node: 20
+            node: 18
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-22.04
            BUILD_TOOLS: ON
-            BUILD_TYPE: Release
+            BUILD_TYPE: Debug
-            CCOMPILER: gcc-14
+            CCOMPILER: clang-15
-            CXXCOMPILER: g++-14
+            CXXCOMPILER: clang++-15
-            CXXFLAGS: '-Wno-array-bounds -Wno-uninitialized'
+            ENABLE_CONAN: ON
-
+          
          - name: gcc-13-release
            continue-on-error: false
            node: 20
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-22.04
            BUILD_TOOLS: ON
            BUILD_TYPE: Release
            CCOMPILER: gcc-13
            CXXCOMPILER: g++-13
            ENABLE_BENCHMARKS: ON
            CXXFLAGS: '-Wno-array-bounds -Wno-uninitialized'
          - name: gcc-12-release
@ -298,16 +274,27 @@ jobs:
            BUILD_TYPE: Release
            CCOMPILER: gcc-12
            CXXCOMPILER: g++-12
            ENABLE_BENCHMARKS: ON
            CXXFLAGS: '-Wno-array-bounds -Wno-uninitialized'
          - name: gcc-11-release
            continue-on-error: false
            node: 20
            runs-on: ubuntu-22.04
            BUILD_TOOLS: ON
            BUILD_TYPE: Release
            CCOMPILER: gcc-11
            CXXCOMPILER: g++-11
            ENABLE_BENCHMARKS: ON
          - name: conan-linux-release-node
            build_node_package: true
            continue-on-error: false
            node: 20
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-22.04
            BUILD_TYPE: Release
-            CCOMPILER: clang-16
+            CCOMPILER: clang-13
-            CXXCOMPILER: clang++-16
+            CXXCOMPILER: clang++-13
            ENABLE_CONAN: ON
            NODE_PACKAGE_TESTS_ONLY: ON
@ -315,10 +302,10 @@ jobs:
            build_node_package: true
            continue-on-error: false
            node: 20
-            runs-on: ubuntu-24.04
+            runs-on: ubuntu-22.04
            BUILD_TYPE: Debug
-            CCOMPILER: clang-16
+            CCOMPILER: clang-13
-            CXXCOMPILER: clang++-16
+            CXXCOMPILER: clang++-13
            ENABLE_CONAN: ON
            NODE_PACKAGE_TESTS_ONLY: ON
@ -367,48 +354,45 @@ 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
+    - uses: actions/checkout@v3
    - name: Build machine architecture
      run: uname -m
    - name: Use Node.js
-      uses: actions/setup-node@v4
+      uses: actions/setup-node@v3
      with:
        node-version: ${{ matrix.node }}
    - name: Enable Node.js cache
-      uses: actions/cache@v4
+      uses: actions/cache@v3
      with:
        path: ~/.npm
        key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
        restore-keys: |
          ${{ runner.os }}-node-
    - name: Enable compiler cache
-      uses: actions/cache@v4
+      uses: actions/cache@v3
      with:
        path: ~/.ccache
        key: ccache-${{ matrix.name }}-${{ github.sha }}
        restore-keys: |
          ccache-${{ matrix.name }}-
    - name: Enable Conan cache
-      uses: actions/cache@v4
+      uses: actions/cache@v3
      with:
        path: ~/.conan
        key: v9-conan-${{ matrix.name }}-${{ github.sha }}
        restore-keys: |
          v9-conan-${{ matrix.name }}-
    - name: Enable test cache
-      uses: actions/cache@v4
+      uses: actions/cache@v3
      with:
        path: ${{github.workspace}}/test/cache
        key: v4-test-${{ matrix.name }}-${{ github.sha }}
        restore-keys: |
          v4-test-${{ matrix.name }}-
    - name: Prepare environment
      run: |
        echo "CCACHE_DIR=$HOME/.ccache" >> $GITHUB_ENV
        mkdir -p $HOME/.ccache
        PACKAGE_JSON_VERSION=$(node -e "console.log(require('./package.json').version)")
        echo PUBLISH=$([[ "${GITHUB_REF:-}" == "refs/tags/v${PACKAGE_JSON_VERSION}" ]] && echo "On" || echo "Off") >> $GITHUB_ENV
        echo "OSRM_INSTALL_DIR=${GITHUB_WORKSPACE}/install-osrm" >> $GITHUB_ENV
@ -425,36 +409,7 @@ jobs:
        elif [[ "${RUNNER_OS}" == "macOS" ]]; then
          echo "JOBS=$((`sysctl -n hw.ncpu` + 1))" >>  $GITHUB_ENV
        fi
    # See: https://github.com/actions/toolkit/issues/946#issuecomment-1590016041
    # We need it to be able to access system folders while restoring cached Boost below
    - name: Give tar root ownership 
      if: runner.os == 'Linux' && matrix.ENABLE_CONAN != 'ON'
      run: sudo chown root /bin/tar && sudo chmod u+s /bin/tar
    - name: Cache Boost
      if: runner.os == 'Linux' && matrix.ENABLE_CONAN != 'ON'
      id: cache-boost
      uses: actions/cache@v4
      with:
        path: |
          /usr/local/include/boost
          /usr/local/lib/libboost*
        key: v1-boost-${{ runner.os }}-${{ runner.arch }}-${{ matrix.runs-on }}
        restore-keys: |
          v1-boost-${{ runner.os }}-${{ runner.arch }}-${{ matrix.runs-on }}
    - name: Install Boost
      if: steps.cache-boost.outputs.cache-hit != 'true' && runner.os == 'Linux' && matrix.ENABLE_CONAN != 'ON'
      run: |
        BOOST_VERSION="1.85.0"
        BOOST_VERSION_FLAVOR="${BOOST_VERSION}-b2-nodocs"
        wget -q https://github.com/boostorg/boost/releases/download/boost-${BOOST_VERSION}/boost-${BOOST_VERSION_FLAVOR}.tar.gz
        tar xzf boost-${BOOST_VERSION_FLAVOR}.tar.gz
        cd boost-${BOOST_VERSION}
        sudo ./bootstrap.sh
        sudo ./b2 install
        cd ..
        sudo rm -rf boost-${BOOST_VERSION}*
    - name: Install dev dependencies
      run: |
        python3 -m pip install "conan<2.0.0" || python3 -m pip install "conan<2.0.0" --break-system-packages
@ -475,7 +430,7 @@ jobs:
        # Linux dev packages
        if [ "${ENABLE_CONAN}" != "ON" ]; then
          sudo apt-get update -y
-          sudo apt-get install -y libbz2-dev libxml2-dev libzip-dev liblua5.2-dev
+          sudo apt-get install -y libbz2-dev libxml2-dev libzip-dev liblua5.2-dev libboost-all-dev
          if [[ "${CCOMPILER}" != clang-* ]]; then
            sudo apt-get install -y ${CXXCOMPILER}
          fi
@ -485,7 +440,7 @@ jobs:
        fi
        # TBB
-        TBB_VERSION=2021.12.0
+        TBB_VERSION=2021.3.0
        if [[ "${RUNNER_OS}" == "Linux" ]]; then
          TBB_URL="https://github.com/oneapi-src/oneTBB/releases/download/v${TBB_VERSION}/oneapi-tbb-${TBB_VERSION}-lin.tgz"
        elif [[ "${RUNNER_OS}" == "macOS" ]]; then
@ -495,20 +450,6 @@ 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: Add Apple-clang 16 to list of Conan compilers # workaround for the issue that Conan 1.x doesn't know about Apple-clang 16
      if: ${{ matrix.ENABLE_CONAN == 'ON' && matrix.runs-on == 'macos-14' }}
      run: |
        sudo wget https://github.com/mikefarah/yq/releases/download/v4.9.6/yq_darwin_arm64 -O /usr/local/bin/yq && sudo chmod +x /usr/local/bin/yq
        conan config init
        yq eval '.compiler.apple-clang.version += ["16.0"]' -i "$HOME/.conan/settings.yml"
    - name: Prepare build
      run: |
        mkdir ${OSRM_BUILD_DIR}
@ -530,8 +471,8 @@ jobs:
      run: |
        echo "Using ${JOBS} jobs"
        pushd ${OSRM_BUILD_DIR}
-        
+
-        ccache --zero-stats
+
        cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} \
                 -DENABLE_CONAN=${ENABLE_CONAN:-OFF} \
                 -DENABLE_ASSERTIONS=${ENABLE_ASSERTIONS:-OFF} \
@ -542,14 +483,13 @@ 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}
        if [[ "${NODE_PACKAGE_TESTS_ONLY}" != "ON" ]]; then
          make tests --jobs=${JOBS}
          make benchmarks --jobs=${JOBS}
-
+          ccache -s
          sudo make install
          if [[ "${RUNNER_OS}" == "Linux" ]]; then
            echo "LD_LIBRARY_PATH=$LD_LIBRARY_PATH:${OSRM_INSTALL_DIR}/lib" >> $GITHUB_ENV
@ -581,10 +521,22 @@ jobs:
        fi
        popd
        npm test
    - name: Run benchmarks
      if: ${{ matrix.ENABLE_BENCHMARKS == 'ON' }}
      run: |
        pushd ${OSRM_BUILD_DIR}
        make --jobs=${JOBS} benchmarks
        ./src/benchmarks/alias-bench
        ./src/benchmarks/json-render-bench ../src/benchmarks/portugal_to_korea.json
        ./src/benchmarks/match-bench ../test/data/ch/monaco.osrm ch
        ./src/benchmarks/match-bench ../test/data/mld/monaco.osrm mld
        ./src/benchmarks/packedvector-bench
        ./src/benchmarks/rtree-bench ../test/data/monaco.osrm.ramIndex ../test/data/monaco.osrm.fileIndex ../test/data/monaco.osrm.nbg_nodes
        popd
    - name: Use Node 18
      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY == 'ON' }}
-      uses: actions/setup-node@v4
+      uses: actions/setup-node@v3
      with:
        node-version: 18
    - name: Run Node package tests on Node 18
@ -594,7 +546,7 @@ jobs:
        npm run nodejs-tests
    - name: Use Node 20
      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY == 'ON' }}
-      uses: actions/setup-node@v4
+      uses: actions/setup-node@v3
      with:
        node-version: 20
    - name: Run Node package tests on Node 20
@ -604,7 +556,7 @@ jobs:
        npm run nodejs-tests
    - name: Use Node latest
      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY == 'ON' }}
-      uses: actions/setup-node@v4
+      uses: actions/setup-node@v3
      with:
        node-version: latest
    - name: Run Node package tests on Node-latest
@ -614,7 +566,7 @@ jobs:
        npm run nodejs-tests
    - name: Upload test logs
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v3
      if: failure()
      with:
        name: logs
@ -630,7 +582,7 @@ jobs:
    # # Uploading report to CodeCov
    # - name: Upload code coverage
    #   if: ${{ matrix.ENABLE_COVERAGE == 'ON' }}
-    #   uses: codecov/codecov-action@v4
+    #   uses: codecov/codecov-action@v1
    #   with:
    #     files: coverage.info
    #     name: codecov-osrm-backend
@ -652,135 +604,9 @@ jobs:
        omitNameDuringUpdate: true
        replacesArtifacts: true
        token: ${{ secrets.GITHUB_TOKEN }}
    - name: Show CCache statistics
      run: |
        ccache -p
        ccache -s
  benchmarks:
    if: github.event_name == 'pull_request'
    needs: [format-taginfo-docs]
    runs-on: self-hosted
    env:
      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: Checkout PR Branch
        uses: actions/checkout@v4
        with:
          ref: ${{ github.head_ref }}
          path: pr
      - 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
              rm -rf ~/data.osm.pbf
              wget http://download.geofabrik.de/europe/poland-latest.osm.pbf -O ~/data.osm.pbf --quiet
              gunzip -c ./pr/test/data/poland_gps_traces.csv.gz > ~/gps_traces.csv
          else
              if [ ! -f "~/data.osm.pbf" ]; then
                wget http://download.geofabrik.de/europe/germany/berlin-latest.osm.pbf -O ~/data.osm.pbf
              else
                echo "Using cached data.osm.pbf"
              fi
              gunzip -c ./pr/test/data/berlin_gps_traces.csv.gz > ~/gps_traces.csv
          fi
      - name: Prepare environment
        run: |
          echo "CCACHE_DIR=$HOME/.ccache" >> $GITHUB_ENV
          mkdir -p $HOME/.ccache
          ccache --zero-stats
          ccache --max-size=256M
      - name: Checkout Base Branch
        uses: actions/checkout@v4
        with:
          ref: ${{ github.event.pull_request.base.ref }}
          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 -DENABLE_NODE_BINDINGS=ON ..
          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: |
          # 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
      # see https://llvm.org/docs/Benchmarking.html
      - name: Run PR Benchmarks 
        run: |
          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
          sudo cset shield --reset
      - name: Run Base Benchmarks
        run: |
          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 ~/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
          sudo cset shield --exec -- 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
          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
-    needs: [build-test-publish, docker-image-matrix, windows-release-node, benchmarks]
+    needs: [build-test-publish, docker-image, windows-release-node]
    steps:
    - run: echo "CI complete"
--- a/.github/workflows/stale.yml
+++ b/.github/workflows/stale.yml
@ -1,29 +0,0 @@
 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:
  issues: write
  pull-requests: write
 jobs:
  stale:
    runs-on: ubuntu-24.04
    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
          days-before-issue-close: 30 # 1 month
          days-before-pr-stale: 180 # 6 months
          days-before-pr-close: -1 # never close PRs
          exempt-issue-labels: 'Do Not Stale,Feature Request,Performance,Bug Report,CI,Starter Task,Refactor,Guidance'
--- a/.gitignore
+++ b/.gitignore
@ -46,6 +46,7 @@ Thumbs.db
 /example/build/
 /test/data/monaco.osrm*
 /test/data/ch
 /test/data/corech
 /test/data/mld
 /cmake/postinst
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -1,18 +1,12 @@
 # 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)
      - ADDED: Add support for disabling feature datasets. [#6666](https://github.com/Project-OSRM/osrm-backend/pull/6666)
      - ADDED: Add support for opposite approach request parameter. [#6842](https://github.com/Project-OSRM/osrm-backend/pull/6842)
      - ADDED: Add support for accessing edge flags in `process_segment` [#6658](https://github.com/Project-OSRM/osrm-backend/pull/6658)
    - Build:
      - CHANGED: Upgrade clang-format to version 15. [#6919](https://github.com/Project-OSRM/osrm-backend/pull/6919)
      - CHANGED: Use Debian Bookworm as base Docker image [#6904](https://github.com/Project-OSRM/osrm-backend/pull/6904)
      - CHANGED: Upgrade CI actions to latest versions [#6893](https://github.com/Project-OSRM/osrm-backend/pull/6893)
      - CHANGED:  Remove outdated warnings #6894 [#6894](https://github.com/Project-OSRM/osrm-backend/pull/6894)
      - ADDED: Add CI job which builds OSRM with gcc 12. [#6455](https://github.com/Project-OSRM/osrm-backend/pull/6455)
      - CHANGED: Upgrade to clang-tidy 15. [#6439](https://github.com/Project-OSRM/osrm-backend/pull/6439)
      - CHANGED: Update actions/cache to v3. [#6420](https://github.com/Project-OSRM/osrm-backend/pull/6420)
@ -25,39 +19,6 @@
    - NodeJS:
      - CHANGED: Use node-api instead of NAN. [#6452](https://github.com/Project-OSRM/osrm-backend/pull/6452)
    - Misc:
      - CHANGED: Use std::string_view for key type in json::Object. [#7062](https://github.com/Project-OSRM/osrm-backend/pull/7062)
      - 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)
      - CHANGED: Apply micro-optimisation for Table & Trip APIs. [#6949](https://github.com/Project-OSRM/osrm-backend/pull/6949)
      - CHANGED: Apply micro-optimisation for Route API. [#6948](https://github.com/Project-OSRM/osrm-backend/pull/6948)
      - CHANGED: Apply micro-optimisation for Match API. [#6945](https://github.com/Project-OSRM/osrm-backend/pull/6945)
      - CHANGED: Apply micro-optimisation for Nearest API. [#6944](https://github.com/Project-OSRM/osrm-backend/pull/6944)
      - CHANGED: Avoid copy of intersection in totalTurnAngle. [#6938](https://github.com/Project-OSRM/osrm-backend/pull/6938)
      - CHANGED: Use std::unordered_map::emplace instead of operator[] when producing JSONs. [#6936](https://github.com/Project-OSRM/osrm-backend/pull/6936)
      - CHANGED: Avoid copy of vectors in MakeRoute function. [#6939](https://github.com/Project-OSRM/osrm-backend/pull/6939)
      - FIXED: Fix bugprone-unused-return-value clang-tidy warning. [#6934](https://github.com/Project-OSRM/osrm-backend/pull/6934)
      - FIXED: Fix performance-noexcept-move-constructor clang-tidy warning. [#6931](https://github.com/Project-OSRM/osrm-backend/pull/6933)
      - FIXED: Fix performance-noexcept-swap clang-tidy warning. [#6931](https://github.com/Project-OSRM/osrm-backend/pull/6931)
      - CHANGED: Use custom struct instead of std::pair in QueryHeap. [#6921](https://github.com/Project-OSRM/osrm-backend/pull/6921)
      - CHANGED: Use std::string_view::starts_with instead of boost::starts_with. [#6918](https://github.com/Project-OSRM/osrm-backend/pull/6918)
      - CHANGED: Get rid of boost::math::constants::* and M_PI in favor of std::numbers. [#6916](https://github.com/Project-OSRM/osrm-backend/pull/6916)
      - CHANGED: Make constants in PackedVector constexpr. [#6917](https://github.com/Project-OSRM/osrm-backend/pull/6917)
      - CHANGED: Use std::variant instead of mapbox::util::variant. [#6903](https://github.com/Project-OSRM/osrm-backend/pull/6903)
      - CHANGED: Bump rapidjson to version f9d53419e912910fd8fa57d5705fa41425428c35 [#6906](https://github.com/Project-OSRM/osrm-backend/pull/6906)
      - CHANGED: Bump mapbox/variant to version 1.2.0 [#6898](https://github.com/Project-OSRM/osrm-backend/pull/6898)
      - CHANGED: Avoid copy of std::function-based callback in path unpacking [#6895](https://github.com/Project-OSRM/osrm-backend/pull/6895)
      - CHANGED: Replace boost::hash by std::hash [#6892](https://github.com/Project-OSRM/osrm-backend/pull/6892)
      - CHANGED: Partial fix migration from boost::optional to std::optional [#6551](https://github.com/Project-OSRM/osrm-backend/issues/6551)
      - CHANGED: Replace boost::filesystem with std::filesystem [#6432](https://github.com/Project-OSRM/osrm-backend/pull/6432)
      - CHANGED: Update Conan Boost version to 1.85.0. [#6868](https://github.com/Project-OSRM/osrm-backend/pull/6868)
      - FIXED: Fix an error in a RouteParameters AnnotationsType operator overload. [#6646](https://github.com/Project-OSRM/osrm-backend/pull/6646)
      - ADDED: Add support for "unlimited" to be passed as a value for the default-radius and max-matching-radius flags. [#6599](https://github.com/Project-OSRM/osrm-backend/pull/6599)
@ -80,7 +41,6 @@
      - ADDED: Extract prerelease/build information from package semver [#6839](https://github.com/Project-OSRM/osrm-backend/pull/6839)
    - Profiles:
      - FIXED: Bicycle and foot profiles now don't route on proposed ways [#6615](https://github.com/Project-OSRM/osrm-backend/pull/6615)
      - ADDED: Add optional support of cargo bike exclusion and width to bicyle profile [#7044](https://github.com/Project-OSRM/osrm-backend/pull/7044)
    - Routing:
      - FIXED: Fix adding traffic signal penalties during compression [#6419](https://github.com/Project-OSRM/osrm-backend/pull/6419)
      - FIXED: Correctly handle compressed traffic signals. [#6724](https://github.com/Project-OSRM/osrm-backend/pull/6724)
@ -88,9 +48,7 @@
      - FIXED: Remove force-loop checks for routes with u-turns [#6858](https://github.com/Project-OSRM/osrm-backend/pull/6858)
      - FIXED: Correctly check runtime search conditions for forcing routing steps [#6866](https://github.com/Project-OSRM/osrm-backend/pull/6866)
    - Map Matching:
      - CHANGED: Optimise path distance calculation in MLD map matching even more. [#6884](https://github.com/Project-OSRM/osrm-backend/pull/6884)
      - CHANGED: Optimise path distance calculation in MLD map matching. [#6876](https://github.com/Project-OSRM/osrm-backend/pull/6876)
      - CHANGED: Optimise R-tree queries in the case of map matching. [#6881](https://github.com/Project-OSRM/osrm-backend/pull/6876)
    - Debug tiles:
      - FIXED: Ensure speed layer features have unique ids. [#6726](https://github.com/Project-OSRM/osrm-backend/pull/6726)
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.18)
-set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
@ -31,12 +31,11 @@ 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 Link Time Optimisation" ON)
+option(ENABLE_LTO "Use LTO if available" OFF)
 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)
@ -56,23 +55,8 @@ endif()
 if (POLICY CMP0074)
  cmake_policy(SET CMP0074 NEW)
 endif()
 if (POLICY CMP0167)
  cmake_policy(SET CMP0167 NEW)
 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")
@ -136,10 +120,10 @@ 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-3.3.0/include)
-include_directories(SYSTEM ${CMAKE_CURRENT_SOURCE_DIR}/third_party/sol2/include)
+include_directories(SYSTEM ${CMAKE_CURRENT_SOURCE_DIR}/third_party/variant/include)
-set(BOOST_COMPONENTS date_time iostreams program_options thread unit_test_framework)
+set(BOOST_COMPONENTS date_time chrono filesystem iostreams program_options regex system thread unit_test_framework)
 configure_file(
  ${CMAKE_CURRENT_SOURCE_DIR}/include/util/version.hpp.in
@ -225,6 +209,17 @@ 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")
@ -272,6 +267,7 @@ elseif(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
  add_dependency_defines(-DBOOST_LIB_DIAGNOSTIC)
  add_dependency_defines(-D_CRT_SECURE_NO_WARNINGS)
  add_dependency_defines(-DNOMINMAX) # avoid min and max macros that can break compilation
  add_dependency_defines(-D_USE_MATH_DEFINES) #needed for M_PI with cmath.h
  add_dependency_defines(-D_WIN32_WINNT=0x0501)
  add_dependency_defines(-DXML_STATIC)
  find_library(ws2_32_LIBRARY_PATH ws2_32)
@ -296,7 +292,6 @@ 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)
@ -337,12 +332,20 @@ if(ENABLE_CONAN)
  set(CONAN_BOOST_VERSION "1.85.0@#14265ec82b25d91305bbb3b30d3357f8")
  set(CONAN_BZIP2_VERSION "1.0.8@#d1b2d5816f25865acf978501dff1f897")
-  set(CONAN_EXPAT_VERSION "2.6.2@#2d385d0d50eb5561006a7ff9e356656b")
+  set(CONAN_EXPAT_VERSION "2.2.10@#916908d4a570ad839edd25322c3268cd")
-  set(CONAN_LUA_VERSION "5.4.6@#658d6089093cf01992c2737ab2e96763")
+  set(CONAN_LUA_VERSION "5.4.4@#3ec62efc37cd0a5d80b9e5cb35277360")
-  set(CONAN_TBB_VERSION "2021.12.0@#e56e5b44be8d690530585dd3634c0106")
+  set(CONAN_TBB_VERSION "2021.3.0@#507ec17cbd51a84167e143b20d170eea")
  set(CONAN_SYSTEM_INCLUDES ON)
  # TODO:
  # if we link TBB dynamically osrm-extract.exe finishes on the first access to any TBB symbol
  # with exit code = -1073741515, which means that program cannot load required DLL.
  if (MSVC)
    set(TBB_SHARED False)
  else()
    set(TBB_SHARED True)
  endif()
  set(CONAN_ARGS
    REQUIRES
@ -355,7 +358,9 @@ if(ENABLE_CONAN)
    GENERATORS cmake_find_package json  # json generator generates a conanbuildinfo.json in the build folder so (non-CMake) projects can easily parse OSRM's dependencies
    KEEP_RPATHS
    NO_OUTPUT_DIRS
-    OPTIONS boost:without_stacktrace=True # Apple Silicon cross-compilation fails without it
+    OPTIONS boost:filesystem_version=3 # https://stackoverflow.com/questions/73392648/error-with-boost-filesystem-version-in-cmake
            onetbb:shared=${TBB_SHARED}
            boost:without_stacktrace=True # Apple Silicon cross-compilation fails without it
    BUILD missing
  )
@ -384,10 +389,14 @@ if(ENABLE_CONAN)
  set(Boost_USE_STATIC_LIBS ON)
  find_package(Boost REQUIRED COMPONENTS ${BOOST_COMPONENTS})
  set(Boost_DATE_TIME_LIBRARY "${Boost_date_time_LIB_TARGETS}")
  set(Boost_CHRONO_LIBRARY "${Boost_chrono_LIB_TARGETS}")
  set(Boost_PROGRAM_OPTIONS_LIBRARY "${Boost_program_options_LIB_TARGETS}")
  set(Boost_FILESYSTEM_LIBRARY "${Boost_filesystem_LIB_TARGETS}")
  set(Boost_IOSTREAMS_LIBRARY "${Boost_iostreams_LIB_TARGETS}")
  set(Boost_THREAD_LIBRARY "${Boost_thread_LIB_TARGETS}")
  set(Boost_SYSTEM_LIBRARY "${Boost_system_LIB_TARGETS}")
  set(Boost_ZLIB_LIBRARY "${Boost_zlib_LIB_TARGETS}")
  set(Boost_REGEX_LIBRARY "${Boost_regex_LIB_TARGETS}")
  set(Boost_UNIT_TEST_FRAMEWORK_LIBRARY "${Boost_unit_test_framework_LIB_TARGETS}")
@ -460,6 +469,7 @@ add_dependency_includes(${ZLIB_INCLUDE_DIRS})
 add_dependency_defines(-DBOOST_SPIRIT_USE_PHOENIX_V3)
 add_dependency_defines(-DBOOST_RESULT_OF_USE_DECLTYPE)
 add_dependency_defines(-DBOOST_FILESYSTEM_NO_DEPRECATED)
 # Workaround for https://github.com/boostorg/phoenix/issues/111
 add_dependency_defines(-DBOOST_PHOENIX_STL_TUPLE_H_)
@ -469,8 +479,11 @@ include_directories(SYSTEM ${DEPENDENCIES_INCLUDE_DIRS})
 set(BOOST_BASE_LIBRARIES
   ${Boost_DATE_TIME_LIBRARY}
   ${Boost_CHRONO_LIBRARY}
   ${Boost_FILESYSTEM_LIBRARY}
   ${Boost_IOSTREAMS_LIBRARY}
-   ${Boost_THREAD_LIBRARY})
+   ${Boost_THREAD_LIBRARY}
   ${Boost_SYSTEM_LIBRARY})
 set(BOOST_ENGINE_LIBRARIES
  ${Boost_ZLIB_LIBRARY}
@ -489,6 +502,7 @@ endif()
 set(EXTRACTOR_LIBRARIES
    ${BZIP2_LIBRARIES}
    ${Boost_REGEX_LIBRARY}
    ${BOOST_BASE_LIBRARIES}
    ${CMAKE_THREAD_LIBS_INIT}
    ${EXPAT_LIBRARIES}
@ -593,6 +607,7 @@ if (BUILD_ROUTED)
  set_property(TARGET osrm-routed PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
 endif()
 file(GLOB VariantGlob third_party/variant/include/mapbox/*.hpp)
 file(GLOB FlatbuffersGlob third_party/flatbuffers/include/flatbuffers/*.h)
 file(GLOB LibraryGlob include/osrm/*.hpp)
 file(GLOB ParametersGlob include/engine/api/*_parameters.hpp)
@ -612,6 +627,7 @@ install(FILES ${ContractorHeader} DESTINATION include/osrm/contractor)
 install(FILES ${LibraryGlob} DESTINATION include/osrm)
 install(FILES ${ParametersGlob} DESTINATION include/osrm/engine/api)
 install(FILES ${ApiHeader} DESTINATION include/osrm/engine/api)
 install(FILES ${VariantGlob} DESTINATION include/mapbox)
 install(FILES ${FlatbuffersGlob} DESTINATION include/flatbuffers)
 install(TARGETS osrm-extract DESTINATION bin)
 install(TARGETS osrm-partition DESTINATION bin)
--- a/README.md
+++ b/README.md
@ -15,7 +15,7 @@ The following services are available via HTTP API, C++ library interface and Nod
 To quickly try OSRM use our [demo server](http://map.project-osrm.org) which comes with both the backend and a frontend on top.
-For a quick introduction about how the road network is represented in OpenStreetMap and how to map specific road network features have a look at [the OSM wiki on routing](https://wiki.openstreetmap.org/wiki/Routing) or [this guide about mapping for navigation](https://web.archive.org/web/20221206013651/https://labs.mapbox.com/mapping/mapping-for-navigation/).
+For a quick introduction about how the road network is represented in OpenStreetMap and how to map specific road network features have a look at [this guide about mapping for navigation](https://www.mapbox.com/mapping/mapping-for-navigation/).
 Related [Project-OSRM](https://github.com/Project-OSRM) repositories:
 - [osrm-frontend](https://github.com/Project-OSRM/osrm-frontend) - User-facing frontend with map. The demo server runs this on top of the backend
--- a/cmake/conan.cmake
+++ b/cmake/conan.cmake
@ -55,7 +55,7 @@ function(_get_msvc_ide_version result)
        set(${result} 15 PARENT_SCOPE)
    elseif(NOT MSVC_VERSION VERSION_LESS 1920 AND MSVC_VERSION VERSION_LESS 1930)
        set(${result} 16 PARENT_SCOPE)
-    elseif(NOT MSVC_VERSION VERSION_LESS 1930 AND MSVC_VERSION VERSION_LESS 1950)
+    elseif(NOT MSVC_VERSION VERSION_LESS 1930 AND MSVC_VERSION VERSION_LESS 1940)
        set(${result} 17 PARENT_SCOPE)
    else()
        message(FATAL_ERROR "Conan: Unknown MSVC compiler version [${MSVC_VERSION}]")
--- a/cmake/warnings.cmake
+++ b/cmake/warnings.cmake
@ -50,7 +50,9 @@ add_warning(all)
 add_warning(extra)
 add_warning(pedantic)
 add_warning(error) # treat all warnings as errors
-if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
+if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
    add_warning(strict-overflow=2)
 elseif(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
    add_warning(strict-overflow=1)
 endif()
 add_warning(suggest-override)
@ -64,6 +66,7 @@ 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)
@ -76,13 +79,15 @@ add_warning(sizeof-array-argument)
 add_warning(switch-bool)
 add_warning(tautological-compare)
 add_warning(trampolines)
-# these warnings are not enabled by default
+no_warning(c++17-extensions)
-# no_warning(name-of-warning)
+# TODO: these warnings are not enabled by default, but we consider them as useful and good to enable in the future
-no_warning(deprecated-comma-subscript)
+no_warning(implicit-int-conversion)
-no_warning(comma-subscript)
+no_warning(implicit-float-conversion)
-no_warning(ambiguous-reversed-operator)
+no_warning(unused-member-function)
-no_warning(restrict)
+no_warning(old-style-cast)
-no_warning(free-nonheap-object)
+no_warning(non-virtual-dtor)
-if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
+no_warning(float-conversion)
-  no_warning(stringop-overflow)
+no_warning(sign-conversion)
-endif()
+no_warning(shorten-64-to-32)
 no_warning(padded)
 no_warning(missing-noreturn)
--- a/docker/Dockerfile
+++ b/docker/Dockerfile
@ -1 +0,0 @@
 Dockerfile-debian
--- a/docker/Dockerfile
+++ b/docker/Dockerfile
@ -0,0 +1,67 @@
 FROM debian:bullseye-slim as builder
 ARG DOCKER_TAG
 ARG BUILD_CONCURRENCY
 RUN mkdir -p /src  && mkdir -p /opt
 RUN apt-get update && \
    apt-get -y --no-install-recommends install ca-certificates cmake make git gcc g++ libbz2-dev libxml2-dev wget \
    libzip-dev libboost1.74-all-dev lua5.4 liblua5.4-dev pkg-config -o APT::Install-Suggests=0 -o APT::Install-Recommends=0
 RUN NPROC=${BUILD_CONCURRENCY:-$(nproc)} && \
    ldconfig /usr/local/lib && \
    git clone --branch v2021.3.0 --single-branch https://github.com/oneapi-src/oneTBB.git && \
    cd oneTBB && \
    mkdir build && \
    cd build && \
    cmake -DTBB_TEST=OFF -DCMAKE_BUILD_TYPE=Release ..  && \
    cmake --build . && \
    cmake --install .
 COPY . /src
 WORKDIR /src
 RUN NPROC=${BUILD_CONCURRENCY:-$(nproc)} && \
    echo "Building OSRM ${DOCKER_TAG}" && \
    git show --format="%H" | head -n1 > /opt/OSRM_GITSHA && \
    echo "Building OSRM gitsha $(cat /opt/OSRM_GITSHA)" && \
    mkdir -p build && \
    cd build && \
    BUILD_TYPE="Release" && \
    ENABLE_ASSERTIONS="Off" && \
    BUILD_TOOLS="Off" && \
    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 && \
    make -j${NPROC} install && \
    cd ../profiles && \
    cp -r * /opt && \
    strip /usr/local/bin/* && \
    rm -rf /src
 # Multistage build to reduce image size - https://docs.docker.com/engine/userguide/eng-image/multistage-build/#use-multi-stage-builds
 # Only the content below ends up in the image, this helps remove /src from the image (which is large)
 FROM debian:bullseye-slim as runstage
 COPY --from=builder /usr/local /usr/local
 COPY --from=builder /opt /opt
 RUN apt-get update && \
    apt-get install -y --no-install-recommends libboost-program-options1.74.0 libboost-regex1.74.0 \
        libboost-date-time1.74.0 libboost-chrono1.74.0 libboost-filesystem1.74.0 \
        libboost-iostreams1.74.0 libboost-system1.74.0 libboost-thread1.74.0 \
        expat liblua5.4-0 && \
    rm -rf /var/lib/apt/lists/* && \
 # add /usr/local/lib to ldconfig to allow loading libraries from there
    ldconfig /usr/local/lib
 RUN /usr/local/bin/osrm-extract --help && \
    /usr/local/bin/osrm-routed --help && \
    /usr/local/bin/osrm-contract --help && \
    /usr/local/bin/osrm-partition --help && \
    /usr/local/bin/osrm-customize --help
 WORKDIR /opt
 EXPOSE 5000
--- a/docker/Dockerfile-alpine
+++ b/docker/Dockerfile-alpine
@ -1,79 +0,0 @@
 FROM alpine:3.21.2 AS alpine-mimalloc
 RUN apk update && \
    apk upgrade && \
    apk add --no-cache \
        boost-iostreams \
        boost-program_options \
        boost-thread \
        mimalloc
 ENV LD_PRELOAD=/usr/lib/libmimalloc.so.2
 ENV MIMALLOC_LARGE_OS_PAGES=1
 FROM alpine-mimalloc AS builder
 ARG DOCKER_TAG
 ARG BUILD_CONCURRENCY
 RUN mkdir -p /src /opt && \
    apk add --no-cache \
    boost-dev \
    boost-filesystem \
    clang \
    cmake \
    expat-dev \
    git \
    libbz2 \
    libxml2 \
    lua5.4-dev \
    make \
    onetbb-dev
 COPY . /src
 WORKDIR /src
 RUN NPROC=${BUILD_CONCURRENCY:-$(nproc)} && \
    echo "Building OSRM ${DOCKER_TAG}" && \
    git show --format="%H" | head -n1 > /opt/OSRM_GITSHA && \
    echo "Building OSRM gitsha $(cat /opt/OSRM_GITSHA)" && \
    mkdir -p build && \
    cd build && \
    BUILD_TYPE="Release" && \
    ENABLE_ASSERTIONS="Off" && \
    BUILD_TOOLS="Off" && \
    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=OFF && \
    make -j${NPROC} install && \
    cd ../profiles && \
    cp -r * /opt && \
    strip /usr/local/bin/* && \
    rm -rf /src
 # Multistage build to reduce image size - https://docs.docker.com/build/building/multi-stage/#use-multi-stage-builds
 # Only the content below ends up in the image, this helps remove /src from the image (which is large)
 FROM alpine-mimalloc AS runstage
 COPY --from=builder /usr/local /usr/local
 COPY --from=builder /opt /opt
 RUN apk add --no-cache \
    boost-date_time \
    expat \
    lua5.4 \
    onetbb && \
    ldconfig /usr/local/lib
 RUN /usr/local/bin/osrm-extract --help && \
    /usr/local/bin/osrm-routed --help && \
    /usr/local/bin/osrm-contract --help && \
    /usr/local/bin/osrm-partition --help && \
    /usr/local/bin/osrm-customize --help
 WORKDIR /opt
 EXPOSE 5000
--- a/docker/Dockerfile-debian
+++ b/docker/Dockerfile-debian
@ -1,76 +0,0 @@
 FROM debian:bookworm-slim AS builder
 ARG DOCKER_TAG
 ARG BUILD_CONCURRENCY
 RUN mkdir -p /src /opt && \
    apt-get update && \
    apt-get -y --no-install-recommends --no-install-suggests install \
        ca-certificates \
        cmake \
        g++ \
        gcc \
        git \
        libboost1.81-all-dev \
        libbz2-dev \
        liblua5.4-dev \
        libtbb-dev \
        libxml2-dev \
        libzip-dev \
        lua5.4 \
        make \
        pkg-config
 COPY . /src
 WORKDIR /src
 RUN NPROC=${BUILD_CONCURRENCY:-$(nproc)} && \
    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)" && \
    mkdir -p build && \
    cd build && \
    BUILD_TYPE="Release" && \
    ENABLE_ASSERTIONS="Off" && \
    BUILD_TOOLS="Off" && \
    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 && \
    make -j${NPROC} install && \
    cd ../profiles && \
    cp -r * /opt && \
    strip /usr/local/bin/* && \
    rm -rf /src
 # Multistage build to reduce image size - https://docs.docker.com/build/building/multi-stage/#use-multi-stage-builds
 # Only the content below ends up in the image, this helps remove /src from the image (which is large)
 FROM debian:bookworm-slim AS runstage
 COPY --from=builder /usr/local /usr/local
 COPY --from=builder /opt /opt
 RUN apt-get update && \
    apt-get install -y --no-install-recommends --no-install-suggests \
        expat \
        libboost-date-time1.81.0 \
        libboost-iostreams1.81.0 \
        libboost-program-options1.81.0 \
        libboost-thread1.81.0 \
        liblua5.4-0 \
        libtbb12 && \
    rm -rf /var/lib/apt/lists/* && \
 # Add /usr/local/lib to ldconfig to allow loading libraries from there
    ldconfig /usr/local/lib
 RUN /usr/local/bin/osrm-extract --help && \
    /usr/local/bin/osrm-routed --help && \
    /usr/local/bin/osrm-contract --help && \
    /usr/local/bin/osrm-partition --help && \
    /usr/local/bin/osrm-customize --help
 WORKDIR /opt
 EXPOSE 5000
--- a/docker/hooks/build
+++ b/docker/hooks/build
@ -6,8 +6,4 @@
 # ensure that "COPY . /src" is referring to the repo root, not the directory
 # that contains the Dockerfile.
 # This script gets executed with a pwd of wherever the Dockerfile is.
-
+docker build --build-arg BUILD_CONCURRENCY=${CONCURRENCY:-1} --build-arg DOCKER_TAG=${DOCKER_TAG} -t $IMAGE_NAME -f Dockerfile ..
 DOCKER_BUILD="docker build --build-arg BUILD_CONCURRENCY=${CONCURRENCY} --build-arg DOCKER_TAG=${DOCKER_TAG:?unset} -t ${IMAGE_NAME:?unset} -f"
 $DOCKER_BUILD Dockerfile ..
 $DOCKER_BUILD Dockerfile-alpine ..
--- a/docs/nodejs/api.md
+++ b/docs/nodejs/api.md
@ -21,7 +21,7 @@ var osrm = new OSRM('network.osrm');
 **Parameters**
 -   `options` **([Object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object) \| [String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String))** Options for creating an OSRM object or string to the `.osrm` file. (optional, default `{shared_memory:true}`)
-    -   `options.algorithm` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)?** The algorithm to use for routing. Can be 'CH', or 'MLD'. Default is 'CH'.
+    -   `options.algorithm` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)?** The algorithm to use for routing. Can be 'CH', 'CoreCH' or 'MLD'. Default is 'CH'.
               Make sure you prepared the dataset with the correct toolchain.
    -   `options.shared_memory` **[Boolean](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean)?** Connects to the persistent shared memory datastore.
               This requires you to run `osrm-datastore` prior to creating an `OSRM` object.
--- a/example/example.cpp
+++ b/example/example.cpp
@ -57,15 +57,15 @@ int main(int argc, const char *argv[])
    // Execute routing request, this does the heavy lifting
    const auto status = osrm.Route(params, result);
-    auto &json_result = std::get<json::Object>(result);
+    auto &json_result = result.get<json::Object>();
    if (status == Status::Ok)
    {
-        auto &routes = std::get<json::Array>(json_result.values["routes"]);
+        auto &routes = json_result.values["routes"].get<json::Array>();
        // Let's just use the first route
-        auto &route = std::get<json::Object>(routes.values.at(0));
+        auto &route = routes.values.at(0).get<json::Object>();
-        const auto distance = std::get<json::Number>(route.values["distance"]).value;
+        const auto distance = route.values["distance"].get<json::Number>().value;
-        const auto duration = std::get<json::Number>(route.values["duration"]).value;
+        const auto duration = route.values["duration"].get<json::Number>().value;
        // Warn users if extract does not contain the default coordinates from above
        if (distance == 0 || duration == 0)
@ -80,8 +80,8 @@ int main(int argc, const char *argv[])
    }
    else if (status == Status::Error)
    {
-        const auto code = std::get<json::String>(json_result.values["code"]).value;
+        const auto code = json_result.values["code"].get<json::String>().value;
-        const auto message = std::get<json::String>(json_result.values["message"]).value;
+        const auto message = json_result.values["message"].get<json::String>().value;
        std::cout << "Code: " << code << "\n";
        std::cout << "Message: " << code << "\n";
--- a/third_party/flatbuffers/grpc/BUILD.bazel
+++ b/third_party/flatbuffers/grpc/BUILD.bazel
--- a/features/foot/access.feature
+++ b/features/foot/access.feature
@ -26,15 +26,7 @@ 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
--- a/features/guidance/collapse.feature
+++ b/features/guidance/collapse.feature
@ -1061,7 +1061,7 @@ Feature: Collapse
        #    i
        #    """
-        Given the node locations
+        And the node locations
          | node |         lat |         lon |        #id |
          | a    | -33.9644254 | 151.1378673 |   33226063 |
          | b    | -33.9644373 | 151.1377172 | 1072787030 |
--- a/features/guidance/roundabout-left-sided.feature
+++ b/features/guidance/roundabout-left-sided.feature
@ -9,7 +9,7 @@ Feature: Basic Roundabout
            """
    Scenario: Roundabout exit counting for left sided driving
-        Given a grid size of 10 meters
+        And 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
-        Given a grid size of 10 meters
+        And a grid size of 10 meters
        And the node map
           """
             c   a
--- a/features/options/contract/help.feature
+++ b/features/options/contract/help.feature
@ -0,0 +1,44 @@
@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
--- a/features/options/customize/help.feature
+++ b/features/options/customize/help.feature
@ -0,0 +1,38 @@
@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
--- a/features/options/datastore/datastore.feature
+++ b/features/options/datastore/datastore.feature
@ -33,6 +33,10 @@ 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."
--- a/features/options/extract/help.feature
+++ b/features/options/extract/help.feature
@ -0,0 +1,47 @@
@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
--- a/features/options/partition/help.feature
+++ b/features/options/partition/help.feature
@ -0,0 +1,53 @@
@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
--- a/features/options/routed/help.feature
+++ b/features/options/routed/help.feature
@ -0,0 +1,71 @@
@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
--- a/features/support/env.js
+++ b/features/support/env.js
@ -42,7 +42,7 @@ module.exports = function () {
        this.OSRM_PORT = process.env.OSRM_PORT && parseInt(process.env.OSRM_PORT) || 5000;
        this.OSRM_IP = process.env.OSRM_IP || '127.0.0.1';
        this.OSRM_CONNECTION_RETRIES = process.env.OSRM_CONNECTION_RETRIES && parseInt(process.env.OSRM_CONNECTION_RETRIES) || 10;
-        this.OSRM_CONNECTION_EXP_BACKOFF_COEF = process.env.OSRM_CONNECTION_EXP_BACKOFF_COEF && parseFloat(process.env.OSRM_CONNECTION_EXP_BACKOFF_COEF) || 1.1;
+        this.OSRM_CONNECTION_EXP_BACKOFF_COEF = process.env.OSRM_CONNECTION_EXP_BACKOFF_COEF && parseFloat(process.env.OSRM_CONNECTION_EXP_BACKOFF_COEF) || 1.0;
        this.HOST = `http://${this.OSRM_IP}:${this.OSRM_PORT}`;
--- a/features/testbot/loop.feature
+++ b/features/testbot/loop.feature
@ -75,7 +75,7 @@ Feature: Avoid weird loops caused by rounding errors
    @412 @via
    Scenario: Avoid weird loops 3
-        Given the node map
+        And the node map
            """
            a
            b e
--- a/features/testbot/matching.feature
+++ b/features/testbot/matching.feature
@ -136,6 +136,22 @@ 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
            """
--- a/features/testbot/snap_intersection.feature
+++ b/features/testbot/snap_intersection.feature
@ -401,12 +401,12 @@ Feature: Snapping at intersections
        Given the extract extra arguments "--small-component-size=4"
        And the ways
-            | nodes | oneway | # comment  |
+            | nodes | oneway |
-            | ab    | no     |            |
+            | ab    | no     |
-            | bc    | no     |            |
+            | bc    | no     |
-            | cd    | no     |            |
+            | cd    | no     |
-            | fed   | no     |            |
+            | fed   | no     |
-            | bg    | yes    | small SCC  |
+            | 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 | # comment |
+            | nodes | oneway |
-            | ab    | no     |           |
+            | ab    | no     |
-            | bc    | no     |           |
+            | bc    | no     |
-            | cd    | no     |           |
+            | cd    | no     |
-            | fed   | no     |           |
+            | fed   | no     |
-            | ghi   | no     |           |
+            | ghi   | no     |
-            | jkl   | no     |           |
+            | jkl   | no     |
-            | bm    | yes    | small SCC |
+            | bm    | yes    | # small SCC
        And the relations
            | type        | way:from | way:to | node:via | restriction   |
--- a/features/testbot/via.feature
+++ b/features/testbot/via.feature
@ -65,6 +65,32 @@ 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
            """
--- a/generated/include/engine/api/flatbuffers/fbresult_generated.h
+++ b/generated/include/engine/api/flatbuffers/fbresult_generated.h
@ -1,249 +0,0 @@
 // 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_
--- a/generated/include/engine/api/flatbuffers/position_generated.h
+++ b/generated/include/engine/api/flatbuffers/position_generated.h
@ -1,51 +0,0 @@
 // 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_
--- a/generated/include/engine/api/flatbuffers/route_generated.h
+++ b/generated/include/engine/api/flatbuffers/route_generated.h
--- a/generated/include/engine/api/flatbuffers/table_generated.h
+++ b/generated/include/engine/api/flatbuffers/table_generated.h
@ -1,149 +0,0 @@
 // 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_
--- a/generated/include/engine/api/flatbuffers/waypoint_generated.h
+++ b/generated/include/engine/api/flatbuffers/waypoint_generated.h
@ -1,205 +0,0 @@
 // 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_
--- a/include/contractor/contractor_config.hpp
+++ b/include/contractor/contractor_config.hpp
@ -31,7 +31,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "storage/io_config.hpp"
 #include "updater/updater_config.hpp"
-#include <filesystem>
+#include <boost/filesystem/path.hpp>
 #include <string>
 namespace osrm::contractor
@ -46,7 +47,7 @@ struct ContractorConfig final : storage::IOConfig
    }
    // Infer the output names from the path of the .osrm file
-    void UseDefaultOutputNames(const std::filesystem::path &base)
+    void UseDefaultOutputNames(const boost::filesystem::path &base)
    {
        IOConfig::UseDefaultOutputNames(base);
        updater_config.UseDefaultOutputNames(base);
--- a/include/contractor/crc32_processor.hpp
+++ b/include/contractor/crc32_processor.hpp
@ -0,0 +1,128 @@
 #ifndef ITERATOR_BASED_CRC32_H
 #define ITERATOR_BASED_CRC32_H
 #if defined(__x86_64__) && !defined(__MINGW64__)
 #include <cpuid.h>
 #endif
 #include <boost/crc.hpp> // for boost::crc_32_type
 #include <iterator>
 namespace osrm::contractor
 {
 class IteratorbasedCRC32
 {
  public:
    bool UsingHardware() const { return use_hardware_implementation; }
    IteratorbasedCRC32() : crc(0) { use_hardware_implementation = DetectHardwareSupport(); }
    template <class Iterator> unsigned operator()(Iterator iter, const Iterator end)
    {
        unsigned crc = 0;
        while (iter != end)
        {
            using value_type = typename std::iterator_traits<Iterator>::value_type;
            const char *data = reinterpret_cast<const char *>(&(*iter));
            if (use_hardware_implementation)
            {
                crc = ComputeInHardware(data, sizeof(value_type));
            }
            else
            {
                crc = ComputeInSoftware(data, sizeof(value_type));
            }
            ++iter;
        }
        return crc;
    }
  private:
    bool DetectHardwareSupport() const
    {
        static const int sse42_bit = 0x00100000;
        const unsigned ecx = cpuid();
        const bool sse42_found = (ecx & sse42_bit) != 0;
        return sse42_found;
    }
    unsigned ComputeInSoftware(const char *str, unsigned len)
    {
        crc_processor.process_bytes(str, len);
        return crc_processor.checksum();
    }
    // adapted from http://byteworm.com/2010/10/13/crc32/
    unsigned ComputeInHardware(const char *str, unsigned len)
    {
 #if defined(__x86_64__)
        unsigned q = len / sizeof(unsigned);
        unsigned r = len % sizeof(unsigned);
        unsigned *p = (unsigned *)str;
        // crc=0;
        while (q--)
        {
            __asm__ __volatile__(".byte 0xf2, 0xf, 0x38, 0xf1, 0xf1;"
                                 : "=S"(crc)
                                 : "0"(crc), "c"(*p));
            ++p;
        }
        str = reinterpret_cast<char *>(p);
        while (r--)
        {
            __asm__ __volatile__(".byte 0xf2, 0xf, 0x38, 0xf1, 0xf1;"
                                 : "=S"(crc)
                                 : "0"(crc), "c"(*str));
            ++str;
        }
 #else
        (void)str;
        (void)len;
 #endif
        return crc;
    }
    inline unsigned cpuid() const
    {
        unsigned eax = 0, ebx = 0, ecx = 0, edx = 0;
        // on X64 this calls hardware cpuid(.) instr. otherwise a dummy impl.
        __get_cpuid(1, &eax, &ebx, &ecx, &edx);
        return ecx;
    }
 #if defined(__MINGW64__) || defined(_MSC_VER) || !defined(__x86_64__)
    inline void __get_cpuid(int /*param*/,
                            unsigned * /*eax*/,
                            unsigned * /*ebx*/,
                            unsigned *ecx,
                            unsigned * /*edx*/) const
    {
        *ecx = 0;
    }
 #endif
    boost::crc_optimal<32, 0x1EDC6F41, 0x0, 0x0, true, true> crc_processor;
    unsigned crc;
    bool use_hardware_implementation;
 };
 struct RangebasedCRC32
 {
    template <typename Iteratable> unsigned operator()(const Iteratable &iterable)
    {
        return crc32(std::begin(iterable), std::end(iterable));
    }
    bool UsingHardware() const { return crc32.UsingHardware(); }
  private:
    IteratorbasedCRC32 crc32;
 };
 } // namespace osrm::contractor
 #endif /* ITERATOR_BASED_CRC32_H */
--- a/include/contractor/files.hpp
+++ b/include/contractor/files.hpp
@ -9,7 +9,7 @@ namespace osrm::contractor::files
 {
 // reads .osrm.hsgr file
 template <typename ContractedMetricT>
-inline void readGraph(const std::filesystem::path &path,
+inline void readGraph(const boost::filesystem::path &path,
                      std::unordered_map<std::string, ContractedMetricT> &metrics,
                      std::uint32_t &connectivity_checksum)
 {
@ -30,7 +30,7 @@ inline void readGraph(const std::filesystem::path &path,
 // writes .osrm.hsgr file
 template <typename ContractedMetricT>
-inline void writeGraph(const std::filesystem::path &path,
+inline void writeGraph(const boost::filesystem::path &path,
                       const std::unordered_map<std::string, ContractedMetricT> &metrics,
                       const std::uint32_t connectivity_checksum)
 {
--- a/include/customizer/customizer_config.hpp
+++ b/include/customizer/customizer_config.hpp
@ -1,8 +1,9 @@
 #ifndef OSRM_CUSTOMIZE_CUSTOMIZER_CONFIG_HPP
 #define OSRM_CUSTOMIZE_CUSTOMIZER_CONFIG_HPP
 #include <boost/filesystem/path.hpp>
 #include <array>
 #include <filesystem>
 #include <string>
 #include "storage/io_config.hpp"
@ -26,7 +27,7 @@ struct CustomizationConfig final : storage::IOConfig
    {
    }
-    void UseDefaultOutputNames(const std::filesystem::path &base)
+    void UseDefaultOutputNames(const boost::filesystem::path &base)
    {
        IOConfig::UseDefaultOutputNames(base);
        updater_config.UseDefaultOutputNames(base);
--- a/include/customizer/edge_based_graph.hpp
+++ b/include/customizer/edge_based_graph.hpp
@ -9,7 +9,7 @@
 #include "storage/shared_memory_ownership.hpp"
-#include <filesystem>
+#include <boost/filesystem/path.hpp>
 namespace osrm::customizer
 {
--- a/include/customizer/files.hpp
+++ b/include/customizer/files.hpp
@ -14,7 +14,7 @@ namespace osrm::customizer::files
 // reads .osrm.cell_metrics file
 template <typename CellMetricT>
-inline void readCellMetrics(const std::filesystem::path &path,
+inline void readCellMetrics(const boost::filesystem::path &path,
                            std::unordered_map<std::string, std::vector<CellMetricT>> &metrics)
 {
    static_assert(std::is_same<CellMetricView, CellMetricT>::value ||
@ -44,7 +44,7 @@ inline void readCellMetrics(const std::filesystem::path &path,
 // writes .osrm.cell_metrics file
 template <typename CellMetricT>
 inline void
-writeCellMetrics(const std::filesystem::path &path,
+writeCellMetrics(const boost::filesystem::path &path,
                 const std::unordered_map<std::string, std::vector<CellMetricT>> &metrics)
 {
    static_assert(std::is_same<CellMetricView, CellMetricT>::value ||
@ -72,7 +72,7 @@ writeCellMetrics(const std::filesystem::path &path,
 // reads .osrm.mldgr file
 template <typename MultiLevelGraphT>
-inline void readGraph(const std::filesystem::path &path,
+inline void readGraph(const boost::filesystem::path &path,
                      MultiLevelGraphT &graph,
                      std::uint32_t &connectivity_checksum)
 {
@ -88,7 +88,7 @@ inline void readGraph(const std::filesystem::path &path,
 // writes .osrm.mldgr file
 template <typename MultiLevelGraphT>
-inline void writeGraph(const std::filesystem::path &path,
+inline void writeGraph(const boost::filesystem::path &path,
                       const MultiLevelGraphT &graph,
                       const std::uint32_t connectivity_checksum)
 {
--- a/include/engine/api/base_parameters.hpp
+++ b/include/engine/api/base_parameters.hpp
@ -33,7 +33,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "engine/hint.hpp"
 #include "util/coordinate.hpp"
-#include <optional>
+#include <boost/optional.hpp>
 #include <algorithm>
 #include <vector>
@ -74,12 +74,12 @@ struct BaseParameters
    };
    std::vector<util::Coordinate> coordinates;
-    std::vector<std::optional<Hint>> hints;
+    std::vector<boost::optional<Hint>> hints;
-    std::vector<std::optional<double>> radiuses;
+    std::vector<boost::optional<double>> radiuses;
-    std::vector<std::optional<Bearing>> bearings;
+    std::vector<boost::optional<Bearing>> bearings;
-    std::vector<std::optional<Approach>> approaches;
+    std::vector<boost::optional<Approach>> approaches;
    std::vector<std::string> exclude;
-    std::optional<OutputFormatType> format = OutputFormatType::JSON;
+    boost::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<std::optional<Hint>> hints_ = {},
+                   std::vector<boost::optional<Hint>> hints_ = {},
-                   std::vector<std::optional<double>> radiuses_ = {},
+                   std::vector<boost::optional<double>> radiuses_ = {},
-                   std::vector<std::optional<Bearing>> bearings_ = {},
+                   std::vector<boost::optional<Bearing>> bearings_ = {},
-                   std::vector<std::optional<Approach>> approaches_ = {},
+                   std::vector<boost::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 std::optional<Bearing> &bearing_and_range)
+                           [](const boost::optional<Bearing> &bearing_and_range)
                           {
                               if (bearing_and_range)
                               {
--- a/include/engine/api/base_result.hpp
+++ b/include/engine/api/base_result.hpp
@ -2,7 +2,7 @@
 #define ENGINE_API_BASE_RESULT_HPP
 #include <flatbuffers/flatbuffers.h>
-#include <variant>
+#include <mapbox/variant.hpp>
 #include <string>
@ -10,7 +10,8 @@
 namespace osrm::engine::api
 {
-using ResultT = std::variant<util::json::Object, std::string, flatbuffers::FlatBufferBuilder>;
+using ResultT =
    mapbox::util::variant<util::json::Object, std::string, flatbuffers::FlatBufferBuilder>;
 } // namespace osrm::engine::api
 #endif
--- a/include/engine/api/flatbuffers/fbresult.fbs
+++ b/include/engine/api/flatbuffers/fbresult.fbs
@ -14,7 +14,7 @@ table FBResult {
    data_version: string;
    waypoints: [Waypoint]; //Used as 'sources' waypoints for a 'Table' service
    routes: [RouteObject];
-    table: TableResult;
+    table: Table;
 }
 root_type FBResult;
--- a/include/engine/api/flatbuffers/fbresult_generated.h
+++ b/include/engine/api/flatbuffers/fbresult_generated.h
--- a/include/engine/api/flatbuffers/table.fbs
+++ b/include/engine/api/flatbuffers/table.fbs
@ -1,7 +1,7 @@
 include "waypoint.fbs";
 namespace osrm.engine.api.fbresult;
-table TableResult {
+table Table {
    durations: [float];
    rows: ushort;
    cols: ushort;
--- a/include/engine/api/json_factory.hpp
+++ b/include/engine/api/json_factory.hpp
@ -12,7 +12,7 @@
 #include "util/coordinate.hpp"
 #include "util/json_container.hpp"
-#include <optional>
+#include <boost/optional.hpp>
 #include <algorithm>
 #include <iterator>
@ -41,7 +41,7 @@ inline bool hasValidLanes(const guidance::IntermediateIntersection &intersection
    return intersection.lanes.lanes_in_turn > 0;
 }
-util::json::Value coordinateToLonLat(const util::Coordinate &coordinate);
+util::json::Array coordinateToLonLat(const util::Coordinate &coordinate);
 /**
 * Ensures that a bearing value is a whole number, and clamped to the range 0-359
@ -79,7 +79,7 @@ util::json::Object makeGeoJSONGeometry(ForwardIter begin, ForwardIter end)
        coordinates.values.push_back(location);
        coordinates.values.push_back(location);
    }
-    geojson.values["coordinates"] = util::json::Value{std::move(coordinates)};
+    geojson.values["coordinates"] = std::move(coordinates);
    return geojson;
 }
@ -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,
-                             std::optional<util::json::Value> geometry,
+                             boost::optional<util::json::Value> geometry,
                             const char *weight_name);
 // Creates a Waypoint without Hint, see the Hint overload below
--- a/include/engine/api/match_api.hpp
+++ b/include/engine/api/match_api.hpp
@ -30,14 +30,14 @@ class MatchAPI final : public RouteAPI
                      osrm::engine::api::ResultT &response) const
    {
        BOOST_ASSERT(sub_matchings.size() == sub_routes.size());
-        if (std::holds_alternative<flatbuffers::FlatBufferBuilder>(response))
+        if (response.is<flatbuffers::FlatBufferBuilder>())
        {
-            auto &fb_result = std::get<flatbuffers::FlatBufferBuilder>(response);
+            auto &fb_result = response.get<flatbuffers::FlatBufferBuilder>();
            MakeResponse(sub_matchings, sub_routes, fb_result);
        }
        else
        {
-            auto &json_result = std::get<util::json::Object>(response);
+            auto &json_result = response.get<util::json::Object>();
            MakeResponse(sub_matchings, sub_routes, json_result);
        }
    }
@ -77,19 +77,19 @@ class MatchAPI final : public RouteAPI
                                   sub_routes[index].unpacked_path_segments,
                                   sub_routes[index].source_traversed_in_reverse,
                                   sub_routes[index].target_traversed_in_reverse);
-            route.values.emplace("confidence", sub_matchings[index].confidence);
+            route.values["confidence"] = sub_matchings[index].confidence;
-            routes.values.emplace_back(std::move(route));
+            routes.values.push_back(std::move(route));
        }
        if (!parameters.skip_waypoints)
        {
-            response.values.emplace("tracepoints", MakeTracepoints(sub_matchings));
+            response.values["tracepoints"] = MakeTracepoints(sub_matchings);
        }
-        response.values.emplace("matchings", std::move(routes));
+        response.values["matchings"] = std::move(routes);
-        response.values.emplace("code", "Ok");
+        response.values["code"] = "Ok";
        auto data_timestamp = facade.GetTimestamp();
        if (!data_timestamp.empty())
        {
-            response.values.emplace("data_version", data_timestamp);
+            response.values["data_version"] = data_timestamp;
        }
    }
@ -132,13 +132,13 @@ class MatchAPI final : public RouteAPI
            if (tidy_result.can_be_removed[trace_index])
            {
-                waypoints.emplace_back(fbresult::WaypointBuilder(fb_result).Finish());
+                waypoints.push_back(fbresult::WaypointBuilder(fb_result).Finish());
                continue;
            }
            auto matching_index = trace_idx_to_matching_idx[trace_index];
            if (matching_index.NotMatched())
            {
-                waypoints.emplace_back(fbresult::WaypointBuilder(fb_result).Finish());
+                waypoints.push_back(fbresult::WaypointBuilder(fb_result).Finish());
                continue;
            }
            const auto &phantom =
@ -165,7 +165,7 @@ class MatchAPI final : public RouteAPI
            {
                waypoint->add_waypoint_index(matching_index.point_index);
            }
-            waypoints.emplace_back(waypoint->Finish());
+            waypoints.push_back(waypoint->Finish());
        }
        return fb_result.CreateVector(waypoints);
@ -186,23 +186,23 @@ class MatchAPI final : public RouteAPI
        {
            if (tidy_result.can_be_removed[trace_index])
            {
-                waypoints.values.emplace_back(util::json::Null());
+                waypoints.values.push_back(util::json::Null());
                continue;
            }
            auto matching_index = trace_idx_to_matching_idx[trace_index];
            if (matching_index.NotMatched())
            {
-                waypoints.values.emplace_back(util::json::Null());
+                waypoints.values.push_back(util::json::Null());
                continue;
            }
            const auto &phantom =
                sub_matchings[matching_index.sub_matching_index].nodes[matching_index.point_index];
            auto waypoint = BaseAPI::MakeWaypoint({phantom});
-            waypoint.values.emplace("matchings_index", matching_index.sub_matching_index);
+            waypoint.values["matchings_index"] = matching_index.sub_matching_index;
-            waypoint.values.emplace("waypoint_index", matching_index.point_index);
+            waypoint.values["waypoint_index"] = matching_index.point_index;
-            waypoint.values.emplace("alternatives_count",
+            waypoint.values["alternatives_count"] =
-                                    sub_matchings[matching_index.sub_matching_index]
+                sub_matchings[matching_index.sub_matching_index]
-                                        .alternatives_count[matching_index.point_index]);
+                    .alternatives_count[matching_index.point_index];
            // waypoint indices need to be adjusted if route legs were collapsed
            // waypoint parameter assumes there is only one match object
            if (!parameters.waypoints.empty())
@ -217,7 +217,7 @@ class MatchAPI final : public RouteAPI
                    waypoint.values["waypoint_index"] = util::json::Null();
                }
            }
-            waypoints.values.emplace_back(std::move(waypoint));
+            waypoints.values.push_back(std::move(waypoint));
        }
        return waypoints;
--- a/include/engine/api/nearest_api.hpp
+++ b/include/engine/api/nearest_api.hpp
@ -29,14 +29,14 @@ class NearestAPI final : public BaseAPI
        BOOST_ASSERT(phantom_nodes.size() == 1);
        BOOST_ASSERT(parameters.coordinates.size() == 1);
-        if (std::holds_alternative<flatbuffers::FlatBufferBuilder>(response))
+        if (response.is<flatbuffers::FlatBufferBuilder>())
        {
-            auto &fb_result = std::get<flatbuffers::FlatBufferBuilder>(response);
+            auto &fb_result = response.get<flatbuffers::FlatBufferBuilder>();
            MakeResponse(phantom_nodes, fb_result);
        }
        else
        {
-            auto &json_result = std::get<util::json::Object>(response);
+            auto &json_result = response.get<util::json::Object>();
            MakeResponse(phantom_nodes, json_result);
        }
    }
@ -45,7 +45,7 @@ class NearestAPI final : public BaseAPI
                      flatbuffers::FlatBufferBuilder &fb_result) const
    {
        auto data_timestamp = facade.GetTimestamp();
-        std::optional<flatbuffers::Offset<flatbuffers::String>> data_version_string = std::nullopt;
+        boost::optional<flatbuffers::Offset<flatbuffers::String>> data_version_string = boost::none;
        if (!data_timestamp.empty())
        {
            data_version_string = fb_result.CreateString(data_timestamp);
@ -100,23 +100,23 @@ class NearestAPI final : public BaseAPI
                               auto waypoint = MakeWaypoint({phantom_node});
                               util::json::Array nodes;
                               nodes.values.reserve(2);
                               auto node_values = MakeNodes(phantom_node);
-                               nodes.values.emplace_back(node_values.first);
+                               nodes.values.push_back(node_values.first);
-                               nodes.values.emplace_back(node_values.second);
+                               nodes.values.push_back(node_values.second);
-                               waypoint.values.emplace("nodes", std::move(nodes));
+                               waypoint.values["nodes"] = std::move(nodes);
                               return waypoint;
                           });
-            response.values.emplace("waypoints", std::move(waypoints));
+            response.values["waypoints"] = std::move(waypoints);
        }
-        response.values.emplace("code", "Ok");
+        response.values["code"] = "Ok";
        auto data_timestamp = facade.GetTimestamp();
        if (!data_timestamp.empty())
        {
-            response.values.emplace("data_version", data_timestamp);
+            response.values["data_version"] = data_timestamp;
        }
    }
--- a/include/engine/api/route_api.hpp
+++ b/include/engine/api/route_api.hpp
@ -50,14 +50,14 @@ class RouteAPI : public BaseAPI
    {
        BOOST_ASSERT(!raw_routes.routes.empty());
-        if (std::holds_alternative<flatbuffers::FlatBufferBuilder>(response))
+        if (response.is<flatbuffers::FlatBufferBuilder>())
        {
-            auto &fb_result = std::get<flatbuffers::FlatBufferBuilder>(response);
+            auto &fb_result = response.get<flatbuffers::FlatBufferBuilder>();
            MakeResponse(raw_routes, waypoint_candidates, fb_result);
        }
        else
        {
-            auto &json_result = std::get<util::json::Object>(response);
+            auto &json_result = response.get<util::json::Object>();
            MakeResponse(raw_routes, waypoint_candidates, json_result);
        }
    }
@ -110,14 +110,14 @@ class RouteAPI : public BaseAPI
        if (!parameters.skip_waypoints)
        {
-            response.values.emplace("waypoints", BaseAPI::MakeWaypoints(waypoint_candidates));
+            response.values["waypoints"] = BaseAPI::MakeWaypoints(waypoint_candidates);
        }
-        response.values.emplace("routes", std::move(jsRoutes));
+        response.values["routes"] = std::move(jsRoutes);
-        response.values.emplace("code", "Ok");
+        response.values["code"] = "Ok";
        auto data_timestamp = facade.GetTimestamp();
        if (!data_timestamp.empty())
        {
-            response.values.emplace("data_version", data_timestamp);
+            response.values["data_version"] = data_timestamp;
        }
    }
@ -158,8 +158,8 @@ class RouteAPI : public BaseAPI
    }
    template <typename ForwardIter>
-    std::variant<flatbuffers::Offset<flatbuffers::String>,
+    mapbox::util::variant<flatbuffers::Offset<flatbuffers::String>,
-                 flatbuffers::Offset<flatbuffers::Vector<const fbresult::Position *>>>
+                          flatbuffers::Offset<flatbuffers::Vector<const fbresult::Position *>>>
    MakeGeometry(flatbuffers::FlatBufferBuilder &builder, ForwardIter begin, ForwardIter end) const
    {
        if (parameters.geometries == RouteParameters::GeometriesType::Polyline)
@ -184,10 +184,10 @@ class RouteAPI : public BaseAPI
        return builder.CreateVectorOfStructs(coordinates);
    }
-    std::optional<util::json::Value>
+    boost::optional<util::json::Value>
-    MakeGeometry(std::optional<std::vector<Coordinate>> &&annotations) const
+    MakeGeometry(boost::optional<std::vector<Coordinate>> &&annotations) const
    {
-        std::optional<util::json::Value> json_geometry;
+        boost::optional<util::json::Value> json_geometry;
        if (annotations)
        {
            auto begin = annotations->begin();
@ -340,8 +340,8 @@ class RouteAPI : public BaseAPI
                                  unpacked_path_segments,
                                  source_traversed_in_reverse,
                                  target_traversed_in_reverse);
-        std::vector<guidance::RouteLeg> &legs = legs_info.first;
+        std::vector<guidance::RouteLeg> legs = legs_info.first;
-        std::vector<guidance::LegGeometry> &leg_geometries = legs_info.second;
+        std::vector<guidance::LegGeometry> leg_geometries = legs_info.second;
        auto route = guidance::assembleRoute(legs);
        // Fill legs
@ -408,8 +408,8 @@ class RouteAPI : public BaseAPI
        // Fill geometry
        auto overview = MakeOverview(leg_geometries);
-        std::variant<flatbuffers::Offset<flatbuffers::String>,
+        mapbox::util::variant<flatbuffers::Offset<flatbuffers::String>,
-                     flatbuffers::Offset<flatbuffers::Vector<const fbresult::Position *>>>
+                              flatbuffers::Offset<flatbuffers::Vector<const fbresult::Position *>>>
            geometry;
        if (overview)
        {
@ -426,7 +426,8 @@ class RouteAPI : public BaseAPI
        routeObject.add_legs(legs_vector);
        if (overview)
        {
-            std::visit(GeometryVisitor<fbresult::RouteObjectBuilder>(routeObject), geometry);
+            mapbox::util::apply_visitor(GeometryVisitor<fbresult::RouteObjectBuilder>(routeObject),
                                        geometry);
        }
        return routeObject.Finish();
@ -442,22 +443,23 @@ class RouteAPI : public BaseAPI
        if (requested_annotations & RouteParameters::AnnotationsType::Speed)
        {
            double prev_speed = 0;
-            speed = GetAnnotations<float>(
+            speed =
-                fb_result,
+                GetAnnotations<float>(fb_result,
-                leg_geometry,
+                                      leg_geometry,
-                [&prev_speed](const guidance::LegGeometry::Annotation &anno)
+                                      [&prev_speed](const guidance::LegGeometry::Annotation &anno)
-                {
+                                      {
-                    if (anno.duration < std::numeric_limits<float>::min())
+                                          if (anno.duration < std::numeric_limits<float>::min())
-                    {
+                                          {
-                        return prev_speed;
+                                              return prev_speed;
-                    }
+                                          }
-                    else
+                                          else
-                    {
+                                          {
-                        auto speed = std::round(anno.distance / anno.duration * 10.) / 10.;
+                                              auto speed =
-                        prev_speed = speed;
+                                                  round(anno.distance / anno.duration * 10.) / 10.;
-                        return util::json::clamp_float(speed);
+                                              prev_speed = speed;
-                    }
+                                              return util::json::clamp_float(speed);
-                });
+                                          }
                                      });
        }
        flatbuffers::Offset<flatbuffers::Vector<uint32_t>> duration;
@ -643,7 +645,7 @@ class RouteAPI : public BaseAPI
        stepBuilder.add_rotary_pronunciation(rotary_pronunciation_string);
        stepBuilder.add_intersections(intersections_vector);
        stepBuilder.add_maneuver(maneuver_buffer);
-        std::visit(GeometryVisitor<fbresult::StepBuilder>(stepBuilder), geometry);
+        mapbox::util::apply_visitor(GeometryVisitor<fbresult::StepBuilder>(stepBuilder), geometry);
        return stepBuilder.Finish();
    };
@ -716,11 +718,12 @@ class RouteAPI : public BaseAPI
                                  unpacked_path_segments,
                                  source_traversed_in_reverse,
                                  target_traversed_in_reverse);
-        std::vector<guidance::RouteLeg> &legs = legs_info.first;
+        std::vector<guidance::RouteLeg> legs = legs_info.first;
-        std::vector<guidance::LegGeometry> &leg_geometries = legs_info.second;
+        std::vector<guidance::LegGeometry> leg_geometries = legs_info.second;
        auto route = guidance::assembleRoute(legs);
-        std::optional<util::json::Value> json_overview = MakeGeometry(MakeOverview(leg_geometries));
+        boost::optional<util::json::Value> json_overview =
            MakeGeometry(MakeOverview(leg_geometries));
        std::vector<util::json::Value> step_geometries;
        const auto total_step_count =
@ -783,57 +786,49 @@ class RouteAPI : public BaseAPI
                if (requested_annotations & RouteParameters::AnnotationsType::Speed)
                {
                    double prev_speed = 0;
-                    annotation.values.emplace(
+                    annotation.values["speed"] = GetAnnotations(
-                        "speed",
+                        leg_geometry,
-                        GetAnnotations(leg_geometry,
+                        [&prev_speed](const guidance::LegGeometry::Annotation &anno)
-                                       [&prev_speed](const guidance::LegGeometry::Annotation &anno)
+                        {
-                                       {
+                            if (anno.duration < std::numeric_limits<double>::min())
-                                           if (anno.duration < std::numeric_limits<double>::min())
+                            {
-                                           {
+                                return prev_speed;
-                                               return prev_speed;
+                            }
-                                           }
+                            else
-                                           else
+                            {
-                                           {
+                                auto speed = std::round(anno.distance / anno.duration * 10.) / 10.;
-                                               auto speed =
+                                prev_speed = speed;
-                                                   std::round(anno.distance / anno.duration * 10.) /
+                                return util::json::clamp_float(speed);
-                                                   10.;
+                            }
-                                               prev_speed = speed;
+                        });
                                               return util::json::clamp_float(speed);
                                           }
                                       }));
                }
                if (requested_annotations & RouteParameters::AnnotationsType::Duration)
                {
-                    annotation.values.emplace(
+                    annotation.values["duration"] =
                        "duration",
                        GetAnnotations(leg_geometry,
                                       [](const guidance::LegGeometry::Annotation &anno)
-                                       { return anno.duration; }));
+                                       { return anno.duration; });
                }
                if (requested_annotations & RouteParameters::AnnotationsType::Distance)
                {
-                    annotation.values.emplace(
+                    annotation.values["distance"] =
                        "distance",
                        GetAnnotations(leg_geometry,
                                       [](const guidance::LegGeometry::Annotation &anno)
-                                       { return anno.distance; }));
+                                       { return anno.distance; });
                }
                if (requested_annotations & RouteParameters::AnnotationsType::Weight)
                {
-                    annotation.values.emplace(
+                    annotation.values["weight"] = GetAnnotations(
-                        "weight",
+                        leg_geometry,
-                        GetAnnotations(leg_geometry,
+                        [](const guidance::LegGeometry::Annotation &anno) { return anno.weight; });
                                       [](const guidance::LegGeometry::Annotation &anno)
                                       { return anno.weight; }));
                }
                if (requested_annotations & RouteParameters::AnnotationsType::Datasources)
                {
-                    annotation.values.emplace(
+                    annotation.values["datasources"] =
                        "datasources",
                        GetAnnotations(leg_geometry,
                                       [](const guidance::LegGeometry::Annotation &anno)
-                                       { return anno.datasource; }));
+                                       { return anno.datasource; });
                }
                if (requested_annotations & RouteParameters::AnnotationsType::Nodes)
                {
@ -844,7 +839,7 @@ class RouteAPI : public BaseAPI
                        nodes.values.push_back(
                            static_cast<std::uint64_t>(facade.GetOSMNodeIDOfNode(node_id)));
                    }
-                    annotation.values.emplace("nodes", std::move(nodes));
+                    annotation.values["nodes"] = std::move(nodes);
                }
                // Add any supporting metadata, if needed
                if (requested_annotations & RouteParameters::AnnotationsType::Datasources)
@ -860,8 +855,8 @@ class RouteAPI : public BaseAPI
                            break;
                        datasource_names.values.push_back(std::string(facade.GetDatasourceName(i)));
                    }
-                    metadata.values.emplace("datasource_names", datasource_names);
+                    metadata.values["datasource_names"] = datasource_names;
-                    annotation.values.emplace("metadata", metadata);
+                    annotation.values["metadata"] = metadata;
                }
                annotations.push_back(std::move(annotation));
@ -996,10 +991,10 @@ class RouteAPI : public BaseAPI
        return result;
    }
-    std::optional<std::vector<Coordinate>>
+    boost::optional<std::vector<Coordinate>>
    MakeOverview(const std::vector<guidance::LegGeometry> &leg_geometries) const
    {
-        std::optional<std::vector<Coordinate>> overview;
+        boost::optional<std::vector<Coordinate>> overview;
        if (parameters.overview != RouteParameters::OverviewType::False)
        {
            const auto use_simplification =
--- a/include/engine/api/route_parameters.hpp
+++ b/include/engine/api/route_parameters.hpp
@ -82,7 +82,7 @@ struct RouteParameters : public BaseParameters
                    const bool alternatives_,
                    const GeometriesType geometries_,
                    const OverviewType overview_,
-                    const std::optional<bool> continue_straight_,
+                    const boost::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 std::optional<bool> continue_straight_,
+                    const boost::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 std::optional<bool> continue_straight_,
+                    const boost::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 std::optional<bool> continue_straight_,
+                    const boost::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 std::optional<bool> continue_straight_,
+                    const boost::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;
-    std::optional<bool> continue_straight;
+    boost::optional<bool> continue_straight;
    std::vector<std::size_t> waypoints;
    bool IsValid() const
--- a/include/engine/api/table_api.hpp
+++ b/include/engine/api/table_api.hpp
@ -50,14 +50,14 @@ class TableAPI final : public BaseAPI
                 const std::vector<TableCellRef> &fallback_speed_cells,
                 osrm::engine::api::ResultT &response) const
    {
-        if (std::holds_alternative<flatbuffers::FlatBufferBuilder>(response))
+        if (response.is<flatbuffers::FlatBufferBuilder>())
        {
-            auto &fb_result = std::get<flatbuffers::FlatBufferBuilder>(response);
+            auto &fb_result = response.get<flatbuffers::FlatBufferBuilder>();
            MakeResponse(tables, candidates, fallback_speed_cells, fb_result);
        }
        else
        {
-            auto &json_result = std::get<util::json::Object>(response);
+            auto &json_result = response.get<util::json::Object>();
            MakeResponse(tables, candidates, fallback_speed_cells, json_result);
        }
    }
@ -137,7 +137,7 @@ class TableAPI final : public BaseAPI
            speed_cells = MakeEstimatesTable(fb_result, fallback_speed_cells);
        }
-        fbresult::TableResultBuilder table(fb_result);
+        fbresult::TableBuilder table(fb_result);
        table.add_destinations(destinations);
        table.add_rows(number_of_sources);
        table.add_cols(number_of_destinations);
@ -179,7 +179,7 @@ class TableAPI final : public BaseAPI
        {
            if (!parameters.skip_waypoints)
            {
-                response.values.emplace("sources", MakeWaypoints(candidates));
+                response.values["sources"] = MakeWaypoints(candidates);
            }
            number_of_sources = candidates.size();
        }
@ -187,7 +187,7 @@ class TableAPI final : public BaseAPI
        {
            if (!parameters.skip_waypoints)
            {
-                response.values.emplace("sources", MakeWaypoints(candidates, parameters.sources));
+                response.values["sources"] = MakeWaypoints(candidates, parameters.sources);
            }
        }
@ -195,7 +195,7 @@ class TableAPI final : public BaseAPI
        {
            if (!parameters.skip_waypoints)
            {
-                response.values.emplace("destinations", MakeWaypoints(candidates));
+                response.values["destinations"] = MakeWaypoints(candidates);
            }
            number_of_destinations = candidates.size();
        }
@ -203,37 +203,34 @@ class TableAPI final : public BaseAPI
        {
            if (!parameters.skip_waypoints)
            {
-                response.values.emplace("destinations",
+                response.values["destinations"] =
-                                        MakeWaypoints(candidates, parameters.destinations));
+                    MakeWaypoints(candidates, parameters.destinations);
            }
        }
        if (parameters.annotations & TableParameters::AnnotationsType::Duration)
        {
-            response.values.emplace(
+            response.values["durations"] =
-                "durations",
+                MakeDurationTable(tables.first, number_of_sources, number_of_destinations);
                MakeDurationTable(tables.first, number_of_sources, number_of_destinations));
        }
        if (parameters.annotations & TableParameters::AnnotationsType::Distance)
        {
-            response.values.emplace(
+            response.values["distances"] =
-                "distances",
+                MakeDistanceTable(tables.second, number_of_sources, number_of_destinations);
                MakeDistanceTable(tables.second, number_of_sources, number_of_destinations));
        }
        if (parameters.fallback_speed != from_alias<double>(INVALID_FALLBACK_SPEED) &&
            parameters.fallback_speed > 0)
        {
-            response.values.emplace("fallback_speed_cells",
+            response.values["fallback_speed_cells"] = MakeEstimatesTable(fallback_speed_cells);
                                    MakeEstimatesTable(fallback_speed_cells));
        }
-        response.values.emplace("code", "Ok");
+        response.values["code"] = "Ok";
        auto data_timestamp = facade.GetTimestamp();
        if (!data_timestamp.empty())
        {
-            response.values.emplace("data_version", data_timestamp);
+            response.values["data_version"] = data_timestamp;
        }
    }
@ -380,8 +377,7 @@ class TableAPI final : public BaseAPI
                               return util::json::Value(
                                   util::json::Number(from_alias<double>(duration) / 10.));
                           });
-
+            json_table.values.push_back(std::move(json_row));
            json_table.values.push_back(util::json::Value{json_row});
        }
        return json_table;
    }
@ -410,7 +406,7 @@ class TableAPI final : public BaseAPI
                               return util::json::Value(util::json::Number(
                                   std::round(from_alias<double>(distance) * 10) / 10.));
                           });
-            json_table.values.push_back(util::json::Value{json_row});
+            json_table.values.push_back(std::move(json_row));
        }
        return json_table;
    }
@ -419,18 +415,15 @@ class TableAPI final : public BaseAPI
    MakeEstimatesTable(const std::vector<TableCellRef> &fallback_speed_cells) const
    {
        util::json::Array json_table;
-        std::for_each(
+        std::for_each(fallback_speed_cells.begin(),
-            fallback_speed_cells.begin(),
+                      fallback_speed_cells.end(),
-            fallback_speed_cells.end(),
+                      [&](const auto &cell)
-            [&](const auto &cell)
+                      {
-            {
+                          util::json::Array row;
-                util::json::Array row;
+                          row.values.push_back(util::json::Number(cell.row));
-                util::json::Value jCellRow{util::json::Number(static_cast<double>(cell.row))};
+                          row.values.push_back(util::json::Number(cell.column));
-                util::json::Value jCellColumn{util::json::Number(static_cast<double>(cell.column))};
+                          json_table.values.push_back(std::move(row));
-                row.values.push_back(jCellRow);
+                      });
                row.values.push_back(jCellColumn);
                json_table.values.push_back(util::json::Value{row});
            });
        return json_table;
    }
--- a/include/engine/api/trip_api.hpp
+++ b/include/engine/api/trip_api.hpp
@ -27,14 +27,14 @@ class TripAPI final : public RouteAPI
    {
        BOOST_ASSERT(sub_trips.size() == sub_routes.size());
-        if (std::holds_alternative<flatbuffers::FlatBufferBuilder>(response))
+        if (response.is<flatbuffers::FlatBufferBuilder>())
        {
-            auto &fb_result = std::get<flatbuffers::FlatBufferBuilder>(response);
+            auto &fb_result = response.get<flatbuffers::FlatBufferBuilder>();
            MakeResponse(sub_trips, sub_routes, candidates, fb_result);
        }
        else
        {
-            auto &json_result = std::get<util::json::Object>(response);
+            auto &json_result = response.get<util::json::Object>();
            MakeResponse(sub_trips, sub_routes, candidates, json_result);
        }
    }
@ -79,14 +79,14 @@ class TripAPI final : public RouteAPI
        }
        if (!parameters.skip_waypoints)
        {
-            response.values.emplace("waypoints", MakeWaypoints(sub_trips, candidates));
+            response.values["waypoints"] = MakeWaypoints(sub_trips, candidates);
        }
-        response.values.emplace("trips", std::move(routes));
+        response.values["trips"] = std::move(routes);
-        response.values.emplace("code", "Ok");
+        response.values["code"] = "Ok";
        auto data_timestamp = facade.GetTimestamp();
        if (!data_timestamp.empty())
        {
-            response.values.emplace("data_version", data_timestamp);
+            response.values["data_version"] = data_timestamp;
        }
    }
@ -151,8 +151,8 @@ class TripAPI final : public RouteAPI
            BOOST_ASSERT(!trip_index.NotUsed());
            auto waypoint = BaseAPI::MakeWaypoint(candidates[input_index]);
-            waypoint.values.emplace("trips_index", trip_index.sub_trip_index);
+            waypoint.values["trips_index"] = trip_index.sub_trip_index;
-            waypoint.values.emplace("waypoint_index", trip_index.point_index);
+            waypoint.values["waypoint_index"] = trip_index.point_index;
            waypoints.values.push_back(std::move(waypoint));
        }
--- a/include/engine/api/trip_parameters.hpp
+++ b/include/engine/api/trip_parameters.hpp
@ -30,7 +30,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "engine/api/route_parameters.hpp"
-#include <optional>
+#include <boost/optional.hpp>
 #include <vector>
 namespace osrm::engine::api
--- a/include/engine/base64.hpp
+++ b/include/engine/base64.hpp
@ -47,29 +47,24 @@ namespace engine
 // Encodes a chunk of memory to Base64.
 inline std::string encodeBase64(const unsigned char *first, std::size_t size)
 {
-    BOOST_ASSERT(size > 0);
+    std::vector<unsigned char> bytes{first, first + size};
    BOOST_ASSERT(!bytes.empty());
-    std::string encoded;
+    std::size_t bytes_to_pad{0};
    encoded.reserve(((size + 2) / 3) * 4);
-    auto padding = (3 - size % 3) % 3;
+    while (bytes.size() % 3 != 0)
    BOOST_ASSERT(padding == 0 || padding == 1 || padding == 2);
    for (auto itr = detail::Base64FromBinary(first); itr != detail::Base64FromBinary(first + size);
         ++itr)
    {
-        encoded.push_back(*itr);
+        bytes_to_pad += 1;
        bytes.push_back(0);
    }
-    for (size_t index = 0; index < padding; ++index)
+    BOOST_ASSERT(bytes_to_pad == 0 || bytes_to_pad == 1 || bytes_to_pad == 2);
-    {
+    BOOST_ASSERT_MSG(0 == bytes.size() % 3, "base64 input data size is not a multiple of 3");
        encoded.push_back('=');
    }
-    BOOST_ASSERT(encoded.size() == (size + 2) / 3 * 4);
+    std::string encoded{detail::Base64FromBinary{bytes.data()},
                        detail::Base64FromBinary{bytes.data() + (bytes.size() - bytes_to_pad)}};
-    return encoded;
+    return encoded.append(bytes_to_pad, '=');
 }
 // C++11 standard 3.9.1/1: Plain char, signed char, and unsigned char are three distinct types
--- a/include/engine/datafacade/algorithm_datafacade.hpp
+++ b/include/engine/datafacade/algorithm_datafacade.hpp
@ -55,7 +55,7 @@ template <> class AlgorithmDataFacade<CH>
    virtual EdgeID FindSmallestEdge(const NodeID edge_based_node_from,
                                    const NodeID edge_based_node_to,
-                                    const std::function<bool(const EdgeData &)> &filter) const = 0;
+                                    const std::function<bool(EdgeData)> filter) const = 0;
 };
 template <> class AlgorithmDataFacade<MLD>
--- a/include/engine/datafacade/contiguous_internalmem_datafacade.hpp
+++ b/include/engine/datafacade/contiguous_internalmem_datafacade.hpp
@ -130,10 +130,9 @@ class ContiguousInternalMemoryAlgorithmDataFacade<CH> : public datafacade::Algor
            edge_based_node_from, edge_based_node_to, result);
    }
-    EdgeID
+    EdgeID FindSmallestEdge(const NodeID edge_based_node_from,
-    FindSmallestEdge(const NodeID edge_based_node_from,
+                            const NodeID edge_based_node_to,
-                     const NodeID edge_based_node_to,
+                            std::function<bool(EdgeData)> filter) const override final
                     const std::function<bool(const EdgeData &)> &filter) const override final
    {
        return m_query_graph.FindSmallestEdge(edge_based_node_from, edge_based_node_to, filter);
    }
@ -177,7 +176,7 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
    SharedRTree m_static_rtree;
    std::unique_ptr<SharedGeospatialQuery> m_geospatial_query;
-    std::filesystem::path file_index_path;
+    boost::filesystem::path file_index_path;
    std::optional<extractor::IntersectionBearingsView> intersection_bearings_view;
@ -369,33 +368,33 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
    std::vector<PhantomNodeWithDistance>
    NearestPhantomNodesInRange(const util::Coordinate input_coordinate,
                               const double max_distance,
-                               const std::optional<Bearing> bearing,
+                               const boost::optional<Bearing> bearing,
                               const Approach approach,
                               const bool use_all_edges) const override final
    {
        BOOST_ASSERT(m_geospatial_query.get());
        return m_geospatial_query->NearestPhantomNodes(
-            input_coordinate, approach, max_distance, bearing, use_all_edges);
+            input_coordinate, approach, boost::none, max_distance, bearing, use_all_edges);
    }
    std::vector<PhantomNodeWithDistance>
    NearestPhantomNodes(const util::Coordinate input_coordinate,
                        const size_t max_results,
-                        const std::optional<double> max_distance,
+                        const boost::optional<double> max_distance,
-                        const std::optional<Bearing> bearing,
+                        const boost::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, std::nullopt);
+            input_coordinate, approach, max_results, max_distance, bearing, boost::none);
    }
    PhantomCandidateAlternatives
    NearestCandidatesWithAlternativeFromBigComponent(const util::Coordinate input_coordinate,
-                                                     const std::optional<double> max_distance,
+                                                     const boost::optional<double> max_distance,
-                                                     const std::optional<Bearing> bearing,
+                                                     const boost::optional<Bearing> bearing,
                                                     const Approach approach,
                                                     const bool use_all_edges) const override final
    {
@ -603,8 +602,6 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
        auto found_range = std::equal_range(
            m_maneuver_overrides.begin(), m_maneuver_overrides.end(), edge_based_node_id, Comp{});
        results.reserve(std::distance(found_range.first, found_range.second));
        std::for_each(found_range.first,
                      found_range.second,
                      [&](const auto &override)
--- a/include/engine/datafacade/datafacade_base.hpp
+++ b/include/engine/datafacade/datafacade_base.hpp
@ -35,7 +35,6 @@
 #include <cstddef>
 #include <engine/bearing.hpp>
 #include <optional>
 #include <string>
 #include <string_view>
 #include <utility>
@ -127,21 +126,21 @@ class BaseDataFacade
    virtual std::vector<PhantomNodeWithDistance>
    NearestPhantomNodesInRange(const util::Coordinate input_coordinate,
                               const double max_distance,
-                               const std::optional<Bearing> bearing,
+                               const boost::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 std::optional<double> max_distance,
+                        const boost::optional<double> max_distance,
-                        const std::optional<Bearing> bearing,
+                        const boost::optional<Bearing> bearing,
                        const Approach approach) const = 0;
    virtual PhantomCandidateAlternatives
    NearestCandidatesWithAlternativeFromBigComponent(const util::Coordinate input_coordinate,
-                                                     const std::optional<double> max_distance,
+                                                     const boost::optional<double> max_distance,
-                                                     const std::optional<Bearing> bearing,
+                                                     const boost::optional<Bearing> bearing,
                                                     const Approach approach,
                                                     const bool use_all_edges) const = 0;
--- a/include/engine/engine_config.hpp
+++ b/include/engine/engine_config.hpp
@ -31,7 +31,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "storage/storage_config.hpp"
 #include "osrm/datasets.hpp"
-#include <filesystem>
+#include <boost/filesystem/path.hpp>
 #include <set>
 #include <string>
@ -53,10 +54,14 @@ namespace osrm::engine
 *
 * In addition, shared memory can be used for datasets loaded with osrm-datastore.
 *
- * You can chose between two algorithms:
+ * You can chose between three algorithms:
 *  - Algorithm::CH
 *      Contraction Hierarchies, extremely fast queries but slow pre-processing. The default right
 * now.
 *  - Algorithm::CoreCH
 *      Deprecated, to be removed in v6.0
 *      Contraction Hierachies with partial contraction for faster pre-processing but slower
 * queries.
 *  - Algorithm::MLD
 *      Multi Level Dijkstra, moderately fast in both pre-processing and query.
 *
@ -69,6 +74,7 @@ struct EngineConfig final
    enum class Algorithm
    {
        CH,
        CoreCH, // Deprecated, will be removed in v6.0
        MLD
    };
@ -79,10 +85,10 @@ struct EngineConfig final
    int max_locations_map_matching = -1;
    double max_radius_map_matching = -1.0;
    int max_results_nearest = -1;
-    double default_radius = -1.0;
+    boost::optional<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;
+    boost::filesystem::path memory_file;
    bool use_mmap = true;
    Algorithm algorithm = Algorithm::CH;
    std::vector<storage::FeatureDataset> disable_feature_dataset;
--- a/include/engine/geospatial_query.hpp
+++ b/include/engine/geospatial_query.hpp
@ -12,8 +12,6 @@
 #include "osrm/coordinate.hpp"
 #include <optional>
 #include <algorithm>
 #include <cmath>
 #include <iterator>
@ -49,45 +47,15 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
        return rtree.SearchInBox(bbox);
    }
    std::vector<PhantomNodeWithDistance>
    NearestPhantomNodes(const util::Coordinate input_coordinate,
                        const Approach approach,
                        const double max_distance,
                        const std::optional<Bearing> bearing_with_range,
                        const std::optional<bool> use_all_edges) const
    {
        auto results = rtree.SearchInRange(
            input_coordinate,
            max_distance,
            [this, approach, &input_coordinate, &bearing_with_range, &use_all_edges, max_distance](
                const CandidateSegment &segment)
            {
                auto invalidDistance =
                    CheckSegmentDistance(input_coordinate, segment, max_distance);
                if (invalidDistance)
                {
                    return std::make_pair(false, false);
                }
                auto valid = CheckSegmentExclude(segment) &&
                             CheckApproach(input_coordinate, segment, approach) &&
                             (use_all_edges ? HasValidEdge(segment, *use_all_edges)
                                            : HasValidEdge(segment)) &&
                             (bearing_with_range ? CheckSegmentBearing(segment, *bearing_with_range)
                                                 : std::make_pair(true, true));
                return valid;
            });
        return MakePhantomNodes(input_coordinate, results);
    }
    // Returns max_results nearest PhantomNodes that are valid within the provided parameters.
    // Does not filter by small/big component!
    std::vector<PhantomNodeWithDistance>
    NearestPhantomNodes(const util::Coordinate input_coordinate,
                        const Approach approach,
-                        const size_t max_results,
+                        const boost::optional<size_t> max_results,
-                        const std::optional<double> max_distance,
+                        const boost::optional<double> max_distance,
-                        const std::optional<Bearing> bearing_with_range,
+                        const boost::optional<Bearing> bearing_with_range,
-                        const std::optional<bool> use_all_edges) const
+                        const boost::optional<bool> use_all_edges) const
    {
        auto results = rtree.Nearest(
            input_coordinate,
@ -102,10 +70,10 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
                                                 : std::make_pair(true, true));
                return valid;
            },
-            [this, &max_distance, max_results, input_coordinate](const std::size_t num_results,
+            [this, &max_distance, &max_results, input_coordinate](const std::size_t num_results,
-                                                                 const CandidateSegment &segment)
+                                                                  const CandidateSegment &segment)
            {
-                return (num_results >= max_results) ||
+                return (max_results && num_results >= *max_results) ||
                       (max_distance && max_distance != -1.0 &&
                        CheckSegmentDistance(input_coordinate, segment, *max_distance));
            });
@ -121,9 +89,9 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
    PhantomCandidateAlternatives NearestCandidatesWithAlternativeFromBigComponent(
        const util::Coordinate input_coordinate,
        const Approach approach,
-        const std::optional<double> max_distance,
+        const boost::optional<double> max_distance,
-        const std::optional<Bearing> bearing_with_range,
+        const boost::optional<Bearing> bearing_with_range,
-        const std::optional<bool> use_all_edges) const
+        const boost::optional<bool> use_all_edges) const
    {
        bool has_nearest = false;
        bool has_big_component = false;
--- a/include/engine/guidance/assemble_geometry.hpp
+++ b/include/engine/guidance/assemble_geometry.hpp
@ -37,14 +37,6 @@ 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);
--- a/include/engine/guidance/assemble_steps.hpp
+++ b/include/engine/guidance/assemble_steps.hpp
@ -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
--- a/include/engine/guidance/collapse_turns.hpp
+++ b/include/engine/guidance/collapse_turns.hpp
@ -1,6 +1,7 @@
 #ifndef OSRM_ENGINE_GUIDANCE_COLLAPSE_HPP
 #include "engine/guidance/route_step.hpp"
 #include "util/attributes.hpp"
 #include <type_traits>
 #include <vector>
@ -11,15 +12,16 @@ namespace osrm::engine::guidance
 // Multiple possible reasons can result in unnecessary/confusing instructions
 // Collapsing such turns into a single turn instruction, we give a clearer
 // set of instructions that is not cluttered by unnecessary turns/name changes.
-[[nodiscard]] std::vector<RouteStep> collapseTurnInstructions(std::vector<RouteStep> steps);
+OSRM_ATTR_WARN_UNUSED
 std::vector<RouteStep> collapseTurnInstructions(std::vector<RouteStep> steps);
 // Multiple possible reasons can result in unnecessary/confusing instructions
 // A prime example would be a segregated intersection. Turning around at this
 // intersection would result in two instructions to turn left.
 // Collapsing such turns into a single turn instruction, we give a clearer
 // set of instructions that is not cluttered by unnecessary turns/name changes.
-[[nodiscard]] std::vector<RouteStep>
+OSRM_ATTR_WARN_UNUSED
-collapseSegregatedTurnInstructions(std::vector<RouteStep> steps);
+std::vector<RouteStep> collapseSegregatedTurnInstructions(std::vector<RouteStep> steps);
 // A combined turn is a set of two instructions that actually form a single turn, as far as we
 // perceive it. A u-turn consisting of two left turns is one such example. But there are also lots
--- a/include/engine/guidance/collapsing_utility.hpp
+++ b/include/engine/guidance/collapsing_utility.hpp
@ -3,6 +3,7 @@
 #include "guidance/turn_instruction.hpp"
 #include "engine/guidance/route_step.hpp"
 #include "util/attributes.hpp"
 #include "util/bearing.hpp"
 #include "util/guidance/name_announcements.hpp"
@ -165,7 +166,8 @@ inline bool areSameSide(const RouteStep &lhs, const RouteStep &rhs)
 }
 // do this after invalidating any steps to compress the step array again
-[[nodiscard]] inline std::vector<RouteStep> removeNoTurnInstructions(std::vector<RouteStep> steps)
+OSRM_ATTR_WARN_UNUSED
 inline std::vector<RouteStep> removeNoTurnInstructions(std::vector<RouteStep> steps)
 {
    // finally clean up the post-processed instructions.
    // Remove all invalid instructions from the set of instructions.
@ -202,8 +204,8 @@ inline double totalTurnAngle(const RouteStep &entry_step, const RouteStep &exit_
    if (entry_step.geometry_begin > exit_step.geometry_begin)
        return totalTurnAngle(exit_step, entry_step);
-    const auto &exit_intersection = exit_step.intersections.front();
+    const auto exit_intersection = exit_step.intersections.front();
-    const auto &entry_intersection = entry_step.intersections.front();
+    const auto entry_intersection = entry_step.intersections.front();
    if ((exit_intersection.out >= exit_intersection.bearings.size()) ||
        (entry_intersection.in >= entry_intersection.bearings.size()))
        return entry_intersection.bearings[entry_intersection.out];
--- a/include/engine/guidance/lane_processing.hpp
+++ b/include/engine/guidance/lane_processing.hpp
@ -1,10 +1,11 @@
 #ifndef OSRM_ENGINE_GUIDANCE_LANE_PROCESSING_HPP_
 #define OSRM_ENGINE_GUIDANCE_LANE_PROCESSING_HPP_
 #include "engine/guidance/route_step.hpp"
 #include <vector>
 #include "engine/guidance/route_step.hpp"
 #include "util/attributes.hpp"
 namespace osrm::engine::guidance
 {
@ -13,9 +14,9 @@ namespace osrm::engine::guidance
 // we anticipate lane changes emitting only matching lanes early on.
 // the second parameter describes the duration that we feel two segments need to be apart to count
 // as separate maneuvers.
-[[nodiscard]] std::vector<RouteStep>
+OSRM_ATTR_WARN_UNUSED
-anticipateLaneChange(std::vector<RouteStep> steps,
+std::vector<RouteStep> anticipateLaneChange(std::vector<RouteStep> steps,
-                     const double min_distance_needed_for_lane_change = 200);
+                                            const double min_distance_needed_for_lane_change = 200);
 } // namespace osrm::engine::guidance
--- a/include/engine/guidance/post_processing.hpp
+++ b/include/engine/guidance/post_processing.hpp
@ -5,6 +5,7 @@
 #include "engine/guidance/leg_geometry.hpp"
 #include "engine/guidance/route_step.hpp"
 #include "engine/phantom_node.hpp"
 #include "util/attributes.hpp"
 #include <vector>
@ -12,7 +13,8 @@ namespace osrm::engine::guidance
 {
 // passed as none-reference to modify in-place and move out again
-[[nodiscard]] std::vector<RouteStep> handleRoundabouts(std::vector<RouteStep> steps);
+OSRM_ATTR_WARN_UNUSED
 std::vector<RouteStep> handleRoundabouts(std::vector<RouteStep> steps);
 // trim initial/final segment of very short length.
 // This function uses in/out parameter passing to modify both steps and geometry in place.
@ -22,21 +24,23 @@ namespace osrm::engine::guidance
 void trimShortSegments(std::vector<RouteStep> &steps, LegGeometry &geometry);
 // assign relative locations to depart/arrive instructions
-[[nodiscard]] std::vector<RouteStep> assignRelativeLocations(std::vector<RouteStep> steps,
+OSRM_ATTR_WARN_UNUSED
-                                                             const LegGeometry &geometry,
+std::vector<RouteStep> assignRelativeLocations(std::vector<RouteStep> steps,
-                                                             const PhantomNode &source_node,
+                                               const LegGeometry &geometry,
-                                                             const PhantomNode &target_node);
+                                               const PhantomNode &source_node,
                                               const PhantomNode &target_node);
 // collapse suppressed instructions remaining into intersections array
-[[nodiscard]] std::vector<RouteStep> buildIntersections(std::vector<RouteStep> steps);
+OSRM_ATTR_WARN_UNUSED
 std::vector<RouteStep> buildIntersections(std::vector<RouteStep> steps);
 // postProcess will break the connection between the leg geometry
 // for which a segment is supposed to represent exactly the coordinates
 // between routing maneuvers and the route steps itself.
 // If required, we can get both in sync again using this function.
 // Move in LegGeometry for modification in place.
-[[nodiscard]] LegGeometry resyncGeometry(LegGeometry leg_geometry,
+OSRM_ATTR_WARN_UNUSED
-                                         const std::vector<RouteStep> &steps);
+LegGeometry resyncGeometry(LegGeometry leg_geometry, const std::vector<RouteStep> &steps);
 /**
 * Apply maneuver override relations to the selected route.
--- a/include/engine/guidance/route_leg.hpp
+++ b/include/engine/guidance/route_leg.hpp
@ -3,7 +3,7 @@
 #include "engine/guidance/route_step.hpp"
-#include <optional>
+#include <boost/optional.hpp>
 #include <string>
 #include <vector>
--- a/include/engine/guidance/verbosity_reduction.hpp
+++ b/include/engine/guidance/verbosity_reduction.hpp
@ -2,6 +2,7 @@
 #define OSRM_ENGINE_GUIDANCE_VERBOSITY_REDUCTION_HPP_
 #include "engine/guidance/route_step.hpp"
 #include "util/attributes.hpp"
 #include <vector>
@ -12,7 +13,8 @@ namespace osrm::engine::guidance
 // to announce them. All these that are not collapsed into a single turn (think segregated
 // intersection) have to be checked for the length they are active in. If they are active for a
 // short distance only, we don't announce them
-[[nodiscard]] std::vector<RouteStep> suppressShortNameSegments(std::vector<RouteStep> steps);
+OSRM_ATTR_WARN_UNUSED
 std::vector<RouteStep> suppressShortNameSegments(std::vector<RouteStep> steps);
 } // namespace osrm::engine::guidance
--- a/include/engine/internal_route_result.hpp
+++ b/include/engine/internal_route_result.hpp
@ -15,7 +15,7 @@
 #include "util/integer_range.hpp"
 #include "util/typedefs.hpp"
-#include <optional>
+#include <boost/optional.hpp>
 #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
-    std::optional<EdgeID> turn_edge;
+    boost::optional<EdgeID> turn_edge;
 };
 struct InternalRouteResult
--- a/include/engine/map_matching/bayes_classifier.hpp
+++ b/include/engine/map_matching/bayes_classifier.hpp
@ -6,7 +6,7 @@
 #include <utility>
 #include <vector>
-#include <numbers>
+#include <boost/math/constants/constants.hpp>
 namespace osrm::engine::map_matching
 {
@ -21,8 +21,10 @@ struct NormalDistribution
    // FIXME implement log-probability version since it's faster
    double Density(const double val) const
    {
        using namespace boost::math::constants;
        const double x = val - mean;
-        return 1.0 / (std::sqrt(2 * std::numbers::pi) * standard_deviation) *
+        return 1.0 / (std::sqrt(two_pi<double>()) * standard_deviation) *
               std::exp(-x * x / (standard_deviation * standard_deviation));
    }
--- a/include/engine/map_matching/hidden_markov_model.hpp
+++ b/include/engine/map_matching/hidden_markov_model.hpp
@ -4,7 +4,7 @@
 #include "util/integer_range.hpp"
 #include <boost/assert.hpp>
-#include <numbers>
+#include <boost/math/constants/constants.hpp>
 #include <cmath>
@ -14,7 +14,7 @@
 namespace osrm::engine::map_matching
 {
-static const double log_2_pi = std::log(2. * std::numbers::pi);
+static const double log_2_pi = std::log(2. * boost::math::constants::pi<double>());
 static const double IMPOSSIBLE_LOG_PROB = -std::numeric_limits<double>::infinity();
 static const double MINIMAL_LOG_PROB = std::numeric_limits<double>::lowest();
 static const std::size_t INVALID_STATE = std::numeric_limits<std::size_t>::max();
--- a/include/engine/map_matching/matching_confidence.hpp
+++ b/include/engine/map_matching/matching_confidence.hpp
@ -2,7 +2,7 @@
 #define ENGINE_MAP_MATCHING_CONFIDENCE_HPP
 #include "engine/map_matching/bayes_classifier.hpp"
-#include <boost/assert.hpp>
+
 #include <cmath>
 namespace osrm::engine::map_matching
--- a/include/engine/plugins/match.hpp
+++ b/include/engine/plugins/match.hpp
@ -22,7 +22,7 @@ class MatchPlugin : public BasePlugin
    MatchPlugin(const int max_locations_map_matching,
                const double max_radius_map_matching,
-                const std::optional<double> default_radius)
+                const boost::optional<double> default_radius)
        : BasePlugin(default_radius), max_locations_map_matching(max_locations_map_matching),
          max_radius_map_matching(max_radius_map_matching)
    {
--- a/include/engine/plugins/nearest.hpp
+++ b/include/engine/plugins/nearest.hpp
@ -13,7 +13,7 @@ namespace osrm::engine::plugins
 class NearestPlugin final : public BasePlugin
 {
  public:
-    explicit NearestPlugin(const int max_results, const std::optional<double> default_radius);
+    explicit NearestPlugin(const int max_results, const boost::optional<double> default_radius);
    Status HandleRequest(const RoutingAlgorithmsInterface &algorithms,
                         const api::NearestParameters &params,
--- a/include/engine/plugins/plugin_base.hpp
+++ b/include/engine/plugins/plugin_base.hpp
@ -29,7 +29,7 @@ class BasePlugin
  protected:
    BasePlugin() = default;
-    BasePlugin(const std::optional<double> default_radius_) : default_radius(default_radius_) {}
+    BasePlugin(const boost::optional<double> default_radius_) : default_radius(default_radius_) {}
    bool CheckAllCoordinates(const std::vector<util::Coordinate> &coordinates) const
    {
@ -95,7 +95,7 @@ class BasePlugin
                 const std::string &message,
                 osrm::engine::api::ResultT &result) const
    {
-        std::visit(ErrorRenderer(code, message), result);
+        mapbox::util::apply_visitor(ErrorRenderer(code, message), result);
        return Status::Error;
    }
@ -200,8 +200,8 @@ class BasePlugin
            phantom_nodes[i] = facade.NearestPhantomNodesInRange(
                parameters.coordinates[i],
                radiuses[i],
-                use_bearings ? parameters.bearings[i] : std::nullopt,
+                use_bearings ? parameters.bearings[i] : boost::none,
-                use_approaches && parameters.approaches[i] ? parameters.approaches[i].value()
+                use_approaches && parameters.approaches[i] ? parameters.approaches[i].get()
                                                           : 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] : std::nullopt,
+                use_bearings ? parameters.bearings[i] : boost::none,
-                use_approaches && parameters.approaches[i] ? parameters.approaches[i].value()
+                use_approaches && parameters.approaches[i] ? parameters.approaches[i].get()
                                                           : 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] : std::nullopt,
+                use_bearings ? parameters.bearings[i] : boost::none,
-                use_approaches && parameters.approaches[i] ? parameters.approaches[i].value()
+                use_approaches && parameters.approaches[i] ? parameters.approaches[i].get()
                                                           : engine::Approach::UNRESTRICTED,
                use_all_edges);
@ -325,7 +325,7 @@ class BasePlugin
               std::to_string(missing_index);
    }
-    const std::optional<double> default_radius;
+    const boost::optional<double> default_radius;
 };
 } // namespace osrm::engine::plugins
--- a/include/engine/plugins/table.hpp
+++ b/include/engine/plugins/table.hpp
@ -15,7 +15,7 @@ class TablePlugin final : public BasePlugin
 {
  public:
    explicit TablePlugin(const int max_locations_distance_table,
-                         const std::optional<double> default_radius);
+                         const boost::optional<double> default_radius);
    Status HandleRequest(const RoutingAlgorithmsInterface &algorithms,
                         const api::TableParameters &params,
--- a/include/engine/plugins/trip.hpp
+++ b/include/engine/plugins/trip.hpp
@ -32,7 +32,7 @@ class TripPlugin final : public BasePlugin
                                     const bool roundtrip) const;
  public:
-    explicit TripPlugin(const int max_locations_trip_, std::optional<double> default_radius)
+    explicit TripPlugin(const int max_locations_trip_, boost::optional<double> default_radius)
        : BasePlugin(default_radius), max_locations_trip(max_locations_trip_)
    {
    }
--- a/include/engine/plugins/viaroute.hpp
+++ b/include/engine/plugins/viaroute.hpp
@ -27,7 +27,7 @@ class ViaRoutePlugin final : public BasePlugin
  public:
    explicit ViaRoutePlugin(int max_locations_viaroute,
                            int max_alternatives,
-                            std::optional<double> default_radius);
+                            boost::optional<double> default_radius);
    Status HandleRequest(const RoutingAlgorithmsInterface &algorithms,
                         const api::RouteParameters &route_parameters,
--- a/include/engine/polyline_compressor.hpp
+++ b/include/engine/polyline_compressor.hpp
@ -12,7 +12,7 @@ namespace osrm::engine
 {
 namespace detail
 {
-void encode(int number_to_encode, std::string &output);
+std::string encode(std::vector<int> &numbers);
 std::int32_t decode_polyline_integer(std::string::const_iterator &first,
                                     std::string::const_iterator last);
 } // namespace detail
@ -30,24 +30,27 @@ std::string encodePolyline(CoordVectorForwardIter begin, CoordVectorForwardIter
        return {};
    }
-    std::string output;
+    std::vector<int> delta_numbers;
-    // just a guess that we will need ~4 bytes per coordinate to avoid reallocations
+    BOOST_ASSERT(size > 0);
-    output.reserve(size * 4);
+    delta_numbers.reserve((size - 1) * 2);
    int current_lat = 0;
    int current_lon = 0;
-    for (auto it = begin; it != end; ++it)
+    std::for_each(
-    {
+        begin,
-        const int lat_diff =
+        end,
-            std::round(static_cast<int>(it->lat) * coordinate_to_polyline) - current_lat;
+        [&delta_numbers, &current_lat, &current_lon, coordinate_to_polyline](
-        const int lon_diff =
+            const util::Coordinate loc)
-            std::round(static_cast<int>(it->lon) * coordinate_to_polyline) - current_lon;
+        {
-        detail::encode(lat_diff, output);
+            const int lat_diff =
-        detail::encode(lon_diff, output);
+                std::round(static_cast<int>(loc.lat) * coordinate_to_polyline) - current_lat;
-        current_lat += lat_diff;
+            const int lon_diff =
-        current_lon += lon_diff;
+                std::round(static_cast<int>(loc.lon) * coordinate_to_polyline) - current_lon;
-    }
+            delta_numbers.emplace_back(lat_diff);
-    return output;
+            delta_numbers.emplace_back(lon_diff);
            current_lat += lat_diff;
            current_lon += lon_diff;
        });
    return detail::encode(delta_numbers);
 }
 // Decodes geometry from polyline format
--- a/include/engine/routing_algorithms.hpp
+++ b/include/engine/routing_algorithms.hpp
@ -25,7 +25,7 @@ class RoutingAlgorithmsInterface
    virtual InternalRouteResult
    ShortestPathSearch(const std::vector<PhantomNodeCandidates> &waypoint_candidates,
-                       const std::optional<bool> continue_straight_at_waypoint) const = 0;
+                       const boost::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<std::optional<double>> &trace_gps_precision,
+                const std::vector<boost::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 std::optional<bool> continue_straight_at_waypoint) const final override;
+        const boost::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<std::optional<double>> &trace_gps_precision,
+                const std::vector<boost::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 std::optional<bool> continue_straight_at_waypoint) const
+    const boost::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<std::optional<double>> &trace_gps_precision,
+    const std::vector<boost::optional<double>> &trace_gps_precision,
    const bool allow_splitting) const
 {
    return routing_algorithms::mapMatching(heaps,
--- a/include/engine/routing_algorithms/map_matching.hpp
+++ b/include/engine/routing_algorithms/map_matching.hpp
@ -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<std::optional<double>> &trace_gps_precision,
+                            const std::vector<boost::optional<double>> &trace_gps_precision,
                            const bool allow_splitting);
 } // namespace osrm::engine::routing_algorithms
--- a/include/engine/routing_algorithms/routing_base.hpp
+++ b/include/engine/routing_algorithms/routing_base.hpp
@ -258,7 +258,7 @@ void annotatePath(const FacadeT &facade,
                                             alias_cast<EdgeDuration>(duration_vector[segment_idx]),
                                             {0},
                                             datasource_vector[segment_idx],
-                                             std::nullopt});
+                                             boost::none});
        }
        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],
-                     std::nullopt});
+                     boost::none});
    }
    if (!unpacked_path.empty())
--- a/include/engine/routing_algorithms/routing_base_ch.hpp
+++ b/include/engine/routing_algorithms/routing_base_ch.hpp
@ -122,7 +122,7 @@ void routingStep(const DataFacade<Algorithm> &facade,
        const EdgeWeight new_weight = reverseHeapNode->weight + heapNode.weight;
        if (new_weight < upper_bound)
        {
-            if (shouldForceStep(force_step_nodes, heapNode, *reverseHeapNode) ||
+            if (shouldForceStep(force_step_nodes, heapNode, reverseHeapNode.get()) ||
                // in this case we are looking at a bi-directional way where the source
                // and target phantom are on the same edge based node
                new_weight < EdgeWeight{0})
--- a/include/engine/routing_algorithms/routing_base_mld.hpp
+++ b/include/engine/routing_algorithms/routing_base_mld.hpp
@ -11,7 +11,6 @@
 #include <boost/assert.hpp>
 #include <algorithm>
 #include <boost/core/ignore_unused.hpp>
 #include <iterator>
 #include <limits>
 #include <tuple>
@ -270,29 +269,10 @@ retrievePackedPathFromHeap(const SearchEngineData<Algorithm>::QueryHeap &forward
    return packed_path;
 }
-template <typename Heap>
+template <bool DIRECTION, typename Algorithm, typename... Args>
 void insertOrUpdate(Heap &heap,
                    const NodeID node,
                    const EdgeWeight weight,
                    const typename Heap::DataType &data)
 {
    const auto heapNode = heap.GetHeapNodeIfWasInserted(node);
    if (!heapNode)
    {
        heap.Insert(node, weight, data);
    }
    else if (weight < heapNode->weight)
    {
        heapNode->data = data;
        heapNode->weight = weight;
        heap.DecreaseKey(*heapNode);
    }
 }
 template <bool DIRECTION, typename Algorithm, typename Heap, typename... Args>
 void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
-                        Heap &forward_heap,
+                        typename SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-                        const typename Heap::HeapNode &heapNode,
+                        const typename SearchEngineData<Algorithm>::QueryHeap::HeapNode &heapNode,
                        const Args &...args)
 {
    const auto &partition = facade.GetMultiLevelPartition();
@ -301,31 +281,14 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
    const auto level = getNodeQueryLevel(partition, heapNode.node, args...);
    static constexpr auto IS_MAP_MATCHING =
        std::is_same_v<typename SearchEngineData<mld::Algorithm>::MapMatchingQueryHeap, Heap>;
    if (level >= 1 && !heapNode.data.from_clique_arc)
    {
-        if constexpr (DIRECTION == FORWARD_DIRECTION)
+        if (DIRECTION == FORWARD_DIRECTION)
        {
            // Shortcuts in forward direction
            const auto &cell =
                cells.GetCell(metric, level, partition.GetCell(level, heapNode.node));
            auto destination = cell.GetDestinationNodes().begin();
            auto distance = [&cell, node = heapNode.node ]() -> auto
            {
                if constexpr (IS_MAP_MATCHING)
                {
                    return cell.GetOutDistance(node).begin();
                }
                else
                {
                    boost::ignore_unused(cell, node);
                    return 0;
                }
            }
            ();
            for (auto shortcut_weight : cell.GetOutWeight(heapNode.node))
            {
                BOOST_ASSERT(destination != cell.GetDestinationNodes().end());
@ -335,23 +298,19 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
                {
                    const EdgeWeight to_weight = heapNode.weight + shortcut_weight;
                    BOOST_ASSERT(to_weight >= heapNode.weight);
-
+                    const auto toHeapNode = forward_heap.GetHeapNodeIfWasInserted(to);
-                    if constexpr (IS_MAP_MATCHING)
+                    if (!toHeapNode)
                    {
-                        const EdgeDistance to_distance = heapNode.data.distance + *distance;
+                        forward_heap.Insert(to, to_weight, {heapNode.node, true});
                        insertOrUpdate(
                            forward_heap, to, to_weight, {heapNode.node, true, to_distance});
                    }
-                    else
+                    else if (to_weight < toHeapNode->weight)
                    {
-                        insertOrUpdate(forward_heap, to, to_weight, {heapNode.node, true});
+                        toHeapNode->data = {heapNode.node, true};
                        toHeapNode->weight = to_weight;
                        forward_heap.DecreaseKey(*toHeapNode);
                    }
                }
                ++destination;
                if constexpr (IS_MAP_MATCHING)
                {
                    ++distance;
                }
            }
        }
        else
@ -360,20 +319,6 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
            const auto &cell =
                cells.GetCell(metric, level, partition.GetCell(level, heapNode.node));
            auto source = cell.GetSourceNodes().begin();
            auto distance = [&cell, node = heapNode.node ]() -> auto
            {
                if constexpr (IS_MAP_MATCHING)
                {
                    return cell.GetInDistance(node).begin();
                }
                else
                {
                    boost::ignore_unused(cell, node);
                    return 0;
                }
            }
            ();
            for (auto shortcut_weight : cell.GetInWeight(heapNode.node))
            {
                BOOST_ASSERT(source != cell.GetSourceNodes().end());
@ -383,22 +328,19 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
                {
                    const EdgeWeight to_weight = heapNode.weight + shortcut_weight;
                    BOOST_ASSERT(to_weight >= heapNode.weight);
-                    if constexpr (IS_MAP_MATCHING)
+                    const auto toHeapNode = forward_heap.GetHeapNodeIfWasInserted(to);
                    if (!toHeapNode)
                    {
-                        const EdgeDistance to_distance = heapNode.data.distance + *distance;
+                        forward_heap.Insert(to, to_weight, {heapNode.node, true});
                        insertOrUpdate(
                            forward_heap, to, to_weight, {heapNode.node, true, to_distance});
                    }
-                    else
+                    else if (to_weight < toHeapNode->weight)
                    {
-                        insertOrUpdate(forward_heap, to, to_weight, {heapNode.node, true});
+                        toHeapNode->data = {heapNode.node, true};
                        toHeapNode->weight = to_weight;
                        forward_heap.DecreaseKey(*toHeapNode);
                    }
                }
                ++source;
                if constexpr (IS_MAP_MATCHING)
                {
                    ++distance;
                }
            }
        }
    }
@ -425,28 +367,26 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
                const EdgeWeight to_weight =
                    heapNode.weight + node_weight + alias_cast<EdgeWeight>(turn_penalty);
-                if constexpr (IS_MAP_MATCHING)
+                const auto toHeapNode = forward_heap.GetHeapNodeIfWasInserted(to);
                if (!toHeapNode)
                {
-                    const auto node_distance =
+                    forward_heap.Insert(to, to_weight, {heapNode.node, false});
                        facade.GetNodeDistance(DIRECTION == FORWARD_DIRECTION ? heapNode.node : to);
                    const EdgeDistance to_distance = heapNode.data.distance + node_distance;
                    insertOrUpdate(
                        forward_heap, to, to_weight, {heapNode.node, false, to_distance});
                }
-                else
+                else if (to_weight < toHeapNode->weight)
                {
-                    insertOrUpdate(forward_heap, to, to_weight, {heapNode.node, false});
+                    toHeapNode->data = {heapNode.node, false};
                    toHeapNode->weight = to_weight;
                    forward_heap.DecreaseKey(*toHeapNode);
                }
            }
        }
    }
 }
-template <bool DIRECTION, typename Algorithm, typename Heap, typename... Args>
+template <bool DIRECTION, typename Algorithm, typename... Args>
 void routingStep(const DataFacade<Algorithm> &facade,
-                 Heap &forward_heap,
+                 typename SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-                 Heap &reverse_heap,
+                 typename SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
                 NodeID &middle_node,
                 EdgeWeight &path_upper_bound,
                 const std::vector<NodeID> &force_step_nodes,
@ -468,7 +408,7 @@ void routingStep(const DataFacade<Algorithm> &facade,
        auto reverse_weight = reverseHeapNode->weight;
        auto path_weight = weight + reverse_weight;
-        if (!shouldForceStep(force_step_nodes, heapNode, *reverseHeapNode) &&
+        if (!shouldForceStep(force_step_nodes, heapNode, reverseHeapNode.get()) &&
            (path_weight >= EdgeWeight{0}) && (path_weight < path_upper_bound))
        {
            middle_node = heapNode.node;
@ -487,27 +427,24 @@ 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
+template <typename Algorithm, typename... Args>
-{
+UnpackedPath search(SearchEngineData<Algorithm> &engine_working_data,
-    EdgeWeight weight;
+                    const DataFacade<Algorithm> &facade,
-    UnpackedNodes nodes;
+                    typename SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-    UnpackedEdges edges;
+                    typename SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
-};
+                    const std::vector<NodeID> &force_step_nodes,
-
+                    EdgeWeight weight_upper_bound,
-template <typename Algorithm, typename Heap, typename... Args>
+                    const Args &...args)
 std::optional<std::pair<NodeID, EdgeWeight>> runSearch(const DataFacade<Algorithm> &facade,
                                                       Heap &forward_heap,
                                                       Heap &reverse_heap,
                                                       const std::vector<NodeID> &force_step_nodes,
                                                       EdgeWeight weight_upper_bound,
                                                       const Args &...args)
 {
    if (forward_heap.Empty() || reverse_heap.Empty())
    {
-        return {};
+        return std::make_tuple(INVALID_EDGE_WEIGHT, std::vector<NodeID>(), std::vector<EdgeID>());
    }
    const auto &partition = facade.GetMultiLevelPartition();
    BOOST_ASSERT(!forward_heap.Empty() && forward_heap.MinKey() < INVALID_EDGE_WEIGHT);
    BOOST_ASSERT(!reverse_heap.Empty() && reverse_heap.MinKey() < INVALID_EDGE_WEIGHT);
@ -538,32 +475,9 @@ std::optional<std::pair<NodeID, EdgeWeight>> runSearch(const DataFacade<Algorith
    // No path found for both target nodes?
    if (weight >= weight_upper_bound || SPECIAL_NODEID == middle)
    {
-        return {};
+        return std::make_tuple(INVALID_EDGE_WEIGHT, std::vector<NodeID>(), std::vector<EdgeID>());
    }
    return {{middle, weight}};
 }
 template <typename Algorithm, typename... Args>
 UnpackedPath search(SearchEngineData<Algorithm> &engine_working_data,
                    const DataFacade<Algorithm> &facade,
                    typename SearchEngineData<Algorithm>::QueryHeap &forward_heap,
                    typename SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
                    const std::vector<NodeID> &force_step_nodes,
                    EdgeWeight weight_upper_bound,
                    const Args &...args)
 {
    auto searchResult = runSearch(
        facade, forward_heap, reverse_heap, force_step_nodes, weight_upper_bound, args...);
    if (!searchResult)
    {
        return {INVALID_EDGE_WEIGHT, std::vector<NodeID>(), std::vector<EdgeID>()};
    }
    auto [middle, weight] = *searchResult;
    const auto &partition = facade.GetMultiLevelPartition();
    // Get packed path as edges {from node ID, to node ID, from_clique_arc}
    auto packed_path = retrievePackedPathFromHeap(forward_heap, reverse_heap, middle);
@ -601,52 +515,25 @@ UnpackedPath search(SearchEngineData<Algorithm> &engine_working_data,
            forward_heap.Insert(source, {0}, {source});
            reverse_heap.Insert(target, {0}, {target});
-            auto unpacked_subpath = search(engine_working_data,
+            auto [subpath_weight, subpath_nodes, subpath_edges] = search(engine_working_data,
-                                           facade,
+                                                                         facade,
-                                           forward_heap,
+                                                                         forward_heap,
-                                           reverse_heap,
+                                                                         reverse_heap,
-                                           force_step_nodes,
+                                                                         force_step_nodes,
-                                           INVALID_EDGE_WEIGHT,
+                                                                         INVALID_EDGE_WEIGHT,
-                                           sublevel,
+                                                                         sublevel,
-                                           parent_cell_id);
+                                                                         parent_cell_id);
-            BOOST_ASSERT(!unpacked_subpath.edges.empty());
+            BOOST_ASSERT(!subpath_edges.empty());
-            BOOST_ASSERT(unpacked_subpath.nodes.size() > 1);
+            BOOST_ASSERT(subpath_nodes.size() > 1);
-            BOOST_ASSERT(unpacked_subpath.nodes.front() == source);
+            BOOST_ASSERT(subpath_nodes.front() == source);
-            BOOST_ASSERT(unpacked_subpath.nodes.back() == target);
+            BOOST_ASSERT(subpath_nodes.back() == target);
-            unpacked_nodes.insert(unpacked_nodes.end(),
+            unpacked_nodes.insert(
-                                  std::next(unpacked_subpath.nodes.begin()),
+                unpacked_nodes.end(), std::next(subpath_nodes.begin()), subpath_nodes.end());
-                                  unpacked_subpath.nodes.end());
+            unpacked_edges.insert(unpacked_edges.end(), subpath_edges.begin(), subpath_edges.end());
            unpacked_edges.insert(
                unpacked_edges.end(), unpacked_subpath.edges.begin(), unpacked_subpath.edges.end());
        }
    }
-    return {weight, std::move(unpacked_nodes), std::move(unpacked_edges)};
+    return std::make_tuple(weight, std::move(unpacked_nodes), std::move(unpacked_edges));
 }
 template <typename Algorithm, typename... Args>
 EdgeDistance
 searchDistance(SearchEngineData<Algorithm> &,
               const DataFacade<Algorithm> &facade,
               typename SearchEngineData<Algorithm>::MapMatchingQueryHeap &forward_heap,
               typename SearchEngineData<Algorithm>::MapMatchingQueryHeap &reverse_heap,
               const std::vector<NodeID> &force_step_nodes,
               EdgeWeight weight_upper_bound,
               const Args &...args)
 {
    auto searchResult = runSearch(
        facade, forward_heap, reverse_heap, force_step_nodes, weight_upper_bound, args...);
    if (!searchResult)
    {
        return INVALID_EDGE_DISTANCE;
    }
    auto [middle, _] = *searchResult;
    auto distance = forward_heap.GetData(middle).distance + reverse_heap.GetData(middle).distance;
    return distance;
 }
 // Alias to be compatible with the CH-based search
@ -662,15 +549,13 @@ 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
-    auto unpacked_path = search(engine_working_data,
+    std::tie(weight, unpacked_nodes, std::ignore) = search(engine_working_data,
-                                facade,
+                                                           facade,
-                                forward_heap,
+                                                           forward_heap,
-                                reverse_heap,
+                                                           reverse_heap,
-                                force_step_nodes,
+                                                           force_step_nodes,
-                                weight_upper_bound,
+                                                           weight_upper_bound,
-                                endpoints);
+                                                           endpoints);
    weight = unpacked_path.weight;
    unpacked_nodes = std::move(unpacked_path.nodes);
 }
 // TODO: refactor CH-related stub to use unpacked_edges
@ -708,8 +593,8 @@ void unpackPath(const FacadeT &facade,
 template <typename Algorithm>
 double getNetworkDistance(SearchEngineData<Algorithm> &engine_working_data,
                          const DataFacade<Algorithm> &facade,
-                          typename SearchEngineData<Algorithm>::MapMatchingQueryHeap &forward_heap,
+                          typename SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-                          typename SearchEngineData<Algorithm>::MapMatchingQueryHeap &reverse_heap,
+                          typename SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
                          const PhantomNode &source_phantom,
                          const PhantomNode &target_phantom,
                          EdgeWeight weight_upper_bound = INVALID_EDGE_WEIGHT)
@ -717,49 +602,48 @@ double getNetworkDistance(SearchEngineData<Algorithm> &engine_working_data,
    forward_heap.Clear();
    reverse_heap.Clear();
    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()});
    }
    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()});
    }
    const PhantomEndpoints endpoints{source_phantom, target_phantom};
    insertNodesInHeaps(forward_heap, reverse_heap, endpoints);
-    auto distance = searchDistance(
+    auto [weight, unpacked_nodes, unpacked_edges] = search(
        engine_working_data, facade, forward_heap, reverse_heap, {}, weight_upper_bound, endpoints);
-    if (distance == INVALID_EDGE_DISTANCE)
+    if (weight == INVALID_EDGE_WEIGHT)
    {
        return std::numeric_limits<double>::max();
    }
    BOOST_ASSERT(unpacked_nodes.size() >= 1);
    EdgeDistance distance = {0.0};
    if (source_phantom.forward_segment_id.id == unpacked_nodes.front())
    {
        BOOST_ASSERT(source_phantom.forward_segment_id.enabled);
        distance = EdgeDistance{0} - source_phantom.GetForwardDistance();
    }
    else if (source_phantom.reverse_segment_id.id == unpacked_nodes.front())
    {
        BOOST_ASSERT(source_phantom.reverse_segment_id.enabled);
        distance = EdgeDistance{0} - source_phantom.GetReverseDistance();
    }
    for (size_t index = 0; index < unpacked_nodes.size() - 1; ++index)
    {
        distance += facade.GetNodeDistance(unpacked_nodes[index]);
    }
    if (target_phantom.forward_segment_id.id == unpacked_nodes.back())
    {
        BOOST_ASSERT(target_phantom.forward_segment_id.enabled);
        distance += target_phantom.GetForwardDistance();
    }
    else if (target_phantom.reverse_segment_id.id == unpacked_nodes.back())
    {
        BOOST_ASSERT(target_phantom.reverse_segment_id.enabled);
        distance += target_phantom.GetReverseDistance();
    }
    return from_alias<double>(distance);
 }
--- a/include/engine/routing_algorithms/shortest_path.hpp
+++ b/include/engine/routing_algorithms/shortest_path.hpp
@ -14,7 +14,7 @@ InternalRouteResult
 shortestPathSearch(SearchEngineData<Algorithm> &engine_working_data,
                   const DataFacade<Algorithm> &facade,
                   const std::vector<PhantomNodeCandidates> &waypoint_candidates,
-                   const std::optional<bool> continue_straight_at_waypoint);
+                   const boost::optional<bool> continue_straight_at_waypoint);
 } // namespace osrm::engine::routing_algorithms
--- a/include/engine/routing_algorithms/shortest_path_impl.hpp
+++ b/include/engine/routing_algorithms/shortest_path_impl.hpp
@ -4,7 +4,7 @@
 #include "engine/routing_algorithms/shortest_path.hpp"
 #include <boost/assert.hpp>
-#include <optional>
+#include <boost/optional.hpp>
 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
-    std::optional<size_t> forward_to_forward;
+    boost::optional<size_t> forward_to_forward;
-    std::optional<size_t> reverse_to_forward;
+    boost::optional<size_t> reverse_to_forward;
-    std::optional<size_t> forward_to_reverse;
+    boost::optional<size_t> forward_to_reverse;
-    std::optional<size_t> reverse_to_reverse;
+    boost::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 std::optional<bool> continue_straight_at_waypoint)
+                   const boost::optional<bool> continue_straight_at_waypoint)
 {
    const bool allow_uturn_at_waypoint =
        !(continue_straight_at_waypoint ? *continue_straight_at_waypoint
--- a/include/engine/search_engine_data.hpp
+++ b/include/engine/search_engine_data.hpp
@ -5,11 +5,14 @@
 #include "util/query_heap.hpp"
 #include "util/typedefs.hpp"
 #include <boost/thread/tss.hpp>
 namespace osrm::engine
 {
 // Algorithm-dependent heaps
 // - CH algorithms use CH heaps
 // - CoreCH algorithms use CH
 // - MLD algorithms use MLD heaps
 template <typename Algorithm> struct SearchEngineData
@ -43,21 +46,16 @@ template <> struct SearchEngineData<routing_algorithms::ch::Algorithm>
                                                ManyToManyHeapData,
                                                util::UnorderedMapStorage<NodeID, int>>;
-    using SearchEngineHeapPtr = std::unique_ptr<QueryHeap>;
+    using SearchEngineHeapPtr = boost::thread_specific_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 thread_local SearchEngineHeapPtr forward_heap_1;
+    static SearchEngineHeapPtr forward_heap_2;
-    static thread_local SearchEngineHeapPtr reverse_heap_1;
+    static SearchEngineHeapPtr reverse_heap_2;
-    static thread_local SearchEngineHeapPtr forward_heap_2;
+    static SearchEngineHeapPtr forward_heap_3;
-    static thread_local SearchEngineHeapPtr reverse_heap_2;
+    static SearchEngineHeapPtr reverse_heap_3;
-    static thread_local SearchEngineHeapPtr forward_heap_3;
+    static ManyToManyHeapPtr many_to_many_heap;
    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;
    void InitializeOrClearMapMatchingThreadLocalStorage(unsigned number_of_nodes);
    void InitializeOrClearFirstThreadLocalStorage(unsigned number_of_nodes);
@ -76,19 +74,6 @@ struct MultiLayerDijkstraHeapData
    MultiLayerDijkstraHeapData(NodeID p, bool from) : parent(p), from_clique_arc(from) {}
 };
 struct MapMatchingMultiLayerDijkstraHeapData
 {
    NodeID parent;
    bool from_clique_arc;
    EdgeDistance distance = {0};
    MapMatchingMultiLayerDijkstraHeapData(NodeID p) : parent(p), from_clique_arc(false) {}
    MapMatchingMultiLayerDijkstraHeapData(NodeID p, bool from) : parent(p), from_clique_arc(from) {}
    MapMatchingMultiLayerDijkstraHeapData(NodeID p, bool from, EdgeDistance d)
        : parent(p), from_clique_arc(from), distance(d)
    {
    }
 };
 struct ManyToManyMultiLayerDijkstraHeapData : MultiLayerDijkstraHeapData
 {
    EdgeDuration duration;
@ -119,31 +104,20 @@ template <> struct SearchEngineData<routing_algorithms::mld::Algorithm>
                                                EdgeWeight,
                                                ManyToManyMultiLayerDijkstraHeapData,
                                                util::TwoLevelStorage<NodeID, int>>;
    using MapMatchingQueryHeap = util::QueryHeap<NodeID,
                                                 NodeID,
                                                 EdgeWeight,
                                                 MapMatchingMultiLayerDijkstraHeapData,
                                                 util::TwoLevelStorage<NodeID, int>>;
-    using SearchEngineHeapPtr = std::unique_ptr<QueryHeap>;
+    using SearchEngineHeapPtr = boost::thread_specific_ptr<QueryHeap>;
-    using ManyToManyHeapPtr = std::unique_ptr<ManyToManyQueryHeap>;
+    using ManyToManyHeapPtr = boost::thread_specific_ptr<ManyToManyQueryHeap>;
    using MapMatchingHeapPtr = std::unique_ptr<MapMatchingQueryHeap>;
-    static thread_local SearchEngineHeapPtr forward_heap_1;
+    static SearchEngineHeapPtr forward_heap_1;
-    static thread_local SearchEngineHeapPtr reverse_heap_1;
+    static SearchEngineHeapPtr reverse_heap_1;
-    static thread_local MapMatchingHeapPtr map_matching_forward_heap_1;
+    static ManyToManyHeapPtr many_to_many_heap;
    static thread_local MapMatchingHeapPtr map_matching_reverse_heap_1;
    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);
    void InitializeOrClearManyToManyThreadLocalStorage(unsigned number_of_nodes,
                                                       unsigned number_of_boundary_nodes);
 };
 } // namespace osrm::engine
-#endif // SEARCH_ENGINE_DATA_HPP
+#endif // SEARCH_ENGINE_DATA_HPP
--- a/include/extractor/extractor_callbacks.hpp
+++ b/include/extractor/extractor_callbacks.hpp
@ -3,9 +3,11 @@
 #include "extractor/class_data.hpp"
 #include "extractor/turn_lane_types.hpp"
 #include "util/std_hash.hpp"
 #include "util/typedefs.hpp"
 #include <boost/functional/hash.hpp>
 #include <boost/optional/optional_fwd.hpp>
 #include <string>
 #include <unordered_map>
@ -16,6 +18,25 @@ class Way;
 class Relation;
 } // namespace osmium
 namespace std
 {
 template <> struct hash<std::tuple<std::string, std::string, std::string, std::string, std::string>>
 {
    std::size_t operator()(
        const std::tuple<std::string, std::string, std::string, std::string, std::string> &mk)
        const noexcept
    {
        std::size_t seed = 0;
        boost::hash_combine(seed, std::get<0>(mk));
        boost::hash_combine(seed, std::get<1>(mk));
        boost::hash_combine(seed, std::get<2>(mk));
        boost::hash_combine(seed, std::get<3>(mk));
        boost::hash_combine(seed, std::get<4>(mk));
        return seed;
    }
 };
 } // namespace std
 namespace osrm::extractor
 {
--- a/include/extractor/extractor_config.hpp
+++ b/include/extractor/extractor_config.hpp
@ -28,12 +28,13 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef EXTRACTOR_CONFIG_HPP
 #define EXTRACTOR_CONFIG_HPP
-#include "storage/io_config.hpp"
+#include <boost/filesystem/path.hpp>
 #include <array>
 #include <filesystem>
 #include <string>
 #include "storage/io_config.hpp"
 namespace osrm::extractor
 {
@ -70,14 +71,14 @@ struct ExtractorConfig final : storage::IOConfig
    {
    }
-    void UseDefaultOutputNames(const std::filesystem::path &base)
+    void UseDefaultOutputNames(const boost::filesystem::path &base)
    {
        IOConfig::UseDefaultOutputNames(base);
    }
-    std::filesystem::path input_path;
+    boost::filesystem::path input_path;
-    std::filesystem::path profile_path;
+    boost::filesystem::path profile_path;
-    std::vector<std::filesystem::path> location_dependent_data_paths;
+    std::vector<boost::filesystem::path> location_dependent_data_paths;
    std::string data_version;
    unsigned requested_num_threads = 0;
--- a/include/extractor/files.hpp
+++ b/include/extractor/files.hpp
@ -23,9 +23,9 @@ namespace osrm::extractor::files
 // writes the .osrm.icd file
 template <typename IntersectionBearingsT, typename EntryClassVectorT>
-void writeIntersections(const std::filesystem::path &path,
+inline void writeIntersections(const boost::filesystem::path &path,
-                        const IntersectionBearingsT &intersection_bearings,
+                               const IntersectionBearingsT &intersection_bearings,
-                        const EntryClassVectorT &entry_classes)
+                               const EntryClassVectorT &entry_classes)
 {
    static_assert(std::is_same<IntersectionBearingsContainer, IntersectionBearingsT>::value ||
                      std::is_same<IntersectionBearingsView, IntersectionBearingsT>::value,
@ -39,9 +39,9 @@ void writeIntersections(const std::filesystem::path &path,
 // read the .osrm.icd file
 template <typename IntersectionBearingsT, typename EntryClassVectorT>
-void readIntersections(const std::filesystem::path &path,
+inline void readIntersections(const boost::filesystem::path &path,
-                       IntersectionBearingsT &intersection_bearings,
+                              IntersectionBearingsT &intersection_bearings,
-                       EntryClassVectorT &entry_classes)
+                              EntryClassVectorT &entry_classes)
 {
    static_assert(std::is_same<IntersectionBearingsContainer, IntersectionBearingsT>::value ||
                      std::is_same<IntersectionBearingsView, IntersectionBearingsT>::value,
@ -54,7 +54,8 @@ void readIntersections(const std::filesystem::path &path,
 }
 // reads .osrm.properties
-inline void readProfileProperties(const std::filesystem::path &path, ProfileProperties &properties)
+inline void readProfileProperties(const boost::filesystem::path &path,
                                  ProfileProperties &properties)
 {
    const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
    storage::tar::FileReader reader{path, fingerprint};
@ -63,7 +64,7 @@ inline void readProfileProperties(const std::filesystem::path &path, ProfileProp
 }
 // writes .osrm.properties
-inline void writeProfileProperties(const std::filesystem::path &path,
+inline void writeProfileProperties(const boost::filesystem::path &path,
                                   const ProfileProperties &properties)
 {
    const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
@ -73,7 +74,7 @@ inline void writeProfileProperties(const std::filesystem::path &path,
 }
 template <typename EdgeBasedEdgeVector>
-void writeEdgeBasedGraph(const std::filesystem::path &path,
+void writeEdgeBasedGraph(const boost::filesystem::path &path,
                         EdgeID const number_of_edge_based_nodes,
                         const EdgeBasedEdgeVector &edge_based_edge_list,
                         const std::uint32_t connectivity_checksum)
@ -91,7 +92,7 @@ void writeEdgeBasedGraph(const std::filesystem::path &path,
 // reads .osrm.ebg file
 template <typename EdgeBasedEdgeVector>
-void readEdgeBasedGraph(const std::filesystem::path &path,
+void readEdgeBasedGraph(const boost::filesystem::path &path,
                        EdgeID &number_of_edge_based_nodes,
                        EdgeBasedEdgeVector &edge_based_edge_list,
                        std::uint32_t &connectivity_checksum)
@ -107,9 +108,9 @@ void readEdgeBasedGraph(const std::filesystem::path &path,
 // reads .osrm.nbg_nodes
 template <typename CoordinatesT, typename PackedOSMIDsT>
-void readNodes(const std::filesystem::path &path,
+inline void readNodes(const boost::filesystem::path &path,
-               CoordinatesT &coordinates,
+                      CoordinatesT &coordinates,
-               PackedOSMIDsT &osm_node_ids)
+                      PackedOSMIDsT &osm_node_ids)
 {
    static_assert(std::is_same<typename CoordinatesT::value_type, util::Coordinate>::value, "");
    static_assert(std::is_same<typename PackedOSMIDsT::value_type, OSMNodeID>::value, "");
@ -123,7 +124,7 @@ void readNodes(const std::filesystem::path &path,
 // reads only coordinates from .osrm.nbg_nodes
 template <typename CoordinatesT>
-void readNodeCoordinates(const std::filesystem::path &path, CoordinatesT &coordinates)
+inline void readNodeCoordinates(const boost::filesystem::path &path, CoordinatesT &coordinates)
 {
    static_assert(std::is_same<typename CoordinatesT::value_type, util::Coordinate>::value, "");
@ -135,9 +136,9 @@ void readNodeCoordinates(const std::filesystem::path &path, CoordinatesT &coordi
 // writes .osrm.nbg_nodes
 template <typename CoordinatesT, typename PackedOSMIDsT>
-void writeNodes(const std::filesystem::path &path,
+inline void writeNodes(const boost::filesystem::path &path,
-                const CoordinatesT &coordinates,
+                       const CoordinatesT &coordinates,
-                const PackedOSMIDsT &osm_node_ids)
+                       const PackedOSMIDsT &osm_node_ids)
 {
    static_assert(std::is_same<typename CoordinatesT::value_type, util::Coordinate>::value, "");
    static_assert(std::is_same<typename PackedOSMIDsT::value_type, OSMNodeID>::value, "");
@ -150,7 +151,7 @@ void writeNodes(const std::filesystem::path &path,
 }
 // reads .osrm.cnbg_to_ebg
-inline void readNBGMapping(const std::filesystem::path &path, std::vector<NBGToEBG> &mapping)
+inline void readNBGMapping(const boost::filesystem::path &path, std::vector<NBGToEBG> &mapping)
 {
    const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
    storage::tar::FileReader reader{path, fingerprint};
@ -159,7 +160,8 @@ inline void readNBGMapping(const std::filesystem::path &path, std::vector<NBGToE
 }
 // writes .osrm.cnbg_to_ebg
-inline void writeNBGMapping(const std::filesystem::path &path, const std::vector<NBGToEBG> &mapping)
+inline void writeNBGMapping(const boost::filesystem::path &path,
                            const std::vector<NBGToEBG> &mapping)
 {
    const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
    storage::tar::FileWriter writer{path, fingerprint};
@ -168,7 +170,7 @@ inline void writeNBGMapping(const std::filesystem::path &path, const std::vector
 }
 // reads .osrm.datasource_names
-inline void readDatasources(const std::filesystem::path &path, Datasources &sources)
+inline void readDatasources(const boost::filesystem::path &path, Datasources &sources)
 {
    const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
    storage::tar::FileReader reader{path, fingerprint};
@ -177,7 +179,7 @@ inline void readDatasources(const std::filesystem::path &path, Datasources &sour
 }
 // writes .osrm.datasource_names
-inline void writeDatasources(const std::filesystem::path &path, Datasources &sources)
+inline void writeDatasources(const boost::filesystem::path &path, Datasources &sources)
 {
    const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
    storage::tar::FileWriter writer{path, fingerprint};
@ -187,7 +189,7 @@ inline void writeDatasources(const std::filesystem::path &path, Datasources &sou
 // reads .osrm.geometry
 template <typename SegmentDataT>
-void readSegmentData(const std::filesystem::path &path, SegmentDataT &segment_data)
+inline void readSegmentData(const boost::filesystem::path &path, SegmentDataT &segment_data)
 {
    static_assert(std::is_same<SegmentDataContainer, SegmentDataT>::value ||
                      std::is_same<SegmentDataView, SegmentDataT>::value,
@ -200,7 +202,7 @@ void readSegmentData(const std::filesystem::path &path, SegmentDataT &segment_da
 // writes .osrm.geometry
 template <typename SegmentDataT>
-void writeSegmentData(const std::filesystem::path &path, const SegmentDataT &segment_data)
+inline void writeSegmentData(const boost::filesystem::path &path, const SegmentDataT &segment_data)
 {
    static_assert(std::is_same<SegmentDataContainer, SegmentDataT>::value ||
                      std::is_same<SegmentDataView, SegmentDataT>::value,
@ -213,7 +215,7 @@ void writeSegmentData(const std::filesystem::path &path, const SegmentDataT &seg
 // reads .osrm.ebg_nodes
 template <typename NodeDataT>
-inline void readNodeData(const std::filesystem::path &path, NodeDataT &node_data)
+inline void readNodeData(const boost::filesystem::path &path, NodeDataT &node_data)
 {
    static_assert(std::is_same<EdgeBasedNodeDataContainer, NodeDataT>::value ||
                      std::is_same<EdgeBasedNodeDataView, NodeDataT>::value ||
@ -227,7 +229,7 @@ inline void readNodeData(const std::filesystem::path &path, NodeDataT &node_data
 // writes .osrm.ebg_nodes
 template <typename NodeDataT>
-inline void writeNodeData(const std::filesystem::path &path, const NodeDataT &node_data)
+inline void writeNodeData(const boost::filesystem::path &path, const NodeDataT &node_data)
 {
    static_assert(std::is_same<EdgeBasedNodeDataContainer, NodeDataT>::value ||
                      std::is_same<EdgeBasedNodeDataView, NodeDataT>::value ||
@ -241,7 +243,7 @@ inline void writeNodeData(const std::filesystem::path &path, const NodeDataT &no
 // reads .osrm.tls
 template <typename OffsetsT, typename MaskT>
-inline void readTurnLaneDescriptions(const std::filesystem::path &path,
+inline void readTurnLaneDescriptions(const boost::filesystem::path &path,
                                     OffsetsT &turn_offsets,
                                     MaskT &turn_masks)
 {
@ -258,7 +260,7 @@ inline void readTurnLaneDescriptions(const std::filesystem::path &path,
 // writes .osrm.tls
 template <typename OffsetsT, typename MaskT>
-inline void writeTurnLaneDescriptions(const std::filesystem::path &path,
+inline void writeTurnLaneDescriptions(const boost::filesystem::path &path,
                                      const OffsetsT &turn_offsets,
                                      const MaskT &turn_masks)
 {
@ -275,7 +277,7 @@ inline void writeTurnLaneDescriptions(const std::filesystem::path &path,
 // reads .osrm.tld
 template <typename TurnLaneDataT>
-inline void readTurnLaneData(const std::filesystem::path &path, TurnLaneDataT &turn_lane_data)
+inline void readTurnLaneData(const boost::filesystem::path &path, TurnLaneDataT &turn_lane_data)
 {
    static_assert(
        std::is_same<typename TurnLaneDataT::value_type, util::guidance::LaneTupleIdPair>::value,
@ -289,7 +291,7 @@ inline void readTurnLaneData(const std::filesystem::path &path, TurnLaneDataT &t
 // writes .osrm.tld
 template <typename TurnLaneDataT>
-inline void writeTurnLaneData(const std::filesystem::path &path,
+inline void writeTurnLaneData(const boost::filesystem::path &path,
                              const TurnLaneDataT &turn_lane_data)
 {
    static_assert(
@ -304,7 +306,7 @@ inline void writeTurnLaneData(const std::filesystem::path &path,
 // reads .osrm.timestamp
 template <typename TimestampDataT>
-inline void readTimestamp(const std::filesystem::path &path, TimestampDataT &timestamp)
+inline void readTimestamp(const boost::filesystem::path &path, TimestampDataT &timestamp)
 {
    const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
    storage::tar::FileReader reader{path, fingerprint};
@ -314,7 +316,7 @@ inline void readTimestamp(const std::filesystem::path &path, TimestampDataT &tim
 // writes .osrm.timestamp
 template <typename TimestampDataT>
-inline void writeTimestamp(const std::filesystem::path &path, const TimestampDataT &timestamp)
+inline void writeTimestamp(const boost::filesystem::path &path, const TimestampDataT &timestamp)
 {
    const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
    storage::tar::FileWriter writer{path, fingerprint};
@ -324,7 +326,7 @@ inline void writeTimestamp(const std::filesystem::path &path, const TimestampDat
 // reads .osrm.maneuver_overrides
 template <typename StorageManeuverOverrideT, typename NodeSequencesT>
-inline void readManeuverOverrides(const std::filesystem::path &path,
+inline void readManeuverOverrides(const boost::filesystem::path &path,
                                  StorageManeuverOverrideT &maneuver_overrides,
                                  NodeSequencesT &node_sequences)
 {
@ -338,7 +340,7 @@ inline void readManeuverOverrides(const std::filesystem::path &path,
 }
 // writes .osrm.maneuver_overrides
-inline void writeManeuverOverrides(const std::filesystem::path &path,
+inline void writeManeuverOverrides(const boost::filesystem::path &path,
                                   const std::vector<StorageManeuverOverride> &maneuver_overrides,
                                   const std::vector<NodeID> &node_sequences)
 {
@ -353,7 +355,7 @@ inline void writeManeuverOverrides(const std::filesystem::path &path,
 // writes .osrm.turn_weight_penalties
 template <typename TurnPenaltyT>
-inline void writeTurnWeightPenalty(const std::filesystem::path &path,
+inline void writeTurnWeightPenalty(const boost::filesystem::path &path,
                                   const TurnPenaltyT &turn_penalty)
 {
    const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
@ -364,7 +366,7 @@ inline void writeTurnWeightPenalty(const std::filesystem::path &path,
 // read .osrm.turn_weight_penalties
 template <typename TurnPenaltyT>
-inline void readTurnWeightPenalty(const std::filesystem::path &path, TurnPenaltyT &turn_penalty)
+inline void readTurnWeightPenalty(const boost::filesystem::path &path, TurnPenaltyT &turn_penalty)
 {
    const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
    storage::tar::FileReader reader{path, fingerprint};
@ -374,7 +376,7 @@ inline void readTurnWeightPenalty(const std::filesystem::path &path, TurnPenalty
 // writes .osrm.turn_duration_penalties
 template <typename TurnPenaltyT>
-inline void writeTurnDurationPenalty(const std::filesystem::path &path,
+inline void writeTurnDurationPenalty(const boost::filesystem::path &path,
                                     const TurnPenaltyT &turn_penalty)
 {
    const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
@ -385,7 +387,7 @@ inline void writeTurnDurationPenalty(const std::filesystem::path &path,
 // read .osrm.turn_weight_penalties
 template <typename TurnPenaltyT>
-inline void readTurnDurationPenalty(const std::filesystem::path &path, TurnPenaltyT &turn_penalty)
+inline void readTurnDurationPenalty(const boost::filesystem::path &path, TurnPenaltyT &turn_penalty)
 {
    const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
    storage::tar::FileReader reader{path, fingerprint};
@ -395,7 +397,7 @@ inline void readTurnDurationPenalty(const std::filesystem::path &path, TurnPenal
 // writes .osrm.turn_penalties_index
 template <typename TurnIndexT>
-inline void writeTurnPenaltiesIndex(const std::filesystem::path &path,
+inline void writeTurnPenaltiesIndex(const boost::filesystem::path &path,
                                    const TurnIndexT &turn_penalties_index)
 {
    const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
@ -406,7 +408,7 @@ inline void writeTurnPenaltiesIndex(const std::filesystem::path &path,
 // read .osrm.turn_penalties_index
 template <typename TurnIndexT>
-inline void readTurnPenaltiesIndex(const std::filesystem::path &path,
+inline void readTurnPenaltiesIndex(const boost::filesystem::path &path,
                                   TurnIndexT &turn_penalties_index)
 {
    const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
@ -417,7 +419,7 @@ inline void readTurnPenaltiesIndex(const std::filesystem::path &path,
 // writes .osrm.restrictions
 template <typename ConditionalRestrictionsT>
-inline void writeConditionalRestrictions(const std::filesystem::path &path,
+inline void writeConditionalRestrictions(const boost::filesystem::path &path,
                                         const ConditionalRestrictionsT &conditional_restrictions)
 {
    const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
@ -428,7 +430,7 @@ inline void writeConditionalRestrictions(const std::filesystem::path &path,
 // read .osrm.restrictions
 template <typename ConditionalRestrictionsT>
-inline void readConditionalRestrictions(const std::filesystem::path &path,
+inline void readConditionalRestrictions(const boost::filesystem::path &path,
                                        ConditionalRestrictionsT &conditional_restrictions)
 {
    const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
@ -439,7 +441,7 @@ inline void readConditionalRestrictions(const std::filesystem::path &path,
 // reads .osrm file which is a temporary file of osrm-extract
 template <typename PackedOSMIDsT>
-void readRawNBGraph(const std::filesystem::path &path,
+void readRawNBGraph(const boost::filesystem::path &path,
                    std::vector<util::Coordinate> &coordinates,
                    PackedOSMIDsT &osm_node_ids,
                    std::vector<extractor::NodeBasedEdge> &edge_list)
@ -464,7 +466,8 @@ void readRawNBGraph(const std::filesystem::path &path,
    storage::serialization::read(reader, "/extractor/edges", edge_list);
 }
-template <typename NameTableT> void readNames(const std::filesystem::path &path, NameTableT &table)
+template <typename NameTableT>
 void readNames(const boost::filesystem::path &path, NameTableT &table)
 {
    const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
    storage::tar::FileReader reader{path, fingerprint};
@ -473,7 +476,7 @@ template <typename NameTableT> void readNames(const std::filesystem::path &path,
 }
 template <typename NameTableT>
-void writeNames(const std::filesystem::path &path, const NameTableT &table)
+void writeNames(const boost::filesystem::path &path, const NameTableT &table)
 {
    const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
    storage::tar::FileWriter writer{path, fingerprint};
@ -482,7 +485,7 @@ void writeNames(const std::filesystem::path &path, const NameTableT &table)
 }
 template <typename NodeWeightsVectorT>
-void readEdgeBasedNodeWeights(const std::filesystem::path &path, NodeWeightsVectorT &weights)
+void readEdgeBasedNodeWeights(const boost::filesystem::path &path, NodeWeightsVectorT &weights)
 {
    const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
    storage::tar::FileReader reader{path, fingerprint};
@ -491,7 +494,8 @@ void readEdgeBasedNodeWeights(const std::filesystem::path &path, NodeWeightsVect
 }
 template <typename NodeDistancesVectorT>
-void readEdgeBasedNodeDistances(const std::filesystem::path &path, NodeDistancesVectorT &distances)
+void readEdgeBasedNodeDistances(const boost::filesystem::path &path,
                                NodeDistancesVectorT &distances)
 {
    const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
    storage::tar::FileReader reader{path, fingerprint};
@ -500,7 +504,7 @@ void readEdgeBasedNodeDistances(const std::filesystem::path &path, NodeDistances
 }
 template <typename NodeWeightsVectorT, typename NodeDurationsVectorT, typename NodeDistancesVectorT>
-void writeEdgeBasedNodeWeightsDurationsDistances(const std::filesystem::path &path,
+void writeEdgeBasedNodeWeightsDurationsDistances(const boost::filesystem::path &path,
                                                 const NodeWeightsVectorT &weights,
                                                 const NodeDurationsVectorT &durations,
                                                 const NodeDistancesVectorT &distances)
@ -514,7 +518,7 @@ void writeEdgeBasedNodeWeightsDurationsDistances(const std::filesystem::path &pa
 }
 template <typename NodeWeightsVectorT, typename NodeDurationsVectorT>
-void readEdgeBasedNodeWeightsDurations(const std::filesystem::path &path,
+void readEdgeBasedNodeWeightsDurations(const boost::filesystem::path &path,
                                       NodeWeightsVectorT &weights,
                                       NodeDurationsVectorT &durations)
 {
@ -526,7 +530,7 @@ void readEdgeBasedNodeWeightsDurations(const std::filesystem::path &path,
 }
 template <typename NodeWeightsVectorT, typename NodeDurationsVectorT>
-void writeEdgeBasedNodeWeightsDurations(const std::filesystem::path &path,
+void writeEdgeBasedNodeWeightsDurations(const boost::filesystem::path &path,
                                        const NodeWeightsVectorT &weights,
                                        const NodeDurationsVectorT &durations)
 {
@ -538,7 +542,7 @@ void writeEdgeBasedNodeWeightsDurations(const std::filesystem::path &path,
 }
 template <typename RTreeT>
-void writeRamIndex(const std::filesystem::path &path, const RTreeT &rtree)
+void writeRamIndex(const boost::filesystem::path &path, const RTreeT &rtree)
 {
    const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
    storage::tar::FileWriter writer{path, fingerprint};
@ -546,7 +550,7 @@ void writeRamIndex(const std::filesystem::path &path, const RTreeT &rtree)
    util::serialization::write(writer, "/common/rtree", rtree);
 }
-template <typename RTreeT> void readRamIndex(const std::filesystem::path &path, RTreeT &rtree)
+template <typename RTreeT> void readRamIndex(const boost::filesystem::path &path, RTreeT &rtree)
 {
    const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
    storage::tar::FileReader reader{path, fingerprint};
@ -555,7 +559,7 @@ template <typename RTreeT> void readRamIndex(const std::filesystem::path &path,
 }
 template <typename EdgeListT>
-void writeCompressedNodeBasedGraph(const std::filesystem::path &path, const EdgeListT &edge_list)
+void writeCompressedNodeBasedGraph(const boost::filesystem::path &path, const EdgeListT &edge_list)
 {
    const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
    storage::tar::FileWriter writer{path, fingerprint};
@ -564,7 +568,7 @@ void writeCompressedNodeBasedGraph(const std::filesystem::path &path, const Edge
 }
 template <typename EdgeListT>
-void readCompressedNodeBasedGraph(const std::filesystem::path &path, EdgeListT &edge_list)
+void readCompressedNodeBasedGraph(const boost::filesystem::path &path, EdgeListT &edge_list)
 {
    const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
    storage::tar::FileReader reader{path, fingerprint};
--- a/include/extractor/internal_extractor_edge.hpp
+++ b/include/extractor/internal_extractor_edge.hpp
@ -7,8 +7,8 @@
 #include "util/typedefs.hpp"
 #include <boost/assert.hpp>
 #include <mapbox/variant.hpp>
 #include <utility>
 #include <variant>
 namespace osrm::extractor
 {
--- a/include/extractor/intersection/coordinate_extractor.hpp
+++ b/include/extractor/intersection/coordinate_extractor.hpp
@ -1,15 +1,16 @@
 #ifndef OSRM_EXTRACTOR_INTERSECTION_COORDINATE_EXTRACTOR_HPP_
 #define OSRM_EXTRACTOR_INTERSECTION_COORDINATE_EXTRACTOR_HPP_
 #include <utility>
 #include <vector>
 #include "extractor/compressed_edge_container.hpp"
 #include "extractor/query_node.hpp"
 #include "util/attributes.hpp"
 #include "util/coordinate.hpp"
 #include "util/node_based_graph.hpp"
 #include <utility>
 #include <vector>
 namespace osrm::extractor::intersection
 {
@ -26,16 +27,17 @@ class CoordinateExtractor
     * Note: The segment between intersection and turn coordinate can be zero, if the OSM modelling
     * is unfortunate. See https://github.com/Project-OSRM/osrm-backend/issues/3470
     */
-    [[nodiscard]] util::Coordinate
+    OSRM_ATTR_WARN_UNUSED
-    GetCoordinateAlongRoad(const NodeID intersection_node,
+    util::Coordinate GetCoordinateAlongRoad(const NodeID intersection_node,
-                           const EdgeID turn_edge,
+                                            const EdgeID turn_edge,
-                           const bool traversed_in_reverse,
+                                            const bool traversed_in_reverse,
-                           const NodeID to_node,
+                                            const NodeID to_node,
-                           const std::uint8_t number_of_in_lanes) const;
+                                            const std::uint8_t number_of_in_lanes) const;
    // Given a set of precomputed coordinates, select the representative coordinate along the road
    // that best describes the turn
-    [[nodiscard]] util::Coordinate
+    OSRM_ATTR_WARN_UNUSED
    util::Coordinate
    ExtractRepresentativeCoordinate(const NodeID intersection_node,
                                    const EdgeID turn_edge,
                                    const bool traversed_in_reverse,
@ -45,7 +47,7 @@ class CoordinateExtractor
    // instead of finding only a single coordinate, we can also list all coordinates along a
    // road.
-    [[nodiscard]] std::vector<util::Coordinate>
+    OSRM_ATTR_WARN_UNUSED std::vector<util::Coordinate>
    GetCoordinatesAlongRoad(const NodeID intersection_node,
                            const EdgeID turn_edge,
                            const bool traversed_in_reverse,
@ -53,18 +55,20 @@ class CoordinateExtractor
    // wrapper in case of normal forward edges (traversed_in_reverse = false, to_node =
    // node_based_graph.GetTarget(turn_edge)
-    [[nodiscard]] std::vector<util::Coordinate>
+    OSRM_ATTR_WARN_UNUSED
-    GetForwardCoordinatesAlongRoad(const NodeID from, const EdgeID turn_edge) const;
+    std::vector<util::Coordinate> GetForwardCoordinatesAlongRoad(const NodeID from,
                                                                 const EdgeID turn_edge) const;
    // a less precise way to compute coordinates along a route. Due to the heavy interaction of
    // graph traversal and turn instructions, we often don't care for high precision. We only want
    // to check for available connections in order, or find (with room for error) the straightmost
    // turn. This function will offer a bit more error potential but allow for much higher
    // performance
-    [[nodiscard]] util::Coordinate GetCoordinateCloseToTurn(const NodeID from_node,
+    OSRM_ATTR_WARN_UNUSED
-                                                            const EdgeID turn_edge,
+    util::Coordinate GetCoordinateCloseToTurn(const NodeID from_node,
-                                                            const bool traversed_in_reverse,
+                                              const EdgeID turn_edge,
-                                                            const NodeID to_node) const;
+                                              const bool traversed_in_reverse,
                                              const NodeID to_node) const;
    /* When extracting the coordinates, we first extract all coordinates. We don't care about most
     * of them, though.
@ -86,19 +90,22 @@ class CoordinateExtractor
     * The optional length cache needs to store the accumulated distance up to the respective
     * coordinate index [0,d(0,1),...]
     */
-    [[nodiscard]] std::vector<util::Coordinate>
+    OSRM_ATTR_WARN_UNUSED
    std::vector<util::Coordinate>
    TrimCoordinatesToLength(std::vector<util::Coordinate> coordinates,
                            const double desired_length,
                            const std::vector<double> &length_cache = {}) const;
-    [[nodiscard]] std::vector<double>
+    OSRM_ATTR_WARN_UNUSED
-    PrepareLengthCache(const std::vector<util::Coordinate> &coordinates, const double limit) const;
+    std::vector<double> PrepareLengthCache(const std::vector<util::Coordinate> &coordinates,
                                           const double limit) const;
    /* when looking at a set of coordinates, this function allows trimming the vector to a smaller,
     * only containing coordinates up to a given distance along the path. The last coordinate might
     * be interpolated
     */
-    [[nodiscard]] std::vector<util::Coordinate>
+    OSRM_ATTR_WARN_UNUSED
    std::vector<util::Coordinate>
    TrimCoordinatesByLengthFront(std::vector<util::Coordinate> coordinates,
                                 const double desired_length) const;
@ -123,9 +130,10 @@ class CoordinateExtractor
     *
     * for fixpoint `b`, vector_base `d` and vector_head `e`
     */
-    [[nodiscard]] util::Coordinate GetCorrectedCoordinate(const util::Coordinate fixpoint,
+    OSRM_ATTR_WARN_UNUSED
-                                                          const util::Coordinate vector_base,
+    util::Coordinate GetCorrectedCoordinate(const util::Coordinate fixpoint,
-                                                          const util::Coordinate vector_head) const;
+                                            const util::Coordinate vector_base,
                                            const util::Coordinate vector_head) const;
    /* generate a uniform vector of coordinates in same range distances
     *
@ -135,7 +143,8 @@ class CoordinateExtractor
     * Into:
     * x -- x -- x -- x -- x - x
     */
-    [[nodiscard]] std::vector<util::Coordinate>
+    OSRM_ATTR_WARN_UNUSED
    std::vector<util::Coordinate>
    SampleCoordinates(const std::vector<util::Coordinate> &coordinates,
                      const double length,
                      const double rate) const;
--- a/include/extractor/intersection/node_based_graph_walker.hpp
+++ b/include/extractor/intersection/node_based_graph_walker.hpp
@ -11,8 +11,8 @@
 #include "util/typedefs.hpp"
 #include <boost/assert.hpp>
 #include <boost/optional.hpp>
 #include <cstdint>
 #include <optional>
 #include <utility>
 namespace osrm::extractor::intersection
@ -42,10 +42,10 @@ class NodeBasedGraphWalker
     * selector not provinding any further edge to traverse)
     */
    template <class accumulator_type, class selector_type>
-    std::optional<std::pair<NodeID, EdgeID>> TraverseRoad(NodeID starting_at_node_id,
+    boost::optional<std::pair<NodeID, EdgeID>> TraverseRoad(NodeID starting_at_node_id,
-                                                          EdgeID following_edge_id,
+                                                            EdgeID following_edge_id,
-                                                          accumulator_type &accumulator,
+                                                            accumulator_type &accumulator,
-                                                          const selector_type &selector) const;
+                                                            const selector_type &selector) const;
  private:
    const util::NodeBasedDynamicGraph &node_based_graph;
@ -111,11 +111,11 @@ struct SelectRoadByNameOnlyChoiceAndStraightness
     * traversal. If no such edge is found, return {} is allowed. Usually you want to choose some
     * form of obious turn to follow.
     */
-    std::optional<EdgeID> operator()(const NodeID nid,
+    boost::optional<EdgeID> operator()(const NodeID nid,
-                                     const EdgeID via_edge_id,
+                                       const EdgeID via_edge_id,
-                                     const IntersectionView &intersection,
+                                       const IntersectionView &intersection,
-                                     const util::NodeBasedDynamicGraph &node_based_graph,
+                                       const util::NodeBasedDynamicGraph &node_based_graph,
-                                     const EdgeBasedNodeDataContainer &node_data_container) const;
+                                       const EdgeBasedNodeDataContainer &node_data_container) const;
  private:
    const NameID desired_name_id;
@ -138,11 +138,11 @@ struct SelectStraightmostRoadByNameAndOnlyChoice
     * traversal. If no such edge is found, return {} is allowed. Usually you want to choose some
     * form of obious turn to follow.
     */
-    std::optional<EdgeID> operator()(const NodeID nid,
+    boost::optional<EdgeID> operator()(const NodeID nid,
-                                     const EdgeID via_edge_id,
+                                       const EdgeID via_edge_id,
-                                     const IntersectionView &intersection,
+                                       const IntersectionView &intersection,
-                                     const util::NodeBasedDynamicGraph &node_based_graph,
+                                       const util::NodeBasedDynamicGraph &node_based_graph,
-                                     const EdgeBasedNodeDataContainer &node_data_container) const;
+                                       const EdgeBasedNodeDataContainer &node_data_container) const;
  private:
    const NameID desired_name_id;
@ -187,7 +187,7 @@ struct IntersectionFinderAccumulator
 };
 template <class accumulator_type, class selector_type>
-std::optional<std::pair<NodeID, EdgeID>>
+boost::optional<std::pair<NodeID, EdgeID>>
 NodeBasedGraphWalker::TraverseRoad(NodeID current_node_id,
                                   EdgeID current_edge_id,
                                   accumulator_type &accumulator,
@ -254,19 +254,19 @@ NodeBasedGraphWalker::TraverseRoad(NodeID current_node_id,
 struct SkipTrafficSignalBarrierRoadSelector
 {
-    std::optional<EdgeID> operator()(const NodeID,
+    boost::optional<EdgeID> operator()(const NodeID,
-                                     const EdgeID,
+                                       const EdgeID,
-                                     const IntersectionView &intersection,
+                                       const IntersectionView &intersection,
-                                     const util::NodeBasedDynamicGraph &,
+                                       const util::NodeBasedDynamicGraph &,
-                                     const EdgeBasedNodeDataContainer &) const
+                                       const EdgeBasedNodeDataContainer &) const
    {
        if (intersection.isTrafficSignalOrBarrier())
        {
-            return std::make_optional(intersection[1].eid);
+            return boost::make_optional(intersection[1].eid);
        }
        else
        {
-            return std::nullopt;
+            return boost::none;
        }
    }
 };
--- a/include/extractor/location_dependent_data.hpp
+++ b/include/extractor/location_dependent_data.hpp
@ -1,13 +1,13 @@
 #ifndef OSRM_LOCATION_DEPENDENT_DATA_HPP
 #define OSRM_LOCATION_DEPENDENT_DATA_HPP
 #include <boost/filesystem/path.hpp>
 #include <boost/geometry.hpp>
 #include <boost/geometry/geometries/point_xy.hpp>
 #include <boost/geometry/index/rtree.hpp>
 #include <osmium/osm/way.hpp>
 #include <filesystem>
 #include <string>
 #include <unordered_map>
@ -30,7 +30,7 @@ struct LocationDependentData
    using property_t = boost::variant<boost::blank, double, std::string, bool>;
    using properties_t = std::unordered_map<std::string, property_t>;
-    LocationDependentData(const std::vector<std::filesystem::path> &file_paths);
+    LocationDependentData(const std::vector<boost::filesystem::path> &file_paths);
    bool empty() const { return rtree.empty(); }
@ -39,7 +39,7 @@ struct LocationDependentData
    property_t FindByKey(const std::vector<std::size_t> &property_indexes, const char *key) const;
  private:
-    void loadLocationDependentData(const std::filesystem::path &file_path,
+    void loadLocationDependentData(const boost::filesystem::path &file_path,
                                   std::vector<rtree_t::value_type> &bounding_boxes);
    rtree_t rtree;
--- a/include/extractor/maneuver_override.hpp
+++ b/include/extractor/maneuver_override.hpp
@ -8,12 +8,10 @@
 #include "turn_path.hpp"
 #include "util/integer_range.hpp"
 #include "util/log.hpp"
 #include "util/std_hash.hpp"
 #include "util/vector_view.hpp"
 #include <variant>
 #include <algorithm>
 #include <boost/functional/hash.hpp>
 #include <mapbox/variant.hpp>
 namespace osrm::extractor
 {
@ -149,6 +147,7 @@ struct UnresolvedManeuverOverride
 namespace std
 {
 template <> struct hash<osrm::extractor::NodeBasedTurn>
 {
    using argument_type = osrm::extractor::NodeBasedTurn;
    using result_type = std::size_t;
@ -156,9 +155,9 @@ template <> struct hash<osrm::extractor::NodeBasedTurn>
    {
        std::size_t seed = 0;
-        hash_combine(seed, s.from);
+        boost::hash_combine(seed, s.from);
-        hash_combine(seed, s.via);
+        boost::hash_combine(seed, s.via);
-        hash_combine(seed, s.to);
+        boost::hash_combine(seed, s.to);
        return seed;
    }
--- a/include/extractor/maneuver_override_relation_parser.hpp
+++ b/include/extractor/maneuver_override_relation_parser.hpp
@ -3,7 +3,7 @@
 #include "maneuver_override.hpp"
-#include <optional>
+#include <boost/optional.hpp>
 #include <string>
 #include <vector>
@ -55,7 +55,7 @@ class ManeuverOverrideRelationParser
 {
  public:
    ManeuverOverrideRelationParser();
-    std::optional<InputManeuverOverride> TryParse(const osmium::Relation &relation) const;
+    boost::optional<InputManeuverOverride> TryParse(const osmium::Relation &relation) const;
 };
 } // namespace osrm::extractor
--- a/include/extractor/node_based_graph_factory.hpp
+++ b/include/extractor/node_based_graph_factory.hpp
@ -12,7 +12,8 @@
 #include "util/coordinate.hpp"
 #include "util/node_based_graph.hpp"
-#include <filesystem>
+#include <boost/filesystem/path.hpp>
 #include <memory>
 #include <string>
 #include <unordered_set>
--- a/Show More
+++ b/Show More