added next node prefetching

2026-08-06 05:34:09 +02:00 · 2022-06-21 20:19:56 +02:00
68 changed files with 510 additions and 1276 deletions
@@ -40,11 +40,52 @@ environment:
      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
      B2_TOOLSET: msvc-12.0,msvc-14.0

-    - FLAVOR: Visual Studio 2017
+    - FLAVOR: Visual Studio 2017 C++14/17
      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      B2_CXXSTD: 14,17,latest
+      B2_CXXSTD: 14,17
      B2_TOOLSET: msvc-14.1

+    - FLAVOR: Visual Studio 2017 C++2a Strict
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      B2_CXXFLAGS: -permissive-
+      B2_CXXSTD: 2a
+      B2_TOOLSET: msvc-14.1
+
+    - FLAVOR: Visual Studio 2019
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
+      B2_CXXFLAGS: -permissive-
+      B2_CXXSTD: 14,17
+      B2_TOOLSET: msvc-14.2
+
+    - FLAVOR: Visual Studio 2022
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2022
+      B2_CXXFLAGS: -permissive-
+      B2_CXXSTD: 14,17
+      B2_TOOLSET: msvc-14.3
+
+    # C++20 Jobs split out from above due to build timeout
+    - FLAVOR: Visual Studio 2019 C++2a
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
+      B2_CXXFLAGS: -permissive-
+      B2_CXXSTD: 2a
+      B2_TOOLSET: msvc-14.2
+
+    - FLAVOR: Visual Studio 2022 C++20
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2022
+      B2_CXXFLAGS: -permissive-
+      B2_CXXSTD: 20
+      B2_TOOLSET: msvc-14.3
+
+    - FLAVOR: clang-cl C++11, C++14
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
+      B2_CXXSTD: 11,14
+      B2_TOOLSET: clang-win
+    # Extra job as compilation takes to long
+    - FLAVOR: clang-cl C++17, C++latest
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
+      B2_CXXSTD: 17,latest
+      B2_TOOLSET: clang-win
+
    - FLAVOR: cygwin (32-bit)
      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
      ADDPATH: C:\cygwin\bin;
@@ -59,35 +100,30 @@ environment:
      B2_CXXSTD: 03,11,14,1z
      B2_TOOLSET: gcc

+    # (Currently) the images up to 2017 use an older Cygwin
+    # This tests that the library works with more recent versions
    - FLAVOR: cygwin (64-bit, latest)
      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2022
      ADDPATH: C:\cygwin64\bin;
      B2_ADDRESS_MODEL: 64
-      B2_CXXSTD: 03,11
+      B2_CXXSTD: 03,11,14,1z
      B2_TOOLSET: gcc
-      B2_FLAGS: "include=libs/unordered/test/unordered include=libs/unordered/test/exception"
+      MAYFAIL: true

-    - FLAVOR: cygwin (64-bit, latest)
-      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2022
-      ADDPATH: C:\cygwin64\bin;
-      B2_ADDRESS_MODEL: 64
-      B2_CXXSTD: 14,1z
-      B2_TOOLSET: gcc
-      B2_FLAGS: "include=libs/unordered/test/unordered include=libs/unordered/test/exception"
-
-    - FLAVOR: mingw-w64, 32 bit
-      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
-      ADDPATH: C:\mingw-w64\i686-8.1.0-posix-dwarf-rt_v6-rev0\mingw32\bin;
-      B2_CXXSTD: 03,11,14,17,2a
-      B2_TOOLSET: gcc
+    - FLAVOR: mingw32
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
      B2_ADDRESS_MODEL: 32
+      ADDPATH: C:\mingw\bin;
+      B2_CXXSTD: 03,11,14,1z
+      B2_TOOLSET: gcc
+      MAYFAIL: true

-    - FLAVOR: mingw-w64, 64 bit
+    - FLAVOR: mingw64
      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
      ADDPATH: C:\mingw-w64\x86_64-8.1.0-posix-seh-rt_v6-rev0\mingw64\bin;
+      B2_ADDRESS_MODEL: 64
      B2_CXXSTD: 03,11,14,17,2a
      B2_TOOLSET: gcc
-      B2_ADDRESS_MODEL: 64

    #- FLAVOR: CodeCov (VS 2019)
    #  APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
@@ -1,180 +0,0 @@
-# Copyright 2022 Peter Dimov
-# Distributed under the Boost Software License, Version 1.0.
-# https://www.boost.org/LICENSE_1_0.txt
-
-local library = "unordered";
-
-local triggers =
-{
-    branch: [ "master", "develop", "feature/*", "bugfix/*" ]
-};
-
-local ubsan = { UBSAN: '1', UBSAN_OPTIONS: 'print_stacktrace=1' };
-local asan = { ASAN: '1' };
-
-local linux_pipeline(name, image, environment, packages = "", sources = [], arch = "amd64") =
-{
-    name: name,
-    kind: "pipeline",
-    type: "docker",
-    trigger: triggers,
-    platform:
-    {
-        os: "linux",
-        arch: arch
-    },
-    steps:
-    [
-        {
-            name: "everything",
-            image: image,
-            environment: environment,
-            commands:
-            [
-                'set -e',
-                'wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | apt-key add -',
-            ] +
-            (if sources != [] then [ ('apt-add-repository "' + source + '"') for source in sources ] else []) +
-            (if packages != "" then [ 'apt-get update', 'apt-get -y install ' + packages ] else []) +
-            [
-                'export LIBRARY=' + library,
-                './.drone/drone.sh',
-            ]
-        }
-    ]
-};
-
-local macos_pipeline(name, environment, xcode_version = "12.2", osx_version = "catalina", arch = "amd64") =
-{
-    name: name,
-    kind: "pipeline",
-    type: "exec",
-    trigger: triggers,
-    platform: {
-        "os": "darwin",
-        "arch": arch
-    },
-    node: {
-        "os": osx_version
-    },
-    steps: [
-        {
-            name: "everything",
-            environment: environment + { "DEVELOPER_DIR": "/Applications/Xcode-" + xcode_version + ".app/Contents/Developer" },
-            commands:
-            [
-                'export LIBRARY=' + library,
-                './.drone/drone.sh',
-            ]
-        }
-    ]
-};
-
-local windows_pipeline(name, image, environment, arch = "amd64") =
-{
-    name: name,
-    kind: "pipeline",
-    type: "docker",
-    trigger: triggers,
-    platform:
-    {
-        os: "windows",
-        arch: arch
-    },
-    "steps":
-    [
-        {
-            name: "everything",
-            image: image,
-            environment: environment,
-            commands:
-            [
-                'cmd /C .drone\\\\drone.bat ' + library,
-            ]
-        }
-    ]
-};
-
-[
-    linux_pipeline(
-        "Linux 14.04 GCC 4.4 32/64",
-        "cppalliance/droneubuntu1404:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++-4.4', CXXSTD: '98,0x', ADDRMD: '32,64' },
-        "g++-4.4-multilib",
-        [ "ppa:ubuntu-toolchain-r/test" ],
-    ),
-
-    linux_pipeline(
-        "Linux 14.04 GCC 4.6 32/64",
-        "cppalliance/droneubuntu1404:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++-4.6', CXXSTD: '98,0x', ADDRMD: '32,64' },
-        "g++-4.6-multilib",
-        [ "ppa:ubuntu-toolchain-r/test" ],
-    ),
-
-    linux_pipeline(
-        "Linux 14.04 GCC 4.7 32/64",
-        "cppalliance/droneubuntu1404:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++-4.7', CXXSTD: '98,0x', ADDRMD: '32,64' },
-        "g++-4.7-multilib",
-        [ "ppa:ubuntu-toolchain-r/test" ],
-    ),
-
-    linux_pipeline(
-        "Linux 14.04 GCC 4.8* 32/64",
-        "cppalliance/droneubuntu1404:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11', ADDRMD: '32,64' },
-    ),
-
-    linux_pipeline(
-        "Linux 14.04 GCC 4.9 32/64",
-        "cppalliance/droneubuntu1404:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++-4.9', CXXSTD: '03,11', ADDRMD: '32,64' },
-        "g++-4.9-multilib",
-        [ "ppa:ubuntu-toolchain-r/test" ],
-    ),
-
-    linux_pipeline(
-        "Linux 20.04 GCC 9* ARM64 32",
-        "cppalliance/droneubuntu2004:multiarch",
-        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17,2a', ADDRMD: '32' },
-        arch="arm64",
-    ),
-
-    linux_pipeline(
-        "Linux 20.04 GCC 9* ARM64 64",
-        "cppalliance/droneubuntu2004:multiarch",
-        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17,2a', ADDRMD: '64' },
-        arch="arm64",
-    ),
-
-    linux_pipeline(
-        "Linux 20.04 GCC 9* S390x 32",
-        "cppalliance/droneubuntu2004:multiarch",
-        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17,2a', ADDRMD: '32' },
-        arch="s390x",
-    ),
-
-    linux_pipeline(
-        "Linux 20.04 GCC 9* S390x 64",
-        "cppalliance/droneubuntu2004:multiarch",
-        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17,2a', ADDRMD: '64' },
-        arch="s390x",
-    ),
-
-    macos_pipeline(
-        "MacOS 10.15 Xcode 12.2 UBSAN",
-        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '03,11,14,1z' } + ubsan,
-    ),
-
-    macos_pipeline(
-        "MacOS 10.15 Xcode 12.2 ASAN",
-        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '03,11,14,1z' } + asan,
-    ),
-
-    windows_pipeline(
-        "Windows VS2017 msvc-14.1",
-        "cppalliance/dronevs2017",
-        { TOOLSET: 'msvc-14.1', CXXSTD: '14,17,latest' },
-    ),
-]
@@ -1,23 +0,0 @@
-@REM Copyright 2022 Peter Dimov
-@REM Distributed under the Boost Software License, Version 1.0.
-@REM https://www.boost.org/LICENSE_1_0.txt
-
-@ECHO ON
-
-set LIBRARY=%1
-set DRONE_BUILD_DIR=%CD%
-
-set BOOST_BRANCH=develop
-if "%DRONE_BRANCH%" == "master" set BOOST_BRANCH=master
-cd ..
-git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
-cd boost-root
-git submodule update --init tools/boostdep
-xcopy /s /e /q %DRONE_BUILD_DIR% libs\%LIBRARY%\
-python tools/boostdep/depinst/depinst.py %LIBRARY%
-cmd /c bootstrap
-b2 -d0 headers
-
-if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
-if not "%ADDRMD%" == "" set ADDRMD=address-model=%ADDRMD%
-b2 -j3 libs/%LIBRARY%/test toolset=%TOOLSET% %CXXSTD% %ADDRMD% variant=debug,release embed-manifest-via=linker
@@ -1,24 +0,0 @@
-#!/bin/bash
-
-# Copyright 2022 Peter Dimov
-# Distributed under the Boost Software License, Version 1.0.
-# https://www.boost.org/LICENSE_1_0.txt
-
-set -ex
-
-DRONE_BUILD_DIR=$(pwd)
-
-BOOST_BRANCH=develop
-if [ "$DRONE_BRANCH" = "master" ]; then BOOST_BRANCH=master; fi
-
-cd ..
-git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
-cd boost-root
-git submodule update --init tools/boostdep
-cp -r $DRONE_BUILD_DIR/* libs/$LIBRARY
-python tools/boostdep/depinst/depinst.py $LIBRARY
-./bootstrap.sh
-./b2 -d0 headers
-
-echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
-./b2 -j3 libs/$LIBRARY/test toolset=$TOOLSET cxxstd=$CXXSTD variant=debug,release ${ADDRMD:+address-model=$ADDRMD} ${UBSAN:+undefined-sanitizer=norecover debug-symbols=on} ${ASAN:+address-sanitizer=norecover debug-symbols=on} ${LINKFLAGS:+linkflags=$LINKFLAGS}
@@ -42,16 +42,16 @@ jobs:
      matrix:
        include:
          # Linux, gcc
-          - { compiler: gcc-4.8,   cxxstd: '03,11',          os: ubuntu-18.04, install: 'g++-4.8-multilib', address-model: '32,64' }
+          - { compiler: gcc-4.8,   cxxstd: '03,11',          os: ubuntu-18.04 }
          - { compiler: gcc-4.9,   cxxstd: '03,11',          os: ubuntu-20.04, container: 'ubuntu:16.04' }
-          - { compiler: gcc-5,     cxxstd: '03,11,14,1z',    os: ubuntu-18.04, install: 'g++-5-multilib', address-model: '32,64' }
-          - { compiler: gcc-6,     cxxstd: '03,11,14,17',    os: ubuntu-18.04, install: 'g++-6-multilib', address-model: '32,64' }
-          - { compiler: gcc-7,     cxxstd: '03,11,14,17',    os: ubuntu-18.04, install: 'g++-7-multilib', address-model: '32,64' }
-          - { compiler: gcc-8,     cxxstd: '03,11,14,17,2a', os: ubuntu-18.04, install: 'g++-8-multilib', address-model: '32,64' }
-          - { compiler: gcc-9,     cxxstd: '03,11,14,17,2a', os: ubuntu-18.04, install: 'g++-9-multilib', address-model: '32,64' }
-          - { compiler: gcc-10,    cxxstd: '03,11,14,17,20', os: ubuntu-20.04, install: 'g++-10-multilib', address-model: '32,64' }
-          - { compiler: gcc-11,    cxxstd: '03,11,14,17,20', os: ubuntu-20.04, install: 'g++-11-multilib', address-model: '32,64' }
-          - { compiler: gcc-12,    cxxstd: '03,11,14,17,20', os: ubuntu-22.04, install: 'g++-12-multilib', address-model: '32,64' }
+          - { compiler: gcc-5,     cxxstd: '03,11,14,1z',    os: ubuntu-18.04 }
+          - { compiler: gcc-6,     cxxstd: '03,11,14,17',    os: ubuntu-18.04 }
+          - { compiler: gcc-7,     cxxstd: '03,11,14,17',    os: ubuntu-18.04 }
+          - { compiler: gcc-8,     cxxstd: '03,11,14,17,2a', os: ubuntu-18.04 }
+          - { compiler: gcc-9,     cxxstd: '03,11,14,17,2a', os: ubuntu-18.04 }
+          - { compiler: gcc-10,    cxxstd: '03,11,14,17,20', os: ubuntu-20.04 }
+          - { compiler: gcc-11,    cxxstd: '03,11,14,17,20', os: ubuntu-20.04 }
+          - { compiler: gcc-12,    cxxstd: '03,11,14,17,20', os: ubuntu-22.04 }
          - { name: GCC w/ sanitizers, sanitize: yes,
              compiler: gcc-12,    cxxstd: '03,11,14,17,20', os: ubuntu-22.04 }
          - { name: Collect coverage, coverage: yes,
@@ -65,7 +65,8 @@ jobs:
          - { compiler: clang-5.0, cxxstd: '03,11,14,1z',    os: ubuntu-18.04 }
          - { compiler: clang-6.0, cxxstd: '03,11,14,17',    os: ubuntu-18.04 }
          - { compiler: clang-7,   cxxstd: '03,11,14,17',    os: ubuntu-18.04 }
-          - { compiler: clang-8,   cxxstd: '03,11,14,17',    os: ubuntu-18.04 }
+          # Note: clang-8 does not fully support C++20, so it is not compatible with some libstdc++ versions in this mode
+          - { compiler: clang-8,   cxxstd: '03,11,14,17,2a', os: ubuntu-18.04, install: 'clang-8 g++-7', gcc_toolchain: 7 }
          - { compiler: clang-9,   cxxstd: '03,11,14,17,2a', os: ubuntu-20.04 }
          - { compiler: clang-10,  cxxstd: '03,11,14,17,20', os: ubuntu-20.04 }
          - { compiler: clang-11,  cxxstd: '03,11,14,17,20', os: ubuntu-20.04 }
@@ -80,7 +81,7 @@ jobs:
              compiler: clang-12,  cxxstd: '03,11,14,17,20', os: ubuntu-20.04, stdlib: libc++, install: 'clang-12 libc++-12-dev libc++abi-12-dev' }

          # OSX, clang
-          - { compiler: clang,     cxxstd: '03,11,14,17,2a', os: macos-11, sanitize: yes }
+          - { compiler: clang,     cxxstd: '03,11,14,17,2a', os: macos-10.15, sanitize: yes }

    timeout-minutes: 120
    runs-on: ${{matrix.os}}
@@ -225,11 +226,11 @@ jobs:
      fail-fast: false
      matrix:
        include:
-          - { toolset: msvc-14.0, cxxstd: '14,latest',       addrmd: '32,64', os: windows-2019 }
-          - { toolset: msvc-14.2, cxxstd: '14,17,20,latest', addrmd: '32,64', os: windows-2019 }
-          - { toolset: msvc-14.3, cxxstd: '14,17,20,latest', addrmd: '32,64', os: windows-2022 }
-          - { toolset: clang-win, cxxstd: '14,17,latest',    addrmd: '32,64', os: windows-2022 }
-          - { toolset: gcc,       cxxstd: '03,11,14,17,2a',  addrmd: '64',    os: windows-2019 }
+          - { toolset: msvc-14.0, cxxstd: '14,latest',      addrmd: '32,64', os: windows-2019 }
+          - { toolset: msvc-14.2, cxxstd: '14,17,20',       addrmd: '32,64', os: windows-2019 }
+          - { toolset: msvc-14.3, cxxstd: '14,17,20,latest',addrmd: '32,64', os: windows-2022 }
+          - { toolset: clang-win, cxxstd: '14,17,latest',   addrmd: '32,64', os: windows-2022 }
+          - { toolset: gcc,       cxxstd: '03,11,14,17,2a', addrmd: '64',    os: windows-2019 }

    runs-on: ${{matrix.os}}

@@ -18,6 +18,7 @@ target_link_libraries(boost_unordered
    Boost::config
    Boost::container_hash
    Boost::core
+    Boost::iterator
    Boost::move
    Boost::mp11
    Boost::predef
@@ -14,12 +14,6 @@
 # include "absl/container/node_hash_map.h"
 # include "absl/container/flat_hash_map.h"
 #endif
-#ifdef HAVE_TSL_HOPSCOTCH
-# include "tsl/hopscotch_map.h"
-#endif
-#ifdef HAVE_TSL_ROBIN
-# include "tsl/robin_map.h"
-#endif
 #include <unordered_map>
 #include <vector>
 #include <memory>
@@ -143,14 +137,7 @@ template<class Map> BOOST_NOINLINE void test_iteration( Map& map, std::chrono::s
    {
        if( it->second & 1 )
        {
-            if constexpr( std::is_void_v< decltype( map.erase( it ) ) > )
-            {
-                map.erase( it++ );
-            }
-            else
-            {
-                it = map.erase( it );
-            }
+            map.erase( it++ );
        }
        else
        {
@@ -172,9 +159,13 @@ template<class Map> BOOST_NOINLINE void test_erase( Map& map, std::chrono::stead

    print_time( t1, "Consecutive erase",  0, map.size() );

-    for( unsigned i = 1; i <= N; ++i )
    {
-        map.erase( indices2[ i ] );
+        boost::detail::splitmix64 rng;
+
+        for( unsigned i = 1; i <= N; ++i )
+        {
+            map.erase( indices2[ i ] );
+        }
    }

    print_time( t1, "Random erase",  0, map.size() );
@@ -304,26 +295,6 @@ template<class K, class V> using absl_flat_hash_map =

 #endif

-#ifdef HAVE_TSL_HOPSCOTCH
-
-template<class K, class V> using tsl_hopscotch_map =
-    tsl::hopscotch_map<K, V, std::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
-
-template<class K, class V> using tsl_hopscotch_pg_map =
-    tsl::hopscotch_pg_map<K, V, std::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
-
-#endif
-
-#ifdef HAVE_TSL_ROBIN
-
-template<class K, class V> using tsl_robin_map =
-    tsl::robin_map<K, V, std::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
-
-template<class K, class V> using tsl_robin_pg_map =
-    tsl::robin_pg_map<K, V, std::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
-
-#endif
-
 // fnv1a_hash

 template<int Bits> struct fnv1a_hash_impl;
@@ -392,26 +363,6 @@ template<class K, class V> using absl_flat_hash_map_fnv1a =

 #endif

-#ifdef HAVE_TSL_HOPSCOTCH
-
-template<class K, class V> using tsl_hopscotch_map_fnv1a =
-    tsl::hopscotch_map<K, V, fnv1a_hash, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
-
-template<class K, class V> using tsl_hopscotch_pg_map_fnv1a =
-    tsl::hopscotch_pg_map<K, V, fnv1a_hash, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
-
-#endif
-
-#ifdef HAVE_TSL_ROBIN
-
-template<class K, class V> using tsl_robin_map_fnv1a =
-    tsl::robin_map<K, V, fnv1a_hash, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
-
-template<class K, class V> using tsl_robin_pg_map_fnv1a =
-    tsl::robin_pg_map<K, V, fnv1a_hash, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
-
-#endif
-
 //

 int main()
@@ -431,20 +382,6 @@ int main()

 #endif

-#ifdef HAVE_TSL_HOPSCOTCH
-
-    test<tsl_hopscotch_map>( "tsl::hopscotch_map" );
-    test<tsl_hopscotch_pg_map>( "tsl::hopscotch_pg_map" );
-
-#endif
-
-#ifdef HAVE_TSL_ROBIN
-
-    test<tsl_robin_map>( "tsl::robin_map" );
-    test<tsl_robin_pg_map>( "tsl::robin_pg_map" );
-
-#endif
-
 #endif

    test<std_unordered_map_fnv1a>( "std::unordered_map, FNV-1a" );
@@ -456,27 +393,13 @@ int main()
    test<absl_node_hash_map_fnv1a>( "absl::node_hash_map, FNV-1a" );
    test<absl_flat_hash_map_fnv1a>( "absl::flat_hash_map, FNV-1a" );

-#endif
-
-#ifdef HAVE_TSL_HOPSCOTCH
-
-    test<tsl_hopscotch_map_fnv1a>( "tsl::hopscotch_map, FNV-1a" );
-    test<tsl_hopscotch_pg_map_fnv1a>( "tsl::hopscotch_pg_map, FNV-1a" );
-
-#endif
-
-#ifdef HAVE_TSL_ROBIN
-
-    test<tsl_robin_map_fnv1a>( "tsl::robin_map, FNV-1a" );
-    test<tsl_robin_pg_map_fnv1a>( "tsl::robin_pg_map, FNV-1a" );
-
 #endif

    std::cout << "---\n\n";

    for( auto const& x: times )
    {
-        std::cout << std::setw( 31 ) << ( x.label_ + ": " ) << std::setw( 5 ) << x.time_ << " ms, " << std::setw( 9 ) << x.bytes_ << " bytes in " << x.count_ << " allocations\n";
+        std::cout << std::setw( 30 ) << ( x.label_ + ": " ) << std::setw( 5 ) << x.time_ << " ms, " << std::setw( 9 ) << x.bytes_ << " bytes in " << x.count_ << " allocations\n";
    }
 }

@@ -14,12 +14,6 @@
 # include "absl/container/node_hash_map.h"
 # include "absl/container/flat_hash_map.h"
 #endif
-#ifdef HAVE_TSL_HOPSCOTCH
-# include "tsl/hopscotch_map.h"
-#endif
-#ifdef HAVE_TSL_ROBIN
-# include "tsl/robin_map.h"
-#endif
 #include <unordered_map>
 #include <string_view>
 #include <vector>
@@ -144,14 +138,7 @@ template<class Map> BOOST_NOINLINE void test_iteration( Map& map, std::chrono::s
    {
        if( it->second & 1 )
        {
-            if constexpr( std::is_void_v< decltype( map.erase( it ) ) > )
-            {
-                map.erase( it++ );
-            }
-            else
-            {
-                it = map.erase( it );
-            }
+            map.erase( it++ );
        }
        else
        {
@@ -173,9 +160,13 @@ template<class Map> BOOST_NOINLINE void test_erase( Map& map, std::chrono::stead

    print_time( t1, "Consecutive erase",  0, map.size() );

-    for( unsigned i = 1; i <= N; ++i )
    {
-        map.erase( indices2[ i ] );
+        boost::detail::splitmix64 rng;
+
+        for( unsigned i = 1; i <= N; ++i )
+        {
+            map.erase( indices2[ i ] );
+        }
    }

    print_time( t1, "Random erase",  0, map.size() );
@@ -305,26 +296,6 @@ template<class K, class V> using absl_flat_hash_map =

 #endif

-#ifdef HAVE_TSL_HOPSCOTCH
-
-template<class K, class V> using tsl_hopscotch_map =
-    tsl::hopscotch_map<K, V, std::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
-
-template<class K, class V> using tsl_hopscotch_pg_map =
-    tsl::hopscotch_pg_map<K, V, std::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
-
-#endif
-
-#ifdef HAVE_TSL_ROBIN
-
-template<class K, class V> using tsl_robin_map =
-    tsl::robin_map<K, V, std::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
-
-template<class K, class V> using tsl_robin_pg_map =
-    tsl::robin_pg_map<K, V, std::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
-
-#endif
-
 // fnv1a_hash

 template<int Bits> struct fnv1a_hash_impl;
@@ -393,26 +364,6 @@ template<class K, class V> using absl_flat_hash_map_fnv1a =

 #endif

-#ifdef HAVE_TSL_HOPSCOTCH
-
-template<class K, class V> using tsl_hopscotch_map_fnv1a =
-    tsl::hopscotch_map<K, V, fnv1a_hash, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
-
-template<class K, class V> using tsl_hopscotch_pg_map_fnv1a =
-    tsl::hopscotch_pg_map<K, V, fnv1a_hash, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
-
-#endif
-
-#ifdef HAVE_TSL_ROBIN
-
-template<class K, class V> using tsl_robin_map_fnv1a =
-    tsl::robin_map<K, V, fnv1a_hash, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
-
-template<class K, class V> using tsl_robin_pg_map_fnv1a =
-    tsl::robin_pg_map<K, V, fnv1a_hash, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
-
-#endif
-
 //

 int main()
@@ -432,20 +383,6 @@ int main()

 #endif

-#ifdef HAVE_TSL_HOPSCOTCH
-
-    test<tsl_hopscotch_map>( "tsl::hopscotch_map" );
-    test<tsl_hopscotch_pg_map>( "tsl::hopscotch_pg_map" );
-
-#endif
-
-#ifdef HAVE_TSL_ROBIN
-
-    test<tsl_robin_map>( "tsl::robin_map" );
-    test<tsl_robin_pg_map>( "tsl::robin_pg_map" );
-
-#endif
-
 #endif

    test<std_unordered_map_fnv1a>( "std::unordered_map, FNV-1a" );
@@ -457,27 +394,13 @@ int main()
    test<absl_node_hash_map_fnv1a>( "absl::node_hash_map, FNV-1a" );
    test<absl_flat_hash_map_fnv1a>( "absl::flat_hash_map, FNV-1a" );

-#endif
-
-#ifdef HAVE_TSL_HOPSCOTCH
-
-    test<tsl_hopscotch_map_fnv1a>( "tsl::hopscotch_map, FNV-1a" );
-    test<tsl_hopscotch_pg_map_fnv1a>( "tsl::hopscotch_pg_map, FNV-1a" );
-
-#endif
-
-#ifdef HAVE_TSL_ROBIN
-
-    test<tsl_robin_map_fnv1a>( "tsl::robin_map, FNV-1a" );
-    test<tsl_robin_pg_map_fnv1a>( "tsl::robin_pg_map, FNV-1a" );
-
 #endif

    std::cout << "---\n\n";

    for( auto const& x: times )
    {
-        std::cout << std::setw( 31 ) << ( x.label_ + ": " ) << std::setw( 5 ) << x.time_ << " ms, " << std::setw( 9 ) << x.bytes_ << " bytes in " << x.count_ << " allocations\n";
+        std::cout << std::setw( 30 ) << ( x.label_ + ": " ) << std::setw( 5 ) << x.time_ << " ms, " << std::setw( 9 ) << x.bytes_ << " bytes in " << x.count_ << " allocations\n";
    }
 }

@@ -8,19 +8,12 @@
 #include <boost/multi_index_container.hpp>
 #include <boost/multi_index/hashed_index.hpp>
 #include <boost/multi_index/member.hpp>
-#include <boost/endian/conversion.hpp>
 #include <boost/core/detail/splitmix64.hpp>
 #include <boost/config.hpp>
 #ifdef HAVE_ABSEIL
 # include "absl/container/node_hash_map.h"
 # include "absl/container/flat_hash_map.h"
 #endif
-#ifdef HAVE_TSL_HOPSCOTCH
-# include "tsl/hopscotch_map.h"
-#endif
-#ifdef HAVE_TSL_ROBIN
-# include "tsl/robin_map.h"
-#endif
 #include <unordered_map>
 #include <vector>
 #include <memory>
@@ -69,7 +62,7 @@ static void init_indices()

    for( unsigned i = 1; i <= N*2; ++i )
    {
-        indices3.push_back( boost::endian::endian_reverse( static_cast<std::uint32_t>( i ) ) );
+        indices3.push_back( (std::uint32_t)i << 11 );
    }
 }

@@ -94,7 +87,7 @@ template<class Map> BOOST_NOINLINE void test_insert( Map& map, std::chrono::stea
        map.insert( { indices3[ i ], i } );
    }

-    print_time( t1, "Consecutive reversed insert",  0, map.size() );
+    print_time( t1, "Consecutive shifted insert",  0, map.size() );

    std::cout << std::endl;
 }
@@ -140,7 +133,7 @@ template<class Map> BOOST_NOINLINE void test_lookup( Map& map, std::chrono::stea
        }
    }

-    print_time( t1, "Consecutive reversed lookup",  s, map.size() );
+    print_time( t1, "Consecutive shifted lookup",  s, map.size() );

    std::cout << std::endl;
 }
@@ -153,14 +146,7 @@ template<class Map> BOOST_NOINLINE void test_iteration( Map& map, std::chrono::s
    {
        if( it->second & 1 )
        {
-            if constexpr( std::is_void_v< decltype( map.erase( it ) ) > )
-            {
-                map.erase( it++ );
-            }
-            else
-            {
-                it = map.erase( it );
-            }
+            map.erase( it++ );
        }
        else
        {
@@ -182,9 +168,13 @@ template<class Map> BOOST_NOINLINE void test_erase( Map& map, std::chrono::stead

    print_time( t1, "Consecutive erase",  0, map.size() );

-    for( unsigned i = 1; i <= N; ++i )
    {
-        map.erase( indices2[ i ] );
+        boost::detail::splitmix64 rng;
+
+        for( unsigned i = 1; i <= N; ++i )
+        {
+            map.erase( indices2[ i ] );
+        }
    }

    print_time( t1, "Random erase",  0, map.size() );
@@ -194,7 +184,7 @@ template<class Map> BOOST_NOINLINE void test_erase( Map& map, std::chrono::stead
        map.erase( indices3[ i ] );
    }

-    print_time( t1, "Consecutive reversed erase",  0, map.size() );
+    print_time( t1, "Consecutive shifted erase",  0, map.size() );

    std::cout << std::endl;
 }
@@ -321,26 +311,6 @@ template<class K, class V> using absl_flat_hash_map =

 #endif

-#ifdef HAVE_TSL_HOPSCOTCH
-
-template<class K, class V> using tsl_hopscotch_map =
-    tsl::hopscotch_map<K, V, std::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
-
-template<class K, class V> using tsl_hopscotch_pg_map =
-    tsl::hopscotch_pg_map<K, V, std::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
-
-#endif
-
-#ifdef HAVE_TSL_ROBIN
-
-template<class K, class V> using tsl_robin_map =
-    tsl::robin_map<K, V, std::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
-
-template<class K, class V> using tsl_robin_pg_map =
-    tsl::robin_pg_map<K, V, std::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
-
-#endif
-
 int main()
 {
    init_indices();
@@ -354,20 +324,6 @@ int main()
    test<absl_node_hash_map>( "absl::node_hash_map" );
    test<absl_flat_hash_map>( "absl::flat_hash_map" );

-#endif
-
-#ifdef HAVE_TSL_HOPSCOTCH
-
-    test<tsl_hopscotch_map>( "tsl::hopscotch_map" );
-    test<tsl_hopscotch_pg_map>( "tsl::hopscotch_pg_map" );
-
-#endif
-
-#ifdef HAVE_TSL_ROBIN
-
-    test<tsl_robin_map>( "tsl::robin_map" );
-    test<tsl_robin_pg_map>( "tsl::robin_pg_map" );
-
 #endif

    std::cout << "---\n\n";
@@ -8,19 +8,12 @@
 #include <boost/multi_index_container.hpp>
 #include <boost/multi_index/hashed_index.hpp>
 #include <boost/multi_index/member.hpp>
-#include <boost/endian/conversion.hpp>
 #include <boost/core/detail/splitmix64.hpp>
 #include <boost/config.hpp>
 #ifdef HAVE_ABSEIL
 # include "absl/container/node_hash_map.h"
 # include "absl/container/flat_hash_map.h"
 #endif
-#ifdef HAVE_TSL_HOPSCOTCH
-# include "tsl/hopscotch_map.h"
-#endif
-#ifdef HAVE_TSL_ROBIN
-# include "tsl/robin_map.h"
-#endif
 #include <unordered_map>
 #include <vector>
 #include <memory>
@@ -69,7 +62,7 @@ static void init_indices()

    for( unsigned i = 1; i <= N*2; ++i )
    {
-        indices3.push_back( boost::endian::endian_reverse( static_cast<std::uint64_t>( i ) ) );
+        indices3.push_back( (std::uint64_t)i << 40 );
    }
 }

@@ -94,7 +87,7 @@ template<class Map> BOOST_NOINLINE void test_insert( Map& map, std::chrono::stea
        map.insert( { indices3[ i ], i } );
    }

-    print_time( t1, "Consecutive reversed insert",  0, map.size() );
+    print_time( t1, "Consecutive shifted insert",  0, map.size() );

    std::cout << std::endl;
 }
@@ -140,7 +133,7 @@ template<class Map> BOOST_NOINLINE void test_lookup( Map& map, std::chrono::stea
        }
    }

-    print_time( t1, "Consecutive reversed lookup",  s, map.size() );
+    print_time( t1, "Consecutive shifted lookup",  s, map.size() );

    std::cout << std::endl;
 }
@@ -153,14 +146,7 @@ template<class Map> BOOST_NOINLINE void test_iteration( Map& map, std::chrono::s
    {
        if( it->second & 1 )
        {
-            if constexpr( std::is_void_v< decltype( map.erase( it ) ) > )
-            {
-                map.erase( it++ );
-            }
-            else
-            {
-                it = map.erase( it );
-            }
+            map.erase( it++ );
        }
        else
        {
@@ -182,9 +168,13 @@ template<class Map> BOOST_NOINLINE void test_erase( Map& map, std::chrono::stead

    print_time( t1, "Consecutive erase",  0, map.size() );

-    for( unsigned i = 1; i <= N; ++i )
    {
-        map.erase( indices2[ i ] );
+        boost::detail::splitmix64 rng;
+
+        for( unsigned i = 1; i <= N; ++i )
+        {
+            map.erase( indices2[ i ] );
+        }
    }

    print_time( t1, "Random erase",  0, map.size() );
@@ -194,7 +184,7 @@ template<class Map> BOOST_NOINLINE void test_erase( Map& map, std::chrono::stead
        map.erase( indices3[ i ] );
    }

-    print_time( t1, "Consecutive reversed erase",  0, map.size() );
+    print_time( t1, "Consecutive shifted erase",  0, map.size() );

    std::cout << std::endl;
 }
@@ -321,26 +311,6 @@ template<class K, class V> using absl_flat_hash_map =

 #endif

-#ifdef HAVE_TSL_HOPSCOTCH
-
-template<class K, class V> using tsl_hopscotch_map =
-    tsl::hopscotch_map<K, V, std::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
-
-template<class K, class V> using tsl_hopscotch_pg_map =
-    tsl::hopscotch_pg_map<K, V, std::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
-
-#endif
-
-#ifdef HAVE_TSL_ROBIN
-
-template<class K, class V> using tsl_robin_map =
-    tsl::robin_map<K, V, std::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
-
-template<class K, class V> using tsl_robin_pg_map =
-    tsl::robin_pg_map<K, V, std::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
-
-#endif
-
 int main()
 {
    init_indices();
@@ -354,20 +324,6 @@ int main()
    test<absl_node_hash_map>( "absl::node_hash_map" );
    test<absl_flat_hash_map>( "absl::flat_hash_map" );

-#endif
-
-#ifdef HAVE_TSL_HOPSCOTCH
-
-    test<tsl_hopscotch_map>( "tsl::hopscotch_map" );
-    test<tsl_hopscotch_pg_map>( "tsl::hopscotch_pg_map" );
-
-#endif
-
-#ifdef HAVE_TSL_ROBIN
-
-    test<tsl_robin_map>( "tsl::robin_map" );
-    test<tsl_robin_pg_map>( "tsl::robin_pg_map" );
-
 #endif

    std::cout << "---\n\n";
@@ -113,7 +113,10 @@ to normal separate chaining implementations.

 */

-#include <boost/unordered/detail/prime_fmod.hpp>
+#include <boost/config.hpp>
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#pragma once
+#endif

 #include <boost/core/addressof.hpp>
 #include <boost/core/allocator_access.hpp>
@@ -121,20 +124,289 @@ to normal separate chaining implementations.
 #include <boost/core/empty_value.hpp>
 #include <boost/core/no_exceptions_support.hpp>
 #include <boost/cstdint.hpp>
+
+// `iterator_facade` has transitive dependencies on Boost.MPL; one of the
+// headers is generating a `-Wsign-conversion` warning which has an open PR to
+// address the issue but merging does not seem likely so for now create a rote
+// workaround.
+//
+// TODO: eventually remove this once MPL is fixed or we decide to migrate off of
+// the Boost.Iterator dependency.
+//
+#if defined(BOOST_GCC)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#pragma GCC diagnostic ignored "-Wconversion"
+#include <boost/iterator/iterator_facade.hpp>
+#pragma GCC diagnostic pop
+#else
+#include <boost/iterator/iterator_facade.hpp>
+#endif
+
 #include <boost/move/core.hpp>
 #include <boost/move/utility_core.hpp>
+#include <boost/preprocessor/seq/enum.hpp>
+#include <boost/preprocessor/seq/for_each.hpp>
+#include <boost/preprocessor/seq/size.hpp>
 #include <boost/swap.hpp>
 #include <boost/type_traits/aligned_storage.hpp>
 #include <boost/type_traits/alignment_of.hpp>

-#include <boost/config.hpp>
-
-#include <iterator>
+#include <climits>

 namespace boost {
  namespace unordered {
    namespace detail {

+#if defined(SIZE_MAX)
+#if ((((SIZE_MAX >> 16) >> 16) >> 16) >> 15) != 0
+#define BOOST_UNORDERED_FCA_HAS_64B_SIZE_T
+#endif
+#elif defined(UINTPTR_MAX) /* used as proxy for std::size_t */
+#if ((((UINTPTR_MAX >> 16) >> 16) >> 16) >> 15) != 0
+#define BOOST_UNORDERED_FCA_HAS_64B_SIZE_T
+#endif
+#endif
+
+#if !defined(BOOST_NO_INT64_T) &&                                              \
+  (defined(BOOST_HAS_INT128) || (defined(BOOST_MSVC) && defined(_WIN64)))
+#define BOOST_UNORDERED_FCA_FASTMOD_SUPPORT
+#endif
+
+      template <class = void> struct prime_fmod_size
+      {
+        // Because we compile for C++03, we don't have access to any inline
+        // initialization for array data members so the definitions must exist
+        // out-of-line. To keep the library header-only, we introduce a dummy
+        // template parameter which permits the definition to be included in
+        // multiple TUs without conflict.
+        //
+        static std::size_t sizes[];
+        static std::size_t const sizes_len;
+        static std::size_t (*positions[])(std::size_t);
+
+#if defined(BOOST_UNORDERED_FCA_FASTMOD_SUPPORT)
+        static uint64_t inv_sizes32[];
+        static std::size_t const inv_sizes32_len;
+#endif /* defined(BOOST_UNORDERED_FCA_FASTMOD_SUPPORT) */
+
+        static inline std::size_t size_index(std::size_t n)
+        {
+          std::size_t i = 0;
+          for (; i < (sizes_len - 1); ++i) {
+            if (sizes[i] >= n) {
+              break;
+            }
+          }
+          return i;
+        }
+
+        static inline std::size_t size(std::size_t size_index)
+        {
+          return sizes[size_index];
+        }
+
+        template <std::size_t Size> static std::size_t modulo(std::size_t hash)
+        {
+          return hash % Size;
+        }
+
+#if defined(BOOST_UNORDERED_FCA_FASTMOD_SUPPORT)
+        // We emulate the techniques taken from:
+        // Faster Remainder by Direct Computation: Applications to Compilers and
+        // Software Libraries
+        // https://arxiv.org/abs/1902.01961
+        //
+        // In essence, use fancy math to directly calculate the remainder (aka
+        // modulo) exploiting how compilers transform division
+        //
+
+#if defined(_MSC_VER)
+        static inline uint64_t get_remainder(uint64_t fractional, uint32_t d)
+        {
+          // use fancy msvc instrinsic when available instead of using `>> 64`
+          //
+          return __umulh(fractional, d);
+        }
+#else
+        static inline uint64_t get_remainder(uint64_t fractional, uint32_t d)
+        {
+          __extension__ typedef unsigned __int128 uint128;
+          return static_cast<uint64_t>(((uint128)fractional * d) >> 64);
+        }
+#endif /* defined(_MSC_VER) */
+
+        static inline uint32_t fast_modulo(uint32_t a, uint64_t M, uint32_t d)
+        {
+          uint64_t fractional = M * a;
+          return (uint32_t)(get_remainder(fractional, d));
+        }
+#endif /* defined(BOOST_UNORDERED_FCA_FASTMOD_SUPPORT) */
+
+        static inline std::size_t position(
+          std::size_t hash, std::size_t size_index)
+        {
+#if defined(BOOST_UNORDERED_FCA_FASTMOD_SUPPORT)
+#if defined(BOOST_UNORDERED_FCA_HAS_64B_SIZE_T)
+          std::size_t sizes_under_32bit = inv_sizes32_len;
+          if (BOOST_LIKELY(size_index < sizes_under_32bit)) {
+            return fast_modulo(uint32_t(hash) + uint32_t(hash >> 32),
+              inv_sizes32[size_index], uint32_t(sizes[size_index]));
+          } else {
+            return positions[size_index - sizes_under_32bit](hash);
+          }
+#else
+          return fast_modulo(
+            hash, inv_sizes32[size_index], uint32_t(sizes[size_index]));
+#endif /* defined(BOOST_UNORDERED_FCA_HAS_64B_SIZE_T) */
+#else
+          return positions[size_index](hash);
+#endif /* defined(BOOST_UNORDERED_FCA_FASTMOD_SUPPORT) */
+        }
+      }; // prime_fmod_size
+
+#define BOOST_UNORDERED_PRIME_FMOD_SIZES_32BIT_INCOMPLETE                      \
+  (13ul)(29ul)(53ul)(97ul)(193ul)(389ul)(769ul)(1543ul)(3079ul)(6151ul)(       \
+    12289ul)(24593ul)(49157ul)(98317ul)(196613ul)(393241ul)(786433ul)(         \
+    1572869ul)(3145739ul)(6291469ul)(12582917ul)(25165843ul)(50331653ul)(      \
+    100663319ul)(201326611ul)(402653189ul)(805306457ul)(1610612741ul)(         \
+    3221225473ul)
+
+#if !defined(BOOST_UNORDERED_FCA_HAS_64B_SIZE_T)
+
+#define BOOST_UNORDERED_PRIME_FMOD_SIZES_32BIT                                 \
+  BOOST_UNORDERED_PRIME_FMOD_SIZES_32BIT_INCOMPLETE(4294967291ul)
+
+#define BOOST_UNORDERED_PRIME_FMOD_SIZES_64BIT
+
+#else
+
+#define BOOST_UNORDERED_PRIME_FMOD_SIZES_32BIT                                 \
+  BOOST_UNORDERED_PRIME_FMOD_SIZES_32BIT_INCOMPLETE
+
+// The original sequence here is this:
+// (6442450939ul)
+// (12884901893ul)
+// (25769803751ul)
+// (51539607551ul)
+// (103079215111ul)
+// (206158430209ul)
+// (412316860441ul)
+// (824633720831ul)
+// (1649267441651ul)
+//
+// but this causes problems on versions of mingw where the `long` type is 32
+// bits, even for 64-bit targets. We work around this by replacing the literals
+// with compile-time arithmetic, using bitshifts to reconstruct the number.
+//
+
+// clang-format off
+#define BOOST_UNORDERED_PRIME_FMOD_SIZES_64BIT                                   \
+  ((boost::ulong_long_type(1ul) << 32)   + boost::ulong_long_type(2147483643ul)) \
+  ((boost::ulong_long_type(3ul) << 32)   + boost::ulong_long_type(5ul))          \
+  ((boost::ulong_long_type(5ul) << 32)   + boost::ulong_long_type(4294967271ul)) \
+  ((boost::ulong_long_type(11ul) << 32)  + boost::ulong_long_type(4294967295ul)) \
+  ((boost::ulong_long_type(24ul) << 32)  + boost::ulong_long_type(7ul))          \
+  ((boost::ulong_long_type(48ul) << 32)  + boost::ulong_long_type(1ul))          \
+  ((boost::ulong_long_type(96ul) << 32)  + boost::ulong_long_type(25ul))         \
+  ((boost::ulong_long_type(191ul) << 32) + boost::ulong_long_type(4294967295ul)) \
+  ((boost::ulong_long_type(383ul) << 32) + boost::ulong_long_type(4294967283ul))
+      // clang-format on
+
+#endif /* BOOST_UNORDERED_FCA_HAS_64B_SIZE_T */
+
+#define BOOST_UNORDERED_PRIME_FMOD_SIZES                                       \
+  BOOST_UNORDERED_PRIME_FMOD_SIZES_32BIT BOOST_UNORDERED_PRIME_FMOD_SIZES_64BIT
+
+      template <class T>
+      std::size_t prime_fmod_size<T>::sizes[] = {
+        BOOST_PP_SEQ_ENUM(BOOST_UNORDERED_PRIME_FMOD_SIZES)};
+
+      template <class T>
+      std::size_t const prime_fmod_size<T>::sizes_len = BOOST_PP_SEQ_SIZE(
+        BOOST_UNORDERED_PRIME_FMOD_SIZES);
+
+// Similarly here, we have to re-express the integer initialization using
+// arithmetic such that each literal can fit in a 32-bit value.
+//
+#if defined(BOOST_UNORDERED_FCA_FASTMOD_SUPPORT)
+      // clang-format off
+        template <class T>
+        uint64_t prime_fmod_size<T>::inv_sizes32[] = {
+          (boost::ulong_long_type(330382099ul) << 32) + boost::ulong_long_type(2973438898ul) /* = 1418980313362273202 */,
+          (boost::ulong_long_type(148102320ul) << 32) + boost::ulong_long_type(2369637129ul) /* = 636094623231363849 */,
+          (boost::ulong_long_type(81037118ul) << 32)  + boost::ulong_long_type(3403558990ul) /* = 348051774975651918 */,
+          (boost::ulong_long_type(44278013ul) << 32)  + boost::ulong_long_type(1549730468ul) /* = 190172619316593316 */,
+          (boost::ulong_long_type(22253716ul) << 32)  + boost::ulong_long_type(2403401389ul) /* = 95578984837873325 */,
+          (boost::ulong_long_type(11041047ul) << 32)  + boost::ulong_long_type(143533612ul)  /* = 47420935922132524 */,
+          (boost::ulong_long_type(5585133ul) << 32)   + boost::ulong_long_type(106117528ul)  /* = 23987963684927896 */,
+          (boost::ulong_long_type(2783517ul) << 32)   + boost::ulong_long_type(1572687312ul) /* = 11955116055547344 */,
+          (boost::ulong_long_type(1394922ul) << 32)   + boost::ulong_long_type(3428720239ul) /* = 5991147799191151 */,
+          (boost::ulong_long_type(698255ul) << 32)    + boost::ulong_long_type(552319807ul)  /* = 2998982941588287 */,
+          (boost::ulong_long_type(349496ul) << 32)    + boost::ulong_long_type(3827689953ul) /* = 1501077717772769 */,
+          (boost::ulong_long_type(174641ul) << 32)    + boost::ulong_long_type(3699438549ul) /* = 750081082979285 */,
+          (boost::ulong_long_type(87372ul) << 32)     + boost::ulong_long_type(1912757574ul) /* = 375261795343686 */,
+          (boost::ulong_long_type(43684ul) << 32)     + boost::ulong_long_type(3821029929ul) /* = 187625172388393 */,
+          (boost::ulong_long_type(21844ul) << 32)     + boost::ulong_long_type(3340590800ul) /* = 93822606204624 */,
+          (boost::ulong_long_type(10921ul) << 32)     + boost::ulong_long_type(4175852267ul) /* = 46909513691883 */,
+          (boost::ulong_long_type(5461ul) << 32)      + boost::ulong_long_type(1401829642ul) /* = 23456218233098 */,
+          (boost::ulong_long_type(2730ul) << 32)      + boost::ulong_long_type(2826028947ul) /* = 11728086747027 */,
+          (boost::ulong_long_type(1365ul) << 32)      + boost::ulong_long_type(1411150351ul) /* = 5864041509391 */,
+          (boost::ulong_long_type(682ul) << 32)       + boost::ulong_long_type(2857253105ul) /* = 2932024948977 */,
+          (boost::ulong_long_type(341ul) << 32)       + boost::ulong_long_type(1431073224ul) /* = 1466014921160 */,
+          (boost::ulong_long_type(170ul) << 32)       + boost::ulong_long_type(2862758116ul) /* = 733007198436 */,
+          (boost::ulong_long_type(85ul) << 32)        + boost::ulong_long_type(1431619357ul) /* = 366503839517 */,
+          (boost::ulong_long_type(42ul) << 32)        + boost::ulong_long_type(2863269661ul) /* = 183251896093 */,
+          (boost::ulong_long_type(21ul) << 32)        + boost::ulong_long_type(1431647119ul) /* = 91625960335 */,
+          (boost::ulong_long_type(10ul) << 32)        + boost::ulong_long_type(2863310962ul) /* = 45812983922 */,
+          (boost::ulong_long_type(5ul) << 32)         + boost::ulong_long_type(1431653234ul) /* = 22906489714 */,
+          (boost::ulong_long_type(2ul) << 32)         + boost::ulong_long_type(2863311496ul) /* = 11453246088 */,
+          (boost::ulong_long_type(1ul) << 32)         + boost::ulong_long_type(1431655764ul) /* = 5726623060 */,
+#if !defined(BOOST_UNORDERED_FCA_HAS_64B_SIZE_T)
+        };
+#else
+          (boost::ulong_long_type(1ul) << 32)         + boost::ulong_long_type(6ul)          /* 4294967302 */
+        };
+      // clang-format on
+#endif /* !defined(BOOST_UNORDERED_FCA_HAS_64B_SIZE_T) */
+
+      template <class T>
+      std::size_t const
+        prime_fmod_size<T>::inv_sizes32_len = sizeof(inv_sizes32) /
+                                              sizeof(inv_sizes32[0]);
+
+#endif /* defined(BOOST_UNORDERED_FCA_FASTMOD_SUPPORT) */
+
+#define BOOST_UNORDERED_PRIME_FMOD_POSITIONS_ELEMENT(z, _, n)                  \
+  prime_fmod_size<T>::template modulo<n>,
+
+      template <class T>
+      std::size_t (*prime_fmod_size<T>::positions[])(std::size_t) = {
+#if !defined(BOOST_UNORDERED_FCA_FASTMOD_SUPPORT)
+        BOOST_PP_SEQ_FOR_EACH(BOOST_UNORDERED_PRIME_FMOD_POSITIONS_ELEMENT, ~,
+          BOOST_UNORDERED_PRIME_FMOD_SIZES_32BIT)
+#endif
+
+#if defined(BOOST_UNORDERED_FCA_HAS_64B_SIZE_T)
+          BOOST_PP_SEQ_FOR_EACH(BOOST_UNORDERED_PRIME_FMOD_POSITIONS_ELEMENT, ~,
+            BOOST_UNORDERED_PRIME_FMOD_SIZES_64BIT)
+#endif
+      };
+
+#undef BOOST_UNORDERED_PRIME_FMOD_POSITIONS_ELEMENT
+#undef BOOST_UNORDERED_PRIME_FMOD_SIZES
+#undef BOOST_UNORDERED_PRIME_FMOD_SIZES_64BIT
+#undef BOOST_UNORDERED_PRIME_FMOD_SIZES_34BIT
+#undef BOOST_UNORDERED_PRIME_FMOD_SIZES_34BIT_INCOMPLETE
+
+#ifdef BOOST_UNORDERED_FCA_FASTMOD_SUPPORT
+#undef BOOST_UNORDERED_FCA_FASTMOD_SUPPORT
+#endif
+
+#ifdef BOOST_UNORDERED_FCA_HAS_64B_SIZE_T
+#undef BOOST_UNORDERED_FCA_HAS_64B_SIZE_T
+#endif
+
      template <class ValueType, class VoidPtr> struct node
      {
        typedef ValueType value_type;
@@ -200,7 +472,10 @@ namespace boost {
        return ~(~(std::size_t(0)) >> (sizeof(std::size_t) * 8 - n));
      }

-      template <class Bucket> struct grouped_bucket_iterator
+      template <class Bucket>
+      struct grouped_bucket_iterator
+          : public boost::iterator_facade<grouped_bucket_iterator<Bucket>,
+              Bucket, boost::forward_traversal_tag>
      {
      public:
        typedef typename Bucket::bucket_pointer bucket_pointer;
@@ -208,12 +483,8 @@ namespace boost {
          typename boost::pointer_traits<bucket_pointer>::template rebind_to<
            bucket_group<Bucket> >::type bucket_group_pointer;

-        typedef Bucket value_type;
        typedef typename boost::pointer_traits<bucket_pointer>::difference_type
          difference_type;
-        typedef Bucket& reference;
-        typedef Bucket* pointer;
-        typedef std::forward_iterator_tag iterator_category;

      private:
        bucket_pointer p;
@@ -222,38 +493,9 @@ namespace boost {
      public:
        grouped_bucket_iterator() : p(), pbg() {}

-        reference operator*() const BOOST_NOEXCEPT { return dereference(); }
-        pointer operator->() const BOOST_NOEXCEPT
-        {
-          return boost::to_address(p);
-        }
-
-        grouped_bucket_iterator& operator++() BOOST_NOEXCEPT
-        {
-          increment();
-          return *this;
-        }
-
-        grouped_bucket_iterator operator++(int) BOOST_NOEXCEPT
-        {
-          grouped_bucket_iterator old = *this;
-          increment();
-          return old;
-        }
-
-        bool operator==(
-          grouped_bucket_iterator const& other) const BOOST_NOEXCEPT
-        {
-          return equal(other);
-        }
-
-        bool operator!=(
-          grouped_bucket_iterator const& other) const BOOST_NOEXCEPT
-        {
-          return !equal(other);
-        }
-
      private:
+        friend class boost::iterator_core_access;
+
        template <typename, typename, typename>
        friend class grouped_bucket_array;

@@ -291,8 +533,12 @@ namespace boost {

      template <class Node> struct const_grouped_local_bucket_iterator;

-      template <class Node> struct grouped_local_bucket_iterator
+      template <class Node>
+      struct grouped_local_bucket_iterator
+          : public boost::iterator_facade<grouped_local_bucket_iterator<Node>,
+              typename Node::value_type, boost::forward_traversal_tag>
      {
+
        typedef typename Node::node_pointer node_pointer;

      public:
@@ -305,39 +551,9 @@ namespace boost {

        grouped_local_bucket_iterator() : p() {}

-        reference operator*() const BOOST_NOEXCEPT { return dereference(); }
-
-        pointer operator->() const BOOST_NOEXCEPT
-        {
-          return boost::to_address(p);
-        }
-
-        grouped_local_bucket_iterator& operator++() BOOST_NOEXCEPT
-        {
-          increment();
-          return *this;
-        }
-
-        grouped_local_bucket_iterator operator++(int) BOOST_NOEXCEPT
-        {
-          grouped_local_bucket_iterator old = *this;
-          increment();
-          return old;
-        }
-
-        bool operator==(
-          grouped_local_bucket_iterator const& other) const BOOST_NOEXCEPT
-        {
-          return equal(other);
-        }
-
-        bool operator!=(
-          grouped_local_bucket_iterator const& other) const BOOST_NOEXCEPT
-        {
-          return !equal(other);
-        }
-
      private:
+        friend class boost::iterator_core_access;
+
        template <typename, typename, typename>
        friend class grouped_bucket_array;

@@ -357,7 +573,11 @@ namespace boost {
        node_pointer p;
      };

-      template <class Node> struct const_grouped_local_bucket_iterator
+      template <class Node>
+      struct const_grouped_local_bucket_iterator
+          : public boost::iterator_facade<
+              const_grouped_local_bucket_iterator<Node>,
+              typename Node::value_type const, boost::forward_traversal_tag>
      {
        typedef typename Node::node_pointer node_pointer;

@@ -376,39 +596,9 @@ namespace boost {
        {
        }

-        reference operator*() const BOOST_NOEXCEPT { return dereference(); }
-
-        pointer operator->() const BOOST_NOEXCEPT
-        {
-          return boost::to_address(p);
-        }
-
-        const_grouped_local_bucket_iterator& operator++() BOOST_NOEXCEPT
-        {
-          increment();
-          return *this;
-        }
-
-        const_grouped_local_bucket_iterator operator++(int) BOOST_NOEXCEPT
-        {
-          const_grouped_local_bucket_iterator old = *this;
-          increment();
-          return old;
-        }
-
-        bool operator==(
-          const_grouped_local_bucket_iterator const& other) const BOOST_NOEXCEPT
-        {
-          return equal(other);
-        }
-
-        bool operator!=(
-          const_grouped_local_bucket_iterator const& other) const BOOST_NOEXCEPT
-        {
-          return !equal(other);
-        }
-
      private:
+        friend class boost::iterator_core_access;
+
        template <typename, typename, typename>
        friend class grouped_bucket_array;

@@ -15,6 +15,7 @@
 #endif

 #include <boost/assert.hpp>
+#include <boost/config.hpp>
 #include <boost/core/allocator_traits.hpp>
 #include <boost/core/bit.hpp>
 #include <boost/core/no_exceptions_support.hpp>
@@ -59,6 +60,15 @@
 #include <type_traits>
 #endif

+#if __SSE2__
+#include <emmintrin.h>
+#endif
+
+#if defined(__SSE2__) || \
+    defined(_M_X64) || (defined(_M_IX86_FP) && _M_IX86_FP >= 2)
+#define BOOST_UNORDERED_SSE2_SUPPORTED
+#endif
+
 ////////////////////////////////////////////////////////////////////////////////
 // Configuration
 //
@@ -1697,9 +1707,10 @@ namespace boost {
      };

      template <typename T>
-      struct rv_ref : boost::conditional<boost::is_class<T>::value,
-                        boost::unordered::detail::rv_ref_impl<T>,
-                        please_ignore_this_overload>::type
+      struct rv_ref
+        : boost::detail::if_true<boost::is_class<T>::value>::
+            BOOST_NESTED_TEMPLATE then<boost::unordered::detail::rv_ref_impl<T>,
+              please_ignore_this_overload>::type
      {
      };

@@ -1729,7 +1740,10 @@ namespace boost {
      namespace iterator_detail {
        template <class Node, class Bucket> class c_iterator;

-        template <class Node, class Bucket> class iterator
+        template <class Node, class Bucket>
+        class iterator
+            : public boost::iterator_facade<iterator<Node, Bucket>,
+                typename Node::value_type, boost::forward_traversal_tag>
        {
        public:
          typedef typename Node::value_type value_type;
@@ -1741,50 +1755,6 @@ namespace boost {

          iterator() : p(), itb(){};

-          reference operator*() const BOOST_NOEXCEPT { return dereference(); }
-          pointer operator->() const BOOST_NOEXCEPT
-          {
-            pointer x = boost::addressof(p->value());
-            return x;
-          }
-
-          iterator& operator++() BOOST_NOEXCEPT
-          {
-            increment();
-            return *this;
-          }
-
-          iterator operator++(int) BOOST_NOEXCEPT
-          {
-            iterator old = *this;
-            increment();
-            return old;
-          }
-
-          bool operator==(iterator const& other) const BOOST_NOEXCEPT
-          {
-            return equal(other);
-          }
-
-          bool operator!=(iterator const& other) const BOOST_NOEXCEPT
-          {
-            return !equal(other);
-          }
-
-          bool operator==(
-            boost::unordered::detail::iterator_detail::c_iterator<Node,
-              Bucket> const& other) const BOOST_NOEXCEPT
-          {
-            return equal(other);
-          }
-
-          bool operator!=(
-            boost::unordered::detail::iterator_detail::c_iterator<Node,
-              Bucket> const& other) const BOOST_NOEXCEPT
-          {
-            return !equal(other);
-          }
-
        private:
          typedef typename Node::node_pointer node_pointer;
          typedef grouped_bucket_iterator<Bucket> bucket_iterator;
@@ -1794,6 +1764,7 @@ namespace boost {

          template <class Types> friend struct boost::unordered::detail::table;
          template <class N, class B> friend class c_iterator;
+          friend class boost::iterator_core_access;

          iterator(node_pointer p_, bucket_iterator itb_) : p(p_), itb(itb_) {}

@@ -1804,13 +1775,6 @@ namespace boost {
            return (p == x.p);
          }

-          bool equal(
-            const boost::unordered::detail::iterator_detail::c_iterator<Node,
-              Bucket>& x) const BOOST_NOEXCEPT
-          {
-            return (p == x.p);
-          }
-
          void increment() BOOST_NOEXCEPT
          {
            p = p->next;
@@ -1820,7 +1784,10 @@ namespace boost {
          }
        };

-        template <class Node, class Bucket> class c_iterator
+        template <class Node, class Bucket>
+        class c_iterator
+            : public boost::iterator_facade<c_iterator<Node, Bucket>,
+                typename Node::value_type const, boost::forward_traversal_tag>
        {
        public:
          typedef typename Node::value_type value_type;
@@ -1831,51 +1798,7 @@ namespace boost {
          typedef std::forward_iterator_tag iterator_category;

          c_iterator() : p(), itb(){};
-          c_iterator(iterator<Node, Bucket> it) : p(it.p), itb(it.itb) {}
-
-          reference operator*() const BOOST_NOEXCEPT { return dereference(); }
-          pointer operator->() const BOOST_NOEXCEPT
-          {
-            pointer x = boost::addressof(p->value());
-            return x;
-          }
-
-          c_iterator& operator++() BOOST_NOEXCEPT
-          {
-            increment();
-            return *this;
-          }
-
-          c_iterator operator++(int) BOOST_NOEXCEPT
-          {
-            c_iterator old = *this;
-            increment();
-            return old;
-          }
-
-          bool operator==(c_iterator const& other) const BOOST_NOEXCEPT
-          {
-            return equal(other);
-          }
-
-          bool operator!=(c_iterator const& other) const BOOST_NOEXCEPT
-          {
-            return !equal(other);
-          }
-
-          bool operator==(
-            boost::unordered::detail::iterator_detail::iterator<Node,
-              Bucket> const& other) const BOOST_NOEXCEPT
-          {
-            return equal(other);
-          }
-
-          bool operator!=(
-            boost::unordered::detail::iterator_detail::iterator<Node,
-              Bucket> const& other) const BOOST_NOEXCEPT
-          {
-            return !equal(other);
-          }
+          c_iterator(iterator<Node, Bucket> it) : p(it.p), itb(it.itb){};

        private:
          typedef typename Node::node_pointer node_pointer;
@@ -1885,7 +1808,7 @@ namespace boost {
          bucket_iterator itb;

          template <class Types> friend struct boost::unordered::detail::table;
-          template <class, class> friend class iterator;
+          friend class boost::iterator_core_access;

          c_iterator(node_pointer p_, bucket_iterator itb_) : p(p_), itb(itb_)
          {
@@ -2453,6 +2376,7 @@ namespace boost {
        inline iterator transparent_find(
          Key const& k, Hash const& h, Pred const& pred) const
        {
+#if 0
          std::size_t const key_hash = h(k);
          bucket_iterator itb = buckets_.at(buckets_.position(key_hash));
          for (node_pointer p = itb->next; p; p = p->next) {
@@ -2460,7 +2384,36 @@ namespace boost {
              return iterator(p, itb);
            }
          }
+#else
+          std::size_t const key_hash = h(k);
+          bucket_iterator itb = buckets_.at(buckets_.position(key_hash));

+          node_pointer p = itb->next;
+          if (p) {
+            for (;;) {
+              node_pointer p1 = p->next;
+              if (p1) {
+
+#if defined(BOOST_GCC)||defined(BOOST_CLANG)
+                __builtin_prefetch((const char*)p1, 0);
+#elif defined(BOOST_UNORDERED_SSE2_SUPPORTED)
+                _mm_prefetch((const char*)p1, _MM_HINT_T0);
+#endif  
+
+                if (BOOST_LIKELY(pred(k, extractor::extract(p->value())))) {
+                  return iterator(p, itb);
+                }
+                p = p1;
+              }
+              else{
+                if (BOOST_LIKELY(pred(k, extractor::extract(p->value())))) {
+                  return iterator(p, itb);
+                }
+                break;
+              }
+            }
+          }
+#endif
          return this->end();
        }

@@ -2928,23 +2881,6 @@ namespace boost {
          return 1;
        }

-        iterator erase_node(c_iterator pos) {
-          c_iterator next = pos;
-          ++next;
-          
-          bucket_iterator itb = pos.itb;
-          node_pointer* pp = boost::addressof(itb->next);
-          while (*pp != pos.p) {
-            pp = boost::addressof((*pp)->next);
-          }
-
-          buckets_.extract_node_after(itb, pp);
-          this->delete_node(pos.p);
-          --size_;
-
-          return iterator(next.p, next.itb);
-        }
-
        iterator erase_nodes_range(c_iterator first, c_iterator last)
        {
          if (first == last) {
@@ -3513,8 +3449,8 @@ namespace boost {
                  sizeof(choice2::type)
        };

-        typedef
-          typename boost::conditional<value, Key const&, no_key>::type type;
+        typedef typename boost::detail::if_true<value>::BOOST_NESTED_TEMPLATE
+          then<Key const&, no_key>::type type;
      };

      template <class ValueType> struct set_extractor
@@ -1,262 +0,0 @@
-// Copyright (C) 2022 Joaquin M Lopez Munoz.
-// Copyright (C) 2022 Christian Mazakas
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_UNORDERED_DETAIL_PRIME_FMOD_HPP
-#define BOOST_UNORDERED_DETAIL_PRIME_FMOD_HPP
-
-#include <boost/cstdint.hpp>
-#include <boost/preprocessor/seq/enum.hpp>
-#include <boost/preprocessor/seq/for_each.hpp>
-#include <boost/preprocessor/seq/size.hpp>
-
-#include <boost/config.hpp>
-
-#include <climits>
-#include <cstddef>
-
-#if defined(SIZE_MAX)
-#if ((((SIZE_MAX >> 16) >> 16) >> 16) >> 15) != 0
-#define BOOST_UNORDERED_FCA_HAS_64B_SIZE_T
-#endif
-#elif defined(UINTPTR_MAX) /* used as proxy for std::size_t */
-#if ((((UINTPTR_MAX >> 16) >> 16) >> 16) >> 15) != 0
-#define BOOST_UNORDERED_FCA_HAS_64B_SIZE_T
-#endif
-#endif
-
-#if defined(BOOST_UNORDERED_FCA_HAS_64B_SIZE_T) && defined(_MSC_VER)
-#include <intrin.h>
-#endif
-
-namespace boost {
-  namespace unordered {
-    namespace detail {
-      template <class = void> struct prime_fmod_size
-      {
-        // Because we compile for C++03, we don't have access to any inline
-        // initialization for array data members so the definitions must exist
-        // out-of-line. To keep the library header-only, we introduce a dummy
-        // template parameter which permits the definition to be included in
-        // multiple TUs without conflict.
-        //
-        static std::size_t sizes[];
-        static std::size_t const sizes_len;
-        static std::size_t (*positions[])(std::size_t);
-
-#if defined(BOOST_UNORDERED_FCA_HAS_64B_SIZE_T)
-        static boost::uint64_t inv_sizes32[];
-        static std::size_t const inv_sizes32_len;
-#endif /* defined(BOOST_UNORDERED_FCA_HAS_64B_SIZE_T) */
-
-        static inline std::size_t size_index(std::size_t n)
-        {
-          std::size_t i = 0;
-          for (; i < (sizes_len - 1); ++i) {
-            if (sizes[i] >= n) {
-              break;
-            }
-          }
-          return i;
-        }
-
-        static inline std::size_t size(std::size_t size_index)
-        {
-          return sizes[size_index];
-        }
-
-        template <std::size_t Size> static std::size_t modulo(std::size_t hash)
-        {
-          return hash % Size;
-        }
-
-#if defined(BOOST_UNORDERED_FCA_HAS_64B_SIZE_T)
-        // We emulate the techniques taken from:
-        // Faster Remainder by Direct Computation: Applications to Compilers and
-        // Software Libraries
-        // https://arxiv.org/abs/1902.01961
-        //
-        // In essence, use fancy math to directly calculate the remainder (aka
-        // modulo) exploiting how compilers transform division
-        //
-
-        static inline boost::uint64_t get_remainder(
-          boost::uint64_t fractional, boost::uint32_t d)
-        {
-#if defined(_MSC_VER)
-          // use MSVC intrinsics when available to avoid promotion to 128 bits
-
-          return __umulh(fractional, d);
-#elif defined(BOOST_HAS_INT128)
-          return static_cast<boost::uint64_t>(
-            ((boost::uint128_type)fractional * d) >> 64);
-#else
-          // portable implementation in the absence of boost::uint128_type on 64
-          // bits, which happens at least in GCC 4.5 and prior
-
-          boost::uint64_t r1 = (fractional & UINT32_MAX) * d;
-          boost::uint64_t r2 = (fractional >> 32) * d;
-          r2 += r1 >> 32;
-          return r2 >> 32;
-#endif /* defined(_MSC_VER) */
-        }
-
-        static inline boost::uint32_t fast_modulo(
-          boost::uint32_t a, boost::uint64_t M, boost::uint32_t d)
-        {
-          boost::uint64_t fractional = M * a;
-          return (boost::uint32_t)(get_remainder(fractional, d));
-        }
-#endif /* defined(BOOST_UNORDERED_FCA_HAS_64B_SIZE_T) */
-
-        static inline std::size_t position(
-          std::size_t hash, std::size_t size_index)
-        {
-#if defined(BOOST_UNORDERED_FCA_HAS_64B_SIZE_T)
-          std::size_t sizes_under_32bit = inv_sizes32_len;
-          if (BOOST_LIKELY(size_index < sizes_under_32bit)) {
-            return fast_modulo(
-              boost::uint32_t(hash) + boost::uint32_t(hash >> 32),
-              inv_sizes32[size_index], boost::uint32_t(sizes[size_index]));
-          } else {
-            return positions[size_index - sizes_under_32bit](hash);
-          }
-#else
-          return positions[size_index](hash);
-#endif /* defined(BOOST_UNORDERED_FCA_HAS_64B_SIZE_T) */
-        }
-      }; // prime_fmod_size
-
-#define BOOST_UNORDERED_PRIME_FMOD_SIZES_32BIT_INCOMPLETE                      \
-  (13ul)(29ul)(53ul)(97ul)(193ul)(389ul)(769ul)(1543ul)(3079ul)(6151ul)(       \
-    12289ul)(24593ul)(49157ul)(98317ul)(196613ul)(393241ul)(786433ul)(         \
-    1572869ul)(3145739ul)(6291469ul)(12582917ul)(25165843ul)(50331653ul)(      \
-    100663319ul)(201326611ul)(402653189ul)(805306457ul)(1610612741ul)(         \
-    3221225473ul)
-
-#if !defined(BOOST_UNORDERED_FCA_HAS_64B_SIZE_T)
-
-#define BOOST_UNORDERED_PRIME_FMOD_SIZES_32BIT                                 \
-  BOOST_UNORDERED_PRIME_FMOD_SIZES_32BIT_INCOMPLETE(4294967291ul)
-
-#define BOOST_UNORDERED_PRIME_FMOD_SIZES_64BIT
-
-#else
-
-#define BOOST_UNORDERED_PRIME_FMOD_SIZES_32BIT                                 \
-  BOOST_UNORDERED_PRIME_FMOD_SIZES_32BIT_INCOMPLETE
-
-// The original sequence here is this:
-// (6442450939ul)
-// (12884901893ul)
-// (25769803751ul)
-// (51539607551ul)
-// (103079215111ul)
-// (206158430209ul)
-// (412316860441ul)
-// (824633720831ul)
-// (1649267441651ul)
-//
-// but this causes problems on versions of mingw where the `long` type is 32
-// bits, even for 64-bit targets. We work around this by replacing the literals
-// with compile-time arithmetic, using bitshifts to reconstruct the number.
-//
-
-// clang-format off
-#define BOOST_UNORDERED_PRIME_FMOD_SIZES_64BIT                                   \
-  ((boost::ulong_long_type(1ul) << 32)   + boost::ulong_long_type(2147483643ul)) \
-  ((boost::ulong_long_type(3ul) << 32)   + boost::ulong_long_type(5ul))          \
-  ((boost::ulong_long_type(5ul) << 32)   + boost::ulong_long_type(4294967271ul)) \
-  ((boost::ulong_long_type(11ul) << 32)  + boost::ulong_long_type(4294967295ul)) \
-  ((boost::ulong_long_type(24ul) << 32)  + boost::ulong_long_type(7ul))          \
-  ((boost::ulong_long_type(48ul) << 32)  + boost::ulong_long_type(1ul))          \
-  ((boost::ulong_long_type(96ul) << 32)  + boost::ulong_long_type(25ul))         \
-  ((boost::ulong_long_type(191ul) << 32) + boost::ulong_long_type(4294967295ul)) \
-  ((boost::ulong_long_type(383ul) << 32) + boost::ulong_long_type(4294967283ul))
-      // clang-format on
-
-#endif /* BOOST_UNORDERED_FCA_HAS_64B_SIZE_T */
-
-#define BOOST_UNORDERED_PRIME_FMOD_SIZES                                       \
-  BOOST_UNORDERED_PRIME_FMOD_SIZES_32BIT BOOST_UNORDERED_PRIME_FMOD_SIZES_64BIT
-
-      template <class T>
-      std::size_t prime_fmod_size<T>::sizes[] = {
-        BOOST_PP_SEQ_ENUM(BOOST_UNORDERED_PRIME_FMOD_SIZES)};
-
-      template <class T>
-      std::size_t const prime_fmod_size<T>::sizes_len = BOOST_PP_SEQ_SIZE(
-        BOOST_UNORDERED_PRIME_FMOD_SIZES);
-
-// Similarly here, we have to re-express the integer initialization using
-// arithmetic such that each literal can fit in a 32-bit value.
-//
-#if defined(BOOST_UNORDERED_FCA_HAS_64B_SIZE_T)
-      // clang-format off
-        template <class T>
-        boost::uint64_t prime_fmod_size<T>::inv_sizes32[] = {
-          (boost::ulong_long_type(330382099ul) << 32) + boost::ulong_long_type(2973438898ul) /* = 1418980313362273202 */,
-          (boost::ulong_long_type(148102320ul) << 32) + boost::ulong_long_type(2369637129ul) /* = 636094623231363849 */,
-          (boost::ulong_long_type(81037118ul) << 32)  + boost::ulong_long_type(3403558990ul) /* = 348051774975651918 */,
-          (boost::ulong_long_type(44278013ul) << 32)  + boost::ulong_long_type(1549730468ul) /* = 190172619316593316 */,
-          (boost::ulong_long_type(22253716ul) << 32)  + boost::ulong_long_type(2403401389ul) /* = 95578984837873325 */,
-          (boost::ulong_long_type(11041047ul) << 32)  + boost::ulong_long_type(143533612ul)  /* = 47420935922132524 */,
-          (boost::ulong_long_type(5585133ul) << 32)   + boost::ulong_long_type(106117528ul)  /* = 23987963684927896 */,
-          (boost::ulong_long_type(2783517ul) << 32)   + boost::ulong_long_type(1572687312ul) /* = 11955116055547344 */,
-          (boost::ulong_long_type(1394922ul) << 32)   + boost::ulong_long_type(3428720239ul) /* = 5991147799191151 */,
-          (boost::ulong_long_type(698255ul) << 32)    + boost::ulong_long_type(552319807ul)  /* = 2998982941588287 */,
-          (boost::ulong_long_type(349496ul) << 32)    + boost::ulong_long_type(3827689953ul) /* = 1501077717772769 */,
-          (boost::ulong_long_type(174641ul) << 32)    + boost::ulong_long_type(3699438549ul) /* = 750081082979285 */,
-          (boost::ulong_long_type(87372ul) << 32)     + boost::ulong_long_type(1912757574ul) /* = 375261795343686 */,
-          (boost::ulong_long_type(43684ul) << 32)     + boost::ulong_long_type(3821029929ul) /* = 187625172388393 */,
-          (boost::ulong_long_type(21844ul) << 32)     + boost::ulong_long_type(3340590800ul) /* = 93822606204624 */,
-          (boost::ulong_long_type(10921ul) << 32)     + boost::ulong_long_type(4175852267ul) /* = 46909513691883 */,
-          (boost::ulong_long_type(5461ul) << 32)      + boost::ulong_long_type(1401829642ul) /* = 23456218233098 */,
-          (boost::ulong_long_type(2730ul) << 32)      + boost::ulong_long_type(2826028947ul) /* = 11728086747027 */,
-          (boost::ulong_long_type(1365ul) << 32)      + boost::ulong_long_type(1411150351ul) /* = 5864041509391 */,
-          (boost::ulong_long_type(682ul) << 32)       + boost::ulong_long_type(2857253105ul) /* = 2932024948977 */,
-          (boost::ulong_long_type(341ul) << 32)       + boost::ulong_long_type(1431073224ul) /* = 1466014921160 */,
-          (boost::ulong_long_type(170ul) << 32)       + boost::ulong_long_type(2862758116ul) /* = 733007198436 */,
-          (boost::ulong_long_type(85ul) << 32)        + boost::ulong_long_type(1431619357ul) /* = 366503839517 */,
-          (boost::ulong_long_type(42ul) << 32)        + boost::ulong_long_type(2863269661ul) /* = 183251896093 */,
-          (boost::ulong_long_type(21ul) << 32)        + boost::ulong_long_type(1431647119ul) /* = 91625960335 */,
-          (boost::ulong_long_type(10ul) << 32)        + boost::ulong_long_type(2863310962ul) /* = 45812983922 */,
-          (boost::ulong_long_type(5ul) << 32)         + boost::ulong_long_type(1431653234ul) /* = 22906489714 */,
-          (boost::ulong_long_type(2ul) << 32)         + boost::ulong_long_type(2863311496ul) /* = 11453246088 */,
-          (boost::ulong_long_type(1ul) << 32)         + boost::ulong_long_type(1431655764ul) /* = 5726623060 */,
-        };
-      // clang-format on
-
-      template <class T>
-      std::size_t const
-        prime_fmod_size<T>::inv_sizes32_len = sizeof(inv_sizes32) /
-                                              sizeof(inv_sizes32[0]);
-
-#endif /* defined(BOOST_UNORDERED_FCA_HAS_64B_SIZE_T) */
-
-#define BOOST_UNORDERED_PRIME_FMOD_POSITIONS_ELEMENT(z, _, n)                  \
-  prime_fmod_size<T>::template modulo<n>,
-
-      template <class T>
-      std::size_t (*prime_fmod_size<T>::positions[])(std::size_t) = {
-#if !defined(BOOST_UNORDERED_FCA_HAS_64B_SIZE_T)
-        BOOST_PP_SEQ_FOR_EACH(BOOST_UNORDERED_PRIME_FMOD_POSITIONS_ELEMENT, ~,
-          BOOST_UNORDERED_PRIME_FMOD_SIZES_32BIT)
-#else
-        BOOST_PP_SEQ_FOR_EACH(BOOST_UNORDERED_PRIME_FMOD_POSITIONS_ELEMENT, ~,
-          BOOST_UNORDERED_PRIME_FMOD_SIZES_64BIT)
-#endif
-      };
-
-#undef BOOST_UNORDERED_PRIME_FMOD_POSITIONS_ELEMENT
-#undef BOOST_UNORDERED_PRIME_FMOD_SIZES
-#undef BOOST_UNORDERED_PRIME_FMOD_SIZES_64BIT
-#undef BOOST_UNORDERED_PRIME_FMOD_SIZES_32BIT
-#undef BOOST_UNORDERED_PRIME_FMOD_SIZES_32BIT_INCOMPLETE
-    } // namespace detail
-  }   // namespace unordered
-} // namespace boost
-
-#endif // BOOST_UNORDERED_DETAIL_PRIME_FMOD_HPP
@@ -1856,14 +1856,18 @@ namespace boost {
    typename unordered_map<K, T, H, P, A>::iterator
    unordered_map<K, T, H, P, A>::erase(iterator position)
    {
-      return table_.erase_node(position);
+      const_iterator last = position;
+      ++last;
+      return table_.erase_nodes_range(position, last);
    }

    template <class K, class T, class H, class P, class A>
    typename unordered_map<K, T, H, P, A>::iterator
    unordered_map<K, T, H, P, A>::erase(const_iterator position)
    {
-      return table_.erase_node(position);
+      const_iterator last = position;
+      ++last;
+      return table_.erase_nodes_range(position, last);
    }

    template <class K, class T, class H, class P, class A>
@@ -2336,7 +2340,9 @@ namespace boost {
    unordered_multimap<K, T, H, P, A>::erase(iterator position)
    {
      BOOST_ASSERT(position != this->end());
-      return table_.erase_node(position);
+      iterator next = position;
+      ++next;
+      return table_.erase_nodes_range(position, next);
    }

    template <class K, class T, class H, class P, class A>
@@ -2344,7 +2350,9 @@ namespace boost {
    unordered_multimap<K, T, H, P, A>::erase(const_iterator position)
    {
      BOOST_ASSERT(position != this->end());
-      return table_.erase_node(position);
+      const_iterator next = position;
+      ++next;
+      return table_.erase_nodes_range(position, next);
    }

    template <class K, class T, class H, class P, class A>
@@ -1457,7 +1457,9 @@ namespace boost {
    typename unordered_set<T, H, P, A>::iterator
    unordered_set<T, H, P, A>::erase(const_iterator position)
    {
-      return table_.erase_node(position);
+      const_iterator last = position;
+      ++last;
+      return table_.erase_nodes_range(position, last);
    }

    template <class T, class H, class P, class A>
@@ -1851,7 +1853,10 @@ namespace boost {
    unordered_multiset<T, H, P, A>::erase(const_iterator position)
    {
      BOOST_ASSERT(position != this->end());
-      return table_.erase_node(position);
+      iterator next = position;
+      ++next;
+      table_.erase_nodes_range(position, next);
+      return next;
    }

    template <class T, class H, class P, class A>
@@ -6,12 +6,6 @@ include(BoostTestJamfile OPTIONAL RESULT_VARIABLE HAVE_BOOST_TEST)

 if(HAVE_BOOST_TEST)

-boost_test_jamfile(
-  FILE Jamfile.v2 
-  LINK_LIBRARIES 
-    Boost::unordered 
-    Boost::core
-    Boost::concept_check
-)
+boost_test_jamfile(FILE Jamfile.v2 LINK_LIBRARIES Boost::unordered Boost::core)

 endif()
@@ -24,15 +24,11 @@ project
        <toolset>clang:<cxxflags>$(clang-flags)
        <toolset>msvc:<cxxflags>$(msvc-flags)

-        <toolset>gcc-4.4:<cxxflags>-Wno-strict-aliasing
-        <toolset>gcc-4.4:<cxxflags>-fno-deduce-init-list
-
        <toolset>gcc:<warnings-as-errors>on
        <toolset>clang:<warnings-as-errors>on
        <toolset>msvc:<warnings-as-errors>on
    ;

-run unordered/prime_fmod_tests.cpp ;
 run unordered/fwd_set_test.cpp ;
 run unordered/fwd_map_test.cpp ;
 run unordered/allocator_traits.cpp ;
@@ -18,6 +18,7 @@ assert
 config
 container_hash
 core
+iterator
 move
 mp11
 predef
@@ -28,10 +29,24 @@ type_traits

 # Secondary dependencies

-detail
-integer
 static_assert
+concept_check
+conversion
+detail
+function_types
+fusion
+mpl
+optional
+smart_ptr
+utility
 winapi
+typeof
+functional
+io
+function
+bind
+integer
+type_index
 )

 foreach(dep IN LISTS deps)
@@ -9,8 +9,8 @@
 #include "./generators.hpp"
 #include "./list.hpp"
 #include "./metafunctions.hpp"
-#include <boost/type_traits/conditional.hpp>
 #include <algorithm>
+#include <boost/detail/select_type.hpp>

 namespace test {
  template <class X> struct unordered_generator_set
@@ -69,8 +69,9 @@ namespace test {

  template <class X>
  struct unordered_generator_base
-      : public boost::conditional<test::is_set<X>::value,
-          test::unordered_generator_set<X>, test::unordered_generator_map<X> >
+    : public boost::detail::if_true<test::is_set<X>::value>::
+        BOOST_NESTED_TEMPLATE then<test::unordered_generator_set<X>,
+          test::unordered_generator_map<X> >
  {
  };

@@ -1,4 +1,4 @@
-// Copyright 2021-2022 Christian Mazakas.
+// Copyright 2021 Christian Mazakas.
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

@@ -11,10 +11,9 @@

 #include "../helpers/test.hpp"

-#include <boost/config.hpp>
 #include <string>

-#if !defined(BOOST_NO_CXX11_REF_QUALIFIERS)
+#if BOOST_CXX_VERSION >= 201103L
 #define UNORDERED_LVALUE_QUAL &
 #else
 #define UNORDERED_LVALUE_QUAL
@@ -189,8 +189,7 @@ namespace noexcept_tests {

 #if !defined(BOOST_NO_SFINAE_EXPR) && !defined(BOOST_NO_CXX11_NOEXCEPT) &&     \
  !defined(BOOST_NO_CXX11_DECLTYPE) &&                                         \
-  !defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS) &&                   \
-  !BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40700)
+  !defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS)
    BOOST_TEST(have_is_nothrow_swap);
 #endif

@@ -1,215 +0,0 @@
-// Copyright 2022 Christian Mazakas.
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#include <boost/unordered/detail/prime_fmod.hpp>
-
-#include <boost/core/detail/splitmix64.hpp>
-#include <boost/core/lightweight_test.hpp>
-
-#include <limits>
-
-#if defined(BOOST_MSVC)
-// conditional expression is constant
-#pragma warning(disable : 4127)
-#endif
-
-void macros_test()
-{
-  if (std::numeric_limits<std::size_t>::digits >= 64) {
-#if !defined(BOOST_UNORDERED_FCA_HAS_64B_SIZE_T)
-    BOOST_ERROR("std::numeric_limits<size_t>::digits >= 64, but "
-                "BOOST_UNORDERED_FCA_HAS_64B_SIZE_T is not defined");
-#endif
-  }
-  else {
-#if defined(BOOST_UNORDERED_FCA_HAS_64B_SIZE_T)
-    BOOST_ERROR("std::numeric_limits<size_t>::digits < 64, but "
-                "BOOST_UNORDERED_FCA_HAS_64B_SIZE_T is defined");
-#endif
-  }
-}
-
-// Pretty inefficient, but the test is fast enough.
-// Might be too slow if we had larger primes?
-bool is_prime(std::size_t x)
-{
-  if (x == 2) {
-    return true;
-  }
-
-  if (x == 1 || x % 2 == 0) {
-    return false;
-  }
-
-  // y*y <= x is susceptible to overflow, so instead make sure to use y <= (x/y)
-  for (std::size_t y = 3; y <= (x / y); y += 2) {
-    if (x % y == 0) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-void prime_sizes_test()
-{
-  // just some basic sanity checks
-  //
-  BOOST_TEST(!is_prime(0));
-  BOOST_TEST(!is_prime(1));
-  BOOST_TEST(is_prime(2));
-  BOOST_TEST(is_prime(3));
-  BOOST_TEST(is_prime(13));
-  BOOST_TEST(!is_prime(4));
-  BOOST_TEST(!is_prime(100));
-  BOOST_TEST(!is_prime(49));
-
-  std::size_t* sizes = boost::unordered::detail::prime_fmod_size<>::sizes;
-  std::size_t sizes_len =
-    boost::unordered::detail::prime_fmod_size<>::sizes_len;
-
-  // prove every number in our sizes array is prime
-  //
-  BOOST_TEST_GT(sizes_len, 0u);
-
-  for (std::size_t i = 0; i < sizes_len; ++i) {
-    BOOST_TEST(is_prime(sizes[i]));
-  }
-
-  // prove that every subsequent number in the sequence is larger than the
-  // previous
-  //
-  for (std::size_t i = 1; i < sizes_len; ++i) {
-    BOOST_TEST_GT(sizes[i], sizes[i - 1]);
-  }
-
-#if defined(BOOST_UNORDERED_FCA_HAS_64B_SIZE_T)
-  // now we wish to prove that if we do have the reciprocals stored, we have the
-  // correct amount of them, i.e. one for every entry in sizes[] that fits in 32
-  // bits
-  //
-  boost::uint64_t* inv_sizes32 =
-    boost::unordered::detail::prime_fmod_size<>::inv_sizes32;
-
-  std::size_t inv_sizes32_len =
-    boost::unordered::detail::prime_fmod_size<>::inv_sizes32_len;
-
-  std::size_t count = 0;
-  for (std::size_t i = 0; i < sizes_len; ++i) {
-    if (sizes[i] <= UINT32_MAX) {
-      ++count;
-    }
-  }
-
-  BOOST_TEST_GT(inv_sizes32_len, 0u);
-  BOOST_TEST_EQ(inv_sizes32_len, count);
-
-  // these values should also be monotonically decreasing
-  //
-  for (std::size_t i = 1; i < inv_sizes32_len; ++i) {
-    BOOST_TEST_LT(inv_sizes32[i], inv_sizes32[i - 1]);
-  }
-
-  // now make sure the values in inv_sizes32 are what they should be as derived
-  // from the paper
-  //
-  for (std::size_t i = 0; i < inv_sizes32_len; ++i) {
-    std::size_t const size = sizes[i];
-    BOOST_TEST_LE(size, UINT_MAX);
-
-    boost::uint32_t d = static_cast<boost::uint32_t>(sizes[i]);
-    boost::uint64_t M = ((boost::ulong_long_type(0xffffffff) << 32) +
-                          boost::ulong_long_type(0xffffffff)) /
-                          d +
-                        1;
-
-    BOOST_TEST_EQ(inv_sizes32[i], M);
-  }
-#endif
-}
-
-void get_remainder_test()
-{
-#if defined(BOOST_UNORDERED_FCA_HAS_64B_SIZE_T)
-  struct
-  {
-    // boost::unordered::detail::prime_fmod_size<>::get_remainder
-    // uses several internal implementations depending on the availability of
-    // certain intrinsics or 128 bit integer support, defaulting to a slow,
-    // portable routine. The following is a transcription of the portable
-    // routine used here for verification purposes.
-    //
-    boost::uint64_t operator()(boost::uint64_t f, boost::uint32_t d)
-    {
-      boost::uint64_t r1 = (f & UINT32_MAX) * d;
-      boost::uint64_t r2 = (f >> 32) * d;
-
-      r2 += r1 >> 32;
-
-      return r2 >> 32;
-    }
-  } get_remainder;
-
-  boost::detail::splitmix64 rng;
-
-  for (std::size_t i = 0; i < 1000000u; ++i) {
-    boost::uint64_t f = rng();
-    boost::uint32_t d = static_cast<uint32_t>(rng());
-
-    boost::uint64_t r1 =
-      boost::unordered::detail::prime_fmod_size<>::get_remainder(f, d);
-
-    boost::uint64_t r2 = get_remainder(f, d);
-
-    if (!BOOST_TEST_EQ(r1, r2)) {
-      std::cerr << "f: " << f << ", d: " << d << std::endl;
-      return;
-    }
-  }
-#endif
-}
-
-void modulo_test()
-{
-  std::size_t* sizes = boost::unordered::detail::prime_fmod_size<>::sizes;
-
-  std::size_t const sizes_len =
-    boost::unordered::detail::prime_fmod_size<>::sizes_len;
-
-  boost::detail::splitmix64 rng;
-
-  for (std::size_t i = 0; i < 1000000u; ++i) {
-    std::size_t hash = static_cast<std::size_t>(rng());
-
-    for (std::size_t j = 0; j < sizes_len; ++j) {
-      std::size_t h = hash;
-
-#if defined(BOOST_UNORDERED_FCA_HAS_64B_SIZE_T)
-      if (sizes[j] <= UINT_MAX) {
-        h = boost::uint32_t(h) + boost::uint32_t(h >> 32);
-      }
-#endif
-      std::size_t p1 =
-        boost::unordered::detail::prime_fmod_size<>::position(hash, j);
-
-      std::size_t p2 = h % sizes[j];
-
-      if (!BOOST_TEST_EQ(p1, p2)) {
-        std::cerr << "hash: " << hash << ", j: " << j << ", h: " << h
-                  << ", sizes[" << j << "]: " << sizes[j] << std::endl;
-        return;
-      }
-    }
-  }
-}
-
-int main()
-{
-  macros_test();
-  prime_sizes_test();
-  get_remainder_test();
-  modulo_test();
-
-  return boost::report_errors();
-}
@@ -1,13 +1,12 @@

-// Copyright 2021-2022 Christian Mazakas.
+// Copyright 2021 Christian Mazakas.
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

 #include <boost/config.hpp>
 #include <boost/config/pragma_message.hpp>
-#include <boost/config/workaround.hpp>

-#if BOOST_CXX_VERSION <= 199711L || BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40800)
+#if BOOST_CXX_VERSION <= 199711L

 BOOST_PRAGMA_MESSAGE(
  "scoped allocator adaptor tests only work under C++11 and above")