From d8ef55d62c0ef3955bb886470800f964e01f2845 Mon Sep 17 00:00:00 2001
From: Stefan <29021710+Saalvage@users.noreply.github.com>
Date: Thu, 22 Jun 2023 18:01:18 +0200
Subject: [PATCH 001/134] Implement `<flat_set>` (#3817)

Co-authored-by: A. Jiang <23228989+frederick-vs-ja@users.noreply.github.com>
Co-authored-by: Stephan T. Lavavej <stl@nuwen.net>
Co-authored-by: Alex Guteniev <3995422+alexguteniev@users.noreply.github.com>
---
 stl/CMakeLists.txt                            |   1 +
 stl/inc/__msvc_all_public_headers.hpp         |   1 +
 stl/inc/flat_set                              | 721 ++++++++++++++++++
 stl/inc/header-units.json                     |   1 +
 stl/inc/yvals_core.h                          |   2 +
 stl/modules/std.ixx                           |   1 +
 .../include/test_header_units_and_modules.hpp |   8 +
 tests/std/test.lst                            |   1 +
 tests/std/tests/P1222R4_flat_set/env.lst      |   4 +
 tests/std/tests/P1222R4_flat_set/test.cpp     | 212 +++++
 .../importable_cxx_library_headers.jsonc      |   1 +
 .../test.cpp                                  |   1 +
 .../test.compile.pass.cpp                     |  14 +
 .../include_each_header_alone_matrix.lst      |   1 +
 14 files changed, 969 insertions(+)
 create mode 100644 stl/inc/flat_set
 create mode 100644 tests/std/tests/P1222R4_flat_set/env.lst
 create mode 100644 tests/std/tests/P1222R4_flat_set/test.cpp

diff --git a/stl/CMakeLists.txt b/stl/CMakeLists.txt
index b559f9c8336..1befa5febb8 100644
--- a/stl/CMakeLists.txt
+++ b/stl/CMakeLists.txt
@@ -156,6 +156,7 @@ set(HEADERS
     ${CMAKE_CURRENT_LIST_DIR}/inc/experimental/unordered_set
     ${CMAKE_CURRENT_LIST_DIR}/inc/experimental/vector
     ${CMAKE_CURRENT_LIST_DIR}/inc/filesystem
+    ${CMAKE_CURRENT_LIST_DIR}/inc/flat_set
     ${CMAKE_CURRENT_LIST_DIR}/inc/format
     ${CMAKE_CURRENT_LIST_DIR}/inc/forward_list
     ${CMAKE_CURRENT_LIST_DIR}/inc/fstream
diff --git a/stl/inc/__msvc_all_public_headers.hpp b/stl/inc/__msvc_all_public_headers.hpp
index ccb3267943a..248d8819dc2 100644
--- a/stl/inc/__msvc_all_public_headers.hpp
+++ b/stl/inc/__msvc_all_public_headers.hpp
@@ -92,6 +92,7 @@
 #include <exception>
 #include <expected>
 #include <filesystem>
+#include <flat_set>
 #include <format>
 #include <forward_list>
 #include <fstream>
diff --git a/stl/inc/flat_set b/stl/inc/flat_set
new file mode 100644
index 00000000000..67dc93c4da7
--- /dev/null
+++ b/stl/inc/flat_set
@@ -0,0 +1,721 @@
+// flat_set standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#pragma once
+#ifndef _FLAT_SET_
+#define _FLAT_SET_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#if !_HAS_CXX23 || !defined(__cpp_lib_concepts) // TRANSITION, GH-395
+_EMIT_STL_WARNING(STL4038, "The contents of <flat_set> are available only with C++23 or later.");
+#else // ^^^ not supported / supported language mode vvv
+#include <algorithm>
+#include <compare>
+#include <initializer_list>
+#include <vector>
+#include <xutility>
+
+_STD_BEGIN
+
+template <class _Ty>
+struct _NODISCARD _Clear_scope_guard {
+    _Ty* _Clearable;
+    ~_Clear_scope_guard() {
+        if (_Clearable) {
+            _Clearable->clear();
+        }
+    }
+};
+
+template <class _Alloc, class _Container>
+concept _Allocator_for = uses_allocator_v<_Container, _Alloc>;
+
+template <class _Kty, class _Keylt, class _Container, bool _Multi, class _Deriv, class _Tsorted>
+class _Base_flat_set {
+private:
+    static constexpr bool _Keylt_transparent = _Is_transparent_v<_Keylt>;
+
+public:
+    static_assert(same_as<_Kty, typename _Container::value_type>,
+        "The C++ Standard dictates that the Key type must be the "
+        "same as the container's value type [flatset.overview]");
+
+    using key_type               = _Kty;
+    using value_type             = _Kty;
+    using key_compare            = _Keylt;
+    using value_compare          = _Keylt;
+    using reference              = value_type&;
+    using const_reference        = const value_type&;
+    using size_type              = _Container::size_type;
+    using difference_type        = _Container::difference_type;
+    using iterator               = _Container::iterator;
+    using const_iterator         = _Container::const_iterator;
+    using reverse_iterator       = _STD reverse_iterator<iterator>;
+    using const_reverse_iterator = _STD reverse_iterator<const_iterator>;
+    using container_type         = _Container;
+
+    static_assert(random_access_iterator<iterator>, "The C++ Standard forbids containers without random "
+                                                    "access iterators from being adapted. See [flatset.overview].");
+
+    _Base_flat_set() : _My_pair(_Zero_then_variadic_args_t{}, _Keylt()) {}
+
+    explicit _Base_flat_set(container_type _Cont, const key_compare& _Comp = key_compare())
+        : _My_pair(_One_then_variadic_args_t{}, _STD move(_Cont), _Comp) {
+        _Make_invariants_fulfilled();
+    }
+    template <_Allocator_for<container_type> _Alloc>
+    _Base_flat_set(const container_type& _Cont, const _Alloc& _Al) : _Base_flat_set(container_type(_Cont, _Al)) {}
+    template <_Allocator_for<container_type> _Alloc>
+    _Base_flat_set(const container_type& _Cont, const key_compare& _Comp, const _Alloc& _Al)
+        : _Base_flat_set(container_type(_Cont, _Al), _Comp) {}
+
+    _Base_flat_set(_Tsorted, container_type _Cont, const key_compare& _Comp = key_compare())
+        : _My_pair(_One_then_variadic_args_t{}, _STD move(_Cont), _Comp) {
+        _Assert_after_sorted_input();
+    }
+    template <_Allocator_for<container_type> _Alloc>
+    _Base_flat_set(_Tsorted _Tsort, const container_type& _Cont, const _Alloc& _Al)
+        : _Base_flat_set(_Tsort, container_type(_Cont, _Al)) {}
+    template <_Allocator_for<container_type> _Alloc>
+    _Base_flat_set(_Tsorted _Tsort, const container_type& _Cont, const key_compare& _Comp, const _Alloc& _Al)
+        : _Base_flat_set(_Tsort, container_type(_Cont, _Al), _Comp) {}
+
+    explicit _Base_flat_set(const key_compare& _Comp) : _My_pair(_Zero_then_variadic_args_t{}, _Comp) {}
+    template <_Allocator_for<container_type> _Alloc>
+    _Base_flat_set(const key_compare& _Comp, const _Alloc& _Al) : _Base_flat_set(_Comp, container_type(_Al)) {}
+    template <_Allocator_for<container_type> _Alloc>
+    explicit _Base_flat_set(const _Alloc& _Al) : _Base_flat_set(container_type(_Al)) {}
+
+    template <input_iterator _Iter>
+    _Base_flat_set(_Iter _First, _Iter _Last, const key_compare& _Comp = key_compare())
+        : _Base_flat_set(container_type(_First, _Last), _Comp) {}
+    template <input_iterator _Iter, _Allocator_for<container_type> _Alloc>
+    _Base_flat_set(_Iter _First, _Iter _Last, const key_compare& _Comp, const _Alloc& _Al)
+        : _Base_flat_set(container_type(_First, _Last, _Al), _Comp) {}
+    template <input_iterator _Iter, _Allocator_for<container_type> _Alloc>
+    _Base_flat_set(_Iter _First, _Iter _Last, const _Alloc& _Al) : _Base_flat_set(container_type(_First, _Last, _Al)) {}
+
+    template <_Container_compatible_range<_Kty> _Rng>
+    _Base_flat_set(from_range_t, _Rng&& _Range, const key_compare& _Comp = key_compare())
+        : _Base_flat_set(container_type(from_range, _STD forward<_Rng>(_Range)), _Comp) {}
+    template <_Container_compatible_range<_Kty> _Rng, _Allocator_for<container_type> _Alloc>
+    _Base_flat_set(from_range_t, _Rng&& _Range, const _Alloc& _Al)
+        : _Base_flat_set(container_type(from_range, _STD forward<_Rng>(_Range), _Al)) {}
+    template <_Container_compatible_range<_Kty> _Rng, _Allocator_for<container_type> _Alloc>
+    _Base_flat_set(from_range_t, _Rng&& _Range, const key_compare& _Comp, const _Alloc& _Al)
+        : _Base_flat_set(container_type(from_range, _STD forward<_Rng>(_Range), _Al), _Comp) {}
+
+    template <input_iterator _Iter>
+    _Base_flat_set(_Tsorted _Tsort, _Iter _First, _Iter _Last, const key_compare& _Comp = key_compare())
+        : _Base_flat_set(_Tsort, container_type(_First, _Last), _Comp) {}
+    template <input_iterator _Iter, _Allocator_for<container_type> _Alloc>
+    _Base_flat_set(_Tsorted _Tsort, _Iter _First, _Iter _Last, const key_compare& _Comp, const _Alloc& _Al)
+        : _Base_flat_set(_Tsort, container_type(_First, _Last, _Al), _Comp) {}
+    template <input_iterator _Iter, _Allocator_for<container_type> _Alloc>
+    _Base_flat_set(_Tsorted _Tsort, _Iter _First, _Iter _Last, const _Alloc& _Al)
+        : _Base_flat_set(_Tsort, container_type(_First, _Last, _Al)) {}
+
+    _Base_flat_set(initializer_list<_Kty> _Ilist, const key_compare& _Comp = key_compare())
+        : _Base_flat_set(_Ilist.begin(), _Ilist.end(), _Comp) {}
+    template <_Allocator_for<container_type> _Alloc>
+    _Base_flat_set(initializer_list<_Kty> _Ilist, const key_compare& _Comp, const _Alloc& _Al)
+        : _Base_flat_set(container_type(_Ilist.begin(), _Ilist.end(), _Al), _Comp) {}
+    template <_Allocator_for<container_type> _Alloc>
+    _Base_flat_set(initializer_list<_Kty> _Ilist, const _Alloc& _Al)
+        : _Base_flat_set(container_type(_Ilist.begin(), _Ilist.end(), _Al)) {}
+
+    _Base_flat_set(_Tsorted _Tsort, initializer_list<_Kty> _Ilist, const key_compare& _Comp = key_compare())
+        : _Base_flat_set(_Tsort, _Ilist.begin(), _Ilist.end(), _Comp) {}
+    template <_Allocator_for<container_type> _Alloc>
+    _Base_flat_set(_Tsorted _Tsort, initializer_list<_Kty> _Ilist, const key_compare& _Comp, const _Alloc& _Al)
+        : _Base_flat_set(_Tsort, container_type(_Ilist.begin(), _Ilist.end(), _Al), _Comp) {}
+    template <_Allocator_for<container_type> _Alloc>
+    _Base_flat_set(_Tsorted _Tsort, initializer_list<_Kty> _Ilist, const _Alloc& _Al)
+        : _Base_flat_set(_Tsort, container_type(_Ilist.begin(), _Ilist.end(), _Al)) {}
+
+    _Deriv& operator=(initializer_list<_Kty> _Ilist) {
+        _Get_cont() = container_type(_Ilist.begin(), _Ilist.end());
+        _Make_invariants_fulfilled();
+        return static_cast<_Deriv&>(*this);
+    }
+
+    _NODISCARD iterator begin() noexcept {
+        return _Get_cont().begin();
+    }
+    _NODISCARD const_iterator begin() const noexcept {
+        return _Get_cont().begin();
+    }
+    _NODISCARD iterator end() noexcept {
+        return _Get_cont().end();
+    }
+    _NODISCARD const_iterator end() const noexcept {
+        return _Get_cont().end();
+    }
+    _NODISCARD reverse_iterator rbegin() noexcept {
+        return _Get_cont().rbegin();
+    }
+    _NODISCARD const_reverse_iterator rbegin() const noexcept {
+        return _Get_cont().rbegin();
+    }
+    _NODISCARD reverse_iterator rend() noexcept {
+        return _Get_cont().rend();
+    }
+    _NODISCARD const_reverse_iterator rend() const noexcept {
+        return _Get_cont().rend();
+    }
+    _NODISCARD const_iterator cbegin() const noexcept {
+        return _Get_cont().cbegin();
+    }
+    _NODISCARD const_iterator cend() const noexcept {
+        return _Get_cont().cend();
+    }
+    _NODISCARD const_reverse_iterator crbegin() const noexcept {
+        return _Get_cont().crbegin();
+    }
+    _NODISCARD const_reverse_iterator crend() const noexcept {
+        return _Get_cont().crend();
+    }
+
+    _NODISCARD_EMPTY_MEMBER bool empty() const noexcept {
+        return _Get_cont().empty();
+    }
+    _NODISCARD size_type size() const noexcept {
+        return _Get_cont().size();
+    }
+    _NODISCARD size_type max_size() const noexcept {
+        return _Get_cont().max_size();
+    }
+
+    template <class... _Args>
+    auto emplace(_Args&&... _Vals) {
+        insert<_Kty>(_Kty{_STD forward<_Args>(_Vals)...});
+    }
+
+    template <class... _Args>
+    iterator emplace_hint(const_iterator _Hint, _Args&&... _Vals) {
+        return _Emplace_hint(_Hint, _Kty{_STD forward<_Args>(_Vals)...});
+    }
+
+    auto insert(const value_type& _Val) {
+        return _Insert<_Kty>(_Val);
+    }
+    auto insert(value_type&& _Val) {
+        return _Insert(_STD move(_Val));
+    }
+
+    template <class _Other>
+        requires (!_Multi && _Keylt_transparent && is_constructible_v<_Kty, _Other>)
+    auto insert(_Other&& _Val) {
+        return _Insert(_STD forward<_Other>(_Val));
+    }
+
+    template <class _Other>
+        requires (!_Multi && _Keylt_transparent && is_constructible_v<_Kty, _Other>)
+    iterator insert(const_iterator _Hint, _Other&& _Val) {
+        return _Emplace_hint(_Hint, _STD forward<_Other>(_Val));
+    }
+
+    iterator insert(const_iterator _Hint, const value_type& _Val) {
+        return _Emplace_hint(_Hint, _Val);
+    }
+    iterator insert(const_iterator _Hint, value_type&& _Val) {
+        return _Emplace_hint(_Hint, _STD move(_Val));
+    }
+
+    template <input_iterator _Iter>
+    void insert(const _Iter& _First, const _Iter& _Last) {
+        _Insert_range<false>(_First, _Last);
+    }
+
+    template <input_iterator _Iter>
+    void insert(_Tsorted, _Iter _First, _Iter _Last) {
+        _Insert_range<true>(_First, _Last);
+    }
+
+    template <_Container_compatible_range<_Kty> _Rng>
+    void insert_range(_Rng&& _Range) {
+        const size_type _Old_size = size();
+        _Get_cont().append_range(_STD forward<_Rng>(_Range));
+        _Restore_invariants_after_insert<false>(_Old_size);
+    }
+
+    _NODISCARD container_type extract() && {
+        // The container NEEDS to be cleared no matter what,
+        // which is not guaranteed by simply moving it away
+        // ("... valid but unspecified ...")
+        container_type& _Cont = _Get_cont();
+        _Clear_scope_guard _Guard{this};
+        container_type _Temp = _STD move(_Cont);
+        return _Temp;
+    }
+
+    void replace(container_type&& _Cont) {
+        _Get_cont() = _STD move(_Cont);
+        _Assert_after_sorted_input();
+    }
+
+    iterator erase(iterator _Where) {
+        return _Get_cont().erase(_Where);
+    }
+    iterator erase(const_iterator _Where) {
+        return _Get_cont().erase(_Where);
+    }
+    size_type erase(const _Kty& _Val) {
+        return _Erase(_Val);
+    }
+
+    template <class _Other>
+        requires _Keylt_transparent
+    size_type erase(_Other&& _Val) {
+        return _Erase(_STD forward<_Other>(_Val));
+    }
+
+    iterator erase(const_iterator _First, const_iterator _Last) {
+        return _Get_cont().erase(_First, _Last);
+    }
+
+    void swap(_Deriv& _Other) noexcept {
+        _RANGES swap(_Get_comp(), _Other._Get_comp());
+        _RANGES swap(_Get_cont(), _Other._Get_cont());
+    }
+
+    void clear() noexcept {
+        _Get_cont().clear();
+    }
+
+    _NODISCARD key_compare key_comp() const {
+        return _Get_comp();
+    }
+    _NODISCARD value_compare value_comp() const {
+        return _Get_comp();
+    }
+
+    _NODISCARD iterator find(const _Kty& _Val) {
+        return _Find(_Val);
+    }
+
+    _NODISCARD const_iterator find(const _Kty& _Val) const {
+        return _Find(_Val);
+    }
+
+    template <class _Other>
+        requires _Keylt_transparent
+    _NODISCARD iterator find(const _Other& _Val) {
+        return _Find(_Val);
+    }
+
+    template <class _Other>
+        requires _Keylt_transparent
+    _NODISCARD const_iterator find(const _Other& _Val) const {
+        return _Find(_Val);
+    }
+
+    _NODISCARD size_type count(const _Kty& _Val) const {
+        const auto [_First, _Last] = equal_range(_Val);
+        return _STD distance(_First, _Last);
+    }
+
+    template <class _Other>
+        requires _Keylt_transparent
+    _NODISCARD size_type count(const _Other& _Val) const {
+        const auto [_First, _Last] = equal_range(_Val);
+        return _STD distance(_First, _Last);
+    }
+
+    _NODISCARD bool contains(const _Kty& _Val) const {
+        return find(_Val) != end();
+    }
+    template <class _Other>
+        requires _Keylt_transparent
+    _NODISCARD bool contains(const _Other& _Val) const {
+        return find(_Val) != end();
+    }
+    _NODISCARD iterator lower_bound(const _Kty& _Val) {
+        return _STD lower_bound(begin(), end(), _Val, _Get_comp());
+    }
+    _NODISCARD const_iterator lower_bound(const _Kty& _Val) const {
+        return _STD lower_bound(cbegin(), cend(), _Val, _Get_comp());
+    }
+
+    template <class _Other>
+        requires _Keylt_transparent
+    _NODISCARD iterator lower_bound(const _Other& _Val) {
+        return _STD lower_bound(begin(), end(), _Val, _Get_comp());
+    }
+
+    template <class _Other>
+        requires _Keylt_transparent
+    _NODISCARD const_iterator lower_bound(const _Other& _Val) const {
+        return _STD lower_bound(cbegin(), cend(), _Val, _Get_comp());
+    }
+
+    _NODISCARD iterator upper_bound(const _Kty& _Val) {
+        return _STD upper_bound(begin(), end(), _Val, _Get_comp());
+    }
+
+    _NODISCARD const_iterator upper_bound(const _Kty& _Val) const {
+        return _STD upper_bound(cbegin(), cend(), _Val, _Get_comp());
+    }
+
+    template <class _Other>
+        requires _Keylt_transparent
+    _NODISCARD iterator upper_bound(const _Other& _Val) {
+        return _STD upper_bound(begin(), end(), _Val, _Get_comp());
+    }
+
+    template <class _Other>
+        requires _Keylt_transparent
+    _NODISCARD const_iterator upper_bound(const _Other& _Val) const {
+        return _STD upper_bound(cbegin(), cend(), _Val, _Get_comp());
+    }
+
+    _NODISCARD pair<iterator, iterator> equal_range(const _Kty& _Val) {
+        return _STD equal_range(begin(), end(), _Val, _Get_comp());
+    }
+
+    _NODISCARD pair<const_iterator, const_iterator> equal_range(const _Kty& _Val) const {
+        return _STD equal_range(cbegin(), cend(), _Val, _Get_comp());
+    }
+
+    template <class _Other>
+        requires _Keylt_transparent
+    _NODISCARD pair<iterator, iterator> equal_range(const _Other& _Val) {
+        return _STD equal_range(begin(), end(), _Val, _Get_comp());
+    }
+
+    template <class _Other>
+        requires _Keylt_transparent
+    _NODISCARD pair<const_iterator, const_iterator> equal_range(const _Other& _Val) const {
+        return _STD equal_range(cbegin(), cend(), _Val, _Get_comp());
+    }
+
+    _NODISCARD friend bool operator==(const _Deriv& _Lhs, const _Deriv& _Rhs) {
+        return _RANGES equal(_Lhs, _Rhs);
+    }
+
+    _NODISCARD friend _Synth_three_way_result<_Kty> operator<=>(const _Deriv& _Lhs, const _Deriv& _Rhs) {
+        return _STD lexicographical_compare_three_way(
+            _Lhs.cbegin(), _Lhs.cend(), _Rhs.cbegin(), _Rhs.cend(), _Synth_three_way{});
+    }
+
+    friend void swap(_Deriv& _Lhs, _Deriv& _Rhs) noexcept {
+        _Lhs.swap(_Rhs);
+    }
+
+private:
+    void inline _Assert_after_sorted_input() const {
+        _STL_ASSERT(_STD is_sorted(begin(), end(), _Get_comp()), "Input was not sorted!");
+        if constexpr (!_Multi) {
+            _STL_ASSERT(_Is_unique(), "Input was not unique!");
+        }
+    }
+
+    bool _Is_unique() const {
+        if (empty()) {
+            return true;
+        }
+        const_iterator _End = cend();
+        const_iterator _It  = begin();
+        while (++_It != _End) {
+            if (_Keys_equal(*(_It - 1), *_It)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    template <class _Ty>
+        requires (_Keylt_transparent && is_constructible_v<_Kty, _Ty>) || is_same_v<_Ty, _Kty>
+    void _Emplace_hint(const_iterator _Where, _Ty&& _Val) {
+        _Container& _Cont     = _Get_cont();
+        _Keylt& _Compare      = _Get_comp();
+        const iterator _Begin = begin();
+        const iterator _End   = end();
+
+        if (_Where == _End || !_Compare(*_Where, _Val)) {
+            // _Val <= *_Where
+            // Left of _Where
+            if (_Where == _Begin || !_Compare(_Val, *(_Where - 1))) {
+                // _Val >= (*_Where - 1)
+                // Insert before _Where
+            } else {
+                // _Val < (*_Where - 1)
+                _Where = _STD upper_bound(_Begin, _Where, _Val, _Compare);
+            }
+        } else {
+            // _Val > *_Where
+            // Right of _Where
+            _Where = _STD lower_bound(_Where + 1, _End, _Val, _Compare);
+        }
+
+        if constexpr (_Multi) {
+            return _Cont.insert(_Where, _STD forward<_Ty>(_Val));
+        } else {
+            if (_Where == _End || !_Keys_equal(_Val, *_Where)) {
+                return _Cont.insert(_Where, _STD forward<_Ty>(_Val));
+            }
+            return _Where;
+        }
+    }
+
+    template <bool _Presorted, class _Iter>
+    void _Insert_range(_Iter _First, _Iter _Last) {
+        const size_type _Old_size = size();
+        _Container& _Cont         = _Get_cont();
+        _Cont.insert(_Cont.end(), _First, _Last);
+        _Restore_invariants_after_insert<_Presorted>(_Old_size);
+    }
+
+    template <class _Ty>
+        requires (!_Multi && _Keylt_transparent && is_constructible_v<_Kty, _Ty>) || is_same_v<_Ty, _Kty>
+    auto _Insert(_Ty&& _Val) {
+        _Container& _Cont     = _Get_cont();
+        const iterator _End   = end();
+        const iterator _Where = lower_bound(_Val);
+        if constexpr (_Multi) {
+            return _Cont.emplace(_Where, _STD forward<_Ty>(_Val));
+        } else {
+            if (_Where != _End && _Keys_equal(*_Where, _Val)) {
+                return pair{_Where, false};
+            }
+            return pair{_Cont.emplace(_Where, _STD forward<_Ty>(_Val)), true};
+        }
+    }
+
+    template <class _Ty>
+        requires _Keylt_transparent || is_same_v<_Ty, _Kty>
+    size_type _Erase(_Ty&& _Val) {
+        const auto [_First, _Last] = equal_range(_Val);
+
+        const difference_type _Removed = _STD distance(_First, _Last);
+        _Get_cont().erase(_First, _Last);
+        return _Removed;
+    }
+
+    template <class _Other>
+        requires _Keylt_transparent || is_same_v<_Other, _Kty>
+    _NODISCARD iterator _Find(const _Other& _Val) {
+        const iterator _End   = end();
+        const iterator _Where = lower_bound(_Val);
+        if (_Where != _End && _Keys_equal(*_Where, _Val)) {
+            return _Where;
+        } else {
+            return _End;
+        }
+    }
+
+    template <class _Other>
+        requires _Keylt_transparent || is_same_v<_Other, _Kty>
+    _NODISCARD const_iterator _Find(const _Other& _Val) const {
+        const iterator _End   = end();
+        const iterator _Where = lower_bound(_Val);
+        if (_Where != _End && _Keys_equal(*_Where, _Val)) {
+            return _Where;
+        } else {
+            return _End;
+        }
+    }
+
+    template <class _Lhty, class _Rhty>
+        requires _Keylt_transparent || (is_same_v<_Kty, _Lhty> && is_same_v<_Lhty, _Rhty>)
+    _NODISCARD bool _Keys_equal(const _Lhty& _Lhs, const _Rhty& _Rhs) const {
+        const key_compare& _Compare = _Get_comp();
+        return !_Compare(_Lhs, _Rhs) && !_Compare(_Rhs, _Lhs);
+    }
+
+    // O(N) if already sorted.
+    void _Sort_potentially_sorted(const iterator& _Begin, const iterator& _End) {
+        key_compare& _Compare          = _Get_comp();
+        const iterator _Begin_unsorted = _STD is_sorted_until(_Begin, _End, _Compare);
+
+        _STD sort(_Begin_unsorted, _End, _Compare);
+
+        _STD inplace_merge(begin(), _Begin_unsorted, _End, _Compare);
+    }
+
+    void _Erase_dupes_if_needed() {
+        if constexpr (!_Multi) {
+            iterator _End = end();
+            iterator _New_end =
+                _STD unique(begin(), _End, [&](const _Kty& _Lhs, const _Kty& _Rhs) { return _Keys_equal(_Lhs, _Rhs); });
+            _Get_cont().erase(_New_end, _End);
+        }
+        if constexpr (!_Multi) {
+            _STL_INTERNAL_CHECK(_Is_unique());
+        }
+    }
+
+    template <bool _Presorted>
+    void _Restore_invariants_after_insert(const size_type& _Old_size) {
+        key_compare& _Compare   = _Get_comp();
+        const iterator _Old_end = begin() + static_cast<difference_type>(_Old_size);
+        const iterator _New_end = end();
+
+        if constexpr (!_Presorted) {
+            _STD sort(_Old_end, _New_end, _Compare);
+        } else {
+            _STL_ASSERT(_STD is_sorted(_Old_end, _New_end, _Compare), "Input was not sorted!");
+        }
+
+        _STD inplace_merge(begin(), _Old_end, _New_end, _Compare);
+
+        _STL_INTERNAL_CHECK(_STD is_sorted(begin(), end(), _Get_comp()));
+
+        _Erase_dupes_if_needed();
+    }
+
+    void _Make_invariants_fulfilled() {
+        const iterator _Begin = begin();
+        const iterator _End   = end();
+
+        if (_Begin == _End) {
+            return;
+        }
+
+        _Sort_potentially_sorted(_Begin, _End);
+        _STL_INTERNAL_CHECK(_STD is_sorted(begin(), end(), _Get_comp()));
+
+        _Erase_dupes_if_needed();
+    }
+
+    _NODISCARD const _Container& _Get_cont() const noexcept {
+        return _My_pair._Get_first();
+    }
+
+    _NODISCARD _Container& _Get_cont() noexcept {
+        return _My_pair._Get_first();
+    }
+
+    _NODISCARD const key_compare& _Get_comp() const noexcept {
+        return _My_pair._Myval2;
+    }
+
+    _NODISCARD key_compare& _Get_comp() noexcept {
+        return _My_pair._Myval2;
+    }
+
+    _Compressed_pair<container_type, key_compare> _My_pair;
+};
+
+_EXPORT_STD struct sorted_unique_t {
+    explicit sorted_unique_t() = default;
+};
+_EXPORT_STD inline constexpr sorted_unique_t sorted_unique{};
+
+_EXPORT_STD struct sorted_equivalent_t {
+    explicit sorted_equivalent_t() = default;
+};
+_EXPORT_STD inline constexpr sorted_equivalent_t sorted_equivalent{};
+
+_EXPORT_STD template <class _Kty, class _Keylt = less<_Kty>, class _Container = vector<_Kty>>
+class flat_set
+    : public _Base_flat_set<_Kty, _Keylt, _Container, false, flat_set<_Kty, _Keylt, _Container>, sorted_unique_t> {
+public:
+    using _Base_flat_set<_Kty, _Keylt, _Container, false, flat_set, sorted_unique_t>::_Base_flat_set;
+};
+
+_EXPORT_STD template <class _Kty, class _Keylt = less<_Kty>, class _Container = vector<_Kty>>
+class flat_multiset : public _Base_flat_set<_Kty, _Keylt, _Container, true, flat_multiset<_Kty, _Keylt, _Container>,
+                          sorted_equivalent_t> {
+public:
+    using _Base_flat_set<_Kty, _Keylt, _Container, true, flat_multiset, sorted_equivalent_t>::_Base_flat_set;
+};
+
+_EXPORT_STD template <class _Kty, class _Keylt, class _Container, class _Pred>
+size_t erase_if(flat_set<_Kty, _Keylt, _Container>& _Val, _Pred _Predicate) {
+    _Clear_scope_guard _Guard{&_Val};
+    return _Erase_remove_if(_Val, _Pass_fn(_Predicate));
+}
+
+_EXPORT_STD template <class _Kty, class _Keylt, class _Container, class _Pred>
+size_t erase_if(flat_multiset<_Kty, _Keylt, _Container>& _Val, _Pred _Predicate) {
+    _Clear_scope_guard _Guard{&_Val};
+    return _Erase_remove_if(_Val, _Pass_fn(_Predicate));
+}
+
+template <class _Kty, class _Keylt, class _Container, class _Alloc>
+struct uses_allocator<flat_set<_Kty, _Keylt, _Container>, _Alloc>
+    : bool_constant<uses_allocator_v<_Container, _Alloc>> {};
+
+template <class _Kty, class _Keylt, class _Container, class _Alloc>
+struct uses_allocator<flat_multiset<_Kty, _Keylt, _Container>, _Alloc>
+    : bool_constant<uses_allocator_v<_Container, _Alloc>> {};
+
+template <class _Container, class _Keylt = less<typename _Container::value_type>>
+flat_set(_Container, _Keylt = _Keylt()) -> flat_set<typename _Container::value_type, _Keylt, _Container>;
+template <class _Container, class _Alloc>
+flat_set(_Container, _Alloc)
+    -> flat_set<typename _Container::value_type, less<typename _Container::value_type>, _Container>;
+template <class _Container, class _Keylt, class _Alloc>
+flat_set(_Container, _Keylt, _Alloc) -> flat_set<typename _Container::value_type, _Keylt, _Container>;
+
+template <class _Container, class _Keylt = less<typename _Container::value_type>>
+flat_set(sorted_unique_t, _Container, _Keylt = _Keylt())
+    -> flat_set<typename _Container::value_type, _Keylt, _Container>;
+template <class _Container, class _Alloc>
+flat_set(sorted_unique_t, _Container, _Alloc)
+    -> flat_set<typename _Container::value_type, less<typename _Container::value_type>, _Container>;
+template <class _Container, class _Keylt, class _Alloc>
+flat_set(sorted_unique_t, _Container, _Keylt, _Alloc) -> flat_set<typename _Container::value_type, _Keylt, _Container>;
+
+template <class _Iter, class _Keylt = less<iter_value_t<_Iter>>>
+flat_set(_Iter, _Iter, _Keylt = _Keylt()) -> flat_set<iter_value_t<_Iter>, _Keylt>;
+template <class _Iter, class _Keylt = less<iter_value_t<_Iter>>>
+flat_set(sorted_unique_t, _Iter, _Iter, _Keylt = _Keylt()) -> flat_set<iter_value_t<_Iter>, _Keylt>;
+template <_RANGES input_range _Range, class _Keylt = less<_RANGES range_value_t<_Range>>,
+    class _Alloc = allocator<_RANGES range_value_t<_Range>>>
+flat_set(from_range_t, _Range&&, _Keylt = _Keylt(), _Alloc = _Alloc()) -> flat_set<_RANGES range_value_t<_Range>,
+    _Keylt, vector<_RANGES range_value_t<_Range>, _Rebind_alloc_t<_Alloc, _RANGES range_value_t<_Range>>>>;
+template <_RANGES input_range _Range, class _Alloc>
+flat_set(from_range_t, _Range&&, _Alloc) -> flat_set<_RANGES range_value_t<_Range>, less<_RANGES range_value_t<_Range>>,
+    vector<_RANGES range_value_t<_Range>, _Rebind_alloc_t<_Alloc, _RANGES range_value_t<_Range>>>>;
+template <class _Kty, class _Keylt = less<_Kty>>
+flat_set(initializer_list<_Kty>, _Keylt = _Keylt()) -> flat_set<_Kty, _Keylt>;
+template <class _Kty, class _Keylt = less<_Kty>>
+flat_set(sorted_unique_t, initializer_list<_Kty>, _Keylt = _Keylt()) -> flat_set<_Kty, _Keylt>;
+
+
+template <class _Container, class _Keylt = less<typename _Container::value_type>>
+flat_multiset(_Container, _Keylt = _Keylt()) -> flat_multiset<typename _Container::value_type, _Keylt, _Container>;
+template <class _Container, class _Alloc>
+flat_multiset(_Container, _Alloc)
+    -> flat_multiset<typename _Container::value_type, less<typename _Container::value_type>, _Container>;
+template <class _Container, class _Keylt, class _Alloc>
+flat_multiset(_Container, _Keylt, _Alloc) -> flat_multiset<typename _Container::value_type, _Keylt, _Container>;
+
+template <class _Container, class _Keylt = less<typename _Container::value_type>>
+flat_multiset(sorted_equivalent_t, _Container, _Keylt = _Keylt())
+    -> flat_multiset<typename _Container::value_type, _Keylt, _Container>;
+template <class _Container, class _Alloc>
+flat_multiset(sorted_equivalent_t, _Container, _Alloc)
+    -> flat_multiset<typename _Container::value_type, less<typename _Container::value_type>, _Container>;
+template <class _Container, class _Keylt, class _Alloc>
+flat_multiset(sorted_equivalent_t, _Container, _Keylt, _Alloc)
+    -> flat_multiset<typename _Container::value_type, _Keylt, _Container>;
+
+template <class _Iter, class _Keylt = less<iter_value_t<_Iter>>>
+flat_multiset(_Iter, _Iter, _Keylt = _Keylt()) -> flat_multiset<iter_value_t<_Iter>, iter_value_t<_Iter>, _Keylt>;
+template <class _Iter, class _Keylt = less<iter_value_t<_Iter>>>
+flat_multiset(sorted_equivalent_t, _Iter, _Iter, _Keylt = _Keylt())
+    -> flat_multiset<iter_value_t<_Iter>, iter_value_t<_Iter>, _Keylt>;
+template <_RANGES input_range _Range, class _Keylt = less<_RANGES range_value_t<_Range>>,
+    class _Alloc = allocator<_RANGES range_value_t<_Range>>>
+flat_multiset(from_range_t, _Range&&, _Keylt = _Keylt(), _Alloc = _Alloc())
+    -> flat_multiset<_RANGES range_value_t<_Range>, _Keylt,
+        vector<_RANGES range_value_t<_Range>, _Rebind_alloc_t<_Alloc, _RANGES range_value_t<_Range>>>>;
+template <_RANGES input_range _Range, class _Alloc>
+flat_multiset(from_range_t, _Range&&, _Alloc)
+    -> flat_multiset<_RANGES range_value_t<_Range>, less<_RANGES range_value_t<_Range>>,
+        vector<_RANGES range_value_t<_Range>, _Rebind_alloc_t<_Alloc, _RANGES range_value_t<_Range>>>>;
+template <class _Kty, class _Keylt = less<_Kty>>
+flat_multiset(initializer_list<_Kty>, _Keylt = _Keylt()) -> flat_multiset<_Kty, _Keylt>;
+template <class _Kty, class _Keylt = less<_Kty>>
+flat_multiset(sorted_equivalent_t, initializer_list<_Kty>, _Keylt = _Keylt()) -> flat_multiset<_Kty, _Keylt>;
+
+_STD_END
+
+#endif // ^^^ supported language mode ^^^
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _FLAT_SET_
diff --git a/stl/inc/header-units.json b/stl/inc/header-units.json
index 0966ec2accf..f4e4048b3b7 100644
--- a/stl/inc/header-units.json
+++ b/stl/inc/header-units.json
@@ -63,6 +63,7 @@
         "execution",
         "expected",
         "filesystem",
+        "flat_set",
         "format",
         "forward_list",
         "fstream",
diff --git a/stl/inc/yvals_core.h b/stl/inc/yvals_core.h
index ceb2fce5ed8..761d5e2291d 100644
--- a/stl/inc/yvals_core.h
+++ b/stl/inc/yvals_core.h
@@ -316,6 +316,7 @@
 // P1132R7 out_ptr(), inout_ptr()
 // P1147R1 Printing volatile Pointers
 // P1206R7 Conversions From Ranges To Containers
+// P1222R4 <flat_set>
 // P1223R5 ranges::find_last, ranges::find_last_if, ranges::find_last_if_not
 // P1272R4 byteswap()
 // P1328R1 constexpr type_info::operator==()
@@ -1722,6 +1723,7 @@ _EMIT_STL_ERROR(STL1004, "C++98 unexpected() is incompatible with C++23 unexpect
 #ifdef __cpp_lib_concepts
 #define __cpp_lib_containers_ranges 202202L
 #define __cpp_lib_expected          202211L
+#define __cpp_lib_flat_set          202207L
 #endif // __cpp_lib_concepts
 
 #define __cpp_lib_forward_like   202207L
diff --git a/stl/modules/std.ixx b/stl/modules/std.ixx
index 326d944d74f..cfae4e6fc95 100644
--- a/stl/modules/std.ixx
+++ b/stl/modules/std.ixx
@@ -59,6 +59,7 @@ export module std;
 #include <execution>
 #include <expected>
 #include <filesystem>
+#include <flat_set>
 #include <format>
 #include <forward_list>
 #include <fstream>
diff --git a/tests/std/include/test_header_units_and_modules.hpp b/tests/std/include/test_header_units_and_modules.hpp
index ce362844dc7..6710a8e7099 100644
--- a/tests/std/include/test_header_units_and_modules.hpp
+++ b/tests/std/include/test_header_units_and_modules.hpp
@@ -234,6 +234,13 @@ void test_filesystem() {
     assert(info.capacity != static_cast<decltype(info.capacity)>(-1));
 }
 
+void test_flat_set() {
+    using namespace std;
+    puts("Testing <flat_set>.");
+
+    // FIXME! ADD TEST COVERAGE HERE!
+}
+
 void test_format() {
     using namespace std;
     puts("Testing <format>.");
@@ -1082,6 +1089,7 @@ void all_cpp_header_tests() {
     test_execution();
     test_expected();
     test_filesystem();
+    test_flat_set();
     test_format();
     test_forward_list();
     test_fstream();
diff --git a/tests/std/test.lst b/tests/std/test.lst
index 822cf153b82..0c0c4e860f9 100644
--- a/tests/std/test.lst
+++ b/tests/std/test.lst
@@ -542,6 +542,7 @@ tests\P1206R7_vector_assign_range
 tests\P1206R7_vector_from_range
 tests\P1206R7_vector_insert_range
 tests\P1208R6_source_location
+tests\P1222R4_flat_set
 tests\P1223R5_ranges_alg_find_last
 tests\P1223R5_ranges_alg_find_last_if
 tests\P1223R5_ranges_alg_find_last_if_not
diff --git a/tests/std/tests/P1222R4_flat_set/env.lst b/tests/std/tests/P1222R4_flat_set/env.lst
new file mode 100644
index 00000000000..18e2d7c71ec
--- /dev/null
+++ b/tests/std/tests/P1222R4_flat_set/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\concepts_latest_matrix.lst
diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
new file mode 100644
index 00000000000..6a3ae2e1223
--- /dev/null
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -0,0 +1,212 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <cassert>
+#include <deque>
+#include <flat_set>
+#include <functional>
+#include <iostream>
+#include <vector>
+
+using namespace std;
+using namespace ranges;
+
+template <class T>
+void assert_container_requirements(const T& s) {
+    T m = s;
+    assert(m == s);
+
+    static_assert(is_same_v<decltype(m = s), T&>);
+    static_assert(is_same_v<decltype(m = std::move(m)), T&>);
+    static_assert(is_same_v<decltype(m.begin()), typename T::iterator>);
+    static_assert(is_same_v<decltype(m.end()), typename T::iterator>);
+    static_assert(is_same_v<decltype(s.cbegin()), typename T::const_iterator>);
+    static_assert(is_same_v<decltype(m.cend()), typename T::const_iterator>);
+    static_assert(is_convertible_v<typename T::iterator, typename T::const_iterator>);
+    static_assert(is_same_v<decltype(m.begin() <=> m.end()), strong_ordering>);
+    static_assert(is_same_v<decltype(s.size()), typename T::size_type>);
+    static_assert(is_same_v<decltype(s.max_size()), typename T::size_type>);
+    static_assert(is_same_v<decltype(*m.begin()), typename T::value_type&>);
+    static_assert(is_same_v<decltype(*m.cbegin()), const typename T::value_type&>);
+
+    T my_moved = std::move(m);
+    assert(!(my_moved != s));
+
+    T empty{};
+    assert(empty.empty());
+
+    T non_empty = s;
+    empty.swap(non_empty);
+    assert(non_empty.empty());
+    assert(empty == s);
+
+    std::swap(empty, non_empty);
+    assert(empty.empty());
+    assert(non_empty == s);
+
+    assert(s.cbegin() <= s.cend());
+    assert(s.cbegin() < s.cend() || s.empty());
+
+    assert(m.begin() <= m.end());
+    assert(m.begin() < m.end() || m.empty());
+
+    assert(static_cast<typename T::size_type>(s.cend() - s.cbegin()) == s.size());
+}
+
+template <class T>
+void assert_reversible_container_requirements(const T& s) {
+    static_assert(is_same_v<reverse_iterator<typename T::iterator>, typename T::reverse_iterator>);
+    static_assert(is_same_v<reverse_iterator<typename T::const_iterator>, typename T::const_reverse_iterator>);
+    static_assert(is_same_v<decltype(T{}.rbegin()), typename T::reverse_iterator>);
+    static_assert(is_same_v<decltype(T{}.rend()), typename T::reverse_iterator>);
+    static_assert(is_same_v<decltype(s.crbegin()), typename T::const_reverse_iterator>);
+    static_assert(is_same_v<decltype(s.crend()), typename T::const_reverse_iterator>);
+    static_assert(is_convertible_v<typename T::reverse_iterator, typename T::const_reverse_iterator>);
+}
+
+template <class T>
+void assert_all_requirements_and_equals(const T& s, const initializer_list<typename T::value_type>& il) {
+    assert_container_requirements(s);
+    assert_reversible_container_requirements(s);
+
+    auto val_comp = s.value_comp();
+    auto begin_it = s.cbegin();
+    auto end_it   = s.cend();
+    assert(std::is_sorted(begin_it, end_it, val_comp));
+    if constexpr (!_Is_specialization_v<T, flat_multiset>) {
+        if (!s.empty()) {
+            auto it = begin_it;
+            while (++it != end_it) {
+                assert(val_comp(*(it - 1), *it));
+            }
+        }
+    }
+
+    if (s.size() != il.size() || !std::equal(s.begin(), s.end(), il.begin())) {
+        cout << "Expected: {";
+        for (auto&& e : il) {
+            cout << e << ", ";
+        }
+        cout << "}" << endl;
+        cout << "Got:      {";
+        for (auto&& e : s) {
+            cout << e << ", ";
+        }
+        cout << "}" << endl;
+        assert(false);
+    }
+}
+
+template <class T>
+void assert_basic() {
+    T s{3, 2, 2, 2, 1};
+    assert_all_requirements_and_equals(s, {1, 2, 3});
+
+    s.insert(43);
+    assert_all_requirements_and_equals(s, {1, 2, 3, 43});
+
+    int my_ints[] = {1, 2, 3, 4, 55};
+    s.insert_range(my_ints);
+    assert_all_requirements_and_equals(s, {1, 2, 3, 4, 43, 55});
+}
+
+template <class C>
+void test_constructors() {
+    using lt = std::less<int>;
+    using gt = std::greater<int>;
+
+    assert_all_requirements_and_equals(flat_set<int, lt, C>(), {});
+    assert_all_requirements_and_equals(flat_multiset<int, lt, C>(), {});
+    assert_all_requirements_and_equals(flat_set<int, lt, C>(C{3, 7, 1, 85, 222, 1}), {1, 3, 7, 85, 222});
+    assert_all_requirements_and_equals(flat_multiset<int, lt, C>(C{3, 7, 1, 85, 7, 222, 1}), {1, 1, 3, 7, 7, 85, 222});
+    assert_all_requirements_and_equals(flat_set<int, gt, C>(C{1, 2, 3, 3}, gt()), {3, 2, 1});
+    assert_all_requirements_and_equals(flat_multiset<int, gt, C>(C{1, 1, 2, 3}, gt()), {3, 2, 1, 1});
+    assert_all_requirements_and_equals(flat_set<int, gt, C>(sorted_unique, C{30000, 200, 1}, gt()), {30000, 200, 1});
+    assert_all_requirements_and_equals(flat_multiset<int, gt, C>(sorted_equivalent, C{3, 3, -1}, gt()), {3, 3, -1});
+    assert_all_requirements_and_equals(flat_set<int, gt, C>({30000, 200, 1}, gt()), {30000, 200, 1});
+    assert_all_requirements_and_equals(flat_multiset<int, gt, C>({3, 3, -1}, gt()), {3, 3, -1});
+    assert_all_requirements_and_equals(flat_set<int, gt, C>(sorted_unique, {30000, 200, 1}, gt()), {30000, 200, 1});
+    assert_all_requirements_and_equals(flat_multiset<int, gt, C>(sorted_equivalent, {3, 3, -1}, gt()), {3, 3, -1});
+
+    flat_set<int> a{};
+    a = {1, 7, 7, 7, 2, 100, -1};
+    assert_all_requirements_and_equals(a, {-1, 1, 2, 7, 100});
+    flat_multiset<int> b{};
+    b = {1, 7, 7, 7, 2, 100, -1};
+    assert_all_requirements_and_equals(b, {-1, 1, 2, 7, 7, 7, 100});
+}
+
+template <class T>
+void test_spaceship_operator() {
+    static constexpr bool multi  = _Is_specialization_v<T, flat_multiset>;
+    static constexpr bool invert = is_same_v<typename T::key_compare, std::greater<typename T::key_type>>;
+
+    T a{3, 2, 2, 1};
+    T b{1, 2, 3};
+    assert((a <=> b) == (multi ? (invert ? strong_ordering::greater : strong_ordering::less) : strong_ordering::equal));
+
+    T c{3, 2};
+    assert((c <=> b) == (invert ? strong_ordering::less : strong_ordering::greater));
+
+    T d{5, 6, 7, 7, 8, 9};
+    T e{5, 6, 7, 8, 100};
+    assert((d <=> e) == strong_ordering::less);
+
+    T f{1, 2, 3, 4};
+    assert((f <=> a) == strong_ordering::greater);
+}
+
+template <class T>
+struct proxy_comparer {
+    bool operator()(const T& lhs, const T& rhs) const {
+        return m_less ? (lhs < rhs) : (lhs > rhs);
+    }
+
+    bool m_less = true;
+};
+
+void test_non_static_comparer() {
+    flat_set<int, proxy_comparer<int>> a{3, 2, 2, 1};
+    assert_all_requirements_and_equals(a, {1, 2, 3});
+    auto b = flat_set<int, proxy_comparer<int>>({-1, 5, 9, 9, 9, 9, 9}, proxy_comparer<int>{.m_less = false});
+    assert_all_requirements_and_equals(b, {9, 5, -1});
+
+    auto aBackup = a;
+    a            = b;
+    assert_all_requirements_and_equals(a, {9, 5, -1});
+    a.insert_range(vector{7, 7, 3, 3, 2});
+    assert_all_requirements_and_equals(a, {9, 7, 5, 3, 2, -1});
+
+    a = std::move(aBackup);
+    assert_all_requirements_and_equals(a, {1, 2, 3});
+
+    a.insert(-100);
+    assert_all_requirements_and_equals(a, {-100, 1, 2, 3});
+
+    a = b;
+    assert_all_requirements_and_equals(a, {9, 5, -1});
+
+    a.insert(7);
+    assert_all_requirements_and_equals(a, {9, 7, 5, -1});
+}
+
+int main() {
+    test_spaceship_operator<flat_set<int>>();
+    test_spaceship_operator<flat_multiset<int>>();
+    test_spaceship_operator<flat_set<int, std::greater<int>>>();
+    test_spaceship_operator<flat_multiset<int, std::greater<int>>>();
+    test_spaceship_operator<flat_set<int, std::less<int>, deque<int>>>();
+    test_spaceship_operator<flat_multiset<int, std::less<int>, deque<int>>>();
+    test_spaceship_operator<flat_set<int, std::greater<int>, deque<int>>>();
+    test_spaceship_operator<flat_multiset<int, std::greater<int>, deque<int>>>();
+
+    test_constructors<vector<int>>();
+    test_constructors<deque<int>>();
+
+    test_non_static_comparer();
+
+    assert_basic<flat_set<int>>();
+    assert_basic<flat_set<int, std::less<int>, deque<int>>>();
+
+    flat_multiset<int, std::less<int>, deque<int>> d;
+}
diff --git a/tests/std/tests/P1502R1_standard_library_header_units/importable_cxx_library_headers.jsonc b/tests/std/tests/P1502R1_standard_library_header_units/importable_cxx_library_headers.jsonc
index 70d0af803ec..51f0fd7365c 100644
--- a/tests/std/tests/P1502R1_standard_library_header_units/importable_cxx_library_headers.jsonc
+++ b/tests/std/tests/P1502R1_standard_library_header_units/importable_cxx_library_headers.jsonc
@@ -23,6 +23,7 @@
     "execution",
     "expected",
     "filesystem",
+    "flat_set",
     "format",
     "forward_list",
     "fstream",
diff --git a/tests/std/tests/P1502R1_standard_library_header_units/test.cpp b/tests/std/tests/P1502R1_standard_library_header_units/test.cpp
index f9fa3090a20..fa11f9e9a79 100644
--- a/tests/std/tests/P1502R1_standard_library_header_units/test.cpp
+++ b/tests/std/tests/P1502R1_standard_library_header_units/test.cpp
@@ -29,6 +29,7 @@ import <exception>;
 import <execution>;
 import <expected>;
 import <filesystem>;
+import <flat_set>;
 import <format>;
 import <forward_list>;
 import <fstream>;
diff --git a/tests/std/tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp b/tests/std/tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp
index 276dd6fdd8d..8a626a8eeb0 100644
--- a/tests/std/tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp
+++ b/tests/std/tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp
@@ -876,6 +876,20 @@ STATIC_ASSERT(__cpp_lib_filesystem == 201703L);
 #endif
 #endif
 
+#if _HAS_CXX23 && defined(__cpp_lib_concepts) // TRANSITION, GH-395
+#ifndef __cpp_lib_flat_set
+#error __cpp_lib_flat_set is not defined
+#elif __cpp_lib_flat_set != 202207L
+#error __cpp_lib_flat_set is not 202207L
+#else
+STATIC_ASSERT(__cpp_lib_flat_set == 202207L);
+#endif
+#else
+#if _HAS_CXX23 && defined(__cpp_lib_concepts) // TRANSITION, GH-395
+#error __cpp_lib_flat_set is defined
+#endif
+#endif
+
 #ifdef __cpp_lib_concepts
 #ifndef __cpp_lib_format
 #error __cpp_lib_format is not defined
diff --git a/tests/std/tests/include_each_header_alone_matrix.lst b/tests/std/tests/include_each_header_alone_matrix.lst
index 9b041e051e5..0de7b470c6c 100644
--- a/tests/std/tests/include_each_header_alone_matrix.lst
+++ b/tests/std/tests/include_each_header_alone_matrix.lst
@@ -26,6 +26,7 @@ PM_CL="/DMEOW_HEADER=exception"
 PM_CL="/DMEOW_HEADER=execution"
 PM_CL="/DMEOW_HEADER=expected"
 PM_CL="/DMEOW_HEADER=filesystem"
+PM_CL="/DMEOW_HEADER=flat_set"
 PM_CL="/DMEOW_HEADER=format"
 PM_CL="/DMEOW_HEADER=forward_list"
 PM_CL="/DMEOW_HEADER=fstream"

From f6baf51619de12ace7dd2d16051d49ec716f13e8 Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34@live.cn>
Date: Sat, 1 Jul 2023 09:24:37 +0800
Subject: [PATCH 002/134] `<flat_set>`: Fix `erase_if` for
 `flat_set`/`flat_multiset` (#3833)

Co-authored-by: Jakub Mazurkiewicz <mazkuba3@gmail.com>
Co-authored-by: Stephan T. Lavavej <stl@nuwen.net>
---
 stl/inc/flat_set                          | 26 +++++++++++++----------
 tests/std/tests/P1222R4_flat_set/test.cpp | 25 ++++++++++++++++++++++
 2 files changed, 40 insertions(+), 11 deletions(-)

diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index 67dc93c4da7..1bfb5e191f9 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -242,11 +242,9 @@ public:
     }
 
     _NODISCARD container_type extract() && {
-        // The container NEEDS to be cleared no matter what,
-        // which is not guaranteed by simply moving it away
-        // ("... valid but unspecified ...")
         container_type& _Cont = _Get_cont();
-        _Clear_scope_guard _Guard{this};
+        // always clears the container (N4950 [flat.set.modifiers]/14 and [flat.multiset.modifiers]/10)
+        _Clear_scope_guard<_Base_flat_set> _Guard{this};
         container_type _Temp = _STD move(_Cont);
         return _Temp;
     }
@@ -405,7 +403,7 @@ public:
     }
 
 private:
-    void inline _Assert_after_sorted_input() const {
+    void _Assert_after_sorted_input() const {
         _STL_ASSERT(_STD is_sorted(begin(), end(), _Get_comp()), "Input was not sorted!");
         if constexpr (!_Multi) {
             _STL_ASSERT(_Is_unique(), "Input was not unique!");
@@ -624,15 +622,21 @@ public:
 };
 
 _EXPORT_STD template <class _Kty, class _Keylt, class _Container, class _Pred>
-size_t erase_if(flat_set<_Kty, _Keylt, _Container>& _Val, _Pred _Predicate) {
-    _Clear_scope_guard _Guard{&_Val};
-    return _Erase_remove_if(_Val, _Pass_fn(_Predicate));
+_Container::size_type erase_if(flat_set<_Kty, _Keylt, _Container>& _Val, _Pred _Predicate) {
+    // clears the container to maintain the invariants when an exception is thrown (N4950 [flat.set.erasure]/5)
+    _Clear_scope_guard<flat_set<_Kty, _Keylt, _Container>> _Guard{_STD addressof(_Val)};
+    const auto _Erased_count = _Erase_remove_if(_Val, _Pass_fn(_Predicate));
+    _Guard._Clearable        = nullptr;
+    return _Erased_count;
 }
 
 _EXPORT_STD template <class _Kty, class _Keylt, class _Container, class _Pred>
-size_t erase_if(flat_multiset<_Kty, _Keylt, _Container>& _Val, _Pred _Predicate) {
-    _Clear_scope_guard _Guard{&_Val};
-    return _Erase_remove_if(_Val, _Pass_fn(_Predicate));
+_Container::size_type erase_if(flat_multiset<_Kty, _Keylt, _Container>& _Val, _Pred _Predicate) {
+    // clears the container to maintain the invariants when an exception is thrown (N4950 [flat.multiset.erasure]/5)
+    _Clear_scope_guard<flat_multiset<_Kty, _Keylt, _Container>> _Guard{_STD addressof(_Val)};
+    const auto _Erased_count = _Erase_remove_if(_Val, _Pass_fn(_Predicate));
+    _Guard._Clearable        = nullptr;
+    return _Erased_count;
 }
 
 template <class _Kty, class _Keylt, class _Container, class _Alloc>
diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index 6a3ae2e1223..a7739cc7353 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
+#include <algorithm>
 #include <cassert>
 #include <deque>
 #include <flat_set>
@@ -190,6 +191,24 @@ void test_non_static_comparer() {
     assert_all_requirements_and_equals(a, {9, 7, 5, -1});
 }
 
+template <class C>
+void test_extract() {
+    constexpr int elements[]{1, 2, 3, 4};
+    C fs{1, 2, 3, 4};
+    auto cont = std::move(fs).extract();
+    assert(fs.empty());
+    assert(ranges::equal(cont, elements));
+}
+
+template <class C>
+void test_erase_if() {
+    constexpr int erased_result[]{1, 3};
+    C fs{1, 2, 3, 4};
+    erase_if(fs, [](int n) { return n % 2 == 0; });
+    assert(fs.size() == 2);
+    assert(ranges::equal(fs, erased_result));
+}
+
 int main() {
     test_spaceship_operator<flat_set<int>>();
     test_spaceship_operator<flat_multiset<int>>();
@@ -205,6 +224,12 @@ int main() {
 
     test_non_static_comparer();
 
+    test_extract<flat_set<int>>();
+    test_extract<flat_multiset<int>>();
+
+    test_erase_if<flat_set<int>>();
+    test_erase_if<flat_multiset<int>>();
+
     assert_basic<flat_set<int>>();
     assert_basic<flat_set<int, std::less<int>, deque<int>>>();
 

From 686123cbf71dcc33fe4a8116a322e996caf75ecc Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34@live.cn>
Date: Thu, 27 Jul 2023 03:16:19 +0800
Subject: [PATCH 003/134] Drop `#pragma once` from `<flat_set>` (#3902)

---
 stl/inc/flat_set | 1 -
 1 file changed, 1 deletion(-)

diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index 1bfb5e191f9..dda412494cd 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -3,7 +3,6 @@
 // Copyright (c) Microsoft Corporation.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-#pragma once
 #ifndef _FLAT_SET_
 #define _FLAT_SET_
 #include <yvals_core.h>

From 1b1e241d8ec30c0d5f3bff8edad93b369bbe9ebf Mon Sep 17 00:00:00 2001
From: achabense <60953653+achabense@users.noreply.github.com>
Date: Sat, 9 Sep 2023 05:39:35 +0800
Subject: [PATCH 004/134] Various bugfixes / enhancements for `<flat_set>`
 (#3993)

Co-authored-by: Stephan T. Lavavej <stl@nuwen.net>
---
 stl/inc/flat_set                          | 315 ++++++++++++++--------
 tests/std/tests/P1222R4_flat_set/test.cpp | 124 +++++++--
 2 files changed, 304 insertions(+), 135 deletions(-)

diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index dda412494cd..7767ba9b951 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -16,6 +16,13 @@ _EMIT_STL_WARNING(STL4038, "The contents of <flat_set> are available only with C
 #include <vector>
 #include <xutility>
 
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
 _STD_BEGIN
 
 template <class _Ty>
@@ -58,10 +65,17 @@ public:
     static_assert(random_access_iterator<iterator>, "The C++ Standard forbids containers without random "
                                                     "access iterators from being adapted. See [flatset.overview].");
 
-    _Base_flat_set() : _My_pair(_Zero_then_variadic_args_t{}, _Keylt()) {}
+    _Base_flat_set() : _My_pair(_Zero_then_variadic_args_t{}) {}
+
+    template <_Allocator_for<container_type> _Alloc>
+    _Base_flat_set(const _Deriv& _Set, const _Alloc& _Al)
+        : _My_pair(_One_then_variadic_args_t{}, _Set._Get_comp(), _Set._Get_cont(), _Al) {}
+    template <_Allocator_for<container_type> _Alloc>
+    _Base_flat_set(_Deriv&& _Set, const _Alloc& _Al)
+        : _My_pair(_One_then_variadic_args_t{}, _STD move(_Set._Get_comp()), _STD move(_Set._Get_cont()), _Al) {}
 
     explicit _Base_flat_set(container_type _Cont, const key_compare& _Comp = key_compare())
-        : _My_pair(_One_then_variadic_args_t{}, _STD move(_Cont), _Comp) {
+        : _My_pair(_One_then_variadic_args_t{}, _Comp, _STD move(_Cont)) {
         _Make_invariants_fulfilled();
     }
     template <_Allocator_for<container_type> _Alloc>
@@ -71,7 +85,7 @@ public:
         : _Base_flat_set(container_type(_Cont, _Al), _Comp) {}
 
     _Base_flat_set(_Tsorted, container_type _Cont, const key_compare& _Comp = key_compare())
-        : _My_pair(_One_then_variadic_args_t{}, _STD move(_Cont), _Comp) {
+        : _My_pair(_One_then_variadic_args_t{}, _Comp, _STD move(_Cont)) {
         _Assert_after_sorted_input();
     }
     template <_Allocator_for<container_type> _Alloc>
@@ -81,11 +95,11 @@ public:
     _Base_flat_set(_Tsorted _Tsort, const container_type& _Cont, const key_compare& _Comp, const _Alloc& _Al)
         : _Base_flat_set(_Tsort, container_type(_Cont, _Al), _Comp) {}
 
-    explicit _Base_flat_set(const key_compare& _Comp) : _My_pair(_Zero_then_variadic_args_t{}, _Comp) {}
+    explicit _Base_flat_set(const key_compare& _Comp) : _My_pair(_One_then_variadic_args_t{}, _Comp) {}
     template <_Allocator_for<container_type> _Alloc>
-    _Base_flat_set(const key_compare& _Comp, const _Alloc& _Al) : _Base_flat_set(_Comp, container_type(_Al)) {}
+    _Base_flat_set(const key_compare& _Comp, const _Alloc& _Al) : _My_pair(_One_then_variadic_args_t{}, _Comp, _Al) {}
     template <_Allocator_for<container_type> _Alloc>
-    explicit _Base_flat_set(const _Alloc& _Al) : _Base_flat_set(container_type(_Al)) {}
+    explicit _Base_flat_set(const _Alloc& _Al) : _My_pair(_Zero_then_variadic_args_t{}, _Al) {}
 
     template <input_iterator _Iter>
     _Base_flat_set(_Iter _First, _Iter _Last, const key_compare& _Comp = key_compare())
@@ -97,11 +111,14 @@ public:
     _Base_flat_set(_Iter _First, _Iter _Last, const _Alloc& _Al) : _Base_flat_set(container_type(_First, _Last, _Al)) {}
 
     template <_Container_compatible_range<_Kty> _Rng>
-    _Base_flat_set(from_range_t, _Rng&& _Range, const key_compare& _Comp = key_compare())
-        : _Base_flat_set(container_type(from_range, _STD forward<_Rng>(_Range)), _Comp) {}
+    _Base_flat_set(from_range_t, _Rng&& _Range)
+        : _Base_flat_set(container_type(from_range, _STD forward<_Rng>(_Range))) {}
     template <_Container_compatible_range<_Kty> _Rng, _Allocator_for<container_type> _Alloc>
     _Base_flat_set(from_range_t, _Rng&& _Range, const _Alloc& _Al)
         : _Base_flat_set(container_type(from_range, _STD forward<_Rng>(_Range), _Al)) {}
+    template <_Container_compatible_range<_Kty> _Rng>
+    _Base_flat_set(from_range_t, _Rng&& _Range, const key_compare& _Comp)
+        : _Base_flat_set(container_type(from_range, _STD forward<_Rng>(_Range)), _Comp) {}
     template <_Container_compatible_range<_Kty> _Rng, _Allocator_for<container_type> _Alloc>
     _Base_flat_set(from_range_t, _Rng&& _Range, const key_compare& _Comp, const _Alloc& _Al)
         : _Base_flat_set(container_type(from_range, _STD forward<_Rng>(_Range), _Al), _Comp) {}
@@ -117,7 +134,7 @@ public:
         : _Base_flat_set(_Tsort, container_type(_First, _Last, _Al)) {}
 
     _Base_flat_set(initializer_list<_Kty> _Ilist, const key_compare& _Comp = key_compare())
-        : _Base_flat_set(_Ilist.begin(), _Ilist.end(), _Comp) {}
+        : _Base_flat_set(container_type(_Ilist.begin(), _Ilist.end()), _Comp) {}
     template <_Allocator_for<container_type> _Alloc>
     _Base_flat_set(initializer_list<_Kty> _Ilist, const key_compare& _Comp, const _Alloc& _Al)
         : _Base_flat_set(container_type(_Ilist.begin(), _Ilist.end(), _Al), _Comp) {}
@@ -126,7 +143,7 @@ public:
         : _Base_flat_set(container_type(_Ilist.begin(), _Ilist.end(), _Al)) {}
 
     _Base_flat_set(_Tsorted _Tsort, initializer_list<_Kty> _Ilist, const key_compare& _Comp = key_compare())
-        : _Base_flat_set(_Tsort, _Ilist.begin(), _Ilist.end(), _Comp) {}
+        : _Base_flat_set(_Tsort, container_type(_Ilist.begin(), _Ilist.end()), _Comp) {}
     template <_Allocator_for<container_type> _Alloc>
     _Base_flat_set(_Tsorted _Tsort, initializer_list<_Kty> _Ilist, const key_compare& _Comp, const _Alloc& _Al)
         : _Base_flat_set(_Tsort, container_type(_Ilist.begin(), _Ilist.end(), _Al), _Comp) {}
@@ -135,11 +152,12 @@ public:
         : _Base_flat_set(_Tsort, container_type(_Ilist.begin(), _Ilist.end(), _Al)) {}
 
     _Deriv& operator=(initializer_list<_Kty> _Ilist) {
-        _Get_cont() = container_type(_Ilist.begin(), _Ilist.end());
+        _Get_cont().assign(_Ilist.begin(), _Ilist.end());
         _Make_invariants_fulfilled();
         return static_cast<_Deriv&>(*this);
     }
 
+    // iterators
     _NODISCARD iterator begin() noexcept {
         return _Get_cont().begin();
     }
@@ -152,6 +170,7 @@ public:
     _NODISCARD const_iterator end() const noexcept {
         return _Get_cont().end();
     }
+
     _NODISCARD reverse_iterator rbegin() noexcept {
         return _Get_cont().rbegin();
     }
@@ -164,6 +183,7 @@ public:
     _NODISCARD const_reverse_iterator rend() const noexcept {
         return _Get_cont().rend();
     }
+
     _NODISCARD const_iterator cbegin() const noexcept {
         return _Get_cont().cbegin();
     }
@@ -177,6 +197,7 @@ public:
         return _Get_cont().crend();
     }
 
+    // capacity
     _NODISCARD_EMPTY_MEMBER bool empty() const noexcept {
         return _Get_cont().empty();
     }
@@ -187,33 +208,36 @@ public:
         return _Get_cont().max_size();
     }
 
+    // modifiers
     template <class... _Args>
     auto emplace(_Args&&... _Vals) {
-        insert<_Kty>(_Kty{_STD forward<_Args>(_Vals)...});
+        constexpr bool _Is_key_type = _In_place_key_extract_set<_Kty, remove_cvref_t<_Args>...>::_Extractable;
+        if constexpr (_Is_key_type) {
+            return _Emplace(_STD forward<_Args>(_Vals)...);
+        } else {
+            return _Emplace(_Kty(_STD forward<_Args>(_Vals)...));
+        }
     }
-
     template <class... _Args>
     iterator emplace_hint(const_iterator _Hint, _Args&&... _Vals) {
-        return _Emplace_hint(_Hint, _Kty{_STD forward<_Args>(_Vals)...});
+        constexpr bool _Is_key_type = _In_place_key_extract_set<_Kty, remove_cvref_t<_Args>...>::_Extractable;
+        if constexpr (_Is_key_type) {
+            return _Emplace_hint(_Hint, _STD forward<_Args>(_Vals)...);
+        } else {
+            return _Emplace_hint(_Hint, _Kty(_STD forward<_Args>(_Vals)...));
+        }
     }
 
     auto insert(const value_type& _Val) {
-        return _Insert<_Kty>(_Val);
+        return _Emplace(_Val);
     }
     auto insert(value_type&& _Val) {
-        return _Insert(_STD move(_Val));
+        return _Emplace(_STD move(_Val));
     }
-
     template <class _Other>
         requires (!_Multi && _Keylt_transparent && is_constructible_v<_Kty, _Other>)
     auto insert(_Other&& _Val) {
-        return _Insert(_STD forward<_Other>(_Val));
-    }
-
-    template <class _Other>
-        requires (!_Multi && _Keylt_transparent && is_constructible_v<_Kty, _Other>)
-    iterator insert(const_iterator _Hint, _Other&& _Val) {
-        return _Emplace_hint(_Hint, _STD forward<_Other>(_Val));
+        return _Emplace(_STD forward<_Other>(_Val));
     }
 
     iterator insert(const_iterator _Hint, const value_type& _Val) {
@@ -222,17 +246,20 @@ public:
     iterator insert(const_iterator _Hint, value_type&& _Val) {
         return _Emplace_hint(_Hint, _STD move(_Val));
     }
+    template <class _Other>
+        requires (!_Multi && _Keylt_transparent && is_constructible_v<_Kty, _Other>)
+    iterator insert(const_iterator _Hint, _Other&& _Val) {
+        return _Emplace_hint(_Hint, _STD forward<_Other>(_Val));
+    }
 
     template <input_iterator _Iter>
-    void insert(const _Iter& _First, const _Iter& _Last) {
+    void insert(_Iter _First, _Iter _Last) {
         _Insert_range<false>(_First, _Last);
     }
-
     template <input_iterator _Iter>
     void insert(_Tsorted, _Iter _First, _Iter _Last) {
         _Insert_range<true>(_First, _Last);
     }
-
     template <_Container_compatible_range<_Kty> _Rng>
     void insert_range(_Rng&& _Range) {
         const size_type _Old_size = size();
@@ -240,14 +267,18 @@ public:
         _Restore_invariants_after_insert<false>(_Old_size);
     }
 
+    void insert(initializer_list<_Kty> _Ilist) {
+        _Insert_range<false>(_Ilist.begin(), _Ilist.end());
+    }
+    void insert(_Tsorted, initializer_list<_Kty> _Ilist) {
+        _Insert_range<true>(_Ilist.begin(), _Ilist.end());
+    }
+
     _NODISCARD container_type extract() && {
-        container_type& _Cont = _Get_cont();
         // always clears the container (N4950 [flat.set.modifiers]/14 and [flat.multiset.modifiers]/10)
         _Clear_scope_guard<_Base_flat_set> _Guard{this};
-        container_type _Temp = _STD move(_Cont);
-        return _Temp;
+        return _STD move(_Get_cont());
     }
-
     void replace(container_type&& _Cont) {
         _Get_cont() = _STD move(_Cont);
         _Assert_after_sorted_input();
@@ -262,13 +293,11 @@ public:
     size_type erase(const _Kty& _Val) {
         return _Erase(_Val);
     }
-
     template <class _Other>
         requires _Keylt_transparent
     size_type erase(_Other&& _Val) {
         return _Erase(_STD forward<_Other>(_Val));
     }
-
     iterator erase(const_iterator _First, const_iterator _Last) {
         return _Get_cont().erase(_First, _Last);
     }
@@ -277,11 +306,11 @@ public:
         _RANGES swap(_Get_comp(), _Other._Get_comp());
         _RANGES swap(_Get_cont(), _Other._Get_cont());
     }
-
     void clear() noexcept {
         _Get_cont().clear();
     }
 
+    // observers
     _NODISCARD key_compare key_comp() const {
         return _Get_comp();
     }
@@ -289,10 +318,10 @@ public:
         return _Get_comp();
     }
 
+    // set operations
     _NODISCARD iterator find(const _Kty& _Val) {
         return _Find(_Val);
     }
-
     _NODISCARD const_iterator find(const _Kty& _Val) const {
         return _Find(_Val);
     }
@@ -302,7 +331,6 @@ public:
     _NODISCARD iterator find(const _Other& _Val) {
         return _Find(_Val);
     }
-
     template <class _Other>
         requires _Keylt_transparent
     _NODISCARD const_iterator find(const _Other& _Val) const {
@@ -313,7 +341,6 @@ public:
         const auto [_First, _Last] = equal_range(_Val);
         return _STD distance(_First, _Last);
     }
-
     template <class _Other>
         requires _Keylt_transparent
     _NODISCARD size_type count(const _Other& _Val) const {
@@ -322,13 +349,14 @@ public:
     }
 
     _NODISCARD bool contains(const _Kty& _Val) const {
-        return find(_Val) != end();
+        return _STD binary_search(cbegin(), cend(), _Val, _Get_comp());
     }
     template <class _Other>
         requires _Keylt_transparent
     _NODISCARD bool contains(const _Other& _Val) const {
-        return find(_Val) != end();
+        return _STD binary_search(cbegin(), cend(), _Val, _Get_comp());
     }
+
     _NODISCARD iterator lower_bound(const _Kty& _Val) {
         return _STD lower_bound(begin(), end(), _Val, _Get_comp());
     }
@@ -341,7 +369,6 @@ public:
     _NODISCARD iterator lower_bound(const _Other& _Val) {
         return _STD lower_bound(begin(), end(), _Val, _Get_comp());
     }
-
     template <class _Other>
         requires _Keylt_transparent
     _NODISCARD const_iterator lower_bound(const _Other& _Val) const {
@@ -351,7 +378,6 @@ public:
     _NODISCARD iterator upper_bound(const _Kty& _Val) {
         return _STD upper_bound(begin(), end(), _Val, _Get_comp());
     }
-
     _NODISCARD const_iterator upper_bound(const _Kty& _Val) const {
         return _STD upper_bound(cbegin(), cend(), _Val, _Get_comp());
     }
@@ -361,7 +387,6 @@ public:
     _NODISCARD iterator upper_bound(const _Other& _Val) {
         return _STD upper_bound(begin(), end(), _Val, _Get_comp());
     }
-
     template <class _Other>
         requires _Keylt_transparent
     _NODISCARD const_iterator upper_bound(const _Other& _Val) const {
@@ -371,7 +396,6 @@ public:
     _NODISCARD pair<iterator, iterator> equal_range(const _Kty& _Val) {
         return _STD equal_range(begin(), end(), _Val, _Get_comp());
     }
-
     _NODISCARD pair<const_iterator, const_iterator> equal_range(const _Kty& _Val) const {
         return _STD equal_range(cbegin(), cend(), _Val, _Get_comp());
     }
@@ -381,7 +405,6 @@ public:
     _NODISCARD pair<iterator, iterator> equal_range(const _Other& _Val) {
         return _STD equal_range(begin(), end(), _Val, _Get_comp());
     }
-
     template <class _Other>
         requires _Keylt_transparent
     _NODISCARD pair<const_iterator, const_iterator> equal_range(const _Other& _Val) const {
@@ -389,7 +412,7 @@ public:
     }
 
     _NODISCARD friend bool operator==(const _Deriv& _Lhs, const _Deriv& _Rhs) {
-        return _RANGES equal(_Lhs, _Rhs);
+        return _RANGES equal(_Lhs._Get_cont(), _Rhs._Get_cont());
     }
 
     _NODISCARD friend _Synth_three_way_result<_Kty> operator<=>(const _Deriv& _Lhs, const _Deriv& _Rhs) {
@@ -403,9 +426,9 @@ public:
 
 private:
     void _Assert_after_sorted_input() const {
-        _STL_ASSERT(_STD is_sorted(begin(), end(), _Get_comp()), "Input was not sorted!");
+        _STL_ASSERT(_STD is_sorted(cbegin(), cend(), _Get_comp()), "Input was not sorted!");
         if constexpr (!_Multi) {
-            _STL_ASSERT(_Is_unique(), "Input was not unique!");
+            _STL_ASSERT(_Is_unique(), "Input was sorted but not unique!");
         }
     }
 
@@ -413,8 +436,8 @@ private:
         if (empty()) {
             return true;
         }
-        const_iterator _End = cend();
-        const_iterator _It  = begin();
+        const const_iterator _End = cend();
+        const_iterator _It        = cbegin();
         while (++_It != _End) {
             if (_Keys_equal(*(_It - 1), *_It)) {
                 return false;
@@ -423,64 +446,114 @@ private:
         return true;
     }
 
+    bool _Check_where(const const_iterator _Where, const _Kty& _Val) const {
+        // check that _Val can be inserted before _Where
+        const key_compare& _Compare = _Get_comp();
+        if constexpr (_Multi) {
+            // check that _Where is the upper_bound for _Val
+            // equivalent to checking *(_Where-1) <= _Val < *_Where
+            return (_Where == cend() || _Compare(_Val, *_Where))
+                && (_Where == cbegin() || !_Compare(_Val, *(_Where - 1)));
+        } else {
+            // check that _Where is the lower_bound for _Val, and *_Where is not equivalent to _Val
+            // equivalent to checking *(_Where-1) < _Val < *_Where
+            return (_Where == cend() || _Compare(_Val, *_Where))
+                && (_Where == cbegin() || _Compare(*(_Where - 1), _Val));
+        }
+    }
+
     template <class _Ty>
-        requires (_Keylt_transparent && is_constructible_v<_Kty, _Ty>) || is_same_v<_Ty, _Kty>
-    void _Emplace_hint(const_iterator _Where, _Ty&& _Val) {
-        _Container& _Cont     = _Get_cont();
-        _Keylt& _Compare      = _Get_comp();
-        const iterator _Begin = begin();
-        const iterator _End   = end();
+    auto _Emplace(_Ty&& _Val) {
+        _Container& _Cont = _Get_cont();
+        if constexpr (_Multi) {
+            _STL_INTERNAL_STATIC_ASSERT(is_same_v<remove_cvref_t<_Ty>, _Kty>);
+            return _Cont.emplace(upper_bound(_Val), _STD forward<_Ty>(_Val));
+        } else {
+            const iterator _End   = end();
+            const iterator _Where = lower_bound(_Val);
+            if (_Where != _End && _Keys_equal(*_Where, _Val)) {
+                return pair{_Where, false};
+            }
 
-        if (_Where == _End || !_Compare(*_Where, _Val)) {
-            // _Val <= *_Where
-            // Left of _Where
-            if (_Where == _Begin || !_Compare(_Val, *(_Where - 1))) {
-                // _Val >= (*_Where - 1)
-                // Insert before _Where
+            if constexpr (is_same_v<remove_cvref_t<_Ty>, _Kty>) {
+                return pair{_Cont.emplace(_Where, _STD forward<_Ty>(_Val)), true};
             } else {
-                // _Val < (*_Where - 1)
-                _Where = _STD upper_bound(_Begin, _Where, _Val, _Compare);
+                // for flat_set::insert(auto&&)
+                _STL_INTERNAL_STATIC_ASSERT(_Keylt_transparent && is_constructible_v<_Kty, _Ty>);
+                _Kty _Keyval(_STD forward<_Ty>(_Val));
+                _STL_ASSERT(_Check_where(_Where, _Keyval), "The input type was not equivalent to key_type!");
+                return pair{_Cont.emplace(_Where, _STD move(_Keyval)), true};
+            }
+        }
+    }
+
+    template <class _Ty>
+    iterator _Emplace_hint(const_iterator _Where, _Ty&& _Val) {
+        _Container& _Cont           = _Get_cont();
+        const key_compare& _Compare = _Get_comp();
+        const const_iterator _Begin = cbegin();
+        const const_iterator _End   = cend();
+
+        if constexpr (_Multi) {
+            // look for the upper_bound for flat_multiset
+            if (_Where == _End || _Compare(_Val, *_Where)) {
+                // _Val < *_Where
+                if (_Where == _Begin || !_Compare(_Val, *(_Where - 1))) {
+                    // _Val >= *(_Where-1) ~ upper_bound is _Where
+                } else {
+                    // _Val < *(_Where-1) ~ upper_bound is in [_Begin,_Where-1]
+                    _Where = _STD upper_bound(_Begin, _Where - 1, _Val);
+                }
+            } else {
+                // _Val >= *_Where ~ upper_bound is in [_Where+1,_End]
+                _Where = _STD upper_bound(_Where + 1, _End, _Val);
             }
         } else {
-            // _Val > *_Where
-            // Right of _Where
-            _Where = _STD lower_bound(_Where + 1, _End, _Val, _Compare);
+            // look for the lower_bound for flat_set
+            if (_Where == _End || !_Compare(*_Where, _Val)) {
+                // _Val <= *_Where
+                if (_Where == _Begin || _Compare(*(_Where - 1), _Val)) {
+                    // _Val > *(_Where-1) ~ lower_bound is _Where
+                } else {
+                    // _Val <= *(_Where-1) ~ lower_bound is in [_Begin,_Where-1]
+                    _Where = _STD lower_bound(_Begin, _Where - 1, _Val);
+                }
+            } else {
+                // _Val > *_Where ~ lower_bound is in [_Where+1,_End]
+                _Where = _STD lower_bound(_Where + 1, _End, _Val);
+            }
         }
 
         if constexpr (_Multi) {
-            return _Cont.insert(_Where, _STD forward<_Ty>(_Val));
+            _STL_INTERNAL_STATIC_ASSERT(is_same_v<remove_cvref_t<_Ty>, _Kty>);
+            _STL_INTERNAL_CHECK(_Check_where(_Where, _Val));
+            return _Cont.emplace(_Where, _STD forward<_Ty>(_Val));
         } else {
-            if (_Where == _End || !_Keys_equal(_Val, *_Where)) {
-                return _Cont.insert(_Where, _STD forward<_Ty>(_Val));
+            if (_Where != _End && _Keys_equal(_Val, *_Where)) {
+                return _Cont.begin() + (_Where - _Begin);
+            }
+
+            if constexpr (is_same_v<remove_cvref_t<_Ty>, _Kty>) {
+                _STL_INTERNAL_CHECK(_Check_where(_Where, _Val));
+                return _Cont.emplace(_Where, _STD forward<_Ty>(_Val));
+            } else {
+                // for flat_set::insert(hint,auto&&)
+                _STL_INTERNAL_STATIC_ASSERT(_Keylt_transparent && is_constructible_v<_Kty, _Ty>);
+                _Kty _Keyval(_STD forward<_Ty>(_Val));
+                _STL_ASSERT(_Check_where(_Where, _Keyval), "The input type was not equivalent to key_type!");
+                return _Cont.emplace(_Where, _STD move(_Keyval));
             }
-            return _Where;
         }
     }
 
     template <bool _Presorted, class _Iter>
-    void _Insert_range(_Iter _First, _Iter _Last) {
+    void _Insert_range(const _Iter _First, const _Iter _Last) {
         const size_type _Old_size = size();
         _Container& _Cont         = _Get_cont();
         _Cont.insert(_Cont.end(), _First, _Last);
         _Restore_invariants_after_insert<_Presorted>(_Old_size);
     }
 
-    template <class _Ty>
-        requires (!_Multi && _Keylt_transparent && is_constructible_v<_Kty, _Ty>) || is_same_v<_Ty, _Kty>
-    auto _Insert(_Ty&& _Val) {
-        _Container& _Cont     = _Get_cont();
-        const iterator _End   = end();
-        const iterator _Where = lower_bound(_Val);
-        if constexpr (_Multi) {
-            return _Cont.emplace(_Where, _STD forward<_Ty>(_Val));
-        } else {
-            if (_Where != _End && _Keys_equal(*_Where, _Val)) {
-                return pair{_Where, false};
-            }
-            return pair{_Cont.emplace(_Where, _STD forward<_Ty>(_Val)), true};
-        }
-    }
-
     template <class _Ty>
         requires _Keylt_transparent || is_same_v<_Ty, _Kty>
     size_type _Erase(_Ty&& _Val) {
@@ -506,8 +579,8 @@ private:
     template <class _Other>
         requires _Keylt_transparent || is_same_v<_Other, _Kty>
     _NODISCARD const_iterator _Find(const _Other& _Val) const {
-        const iterator _End   = end();
-        const iterator _Where = lower_bound(_Val);
+        const const_iterator _End   = cend();
+        const const_iterator _Where = lower_bound(_Val);
         if (_Where != _End && _Keys_equal(*_Where, _Val)) {
             return _Where;
         } else {
@@ -522,33 +595,22 @@ private:
         return !_Compare(_Lhs, _Rhs) && !_Compare(_Rhs, _Lhs);
     }
 
-    // O(N) if already sorted.
-    void _Sort_potentially_sorted(const iterator& _Begin, const iterator& _End) {
-        key_compare& _Compare          = _Get_comp();
-        const iterator _Begin_unsorted = _STD is_sorted_until(_Begin, _End, _Compare);
-
-        _STD sort(_Begin_unsorted, _End, _Compare);
-
-        _STD inplace_merge(begin(), _Begin_unsorted, _End, _Compare);
-    }
-
     void _Erase_dupes_if_needed() {
         if constexpr (!_Multi) {
-            iterator _End = end();
-            iterator _New_end =
+            const iterator _End = end();
+            const iterator _New_end =
                 _STD unique(begin(), _End, [&](const _Kty& _Lhs, const _Kty& _Rhs) { return _Keys_equal(_Lhs, _Rhs); });
             _Get_cont().erase(_New_end, _End);
-        }
-        if constexpr (!_Multi) {
+
             _STL_INTERNAL_CHECK(_Is_unique());
         }
     }
 
     template <bool _Presorted>
-    void _Restore_invariants_after_insert(const size_type& _Old_size) {
-        key_compare& _Compare   = _Get_comp();
-        const iterator _Old_end = begin() + static_cast<difference_type>(_Old_size);
-        const iterator _New_end = end();
+    void _Restore_invariants_after_insert(const size_type _Old_size) {
+        const key_compare& _Compare = _Get_comp();
+        const iterator _Old_end     = begin() + static_cast<difference_type>(_Old_size);
+        const iterator _New_end     = end();
 
         if constexpr (!_Presorted) {
             _STD sort(_Old_end, _New_end, _Compare);
@@ -558,7 +620,7 @@ private:
 
         _STD inplace_merge(begin(), _Old_end, _New_end, _Compare);
 
-        _STL_INTERNAL_CHECK(_STD is_sorted(begin(), end(), _Get_comp()));
+        _STL_INTERNAL_CHECK(_STD is_sorted(begin(), end(), _Compare));
 
         _Erase_dupes_if_needed();
     }
@@ -571,29 +633,35 @@ private:
             return;
         }
 
-        _Sort_potentially_sorted(_Begin, _End);
-        _STL_INTERNAL_CHECK(_STD is_sorted(begin(), end(), _Get_comp()));
+        // O(N) if already sorted.
+        const key_compare& _Compare    = _Get_comp();
+        const iterator _Begin_unsorted = _STD is_sorted_until(_Begin, _End, _Compare);
+
+        _STD sort(_Begin_unsorted, _End, _Compare);
+        _STD inplace_merge(_Begin, _Begin_unsorted, _End, _Compare);
+
+        _STL_INTERNAL_CHECK(_STD is_sorted(_Begin, _End, _Compare));
 
         _Erase_dupes_if_needed();
     }
 
     _NODISCARD const _Container& _Get_cont() const noexcept {
-        return _My_pair._Get_first();
+        return _My_pair._Myval2;
     }
 
     _NODISCARD _Container& _Get_cont() noexcept {
-        return _My_pair._Get_first();
+        return _My_pair._Myval2;
     }
 
     _NODISCARD const key_compare& _Get_comp() const noexcept {
-        return _My_pair._Myval2;
+        return _My_pair._Get_first();
     }
 
     _NODISCARD key_compare& _Get_comp() noexcept {
-        return _My_pair._Myval2;
+        return _My_pair._Get_first();
     }
 
-    _Compressed_pair<container_type, key_compare> _My_pair;
+    _Compressed_pair<key_compare, container_type> _My_pair;
 };
 
 _EXPORT_STD struct sorted_unique_t {
@@ -609,15 +677,23 @@ _EXPORT_STD inline constexpr sorted_equivalent_t sorted_equivalent{};
 _EXPORT_STD template <class _Kty, class _Keylt = less<_Kty>, class _Container = vector<_Kty>>
 class flat_set
     : public _Base_flat_set<_Kty, _Keylt, _Container, false, flat_set<_Kty, _Keylt, _Container>, sorted_unique_t> {
+private:
+    using _Mybase = _Base_flat_set<_Kty, _Keylt, _Container, false, flat_set, sorted_unique_t>;
+
 public:
-    using _Base_flat_set<_Kty, _Keylt, _Container, false, flat_set, sorted_unique_t>::_Base_flat_set;
+    using _Mybase::_Mybase;
+    using _Mybase::operator=;
 };
 
 _EXPORT_STD template <class _Kty, class _Keylt = less<_Kty>, class _Container = vector<_Kty>>
 class flat_multiset : public _Base_flat_set<_Kty, _Keylt, _Container, true, flat_multiset<_Kty, _Keylt, _Container>,
                           sorted_equivalent_t> {
+private:
+    using _Mybase = _Base_flat_set<_Kty, _Keylt, _Container, true, flat_multiset, sorted_equivalent_t>;
+
 public:
-    using _Base_flat_set<_Kty, _Keylt, _Container, true, flat_multiset, sorted_equivalent_t>::_Base_flat_set;
+    using _Mybase::_Mybase;
+    using _Mybase::operator=;
 };
 
 _EXPORT_STD template <class _Kty, class _Keylt, class _Container, class _Pred>
@@ -719,6 +795,11 @@ flat_multiset(sorted_equivalent_t, initializer_list<_Kty>, _Keylt = _Keylt()) ->
 
 _STD_END
 
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+
 #endif // ^^^ supported language mode ^^^
 #endif // _STL_COMPILER_PREPROCESSOR
 #endif // _FLAT_SET_
diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index a7739cc7353..7547d6887df 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -7,6 +7,7 @@
 #include <flat_set>
 #include <functional>
 #include <iostream>
+#include <memory>
 #include <vector>
 
 using namespace std;
@@ -65,10 +66,23 @@ void assert_reversible_container_requirements(const T& s) {
     static_assert(is_convertible_v<typename T::reverse_iterator, typename T::const_reverse_iterator>);
 }
 
+template <class T>
+void test_ebco() {
+    // This tests an implementation-specific optimization.
+    using key_compare    = T::key_compare;
+    using container_type = T::container_type;
+    if constexpr (is_empty_v<key_compare> && !is_final_v<key_compare>) {
+        static_assert(sizeof(container_type) == sizeof(T));
+    } else {
+        static_assert(sizeof(container_type) < sizeof(T));
+    }
+}
+
 template <class T>
 void assert_all_requirements_and_equals(const T& s, const initializer_list<typename T::value_type>& il) {
     assert_container_requirements(s);
     assert_reversible_container_requirements(s);
+    test_ebco<T>();
 
     auto val_comp = s.value_comp();
     auto begin_it = s.cbegin();
@@ -98,19 +112,6 @@ void assert_all_requirements_and_equals(const T& s, const initializer_list<typen
     }
 }
 
-template <class T>
-void assert_basic() {
-    T s{3, 2, 2, 2, 1};
-    assert_all_requirements_and_equals(s, {1, 2, 3});
-
-    s.insert(43);
-    assert_all_requirements_and_equals(s, {1, 2, 3, 43});
-
-    int my_ints[] = {1, 2, 3, 4, 55};
-    s.insert_range(my_ints);
-    assert_all_requirements_and_equals(s, {1, 2, 3, 4, 43, 55});
-}
-
 template <class C>
 void test_constructors() {
     using lt = std::less<int>;
@@ -132,9 +133,95 @@ void test_constructors() {
     flat_set<int> a{};
     a = {1, 7, 7, 7, 2, 100, -1};
     assert_all_requirements_and_equals(a, {-1, 1, 2, 7, 100});
+    assert_all_requirements_and_equals(flat_set<int>(a, allocator<int>{}), {-1, 1, 2, 7, 100});
+    assert_all_requirements_and_equals(flat_set<int>(std::move(a), allocator<int>{}), {-1, 1, 2, 7, 100});
     flat_multiset<int> b{};
     b = {1, 7, 7, 7, 2, 100, -1};
     assert_all_requirements_and_equals(b, {-1, 1, 2, 7, 7, 7, 100});
+    assert_all_requirements_and_equals(flat_multiset<int>(b, allocator<int>{}), {-1, 1, 2, 7, 7, 7, 100});
+    assert_all_requirements_and_equals(flat_multiset<int>(std::move(b), allocator<int>{}), {-1, 1, 2, 7, 7, 7, 100});
+}
+
+template <class C>
+void test_insert_1() {
+    using lt = std::less<int>;
+
+    const vector<int> vec{0, 1, 2};
+    {
+        flat_set<int, lt, C> a{5, 5};
+        assert_all_requirements_and_equals(a, {5});
+        a.emplace();
+        assert_all_requirements_and_equals(a, {0, 5});
+        a.emplace(1);
+        assert_all_requirements_and_equals(a, {0, 1, 5});
+        a.insert(vec[2]);
+        assert_all_requirements_and_equals(a, {0, 1, 2, 5});
+        a.insert(2);
+        assert_all_requirements_and_equals(a, {0, 1, 2, 5});
+        a.insert(vec.rbegin(), vec.rend());
+        assert_all_requirements_and_equals(a, {0, 1, 2, 5});
+        a.insert(sorted_unique, vec.begin(), vec.end());
+        assert_all_requirements_and_equals(a, {0, 1, 2, 5});
+        a.insert_range(vec);
+        assert_all_requirements_and_equals(a, {0, 1, 2, 5});
+        a.insert({6, 2, 3});
+        assert_all_requirements_and_equals(a, {0, 1, 2, 3, 5, 6});
+        a.insert(sorted_unique, {4, 5});
+        assert_all_requirements_and_equals(a, {0, 1, 2, 3, 4, 5, 6});
+    }
+    {
+        flat_multiset<int, lt, C> a{5, 5};
+        assert_all_requirements_and_equals(a, {5, 5});
+        a.emplace();
+        assert_all_requirements_and_equals(a, {0, 5, 5});
+        a.emplace(1);
+        assert_all_requirements_and_equals(a, {0, 1, 5, 5});
+        a.insert(vec[2]);
+        assert_all_requirements_and_equals(a, {0, 1, 2, 5, 5});
+        a.insert(2);
+        assert_all_requirements_and_equals(a, {0, 1, 2, 2, 5, 5});
+        a.insert(vec.rbegin(), vec.rend());
+        assert_all_requirements_and_equals(a, {0, 0, 1, 1, 2, 2, 2, 5, 5});
+        a.insert(sorted_equivalent, vec.begin(), vec.end());
+        assert_all_requirements_and_equals(a, {0, 0, 0, 1, 1, 1, 2, 2, 2, 2, 5, 5});
+        a.insert_range(vec);
+        assert_all_requirements_and_equals(a, {0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 2, 5, 5});
+        a.insert({6, 2, 3});
+        assert_all_requirements_and_equals(a, {0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 5, 5, 6});
+        a.insert(sorted_equivalent, {4, 5});
+        assert_all_requirements_and_equals(a, {0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 4, 5, 5, 5, 6});
+    }
+}
+
+template <class C>
+void test_insert_2() {
+    using lt = std::less<int>;
+
+    const int val = 1;
+    {
+        flat_set<int, lt, C> a{0, 5};
+        assert_all_requirements_and_equals(a, {0, 5});
+        a.emplace_hint(a.end());
+        assert_all_requirements_and_equals(a, {0, 5});
+        a.emplace_hint(a.end(), 0);
+        assert_all_requirements_and_equals(a, {0, 5});
+        a.insert(a.begin(), 6);
+        assert_all_requirements_and_equals(a, {0, 5, 6});
+        a.insert(a.begin(), val);
+        assert_all_requirements_and_equals(a, {0, 1, 5, 6});
+    }
+    {
+        flat_multiset<int, lt, C> a{0, 5};
+        assert_all_requirements_and_equals(a, {0, 5});
+        a.emplace_hint(a.end());
+        assert_all_requirements_and_equals(a, {0, 0, 5});
+        a.emplace_hint(a.end(), 0);
+        assert_all_requirements_and_equals(a, {0, 0, 0, 5});
+        a.insert(a.begin(), 6);
+        assert_all_requirements_and_equals(a, {0, 0, 0, 5, 6});
+        a.insert(a.begin(), val);
+        assert_all_requirements_and_equals(a, {0, 0, 0, 1, 5, 6});
+    }
 }
 
 template <class T>
@@ -191,6 +278,7 @@ void test_non_static_comparer() {
     assert_all_requirements_and_equals(a, {9, 7, 5, -1});
 }
 
+
 template <class C>
 void test_extract() {
     constexpr int elements[]{1, 2, 3, 4};
@@ -222,6 +310,11 @@ int main() {
     test_constructors<vector<int>>();
     test_constructors<deque<int>>();
 
+    test_insert_1<vector<int>>();
+    test_insert_1<deque<int>>();
+    test_insert_2<vector<int>>();
+    test_insert_2<deque<int>>();
+
     test_non_static_comparer();
 
     test_extract<flat_set<int>>();
@@ -229,9 +322,4 @@ int main() {
 
     test_erase_if<flat_set<int>>();
     test_erase_if<flat_multiset<int>>();
-
-    assert_basic<flat_set<int>>();
-    assert_basic<flat_set<int, std::less<int>, deque<int>>>();
-
-    flat_multiset<int, std::less<int>, deque<int>> d;
 }

From 8dd198ffa6528a3bb3fff015c0c90c056390b8ba Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Fri, 8 Sep 2023 14:44:35 -0700
Subject: [PATCH 005/134] Fix stealth merge conflict with C++20 Standard
 Library Modules.

---
 stl/modules/std.ixx                                           | 2 ++
 tests/std/include/test_header_units_and_modules.hpp           | 4 ++++
 .../std/tests/P1502R1_standard_library_header_units/test.cpp  | 2 ++
 3 files changed, 8 insertions(+)

diff --git a/stl/modules/std.ixx b/stl/modules/std.ixx
index 07d18e66b2c..0d094093b5f 100644
--- a/stl/modules/std.ixx
+++ b/stl/modules/std.ixx
@@ -61,7 +61,9 @@ export module std;
 #include <expected>
 #endif // _HAS_CXX23
 #include <filesystem>
+#if _HAS_CXX23
 #include <flat_set>
+#endif // _HAS_CXX23
 #include <format>
 #include <forward_list>
 #include <fstream>
diff --git a/tests/std/include/test_header_units_and_modules.hpp b/tests/std/include/test_header_units_and_modules.hpp
index 06546ff448c..ce9482aac30 100644
--- a/tests/std/include/test_header_units_and_modules.hpp
+++ b/tests/std/include/test_header_units_and_modules.hpp
@@ -236,12 +236,14 @@ void test_filesystem() {
     assert(info.capacity != static_cast<decltype(info.capacity)>(-1));
 }
 
+#if TEST_STANDARD >= 23
 void test_flat_set() {
     using namespace std;
     puts("Testing <flat_set>.");
 
     // FIXME! ADD TEST COVERAGE HERE!
 }
+#endif // TEST_STANDARD >= 23
 
 void test_format() {
     using namespace std;
@@ -1101,7 +1103,9 @@ void all_cpp_header_tests() {
     test_expected();
 #endif // TEST_STANDARD >= 23
     test_filesystem();
+#if TEST_STANDARD >= 23
     test_flat_set();
+#endif // TEST_STANDARD >= 23
     test_format();
     test_forward_list();
     test_fstream();
diff --git a/tests/std/tests/P1502R1_standard_library_header_units/test.cpp b/tests/std/tests/P1502R1_standard_library_header_units/test.cpp
index 9ca66909b06..4362fd8e20f 100644
--- a/tests/std/tests/P1502R1_standard_library_header_units/test.cpp
+++ b/tests/std/tests/P1502R1_standard_library_header_units/test.cpp
@@ -31,7 +31,9 @@ import <execution>;
 import <expected>;
 #endif // TEST_STANDARD >= 23
 import <filesystem>;
+#if TEST_STANDARD >= 23
 import <flat_set>;
+#endif // TEST_STANDARD >= 23
 import <format>;
 import <forward_list>;
 import <fstream>;

From 384040a9e1483a22483d1a35592468f0dbf93440 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Fri, 8 Sep 2023 14:49:18 -0700
Subject: [PATCH 006/134] Use 4-arg std::equal().

---
 tests/std/tests/P1222R4_flat_set/test.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index 7547d6887df..cdbe4b7698f 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -97,7 +97,7 @@ void assert_all_requirements_and_equals(const T& s, const initializer_list<typen
         }
     }
 
-    if (s.size() != il.size() || !std::equal(s.begin(), s.end(), il.begin())) {
+    if (!std::equal(s.begin(), s.end(), il.begin(), il.end())) {
         cout << "Expected: {";
         for (auto&& e : il) {
             cout << e << ", ";

From 90a536318e5782a88d17785ef11b65ad9e9ffee2 Mon Sep 17 00:00:00 2001
From: achabense <60953653+achabense@users.noreply.github.com>
Date: Tue, 19 Sep 2023 05:50:05 +0800
Subject: [PATCH 007/134] More bugfixes for `flat_set` (#4034)

Co-authored-by: Stephan T. Lavavej <stl@nuwen.net>
---
 stl/inc/flat_set                          | 21 ++++-----
 tests/std/tests/P1222R4_flat_set/test.cpp | 54 +++++++++++++++++++++++
 2 files changed, 65 insertions(+), 10 deletions(-)

diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index 7767ba9b951..18fb0f2553b 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -294,9 +294,10 @@ public:
         return _Erase(_Val);
     }
     template <class _Other>
-        requires _Keylt_transparent
+        requires (
+            _Keylt_transparent && !is_convertible_v<_Other, iterator> && !is_convertible_v<_Other, const_iterator>)
     size_type erase(_Other&& _Val) {
-        return _Erase(_STD forward<_Other>(_Val));
+        return _Erase(_Val);
     }
     iterator erase(const_iterator _First, const_iterator _Last) {
         return _Get_cont().erase(_First, _Last);
@@ -339,13 +340,13 @@ public:
 
     _NODISCARD size_type count(const _Kty& _Val) const {
         const auto [_First, _Last] = equal_range(_Val);
-        return _STD distance(_First, _Last);
+        return static_cast<size_type>(_Last - _First);
     }
     template <class _Other>
         requires _Keylt_transparent
     _NODISCARD size_type count(const _Other& _Val) const {
         const auto [_First, _Last] = equal_range(_Val);
-        return _STD distance(_First, _Last);
+        return static_cast<size_type>(_Last - _First);
     }
 
     _NODISCARD bool contains(const _Kty& _Val) const {
@@ -502,11 +503,11 @@ private:
                     // _Val >= *(_Where-1) ~ upper_bound is _Where
                 } else {
                     // _Val < *(_Where-1) ~ upper_bound is in [_Begin,_Where-1]
-                    _Where = _STD upper_bound(_Begin, _Where - 1, _Val);
+                    _Where = _STD upper_bound(_Begin, _Where - 1, _Val, _Compare);
                 }
             } else {
                 // _Val >= *_Where ~ upper_bound is in [_Where+1,_End]
-                _Where = _STD upper_bound(_Where + 1, _End, _Val);
+                _Where = _STD upper_bound(_Where + 1, _End, _Val, _Compare);
             }
         } else {
             // look for the lower_bound for flat_set
@@ -516,11 +517,11 @@ private:
                     // _Val > *(_Where-1) ~ lower_bound is _Where
                 } else {
                     // _Val <= *(_Where-1) ~ lower_bound is in [_Begin,_Where-1]
-                    _Where = _STD lower_bound(_Begin, _Where - 1, _Val);
+                    _Where = _STD lower_bound(_Begin, _Where - 1, _Val, _Compare);
                 }
             } else {
                 // _Val > *_Where ~ lower_bound is in [_Where+1,_End]
-                _Where = _STD lower_bound(_Where + 1, _End, _Val);
+                _Where = _STD lower_bound(_Where + 1, _End, _Val, _Compare);
             }
         }
 
@@ -556,10 +557,10 @@ private:
 
     template <class _Ty>
         requires _Keylt_transparent || is_same_v<_Ty, _Kty>
-    size_type _Erase(_Ty&& _Val) {
+    size_type _Erase(const _Ty& _Val) {
         const auto [_First, _Last] = equal_range(_Val);
 
-        const difference_type _Removed = _STD distance(_First, _Last);
+        const auto _Removed = static_cast<size_type>(_Last - _First);
         _Get_cont().erase(_First, _Last);
         return _Removed;
     }
diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index cdbe4b7698f..7422f959fca 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -222,6 +222,17 @@ void test_insert_2() {
         a.insert(a.begin(), val);
         assert_all_requirements_and_equals(a, {0, 0, 0, 1, 5, 6});
     }
+
+    // TRANSITION, too simple
+    using gt = std::greater<int>;
+    {
+        flat_set<int, gt, C> a{0, 5};
+        assert_all_requirements_and_equals(a, {5, 0});
+        a.insert(a.begin(), 3);
+        assert_all_requirements_and_equals(a, {5, 3, 0});
+        a.insert(a.end(), 4);
+        assert_all_requirements_and_equals(a, {5, 4, 3, 0});
+    }
 }
 
 template <class T>
@@ -288,6 +299,35 @@ void test_extract() {
     assert(ranges::equal(cont, elements));
 }
 
+// TRANSITION, too simple
+void test_erase_1() {
+    flat_set<int> fs{1};
+    fs.erase(1);
+    assert_all_requirements_and_equals(fs, {});
+}
+
+template <class T>
+struct holder {
+    T t;
+    operator T() && {
+        return std::move(t);
+    }
+};
+
+void test_erase_2() {
+    using C = flat_set<int, std::less<>>;
+    C fs{0, 1, 2, 3};
+    assert_all_requirements_and_equals(fs, {0, 1, 2, 3});
+    // this should be allowed per P2077R3:
+    fs.erase(holder<C::const_iterator>{fs.cbegin()});
+    assert_all_requirements_and_equals(fs, {1, 2, 3});
+    fs.erase(holder<C::iterator>{fs.begin()});
+    assert_all_requirements_and_equals(fs, {2, 3});
+    int i = 2;
+    fs.erase(ref(i));
+    assert_all_requirements_and_equals(fs, {3});
+}
+
 template <class C>
 void test_erase_if() {
     constexpr int erased_result[]{1, 3};
@@ -297,6 +337,15 @@ void test_erase_if() {
     assert(ranges::equal(fs, erased_result));
 }
 
+// TRANSITION, too simple
+void test_count() {
+    flat_set<int> fs{2};
+    assert(fs.count(1) == 0);
+
+    flat_multiset<int> fs2{1, 2, 2, 3};
+    assert(fs2.count(2) == 2);
+}
+
 int main() {
     test_spaceship_operator<flat_set<int>>();
     test_spaceship_operator<flat_multiset<int>>();
@@ -320,6 +369,11 @@ int main() {
     test_extract<flat_set<int>>();
     test_extract<flat_multiset<int>>();
 
+    test_erase_1();
+    test_erase_2();
+
     test_erase_if<flat_set<int>>();
     test_erase_if<flat_multiset<int>>();
+
+    test_count();
 }

From bec079ac808a0b6f91a888c82ad657aeff8ed92e Mon Sep 17 00:00:00 2001
From: achabense <60953653+achabense@users.noreply.github.com>
Date: Wed, 20 Sep 2023 03:03:53 +0800
Subject: [PATCH 008/134] More enhancements for `<flat_set>` (#4019)

---
 stl/inc/flat_set | 159 ++++++++++++++++++++++++++++-------------------
 1 file changed, 94 insertions(+), 65 deletions(-)

diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index 18fb0f2553b..d39368763f7 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -172,29 +172,29 @@ public:
     }
 
     _NODISCARD reverse_iterator rbegin() noexcept {
-        return _Get_cont().rbegin();
+        return reverse_iterator(end());
     }
     _NODISCARD const_reverse_iterator rbegin() const noexcept {
-        return _Get_cont().rbegin();
+        return const_reverse_iterator(end());
     }
     _NODISCARD reverse_iterator rend() noexcept {
-        return _Get_cont().rend();
+        return reverse_iterator(begin());
     }
     _NODISCARD const_reverse_iterator rend() const noexcept {
-        return _Get_cont().rend();
+        return const_reverse_iterator(begin());
     }
 
     _NODISCARD const_iterator cbegin() const noexcept {
-        return _Get_cont().cbegin();
+        return begin();
     }
     _NODISCARD const_iterator cend() const noexcept {
-        return _Get_cont().cend();
+        return end();
     }
     _NODISCARD const_reverse_iterator crbegin() const noexcept {
-        return _Get_cont().crbegin();
+        return rbegin();
     }
     _NODISCARD const_reverse_iterator crend() const noexcept {
-        return _Get_cont().crend();
+        return rend();
     }
 
     // capacity
@@ -339,8 +339,12 @@ public:
     }
 
     _NODISCARD size_type count(const _Kty& _Val) const {
-        const auto [_First, _Last] = equal_range(_Val);
-        return static_cast<size_type>(_Last - _First);
+        if constexpr (!_Multi) {
+            return contains(_Val);
+        } else {
+            const auto [_First, _Last] = equal_range(_Val);
+            return static_cast<size_type>(_Last - _First);
+        }
     }
     template <class _Other>
         requires _Keylt_transparent
@@ -350,66 +354,66 @@ public:
     }
 
     _NODISCARD bool contains(const _Kty& _Val) const {
-        return _STD binary_search(cbegin(), cend(), _Val, _Get_comp());
+        return _STD binary_search(cbegin(), cend(), _Val, _Get_comp_v());
     }
     template <class _Other>
         requires _Keylt_transparent
     _NODISCARD bool contains(const _Other& _Val) const {
-        return _STD binary_search(cbegin(), cend(), _Val, _Get_comp());
+        return _STD binary_search(cbegin(), cend(), _Val, _Get_comp_v());
     }
 
     _NODISCARD iterator lower_bound(const _Kty& _Val) {
-        return _STD lower_bound(begin(), end(), _Val, _Get_comp());
+        return _STD lower_bound(begin(), end(), _Val, _Get_comp_v());
     }
     _NODISCARD const_iterator lower_bound(const _Kty& _Val) const {
-        return _STD lower_bound(cbegin(), cend(), _Val, _Get_comp());
+        return _STD lower_bound(cbegin(), cend(), _Val, _Get_comp_v());
     }
 
     template <class _Other>
         requires _Keylt_transparent
     _NODISCARD iterator lower_bound(const _Other& _Val) {
-        return _STD lower_bound(begin(), end(), _Val, _Get_comp());
+        return _STD lower_bound(begin(), end(), _Val, _Get_comp_v());
     }
     template <class _Other>
         requires _Keylt_transparent
     _NODISCARD const_iterator lower_bound(const _Other& _Val) const {
-        return _STD lower_bound(cbegin(), cend(), _Val, _Get_comp());
+        return _STD lower_bound(cbegin(), cend(), _Val, _Get_comp_v());
     }
 
     _NODISCARD iterator upper_bound(const _Kty& _Val) {
-        return _STD upper_bound(begin(), end(), _Val, _Get_comp());
+        return _STD upper_bound(begin(), end(), _Val, _Get_comp_v());
     }
     _NODISCARD const_iterator upper_bound(const _Kty& _Val) const {
-        return _STD upper_bound(cbegin(), cend(), _Val, _Get_comp());
+        return _STD upper_bound(cbegin(), cend(), _Val, _Get_comp_v());
     }
 
     template <class _Other>
         requires _Keylt_transparent
     _NODISCARD iterator upper_bound(const _Other& _Val) {
-        return _STD upper_bound(begin(), end(), _Val, _Get_comp());
+        return _STD upper_bound(begin(), end(), _Val, _Get_comp_v());
     }
     template <class _Other>
         requires _Keylt_transparent
     _NODISCARD const_iterator upper_bound(const _Other& _Val) const {
-        return _STD upper_bound(cbegin(), cend(), _Val, _Get_comp());
+        return _STD upper_bound(cbegin(), cend(), _Val, _Get_comp_v());
     }
 
     _NODISCARD pair<iterator, iterator> equal_range(const _Kty& _Val) {
-        return _STD equal_range(begin(), end(), _Val, _Get_comp());
+        return _STD equal_range(begin(), end(), _Val, _Get_comp_v());
     }
     _NODISCARD pair<const_iterator, const_iterator> equal_range(const _Kty& _Val) const {
-        return _STD equal_range(cbegin(), cend(), _Val, _Get_comp());
+        return _STD equal_range(cbegin(), cend(), _Val, _Get_comp_v());
     }
 
     template <class _Other>
         requires _Keylt_transparent
     _NODISCARD pair<iterator, iterator> equal_range(const _Other& _Val) {
-        return _STD equal_range(begin(), end(), _Val, _Get_comp());
+        return _STD equal_range(begin(), end(), _Val, _Get_comp_v());
     }
     template <class _Other>
         requires _Keylt_transparent
     _NODISCARD pair<const_iterator, const_iterator> equal_range(const _Other& _Val) const {
-        return _STD equal_range(cbegin(), cend(), _Val, _Get_comp());
+        return _STD equal_range(cbegin(), cend(), _Val, _Get_comp_v());
     }
 
     _NODISCARD friend bool operator==(const _Deriv& _Lhs, const _Deriv& _Rhs) {
@@ -427,7 +431,7 @@ public:
 
 private:
     void _Assert_after_sorted_input() const {
-        _STL_ASSERT(_STD is_sorted(cbegin(), cend(), _Get_comp()), "Input was not sorted!");
+        _STL_ASSERT(_STD is_sorted(cbegin(), cend(), _Get_comp_v()), "Input was not sorted!");
         if constexpr (!_Multi) {
             _STL_ASSERT(_Is_unique(), "Input was sorted but not unique!");
         }
@@ -449,7 +453,6 @@ private:
 
     bool _Check_where(const const_iterator _Where, const _Kty& _Val) const {
         // check that _Val can be inserted before _Where
-        const key_compare& _Compare = _Get_comp();
         if constexpr (_Multi) {
             // check that _Where is the upper_bound for _Val
             // equivalent to checking *(_Where-1) <= _Val < *_Where
@@ -472,7 +475,7 @@ private:
         } else {
             const iterator _End   = end();
             const iterator _Where = lower_bound(_Val);
-            if (_Where != _End && _Keys_equal(*_Where, _Val)) {
+            if (_Where != _End && !_Compare(_Val, *_Where)) {
                 return pair{_Where, false};
             }
 
@@ -491,7 +494,7 @@ private:
     template <class _Ty>
     iterator _Emplace_hint(const_iterator _Where, _Ty&& _Val) {
         _Container& _Cont           = _Get_cont();
-        const key_compare& _Compare = _Get_comp();
+        auto _Comp                  = _Get_comp_v();
         const const_iterator _Begin = cbegin();
         const const_iterator _End   = cend();
 
@@ -503,11 +506,11 @@ private:
                     // _Val >= *(_Where-1) ~ upper_bound is _Where
                 } else {
                     // _Val < *(_Where-1) ~ upper_bound is in [_Begin,_Where-1]
-                    _Where = _STD upper_bound(_Begin, _Where - 1, _Val, _Compare);
+                    _Where = _STD upper_bound(_Begin, _Where - 1, _Val, _Comp);
                 }
             } else {
                 // _Val >= *_Where ~ upper_bound is in [_Where+1,_End]
-                _Where = _STD upper_bound(_Where + 1, _End, _Val, _Compare);
+                _Where = _STD upper_bound(_Where + 1, _End, _Val, _Comp);
             }
         } else {
             // look for the lower_bound for flat_set
@@ -517,11 +520,11 @@ private:
                     // _Val > *(_Where-1) ~ lower_bound is _Where
                 } else {
                     // _Val <= *(_Where-1) ~ lower_bound is in [_Begin,_Where-1]
-                    _Where = _STD lower_bound(_Begin, _Where - 1, _Val, _Compare);
+                    _Where = _STD lower_bound(_Begin, _Where - 1, _Val, _Comp);
                 }
             } else {
                 // _Val > *_Where ~ lower_bound is in [_Where+1,_End]
-                _Where = _STD lower_bound(_Where + 1, _End, _Val, _Compare);
+                _Where = _STD lower_bound(_Where + 1, _End, _Val, _Comp);
             }
         }
 
@@ -530,7 +533,7 @@ private:
             _STL_INTERNAL_CHECK(_Check_where(_Where, _Val));
             return _Cont.emplace(_Where, _STD forward<_Ty>(_Val));
         } else {
-            if (_Where != _End && _Keys_equal(_Val, *_Where)) {
+            if (_Where != _End && !_Compare(_Val, *_Where)) {
                 return _Cont.begin() + (_Where - _Begin);
             }
 
@@ -556,46 +559,51 @@ private:
     }
 
     template <class _Ty>
-        requires _Keylt_transparent || is_same_v<_Ty, _Kty>
     size_type _Erase(const _Ty& _Val) {
-        const auto [_First, _Last] = equal_range(_Val);
+        _STL_INTERNAL_STATIC_ASSERT(_Keylt_transparent || is_same_v<_Ty, _Kty>);
 
-        const auto _Removed = static_cast<size_type>(_Last - _First);
-        _Get_cont().erase(_First, _Last);
-        return _Removed;
+        if constexpr (!_Multi && is_same_v<_Ty, _Kty>) {
+            const iterator _Where = lower_bound(_Val);
+            if (_Where != end() && !_Compare(_Val, *_Where)) {
+                _Get_cont().erase(_Where);
+                return 1;
+            }
+            return 0;
+        } else {
+            const auto [_First, _Last] = equal_range(_Val);
+
+            const auto _Removed = static_cast<size_type>(_Last - _First);
+            _Get_cont().erase(_First, _Last);
+            return _Removed;
+        }
     }
 
-    template <class _Other>
-        requires _Keylt_transparent || is_same_v<_Other, _Kty>
-    _NODISCARD iterator _Find(const _Other& _Val) {
+    template <class _Ty>
+    _NODISCARD iterator _Find(const _Ty& _Val) {
+        _STL_INTERNAL_STATIC_ASSERT(_Keylt_transparent || is_same_v<_Ty, _Kty>);
+
         const iterator _End   = end();
         const iterator _Where = lower_bound(_Val);
-        if (_Where != _End && _Keys_equal(*_Where, _Val)) {
+        if (_Where != _End && !_Compare(_Val, *_Where)) {
             return _Where;
         } else {
             return _End;
         }
     }
 
-    template <class _Other>
-        requires _Keylt_transparent || is_same_v<_Other, _Kty>
-    _NODISCARD const_iterator _Find(const _Other& _Val) const {
+    template <class _Ty>
+    _NODISCARD const_iterator _Find(const _Ty& _Val) const {
+        _STL_INTERNAL_STATIC_ASSERT(_Keylt_transparent || is_same_v<_Ty, _Kty>);
+
         const const_iterator _End   = cend();
         const const_iterator _Where = lower_bound(_Val);
-        if (_Where != _End && _Keys_equal(*_Where, _Val)) {
+        if (_Where != _End && !_Compare(_Val, *_Where)) {
             return _Where;
         } else {
             return _End;
         }
     }
 
-    template <class _Lhty, class _Rhty>
-        requires _Keylt_transparent || (is_same_v<_Kty, _Lhty> && is_same_v<_Lhty, _Rhty>)
-    _NODISCARD bool _Keys_equal(const _Lhty& _Lhs, const _Rhty& _Rhs) const {
-        const key_compare& _Compare = _Get_comp();
-        return !_Compare(_Lhs, _Rhs) && !_Compare(_Rhs, _Lhs);
-    }
-
     void _Erase_dupes_if_needed() {
         if constexpr (!_Multi) {
             const iterator _End = end();
@@ -609,19 +617,20 @@ private:
 
     template <bool _Presorted>
     void _Restore_invariants_after_insert(const size_type _Old_size) {
-        const key_compare& _Compare = _Get_comp();
-        const iterator _Old_end     = begin() + static_cast<difference_type>(_Old_size);
-        const iterator _New_end     = end();
+        auto _Comp              = _Get_comp_v();
+        const iterator _Begin   = begin();
+        const iterator _Old_end = _Begin + static_cast<difference_type>(_Old_size);
+        const iterator _New_end = end();
 
         if constexpr (!_Presorted) {
-            _STD sort(_Old_end, _New_end, _Compare);
+            _STD sort(_Old_end, _New_end, _Comp);
         } else {
-            _STL_ASSERT(_STD is_sorted(_Old_end, _New_end, _Compare), "Input was not sorted!");
+            _STL_ASSERT(_STD is_sorted(_Old_end, _New_end, _Comp), "Input was not sorted!");
         }
 
-        _STD inplace_merge(begin(), _Old_end, _New_end, _Compare);
+        _STD inplace_merge(_Begin, _Old_end, _New_end, _Comp);
 
-        _STL_INTERNAL_CHECK(_STD is_sorted(begin(), end(), _Compare));
+        _STL_INTERNAL_CHECK(_STD is_sorted(_Begin, _New_end, _Comp));
 
         _Erase_dupes_if_needed();
     }
@@ -635,17 +644,33 @@ private:
         }
 
         // O(N) if already sorted.
-        const key_compare& _Compare    = _Get_comp();
-        const iterator _Begin_unsorted = _STD is_sorted_until(_Begin, _End, _Compare);
+        auto _Comp                     = _Get_comp_v();
+        const iterator _Begin_unsorted = _STD is_sorted_until(_Begin, _End, _Comp);
 
-        _STD sort(_Begin_unsorted, _End, _Compare);
-        _STD inplace_merge(_Begin, _Begin_unsorted, _End, _Compare);
+        _STD sort(_Begin_unsorted, _End, _Comp);
+        _STD inplace_merge(_Begin, _Begin_unsorted, _End, _Comp);
 
-        _STL_INTERNAL_CHECK(_STD is_sorted(_Begin, _End, _Compare));
+        _STL_INTERNAL_CHECK(_STD is_sorted(_Begin, _End, _Comp));
 
         _Erase_dupes_if_needed();
     }
 
+    template <class _Lty, class _Rty>
+    _NODISCARD bool _Compare(const _Lty& _Lhs, const _Rty& _Rhs) const
+        noexcept(noexcept(_DEBUG_LT_PRED(_My_pair._Get_first(), _Lhs, _Rhs))) {
+        _STL_INTERNAL_STATIC_ASSERT(_Keylt_transparent || (is_same_v<_Kty, _Lty> && is_same_v<_Kty, _Rty>) );
+
+        return _DEBUG_LT_PRED(_My_pair._Get_first(), _Lhs, _Rhs);
+    }
+
+    template <class _Lty, class _Rty>
+    _NODISCARD bool _Keys_equal(const _Lty& _Lhs, const _Rty& _Rhs) const
+        noexcept(noexcept(!_Compare(_Lhs, _Rhs) && !_Compare(_Rhs, _Lhs))) {
+        _STL_INTERNAL_STATIC_ASSERT(_Keylt_transparent || (is_same_v<_Kty, _Lty> && is_same_v<_Kty, _Rty>) );
+
+        return !_Compare(_Lhs, _Rhs) && !_Compare(_Rhs, _Lhs);
+    }
+
     _NODISCARD const _Container& _Get_cont() const noexcept {
         return _My_pair._Myval2;
     }
@@ -662,6 +687,10 @@ private:
         return _My_pair._Get_first();
     }
 
+    _NODISCARD auto _Get_comp_v() const noexcept {
+        return _STD _Pass_fn(_My_pair._Get_first());
+    }
+
     _Compressed_pair<key_compare, container_type> _My_pair;
 };
 

From e23a4e2a05eeaea9cc93b640828288080a3b7ad2 Mon Sep 17 00:00:00 2001
From: achabense <60953653+achabense@users.noreply.github.com>
Date: Thu, 28 Sep 2023 04:07:34 +0800
Subject: [PATCH 009/134] Fixes for `flat_set` (#4050)

Co-authored-by: Stephan T. Lavavej <stl@nuwen.net>
---
 stl/inc/flat_set                          | 141 +++++++++++-----------
 tests/std/tests/P1222R4_flat_set/test.cpp | 126 ++++++++++++++++++-
 2 files changed, 197 insertions(+), 70 deletions(-)

diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index d39368763f7..1efe93be36c 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -25,16 +25,21 @@ _STL_DISABLE_CLANG_WARNINGS
 
 _STD_BEGIN
 
-template <class _Ty>
-struct _NODISCARD _Clear_scope_guard {
-    _Ty* _Clearable;
-    ~_Clear_scope_guard() {
-        if (_Clearable) {
-            _Clearable->clear();
+template <class _Ty, bool _Noexcept = false>
+struct _NODISCARD _Clear_guard {
+    _Ty* _Target;
+    ~_Clear_guard() {
+        if (_Target) {
+            _Target->clear();
         }
     }
 };
 
+template <class _Ty>
+struct [[maybe_unused]] _NODISCARD _Clear_guard<_Ty, true> {
+    _Ty* _Target; // do nothing as the guarded operations don't throw.
+};
+
 template <class _Alloc, class _Container>
 concept _Allocator_for = uses_allocator_v<_Container, _Alloc>;
 
@@ -86,7 +91,7 @@ public:
 
     _Base_flat_set(_Tsorted, container_type _Cont, const key_compare& _Comp = key_compare())
         : _My_pair(_One_then_variadic_args_t{}, _Comp, _STD move(_Cont)) {
-        _Assert_after_sorted_input();
+        _STL_ASSERT(_Check_sorted(cbegin(), cend()), _Msg_not_sorted);
     }
     template <_Allocator_for<container_type> _Alloc>
     _Base_flat_set(_Tsorted _Tsort, const container_type& _Cont, const _Alloc& _Al)
@@ -152,8 +157,10 @@ public:
         : _Base_flat_set(_Tsort, container_type(_Ilist.begin(), _Ilist.end(), _Al)) {}
 
     _Deriv& operator=(initializer_list<_Kty> _Ilist) {
+        _Clear_guard<_Base_flat_set> _Guard{this};
         _Get_cont().assign(_Ilist.begin(), _Ilist.end());
         _Make_invariants_fulfilled();
+        _Guard._Target = nullptr;
         return static_cast<_Deriv&>(*this);
     }
 
@@ -228,25 +235,25 @@ public:
         }
     }
 
-    auto insert(const value_type& _Val) {
+    auto insert(const _Kty& _Val) {
         return _Emplace(_Val);
     }
-    auto insert(value_type&& _Val) {
+    auto insert(_Kty&& _Val) {
         return _Emplace(_STD move(_Val));
     }
-    template <class _Other>
+    template <_Different_from<_Kty> _Other>
         requires (!_Multi && _Keylt_transparent && is_constructible_v<_Kty, _Other>)
     auto insert(_Other&& _Val) {
         return _Emplace(_STD forward<_Other>(_Val));
     }
 
-    iterator insert(const_iterator _Hint, const value_type& _Val) {
+    iterator insert(const_iterator _Hint, const _Kty& _Val) {
         return _Emplace_hint(_Hint, _Val);
     }
-    iterator insert(const_iterator _Hint, value_type&& _Val) {
+    iterator insert(const_iterator _Hint, _Kty&& _Val) {
         return _Emplace_hint(_Hint, _STD move(_Val));
     }
-    template <class _Other>
+    template <_Different_from<_Kty> _Other>
         requires (!_Multi && _Keylt_transparent && is_constructible_v<_Kty, _Other>)
     iterator insert(const_iterator _Hint, _Other&& _Val) {
         return _Emplace_hint(_Hint, _STD forward<_Other>(_Val));
@@ -263,7 +270,15 @@ public:
     template <_Container_compatible_range<_Kty> _Rng>
     void insert_range(_Rng&& _Range) {
         const size_type _Old_size = size();
-        _Get_cont().append_range(_STD forward<_Rng>(_Range));
+
+        _Container& _Cont = _Get_cont();
+        if constexpr (requires { _Cont.append_range(_STD forward<_Rng>(_Range)); }) {
+            _Cont.append_range(_STD forward<_Rng>(_Range));
+        } else {
+            for (const auto& _Val : _Range) {
+                _Cont.insert(_Cont.end(), _Val);
+            }
+        }
         _Restore_invariants_after_insert<false>(_Old_size);
     }
 
@@ -274,14 +289,16 @@ public:
         _Insert_range<true>(_Ilist.begin(), _Ilist.end());
     }
 
-    _NODISCARD container_type extract() && {
+    _NODISCARD container_type extract() && noexcept(is_nothrow_move_constructible_v<_Container>) /* strengthened */ {
         // always clears the container (N4950 [flat.set.modifiers]/14 and [flat.multiset.modifiers]/10)
-        _Clear_scope_guard<_Base_flat_set> _Guard{this};
+        _Clear_guard<_Base_flat_set, is_nothrow_move_constructible_v<_Container>> _Guard{this};
         return _STD move(_Get_cont());
     }
     void replace(container_type&& _Cont) {
-        _Get_cont() = _STD move(_Cont);
-        _Assert_after_sorted_input();
+        _STL_ASSERT(_Check_sorted(_Cont.cbegin(), _Cont.cend()), _Msg_not_sorted);
+        _Clear_guard<_Base_flat_set, is_nothrow_move_assignable_v<_Container>> _Guard{this};
+        _Get_cont()    = _STD move(_Cont);
+        _Guard._Target = nullptr;
     }
 
     iterator erase(iterator _Where) {
@@ -293,7 +310,7 @@ public:
     size_type erase(const _Kty& _Val) {
         return _Erase(_Val);
     }
-    template <class _Other>
+    template <_Different_from<_Kty> _Other>
         requires (
             _Keylt_transparent && !is_convertible_v<_Other, iterator> && !is_convertible_v<_Other, const_iterator>)
     size_type erase(_Other&& _Val) {
@@ -339,11 +356,11 @@ public:
     }
 
     _NODISCARD size_type count(const _Kty& _Val) const {
-        if constexpr (!_Multi) {
-            return contains(_Val);
-        } else {
+        if constexpr (_Multi) {
             const auto [_First, _Last] = equal_range(_Val);
             return static_cast<size_type>(_Last - _First);
+        } else {
+            return contains(_Val);
         }
     }
     template <class _Other>
@@ -420,7 +437,7 @@ public:
         return _RANGES equal(_Lhs._Get_cont(), _Rhs._Get_cont());
     }
 
-    _NODISCARD friend _Synth_three_way_result<_Kty> operator<=>(const _Deriv& _Lhs, const _Deriv& _Rhs) {
+    _NODISCARD friend auto operator<=>(const _Deriv& _Lhs, const _Deriv& _Rhs) {
         return _STD lexicographical_compare_three_way(
             _Lhs.cbegin(), _Lhs.cend(), _Rhs.cbegin(), _Rhs.cend(), _Synth_three_way{});
     }
@@ -430,28 +447,26 @@ public:
     }
 
 private:
-    void _Assert_after_sorted_input() const {
-        _STL_ASSERT(_STD is_sorted(cbegin(), cend(), _Get_comp_v()), "Input was not sorted!");
-        if constexpr (!_Multi) {
-            _STL_ASSERT(_Is_unique(), "Input was sorted but not unique!");
-        }
-    }
-
-    bool _Is_unique() const {
-        if (empty()) {
-            return true;
-        }
-        const const_iterator _End = cend();
-        const_iterator _It        = cbegin();
-        while (++_It != _End) {
-            if (_Keys_equal(*(_It - 1), *_It)) {
-                return false;
+    _NODISCARD bool _Check_sorted(const_iterator _It, const const_iterator _End) const {
+        if constexpr (_Multi) {
+            return _STD is_sorted(_It, _End, _Get_comp_v());
+        } else {
+            // sorted-unique
+            if (_It == _End) {
+                return true;
             }
+            while (++_It != _End) {
+                if (!_Compare(*(_It - 1), *_It)) {
+                    return false;
+                }
+            }
+            return true;
         }
-        return true;
     }
 
-    bool _Check_where(const const_iterator _Where, const _Kty& _Val) const {
+    static constexpr const char* _Msg_not_sorted = _Multi ? "Input was not sorted!" : "Input was not sorted-unique!";
+
+    _NODISCARD bool _Check_where(const const_iterator _Where, const _Kty& _Val) const {
         // check that _Val can be inserted before _Where
         if constexpr (_Multi) {
             // check that _Where is the upper_bound for _Val
@@ -604,14 +619,14 @@ private:
         }
     }
 
-    void _Erase_dupes_if_needed() {
+    void _Erase_dupes_if_not_multi() {
         if constexpr (!_Multi) {
-            const iterator _End = end();
-            const iterator _New_end =
-                _STD unique(begin(), _End, [&](const _Kty& _Lhs, const _Kty& _Rhs) { return _Keys_equal(_Lhs, _Rhs); });
+            const auto _Equal_to = [this](const _Kty& _Lhs, const _Kty& _Rhs) {
+                return !_Compare(_Lhs, _Rhs) && !_Compare(_Rhs, _Lhs);
+            };
+            const iterator _End     = end();
+            const iterator _New_end = _STD unique(begin(), _End, _Equal_to);
             _Get_cont().erase(_New_end, _End);
-
-            _STL_INTERNAL_CHECK(_Is_unique());
         }
     }
 
@@ -625,14 +640,13 @@ private:
         if constexpr (!_Presorted) {
             _STD sort(_Old_end, _New_end, _Comp);
         } else {
-            _STL_ASSERT(_STD is_sorted(_Old_end, _New_end, _Comp), "Input was not sorted!");
+            _STL_ASSERT(_Check_sorted(_Old_end, _New_end), _Msg_not_sorted);
         }
 
         _STD inplace_merge(_Begin, _Old_end, _New_end, _Comp);
+        _Erase_dupes_if_not_multi();
 
-        _STL_INTERNAL_CHECK(_STD is_sorted(_Begin, _New_end, _Comp));
-
-        _Erase_dupes_if_needed();
+        _STL_INTERNAL_CHECK(_Check_sorted(cbegin(), cend()));
     }
 
     void _Make_invariants_fulfilled() {
@@ -649,10 +663,9 @@ private:
 
         _STD sort(_Begin_unsorted, _End, _Comp);
         _STD inplace_merge(_Begin, _Begin_unsorted, _End, _Comp);
+        _Erase_dupes_if_not_multi();
 
-        _STL_INTERNAL_CHECK(_STD is_sorted(_Begin, _End, _Comp));
-
-        _Erase_dupes_if_needed();
+        _STL_INTERNAL_CHECK(_Check_sorted(cbegin(), cend()));
     }
 
     template <class _Lty, class _Rty>
@@ -663,14 +676,6 @@ private:
         return _DEBUG_LT_PRED(_My_pair._Get_first(), _Lhs, _Rhs);
     }
 
-    template <class _Lty, class _Rty>
-    _NODISCARD bool _Keys_equal(const _Lty& _Lhs, const _Rty& _Rhs) const
-        noexcept(noexcept(!_Compare(_Lhs, _Rhs) && !_Compare(_Rhs, _Lhs))) {
-        _STL_INTERNAL_STATIC_ASSERT(_Keylt_transparent || (is_same_v<_Kty, _Lty> && is_same_v<_Kty, _Rty>) );
-
-        return !_Compare(_Lhs, _Rhs) && !_Compare(_Rhs, _Lhs);
-    }
-
     _NODISCARD const _Container& _Get_cont() const noexcept {
         return _My_pair._Myval2;
     }
@@ -729,18 +734,18 @@ public:
 _EXPORT_STD template <class _Kty, class _Keylt, class _Container, class _Pred>
 _Container::size_type erase_if(flat_set<_Kty, _Keylt, _Container>& _Val, _Pred _Predicate) {
     // clears the container to maintain the invariants when an exception is thrown (N4950 [flat.set.erasure]/5)
-    _Clear_scope_guard<flat_set<_Kty, _Keylt, _Container>> _Guard{_STD addressof(_Val)};
-    const auto _Erased_count = _Erase_remove_if(_Val, _Pass_fn(_Predicate));
-    _Guard._Clearable        = nullptr;
+    _Clear_guard<flat_set<_Kty, _Keylt, _Container>> _Guard{_STD addressof(_Val)};
+    const auto _Erased_count = _STD _Erase_remove_if(_Val, _STD _Pass_fn(_Predicate));
+    _Guard._Target           = nullptr;
     return _Erased_count;
 }
 
 _EXPORT_STD template <class _Kty, class _Keylt, class _Container, class _Pred>
 _Container::size_type erase_if(flat_multiset<_Kty, _Keylt, _Container>& _Val, _Pred _Predicate) {
     // clears the container to maintain the invariants when an exception is thrown (N4950 [flat.multiset.erasure]/5)
-    _Clear_scope_guard<flat_multiset<_Kty, _Keylt, _Container>> _Guard{_STD addressof(_Val)};
-    const auto _Erased_count = _Erase_remove_if(_Val, _Pass_fn(_Predicate));
-    _Guard._Clearable        = nullptr;
+    _Clear_guard<flat_multiset<_Kty, _Keylt, _Container>> _Guard{_STD addressof(_Val)};
+    const auto _Erased_count = _STD _Erase_remove_if(_Val, _STD _Pass_fn(_Predicate));
+    _Guard._Target           = nullptr;
     return _Erased_count;
 }
 
diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index 7422f959fca..9bb2adcd0df 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -8,6 +8,7 @@
 #include <functional>
 #include <iostream>
 #include <memory>
+#include <random>
 #include <vector>
 
 using namespace std;
@@ -235,6 +236,124 @@ void test_insert_2() {
     }
 }
 
+struct key_comparer {
+    const auto& extract_key(const auto& obj) const {
+        if constexpr (requires { obj.key; }) {
+            return obj.key;
+        } else {
+            return obj;
+        }
+    }
+
+    bool operator()(const auto& lhs, const auto& rhs) const {
+        return extract_key(lhs) < extract_key(rhs);
+    }
+
+    using is_transparent = int;
+};
+
+void test_comparer_application() {
+    // The set must rely on its comparer to do the comparisons.
+    struct incomparable {
+        int key;
+        bool operator<(const incomparable&) const  = delete;
+        bool operator==(const incomparable&) const = delete;
+    };
+
+    flat_set<incomparable, key_comparer> fs{{0}, {3}, {1}, {0}, {5}};
+    assert(fs.contains(0));
+    assert(!fs.contains(2));
+    fs.insert(fs.begin(), incomparable{4});
+    fs.insert(2);
+    assert(fs.contains(4));
+    assert(fs.contains(incomparable{2}));
+
+    assert(fs.lower_bound(3) == fs.lower_bound(incomparable{3}));
+    fs.erase(2);
+    assert(!fs.contains(incomparable{2}));
+}
+
+void test_insert_transparent() {
+    // For flat_set::insert([hint,]auto&&), the input should be unchanged if the set already
+    // contains an equivalent element.
+    struct detect_conversion {
+        int key;
+        mutable bool converted = false;
+
+        explicit operator int() const {
+            converted = true;
+            return key;
+        }
+    };
+
+    flat_set<int, key_comparer> fs{0, 3, 5};
+    assert_all_requirements_and_equals(fs, {0, 3, 5});
+    detect_conversion detector{3};
+
+    assert(!detector.converted);
+    fs.insert(detector /*3*/);
+    assert_all_requirements_and_equals(fs, {0, 3, 5});
+    assert(!detector.converted);
+
+    detector.key = 1;
+
+    assert(!detector.converted);
+    fs.insert(detector /*1*/);
+    assert_all_requirements_and_equals(fs, {0, 1, 3, 5});
+    assert(detector.converted);
+
+    detector.converted = false;
+
+    assert(!detector.converted);
+    fs.insert(fs.end(), detector /*1*/);
+    assert_all_requirements_and_equals(fs, {0, 1, 3, 5});
+    assert(!detector.converted);
+
+    detector.key = 2;
+
+    assert(!detector.converted);
+    fs.insert(fs.begin(), detector /*2*/);
+    assert_all_requirements_and_equals(fs, {0, 1, 2, 3, 5});
+    assert(detector.converted);
+}
+
+void test_insert_using_invalid_hint() {
+    mt19937 eng(42);
+
+    uniform_int_distribution<int> dist_seq(0, 20);
+
+    vector<int> seq(200);
+    for (int& val : seq) {
+        val = dist_seq(eng);
+    }
+
+    {
+        flat_multiset<int> with_hint;
+        flat_multiset<int> no_hint;
+        for (const int val : seq) {
+            uniform_int_distribution<int> dist_idx(0, static_cast<int>(with_hint.size()));
+            auto random_hint = with_hint.begin() + dist_idx(eng);
+            with_hint.insert(random_hint, val);
+            no_hint.insert(val);
+        }
+
+        assert(with_hint == no_hint);
+    }
+
+    {
+        flat_set<int> with_hint;
+        flat_set<int> no_hint;
+        for (const int val : seq) {
+            uniform_int_distribution<int> dist_idx(0, static_cast<int>(with_hint.size()));
+            auto random_hint = with_hint.begin() + dist_idx(eng);
+            with_hint.insert(random_hint, val);
+            no_hint.insert(val);
+        }
+
+        assert(with_hint == no_hint);
+    }
+}
+
 template <class T>
 void test_spaceship_operator() {
     static constexpr bool multi  = _Is_specialization_v<T, flat_multiset>;
@@ -342,8 +461,8 @@ void test_count() {
     flat_set<int> fs{2};
     assert(fs.count(1) == 0);
 
-    flat_multiset<int> fs2{1, 2, 2, 3};
-    assert(fs2.count(2) == 2);
+    flat_multiset<int> fs2{10, 20, 20, 30};
+    assert(fs2.count(20) == 2);
 }
 
 int main() {
@@ -363,7 +482,10 @@ int main() {
     test_insert_1<deque<int>>();
     test_insert_2<vector<int>>();
     test_insert_2<deque<int>>();
+    test_insert_transparent();
+    test_insert_using_invalid_hint();
 
+    test_comparer_application();
     test_non_static_comparer();
 
     test_extract<flat_set<int>>();

From b37931c69cb9ee1f7a650f5957e8c2faeece08e0 Mon Sep 17 00:00:00 2001
From: achabense <60953653+achabense@users.noreply.github.com>
Date: Tue, 3 Oct 2023 09:20:38 +0800
Subject: [PATCH 010/134] Cleanups for `<flat_set>` (#4064)

Co-authored-by: Stephan T. Lavavej <stl@nuwen.net>
---
 stl/inc/flat_set                          | 340 +++++++++++-----------
 tests/std/tests/P1222R4_flat_set/test.cpp |  95 ++++--
 2 files changed, 240 insertions(+), 195 deletions(-)

diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index 1efe93be36c..a8c5cd92748 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -25,7 +25,7 @@ _STL_DISABLE_CLANG_WARNINGS
 
 _STD_BEGIN
 
-template <class _Ty, bool _Noexcept = false>
+template <class _Ty>
 struct _NODISCARD _Clear_guard {
     _Ty* _Target;
     ~_Clear_guard() {
@@ -35,11 +35,6 @@ struct _NODISCARD _Clear_guard {
     }
 };
 
-template <class _Ty>
-struct [[maybe_unused]] _NODISCARD _Clear_guard<_Ty, true> {
-    _Ty* _Target; // do nothing as the guarded operations don't throw.
-};
-
 template <class _Alloc, class _Container>
 concept _Allocator_for = uses_allocator_v<_Container, _Alloc>;
 
@@ -70,17 +65,17 @@ public:
     static_assert(random_access_iterator<iterator>, "The C++ Standard forbids containers without random "
                                                     "access iterators from being adapted. See [flatset.overview].");
 
-    _Base_flat_set() : _My_pair(_Zero_then_variadic_args_t{}) {}
+    _Base_flat_set() : _Mycont(), _Mycomp() {}
 
+    // TRANSITION, "_Mycomp" may need to be copied, even in move construction / assignment.
     template <_Allocator_for<container_type> _Alloc>
-    _Base_flat_set(const _Deriv& _Set, const _Alloc& _Al)
-        : _My_pair(_One_then_variadic_args_t{}, _Set._Get_comp(), _Set._Get_cont(), _Al) {}
+    _Base_flat_set(const _Deriv& _Set, const _Alloc& _Al) : _Mycont(_Set._Mycont, _Al), _Mycomp(_Set._Mycomp) {}
     template <_Allocator_for<container_type> _Alloc>
     _Base_flat_set(_Deriv&& _Set, const _Alloc& _Al)
-        : _My_pair(_One_then_variadic_args_t{}, _STD move(_Set._Get_comp()), _STD move(_Set._Get_cont()), _Al) {}
+        : _Mycont(_STD move(_Set._Mycont), _Al), _Mycomp(_STD move(_Set._Mycomp)) {}
 
     explicit _Base_flat_set(container_type _Cont, const key_compare& _Comp = key_compare())
-        : _My_pair(_One_then_variadic_args_t{}, _Comp, _STD move(_Cont)) {
+        : _Mycont(_STD move(_Cont)), _Mycomp(_Comp) {
         _Make_invariants_fulfilled();
     }
     template <_Allocator_for<container_type> _Alloc>
@@ -90,8 +85,8 @@ public:
         : _Base_flat_set(container_type(_Cont, _Al), _Comp) {}
 
     _Base_flat_set(_Tsorted, container_type _Cont, const key_compare& _Comp = key_compare())
-        : _My_pair(_One_then_variadic_args_t{}, _Comp, _STD move(_Cont)) {
-        _STL_ASSERT(_Check_sorted(cbegin(), cend()), _Msg_not_sorted);
+        : _Mycont(_STD move(_Cont)), _Mycomp(_Comp) {
+        _STL_ASSERT(_Is_sorted(_Mycont), _Msg_not_sorted);
     }
     template <_Allocator_for<container_type> _Alloc>
     _Base_flat_set(_Tsorted _Tsort, const container_type& _Cont, const _Alloc& _Al)
@@ -100,12 +95,13 @@ public:
     _Base_flat_set(_Tsorted _Tsort, const container_type& _Cont, const key_compare& _Comp, const _Alloc& _Al)
         : _Base_flat_set(_Tsort, container_type(_Cont, _Al), _Comp) {}
 
-    explicit _Base_flat_set(const key_compare& _Comp) : _My_pair(_One_then_variadic_args_t{}, _Comp) {}
+    explicit _Base_flat_set(const key_compare& _Comp) : _Mycont(), _Mycomp(_Comp) {}
     template <_Allocator_for<container_type> _Alloc>
-    _Base_flat_set(const key_compare& _Comp, const _Alloc& _Al) : _My_pair(_One_then_variadic_args_t{}, _Comp, _Al) {}
+    _Base_flat_set(const key_compare& _Comp, const _Alloc& _Al) : _Mycont(_Al), _Mycomp(_Comp) {}
     template <_Allocator_for<container_type> _Alloc>
-    explicit _Base_flat_set(const _Alloc& _Al) : _My_pair(_Zero_then_variadic_args_t{}, _Al) {}
+    explicit _Base_flat_set(const _Alloc& _Al) : _Mycont(_Al), _Mycomp() {}
 
+    // TRANSITION, an allocator-aware container may not support "C(_First, _Last, _Al)".
     template <input_iterator _Iter>
     _Base_flat_set(_Iter _First, _Iter _Last, const key_compare& _Comp = key_compare())
         : _Base_flat_set(container_type(_First, _Last), _Comp) {}
@@ -115,6 +111,7 @@ public:
     template <input_iterator _Iter, _Allocator_for<container_type> _Alloc>
     _Base_flat_set(_Iter _First, _Iter _Last, const _Alloc& _Al) : _Base_flat_set(container_type(_First, _Last, _Al)) {}
 
+    // TRANSITION, an allocator-aware container may not support "C(from_range, _STD forward<_Rng>(_Range), _Al)".
     template <_Container_compatible_range<_Kty> _Rng>
     _Base_flat_set(from_range_t, _Rng&& _Range)
         : _Base_flat_set(container_type(from_range, _STD forward<_Rng>(_Range))) {}
@@ -138,27 +135,27 @@ public:
     _Base_flat_set(_Tsorted _Tsort, _Iter _First, _Iter _Last, const _Alloc& _Al)
         : _Base_flat_set(_Tsort, container_type(_First, _Last, _Al)) {}
 
+    // TRANSITION, an allocator-aware container may not support "C(_Ilist, _Al)".
     _Base_flat_set(initializer_list<_Kty> _Ilist, const key_compare& _Comp = key_compare())
-        : _Base_flat_set(container_type(_Ilist.begin(), _Ilist.end()), _Comp) {}
+        : _Base_flat_set(container_type(_Ilist), _Comp) {}
     template <_Allocator_for<container_type> _Alloc>
     _Base_flat_set(initializer_list<_Kty> _Ilist, const key_compare& _Comp, const _Alloc& _Al)
-        : _Base_flat_set(container_type(_Ilist.begin(), _Ilist.end(), _Al), _Comp) {}
+        : _Base_flat_set(container_type(_Ilist, _Al), _Comp) {}
     template <_Allocator_for<container_type> _Alloc>
-    _Base_flat_set(initializer_list<_Kty> _Ilist, const _Alloc& _Al)
-        : _Base_flat_set(container_type(_Ilist.begin(), _Ilist.end(), _Al)) {}
+    _Base_flat_set(initializer_list<_Kty> _Ilist, const _Alloc& _Al) : _Base_flat_set(container_type(_Ilist, _Al)) {}
 
     _Base_flat_set(_Tsorted _Tsort, initializer_list<_Kty> _Ilist, const key_compare& _Comp = key_compare())
-        : _Base_flat_set(_Tsort, container_type(_Ilist.begin(), _Ilist.end()), _Comp) {}
+        : _Base_flat_set(_Tsort, container_type(_Ilist), _Comp) {}
     template <_Allocator_for<container_type> _Alloc>
     _Base_flat_set(_Tsorted _Tsort, initializer_list<_Kty> _Ilist, const key_compare& _Comp, const _Alloc& _Al)
-        : _Base_flat_set(_Tsort, container_type(_Ilist.begin(), _Ilist.end(), _Al), _Comp) {}
+        : _Base_flat_set(_Tsort, container_type(_Ilist, _Al), _Comp) {}
     template <_Allocator_for<container_type> _Alloc>
     _Base_flat_set(_Tsorted _Tsort, initializer_list<_Kty> _Ilist, const _Alloc& _Al)
-        : _Base_flat_set(_Tsort, container_type(_Ilist.begin(), _Ilist.end(), _Al)) {}
+        : _Base_flat_set(_Tsort, container_type(_Ilist, _Al)) {}
 
     _Deriv& operator=(initializer_list<_Kty> _Ilist) {
         _Clear_guard<_Base_flat_set> _Guard{this};
-        _Get_cont().assign(_Ilist.begin(), _Ilist.end());
+        _Mycont.assign(_Ilist);
         _Make_invariants_fulfilled();
         _Guard._Target = nullptr;
         return static_cast<_Deriv&>(*this);
@@ -166,16 +163,16 @@ public:
 
     // iterators
     _NODISCARD iterator begin() noexcept {
-        return _Get_cont().begin();
+        return _Mycont.begin();
     }
     _NODISCARD const_iterator begin() const noexcept {
-        return _Get_cont().begin();
+        return _Mycont.begin();
     }
     _NODISCARD iterator end() noexcept {
-        return _Get_cont().end();
+        return _Mycont.end();
     }
     _NODISCARD const_iterator end() const noexcept {
-        return _Get_cont().end();
+        return _Mycont.end();
     }
 
     _NODISCARD reverse_iterator rbegin() noexcept {
@@ -192,10 +189,10 @@ public:
     }
 
     _NODISCARD const_iterator cbegin() const noexcept {
-        return begin();
+        return _Mycont.cbegin();
     }
     _NODISCARD const_iterator cend() const noexcept {
-        return end();
+        return _Mycont.cend();
     }
     _NODISCARD const_reverse_iterator crbegin() const noexcept {
         return rbegin();
@@ -206,16 +203,18 @@ public:
 
     // capacity
     _NODISCARD_EMPTY_MEMBER bool empty() const noexcept {
-        return _Get_cont().empty();
+        return _Mycont.empty();
     }
     _NODISCARD size_type size() const noexcept {
-        return _Get_cont().size();
+        return _Mycont.size();
     }
     _NODISCARD size_type max_size() const noexcept {
-        return _Get_cont().max_size();
+        return _Mycont.max_size();
     }
 
     // modifiers
+    // TRANSITION, the "insert" and "erase" methods may not be able to restore the invariant, if the underlying
+    // container is unable to provide strong guarantee for "erase" and "insert" methods.
     template <class... _Args>
     auto emplace(_Args&&... _Vals) {
         constexpr bool _Is_key_type = _In_place_key_extract_set<_Kty, remove_cvref_t<_Args>...>::_Extractable;
@@ -271,13 +270,10 @@ public:
     void insert_range(_Rng&& _Range) {
         const size_type _Old_size = size();
 
-        _Container& _Cont = _Get_cont();
-        if constexpr (requires { _Cont.append_range(_STD forward<_Rng>(_Range)); }) {
-            _Cont.append_range(_STD forward<_Rng>(_Range));
+        if constexpr (requires { _Mycont.append_range(_STD forward<_Rng>(_Range)); }) {
+            _Mycont.append_range(_STD forward<_Rng>(_Range));
         } else {
-            for (const auto& _Val : _Range) {
-                _Cont.insert(_Cont.end(), _Val);
-            }
+            _Mycont.insert_range(_Mycont.end(), _STD forward<_Rng>(_Range));
         }
         _Restore_invariants_after_insert<false>(_Old_size);
     }
@@ -289,23 +285,24 @@ public:
         _Insert_range<true>(_Ilist.begin(), _Ilist.end());
     }
 
-    _NODISCARD container_type extract() && noexcept(is_nothrow_move_constructible_v<_Container>) /* strengthened */ {
+    _NODISCARD container_type extract() && noexcept(
+        is_nothrow_move_constructible_v<container_type>) /* strengthened */ {
         // always clears the container (N4950 [flat.set.modifiers]/14 and [flat.multiset.modifiers]/10)
-        _Clear_guard<_Base_flat_set, is_nothrow_move_constructible_v<_Container>> _Guard{this};
-        return _STD move(_Get_cont());
+        _Clear_guard<_Base_flat_set> _Guard{this};
+        return _STD move(_Mycont);
     }
     void replace(container_type&& _Cont) {
-        _STL_ASSERT(_Check_sorted(_Cont.cbegin(), _Cont.cend()), _Msg_not_sorted);
-        _Clear_guard<_Base_flat_set, is_nothrow_move_assignable_v<_Container>> _Guard{this};
-        _Get_cont()    = _STD move(_Cont);
+        _STL_ASSERT(_Is_sorted(_Cont), _Msg_not_sorted);
+        _Clear_guard<_Base_flat_set> _Guard{this};
+        _Mycont        = _STD move(_Cont);
         _Guard._Target = nullptr;
     }
 
     iterator erase(iterator _Where) {
-        return _Get_cont().erase(_Where);
+        return _Mycont.erase(_Where);
     }
     iterator erase(const_iterator _Where) {
-        return _Get_cont().erase(_Where);
+        return _Mycont.erase(_Where);
     }
     size_type erase(const _Kty& _Val) {
         return _Erase(_Val);
@@ -317,23 +314,23 @@ public:
         return _Erase(_Val);
     }
     iterator erase(const_iterator _First, const_iterator _Last) {
-        return _Get_cont().erase(_First, _Last);
+        return _Mycont.erase(_First, _Last);
     }
 
     void swap(_Deriv& _Other) noexcept {
-        _RANGES swap(_Get_comp(), _Other._Get_comp());
-        _RANGES swap(_Get_cont(), _Other._Get_cont());
+        _RANGES swap(_Mycomp, _Other._Mycomp);
+        _RANGES swap(_Mycont, _Other._Mycont);
     }
     void clear() noexcept {
-        _Get_cont().clear();
+        _Mycont.clear();
     }
 
     // observers
     _NODISCARD key_compare key_comp() const {
-        return _Get_comp();
+        return _Mycomp;
     }
     _NODISCARD value_compare value_comp() const {
-        return _Get_comp();
+        return _Mycomp;
     }
 
     // set operations
@@ -371,70 +368,70 @@ public:
     }
 
     _NODISCARD bool contains(const _Kty& _Val) const {
-        return _STD binary_search(cbegin(), cend(), _Val, _Get_comp_v());
+        return _STD binary_search(cbegin(), cend(), _Val, _Pass_comp());
     }
     template <class _Other>
         requires _Keylt_transparent
     _NODISCARD bool contains(const _Other& _Val) const {
-        return _STD binary_search(cbegin(), cend(), _Val, _Get_comp_v());
+        return _STD binary_search(cbegin(), cend(), _Val, _Pass_comp());
     }
 
     _NODISCARD iterator lower_bound(const _Kty& _Val) {
-        return _STD lower_bound(begin(), end(), _Val, _Get_comp_v());
+        return _STD lower_bound(begin(), end(), _Val, _Pass_comp());
     }
     _NODISCARD const_iterator lower_bound(const _Kty& _Val) const {
-        return _STD lower_bound(cbegin(), cend(), _Val, _Get_comp_v());
+        return _STD lower_bound(cbegin(), cend(), _Val, _Pass_comp());
     }
 
     template <class _Other>
         requires _Keylt_transparent
     _NODISCARD iterator lower_bound(const _Other& _Val) {
-        return _STD lower_bound(begin(), end(), _Val, _Get_comp_v());
+        return _STD lower_bound(begin(), end(), _Val, _Pass_comp());
     }
     template <class _Other>
         requires _Keylt_transparent
     _NODISCARD const_iterator lower_bound(const _Other& _Val) const {
-        return _STD lower_bound(cbegin(), cend(), _Val, _Get_comp_v());
+        return _STD lower_bound(cbegin(), cend(), _Val, _Pass_comp());
     }
 
     _NODISCARD iterator upper_bound(const _Kty& _Val) {
-        return _STD upper_bound(begin(), end(), _Val, _Get_comp_v());
+        return _STD upper_bound(begin(), end(), _Val, _Pass_comp());
     }
     _NODISCARD const_iterator upper_bound(const _Kty& _Val) const {
-        return _STD upper_bound(cbegin(), cend(), _Val, _Get_comp_v());
+        return _STD upper_bound(cbegin(), cend(), _Val, _Pass_comp());
     }
 
     template <class _Other>
         requires _Keylt_transparent
     _NODISCARD iterator upper_bound(const _Other& _Val) {
-        return _STD upper_bound(begin(), end(), _Val, _Get_comp_v());
+        return _STD upper_bound(begin(), end(), _Val, _Pass_comp());
     }
     template <class _Other>
         requires _Keylt_transparent
     _NODISCARD const_iterator upper_bound(const _Other& _Val) const {
-        return _STD upper_bound(cbegin(), cend(), _Val, _Get_comp_v());
+        return _STD upper_bound(cbegin(), cend(), _Val, _Pass_comp());
     }
 
     _NODISCARD pair<iterator, iterator> equal_range(const _Kty& _Val) {
-        return _STD equal_range(begin(), end(), _Val, _Get_comp_v());
+        return _STD equal_range(begin(), end(), _Val, _Pass_comp());
     }
     _NODISCARD pair<const_iterator, const_iterator> equal_range(const _Kty& _Val) const {
-        return _STD equal_range(cbegin(), cend(), _Val, _Get_comp_v());
+        return _STD equal_range(cbegin(), cend(), _Val, _Pass_comp());
     }
 
     template <class _Other>
         requires _Keylt_transparent
     _NODISCARD pair<iterator, iterator> equal_range(const _Other& _Val) {
-        return _STD equal_range(begin(), end(), _Val, _Get_comp_v());
+        return _STD equal_range(begin(), end(), _Val, _Pass_comp());
     }
     template <class _Other>
         requires _Keylt_transparent
     _NODISCARD pair<const_iterator, const_iterator> equal_range(const _Other& _Val) const {
-        return _STD equal_range(cbegin(), cend(), _Val, _Get_comp_v());
+        return _STD equal_range(cbegin(), cend(), _Val, _Pass_comp());
     }
 
     _NODISCARD friend bool operator==(const _Deriv& _Lhs, const _Deriv& _Rhs) {
-        return _RANGES equal(_Lhs._Get_cont(), _Rhs._Get_cont());
+        return _RANGES equal(_Lhs._Mycont, _Rhs._Mycont);
     }
 
     _NODISCARD friend auto operator<=>(const _Deriv& _Lhs, const _Deriv& _Rhs) {
@@ -447,9 +444,9 @@ public:
     }
 
 private:
-    _NODISCARD bool _Check_sorted(const_iterator _It, const const_iterator _End) const {
+    _NODISCARD bool _Is_sorted(const_iterator _It, const const_iterator _End) const {
         if constexpr (_Multi) {
-            return _STD is_sorted(_It, _End, _Get_comp_v());
+            return _STD is_sorted(_It, _End, _Pass_comp());
         } else {
             // sorted-unique
             if (_It == _End) {
@@ -464,9 +461,16 @@ private:
         }
     }
 
+    _NODISCARD bool _Is_sorted(const container_type& _Cont) const {
+        return _Is_sorted(_Cont.cbegin(), _Cont.cend());
+    }
+
     static constexpr const char* _Msg_not_sorted = _Multi ? "Input was not sorted!" : "Input was not sorted-unique!";
 
-    _NODISCARD bool _Check_where(const const_iterator _Where, const _Kty& _Val) const {
+    template <class _Ty>
+    _NODISCARD bool _Can_insert(const const_iterator _Where, const _Ty& _Val) const {
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_Ty, _Kty>); // only accepts _Kty
+
         // check that _Val can be inserted before _Where
         if constexpr (_Multi) {
             // check that _Where is the upper_bound for _Val
@@ -482,94 +486,102 @@ private:
     }
 
     template <class _Ty>
-    auto _Emplace(_Ty&& _Val) {
-        _Container& _Cont = _Get_cont();
-        if constexpr (_Multi) {
-            _STL_INTERNAL_STATIC_ASSERT(is_same_v<remove_cvref_t<_Ty>, _Kty>);
-            return _Cont.emplace(upper_bound(_Val), _STD forward<_Ty>(_Val));
+        requires _Multi // flat_multiset
+    iterator _Emplace(_Ty&& _Val) {
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<remove_cvref_t<_Ty>, _Kty>);
+        return _Mycont.emplace(upper_bound(_Val), _STD forward<_Ty>(_Val));
+    }
+
+    template <class _Ty>
+        requires (!_Multi) // flat_set
+    pair<iterator, bool> _Emplace(_Ty&& _Val) {
+        const iterator _Where = lower_bound(_Val);
+        if (_Where != end() && !_Compare(_Val, *_Where)) {
+            return pair{_Where, false};
+        }
+
+        if constexpr (is_same_v<remove_cvref_t<_Ty>, _Kty>) {
+            return pair{_Mycont.emplace(_Where, _STD forward<_Ty>(_Val)), true};
         } else {
-            const iterator _End   = end();
-            const iterator _Where = lower_bound(_Val);
-            if (_Where != _End && !_Compare(_Val, *_Where)) {
-                return pair{_Where, false};
-            }
+            // heterogeneous insertion
+            // TRANSITION, the requirements may be stricter than needed by the standard.
+            _STL_INTERNAL_STATIC_ASSERT(_Keylt_transparent && is_constructible_v<_Kty, _Ty>);
+            _Kty _Keyval(_STD forward<_Ty>(_Val));
+            _STL_ASSERT(_Can_insert(_Where, _Keyval), "The conversion from the heterogeneous key to key_type should "
+                                                      "be consistent with the heterogeneous lookup!");
+            return pair{_Mycont.emplace(_Where, _STD move(_Keyval)), true};
+        }
+    }
+
+    template <class _Ty>
+        requires _Multi // flat_multiset
+    iterator _Emplace_hint(const_iterator _Where, _Ty&& _Val) {
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<remove_cvref_t<_Ty>, _Kty>);
 
-            if constexpr (is_same_v<remove_cvref_t<_Ty>, _Kty>) {
-                return pair{_Cont.emplace(_Where, _STD forward<_Ty>(_Val)), true};
+        const const_iterator _Begin = cbegin();
+        const const_iterator _End   = cend();
+
+        // look for upper_bound(_Val)
+        if (_Where == _End || _Compare(_Val, *_Where)) {
+            // _Val < *_Where
+            if (_Where == _Begin || !_Compare(_Val, *(_Where - 1))) {
+                // _Val >= *(_Where-1) ~ upper_bound is _Where
             } else {
-                // for flat_set::insert(auto&&)
-                _STL_INTERNAL_STATIC_ASSERT(_Keylt_transparent && is_constructible_v<_Kty, _Ty>);
-                _Kty _Keyval(_STD forward<_Ty>(_Val));
-                _STL_ASSERT(_Check_where(_Where, _Keyval), "The input type was not equivalent to key_type!");
-                return pair{_Cont.emplace(_Where, _STD move(_Keyval)), true};
+                // _Val < *(_Where-1) ~ upper_bound is in [_Begin,_Where-1]
+                _Where = _STD upper_bound(_Begin, _Where - 1, _Val, _Pass_comp());
             }
+        } else {
+            // _Val >= *_Where ~ upper_bound is in [_Where+1,_End]
+            _Where = _STD upper_bound(_Where + 1, _End, _Val, _Pass_comp());
         }
+
+        _STL_INTERNAL_CHECK(_Can_insert(_Where, _Val));
+        return _Mycont.emplace(_Where, _STD forward<_Ty>(_Val));
     }
 
     template <class _Ty>
+        requires (!_Multi) // flat_set
     iterator _Emplace_hint(const_iterator _Where, _Ty&& _Val) {
-        _Container& _Cont           = _Get_cont();
-        auto _Comp                  = _Get_comp_v();
         const const_iterator _Begin = cbegin();
         const const_iterator _End   = cend();
 
-        if constexpr (_Multi) {
-            // look for the upper_bound for flat_multiset
-            if (_Where == _End || _Compare(_Val, *_Where)) {
-                // _Val < *_Where
-                if (_Where == _Begin || !_Compare(_Val, *(_Where - 1))) {
-                    // _Val >= *(_Where-1) ~ upper_bound is _Where
-                } else {
-                    // _Val < *(_Where-1) ~ upper_bound is in [_Begin,_Where-1]
-                    _Where = _STD upper_bound(_Begin, _Where - 1, _Val, _Comp);
-                }
+        // look for lower_bound(_Val)
+        if (_Where == _End || !_Compare(*_Where, _Val)) {
+            // _Val <= *_Where
+            if (_Where == _Begin || _Compare(*(_Where - 1), _Val)) {
+                // _Val > *(_Where-1) ~ lower_bound is _Where
             } else {
-                // _Val >= *_Where ~ upper_bound is in [_Where+1,_End]
-                _Where = _STD upper_bound(_Where + 1, _End, _Val, _Comp);
+                // _Val <= *(_Where-1) ~ lower_bound is in [_Begin,_Where-1]
+                _Where = _STD lower_bound(_Begin, _Where - 1, _Val, _Pass_comp());
             }
         } else {
-            // look for the lower_bound for flat_set
-            if (_Where == _End || !_Compare(*_Where, _Val)) {
-                // _Val <= *_Where
-                if (_Where == _Begin || _Compare(*(_Where - 1), _Val)) {
-                    // _Val > *(_Where-1) ~ lower_bound is _Where
-                } else {
-                    // _Val <= *(_Where-1) ~ lower_bound is in [_Begin,_Where-1]
-                    _Where = _STD lower_bound(_Begin, _Where - 1, _Val, _Comp);
-                }
-            } else {
-                // _Val > *_Where ~ lower_bound is in [_Where+1,_End]
-                _Where = _STD lower_bound(_Where + 1, _End, _Val, _Comp);
-            }
+            // _Val > *_Where ~ lower_bound is in [_Where+1,_End]
+            _Where = _STD lower_bound(_Where + 1, _End, _Val, _Pass_comp());
         }
 
-        if constexpr (_Multi) {
-            _STL_INTERNAL_STATIC_ASSERT(is_same_v<remove_cvref_t<_Ty>, _Kty>);
-            _STL_INTERNAL_CHECK(_Check_where(_Where, _Val));
-            return _Cont.emplace(_Where, _STD forward<_Ty>(_Val));
-        } else {
-            if (_Where != _End && !_Compare(_Val, *_Where)) {
-                return _Cont.begin() + (_Where - _Begin);
-            }
+        if (_Where != _End && !_Compare(_Val, *_Where)) {
+            // convert const_iterator to iterator
+            return _Mycont.begin() + (_Where - _Begin);
+        }
 
-            if constexpr (is_same_v<remove_cvref_t<_Ty>, _Kty>) {
-                _STL_INTERNAL_CHECK(_Check_where(_Where, _Val));
-                return _Cont.emplace(_Where, _STD forward<_Ty>(_Val));
-            } else {
-                // for flat_set::insert(hint,auto&&)
-                _STL_INTERNAL_STATIC_ASSERT(_Keylt_transparent && is_constructible_v<_Kty, _Ty>);
-                _Kty _Keyval(_STD forward<_Ty>(_Val));
-                _STL_ASSERT(_Check_where(_Where, _Keyval), "The input type was not equivalent to key_type!");
-                return _Cont.emplace(_Where, _STD move(_Keyval));
-            }
+        if constexpr (is_same_v<remove_cvref_t<_Ty>, _Kty>) {
+            _STL_INTERNAL_CHECK(_Can_insert(_Where, _Val));
+            return _Mycont.emplace(_Where, _STD forward<_Ty>(_Val));
+        } else {
+            // heterogeneous insertion
+            // TRANSITION, the requirements may be stricter than needed by the standard.
+            _STL_INTERNAL_STATIC_ASSERT(_Keylt_transparent && is_constructible_v<_Kty, _Ty>);
+            _Kty _Keyval(_STD forward<_Ty>(_Val));
+            _STL_ASSERT(_Can_insert(_Where, _Keyval), "The conversion from the heterogeneous key to key_type should "
+                                                      "be consistent with the heterogeneous lookup!");
+            return _Mycont.emplace(_Where, _STD move(_Keyval));
         }
     }
 
     template <bool _Presorted, class _Iter>
     void _Insert_range(const _Iter _First, const _Iter _Last) {
         const size_type _Old_size = size();
-        _Container& _Cont         = _Get_cont();
-        _Cont.insert(_Cont.end(), _First, _Last);
+        _Mycont.insert(_Mycont.end(), _First, _Last);
         _Restore_invariants_after_insert<_Presorted>(_Old_size);
     }
 
@@ -580,7 +592,7 @@ private:
         if constexpr (!_Multi && is_same_v<_Ty, _Kty>) {
             const iterator _Where = lower_bound(_Val);
             if (_Where != end() && !_Compare(_Val, *_Where)) {
-                _Get_cont().erase(_Where);
+                _Mycont.erase(_Where);
                 return 1;
             }
             return 0;
@@ -588,7 +600,7 @@ private:
             const auto [_First, _Last] = equal_range(_Val);
 
             const auto _Removed = static_cast<size_type>(_Last - _First);
-            _Get_cont().erase(_First, _Last);
+            _Mycont.erase(_First, _Last);
             return _Removed;
         }
     }
@@ -621,32 +633,30 @@ private:
 
     void _Erase_dupes_if_not_multi() {
         if constexpr (!_Multi) {
-            const auto _Equal_to = [this](const _Kty& _Lhs, const _Kty& _Rhs) {
+            const auto _Equivalent = [this](const _Kty& _Lhs, const _Kty& _Rhs) {
                 return !_Compare(_Lhs, _Rhs) && !_Compare(_Rhs, _Lhs);
             };
-            const iterator _End     = end();
-            const iterator _New_end = _STD unique(begin(), _End, _Equal_to);
-            _Get_cont().erase(_New_end, _End);
+            const iterator _End = end();
+            _Mycont.erase(_STD unique(begin(), _End, _Equivalent), _End);
         }
     }
 
     template <bool _Presorted>
     void _Restore_invariants_after_insert(const size_type _Old_size) {
-        auto _Comp              = _Get_comp_v();
         const iterator _Begin   = begin();
         const iterator _Old_end = _Begin + static_cast<difference_type>(_Old_size);
-        const iterator _New_end = end();
+        const iterator _End     = end();
 
         if constexpr (!_Presorted) {
-            _STD sort(_Old_end, _New_end, _Comp);
+            _STD sort(_Old_end, _End, _Pass_comp());
         } else {
-            _STL_ASSERT(_Check_sorted(_Old_end, _New_end), _Msg_not_sorted);
+            _STL_ASSERT(_Is_sorted(_Old_end, _End), _Msg_not_sorted);
         }
 
-        _STD inplace_merge(_Begin, _Old_end, _New_end, _Comp);
+        _STD inplace_merge(_Begin, _Old_end, _End, _Pass_comp());
         _Erase_dupes_if_not_multi();
 
-        _STL_INTERNAL_CHECK(_Check_sorted(cbegin(), cend()));
+        _STL_INTERNAL_CHECK(_Is_sorted(_Mycont));
     }
 
     void _Make_invariants_fulfilled() {
@@ -658,45 +668,29 @@ private:
         }
 
         // O(N) if already sorted.
-        auto _Comp                     = _Get_comp_v();
-        const iterator _Begin_unsorted = _STD is_sorted_until(_Begin, _End, _Comp);
+        const iterator _Begin_unsorted = _STD is_sorted_until(_Begin, _End, _Pass_comp());
 
-        _STD sort(_Begin_unsorted, _End, _Comp);
-        _STD inplace_merge(_Begin, _Begin_unsorted, _End, _Comp);
+        _STD sort(_Begin_unsorted, _End, _Pass_comp());
+        _STD inplace_merge(_Begin, _Begin_unsorted, _End, _Pass_comp());
         _Erase_dupes_if_not_multi();
 
-        _STL_INTERNAL_CHECK(_Check_sorted(cbegin(), cend()));
+        _STL_INTERNAL_CHECK(_Is_sorted(_Mycont));
     }
 
     template <class _Lty, class _Rty>
     _NODISCARD bool _Compare(const _Lty& _Lhs, const _Rty& _Rhs) const
-        noexcept(noexcept(_DEBUG_LT_PRED(_My_pair._Get_first(), _Lhs, _Rhs))) {
+        noexcept(noexcept(_DEBUG_LT_PRED(_Mycomp, _Lhs, _Rhs))) {
         _STL_INTERNAL_STATIC_ASSERT(_Keylt_transparent || (is_same_v<_Kty, _Lty> && is_same_v<_Kty, _Rty>) );
 
-        return _DEBUG_LT_PRED(_My_pair._Get_first(), _Lhs, _Rhs);
-    }
-
-    _NODISCARD const _Container& _Get_cont() const noexcept {
-        return _My_pair._Myval2;
-    }
-
-    _NODISCARD _Container& _Get_cont() noexcept {
-        return _My_pair._Myval2;
-    }
-
-    _NODISCARD const key_compare& _Get_comp() const noexcept {
-        return _My_pair._Get_first();
-    }
-
-    _NODISCARD key_compare& _Get_comp() noexcept {
-        return _My_pair._Get_first();
+        return _DEBUG_LT_PRED(_Mycomp, _Lhs, _Rhs);
     }
 
-    _NODISCARD auto _Get_comp_v() const noexcept {
-        return _STD _Pass_fn(_My_pair._Get_first());
+    _NODISCARD auto _Pass_comp() const noexcept {
+        return _STD _Pass_fn(_Mycomp);
     }
 
-    _Compressed_pair<key_compare, container_type> _My_pair;
+    container_type _Mycont;
+    /* [[no_unique_address]] */ key_compare _Mycomp;
 };
 
 _EXPORT_STD struct sorted_unique_t {
diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index 9bb2adcd0df..e0dad813302 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -9,6 +9,7 @@
 #include <iostream>
 #include <memory>
 #include <random>
+#include <utility>
 #include <vector>
 
 using namespace std;
@@ -67,23 +68,10 @@ void assert_reversible_container_requirements(const T& s) {
     static_assert(is_convertible_v<typename T::reverse_iterator, typename T::const_reverse_iterator>);
 }
 
-template <class T>
-void test_ebco() {
-    // This tests an implementation-specific optimization.
-    using key_compare    = T::key_compare;
-    using container_type = T::container_type;
-    if constexpr (is_empty_v<key_compare> && !is_final_v<key_compare>) {
-        static_assert(sizeof(container_type) == sizeof(T));
-    } else {
-        static_assert(sizeof(container_type) < sizeof(T));
-    }
-}
-
 template <class T>
 void assert_all_requirements_and_equals(const T& s, const initializer_list<typename T::value_type>& il) {
     assert_container_requirements(s);
     assert_reversible_container_requirements(s);
-    test_ebco<T>();
 
     auto val_comp = s.value_comp();
     auto begin_it = s.cbegin();
@@ -408,14 +396,75 @@ void test_non_static_comparer() {
     assert_all_requirements_and_equals(a, {9, 7, 5, -1});
 }
 
+template <template <class...> class Set>
+void test_extract_1() {
+    // Test that the container will be emptied, even if the container's move ctor exits via an exception.
 
-template <class C>
-void test_extract() {
-    constexpr int elements[]{1, 2, 3, 4};
-    C fs{1, 2, 3, 4};
-    auto cont = std::move(fs).extract();
-    assert(fs.empty());
-    assert(ranges::equal(cont, elements));
+    static bool will_throw = false;
+
+    class test_exception : public vector<int> {
+    private:
+        using base = vector<int>;
+
+    public:
+        using base::base;
+        test_exception(const test_exception&)            = default;
+        test_exception& operator=(const test_exception&) = default;
+        test_exception& operator=(test_exception&&)      = default;
+
+        test_exception(test_exception&& other) : base(static_cast<base&&>(other)) {
+            if (will_throw) {
+                throw 0; // will be caught by "catch (...)"
+            }
+        }
+    };
+
+    will_throw = false;
+    Set<int, std::less<int>, test_exception> fs{4, 3, 2, 1};
+    assert_all_requirements_and_equals(fs, {1, 2, 3, 4});
+    auto extr = std::move(fs).extract();
+    assert(ranges::equal(extr, vector{1, 2, 3, 4}));
+    assert_all_requirements_and_equals(fs, {}); // assert empty
+
+    fs = {4, 3, 2, 1};
+    assert_all_requirements_and_equals(fs, {1, 2, 3, 4});
+    try {
+        will_throw = true;
+        (void) std::move(fs).extract();
+    } catch (...) {
+        will_throw = false;
+        assert_all_requirements_and_equals(fs, {}); // assert empty
+        return;
+    }
+
+    assert(false);
+}
+
+template <template <class...> class Set>
+void test_extract_2() {
+    // Test that the container will be emptied, even if the container's move ctor doesn't empty the container.
+
+    class always_copy : public vector<int> {
+    private:
+        using base = vector<int>;
+
+    public:
+        using base::base;
+        always_copy(const always_copy&)            = default;
+        always_copy& operator=(const always_copy&) = default;
+
+        // the move ctor and assignment will not empty the container.
+        always_copy(always_copy&& other) noexcept /* intentional */ : always_copy(as_const(other)) {}
+        always_copy& operator=(always_copy&& other) noexcept /* intentional */ {
+            return operator=(as_const(other));
+        }
+    };
+
+    Set<int, std::less<int>, always_copy> fs{4, 3, 2, 1};
+    assert_all_requirements_and_equals(fs, {1, 2, 3, 4});
+    auto extr = std::move(fs).extract();
+    assert(ranges::equal(extr, vector{1, 2, 3, 4}));
+    assert_all_requirements_and_equals(fs, {}); // assert empty
 }
 
 // TRANSITION, too simple
@@ -488,8 +537,10 @@ int main() {
     test_comparer_application();
     test_non_static_comparer();
 
-    test_extract<flat_set<int>>();
-    test_extract<flat_multiset<int>>();
+    test_extract_1<flat_set>();
+    test_extract_1<flat_multiset>();
+    test_extract_2<flat_set>();
+    test_extract_2<flat_multiset>();
 
     test_erase_1();
     test_erase_2();

From 4c866ae0099333136f5d140eeaad6f693caa15dd Mon Sep 17 00:00:00 2001
From: achabense <60953653+achabense@users.noreply.github.com>
Date: Thu, 19 Oct 2023 03:45:36 +0800
Subject: [PATCH 011/134] `<flat_set>`: the copy/move functions should be
 user-defined (#4079)

Co-authored-by: Stephan T. Lavavej <stl@nuwen.net>
---
 stl/inc/flat_set                          |  42 +++++-
 tests/std/tests/P1222R4_flat_set/test.cpp | 158 +++++++++++++++++++++-
 2 files changed, 196 insertions(+), 4 deletions(-)

diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index a8c5cd92748..3503f01d9f9 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -67,12 +67,12 @@ public:
 
     _Base_flat_set() : _Mycont(), _Mycomp() {}
 
-    // TRANSITION, "_Mycomp" may need to be copied, even in move construction / assignment.
     template <_Allocator_for<container_type> _Alloc>
     _Base_flat_set(const _Deriv& _Set, const _Alloc& _Al) : _Mycont(_Set._Mycont, _Al), _Mycomp(_Set._Mycomp) {}
     template <_Allocator_for<container_type> _Alloc>
     _Base_flat_set(_Deriv&& _Set, const _Alloc& _Al)
-        : _Mycont(_STD move(_Set._Mycont), _Al), _Mycomp(_STD move(_Set._Mycomp)) {}
+        : _Mycont(_STD move(_Set).extract(), _Al), _Mycomp(_Set._Mycomp) // intentionally copy comparator, see LWG-2227
+    {}
 
     explicit _Base_flat_set(container_type _Cont, const key_compare& _Comp = key_compare())
         : _Mycont(_STD move(_Cont)), _Mycomp(_Comp) {
@@ -153,6 +153,32 @@ public:
     _Base_flat_set(_Tsorted _Tsort, initializer_list<_Kty> _Ilist, const _Alloc& _Al)
         : _Base_flat_set(_Tsort, container_type(_Ilist, _Al)) {}
 
+    _Base_flat_set(const _Base_flat_set&) = default;
+    _Base_flat_set(_Base_flat_set&& _Other) noexcept(
+        is_nothrow_move_constructible_v<container_type>&& is_nothrow_copy_constructible_v<key_compare>) // strengthened
+        : _Mycont(_STD move(_Other).extract()), _Mycomp(_Other._Mycomp) // intentionally copy comparator, see LWG-2227
+    {}
+
+    _Base_flat_set& operator=(const _Base_flat_set& _Other) {
+        _Clear_guard<_Base_flat_set> _Guard{this};
+        _Mycont        = _Other._Mycont;
+        _Mycomp        = _Other._Mycomp;
+        _Guard._Target = nullptr;
+        return *this;
+    }
+    _Base_flat_set& operator=(_Base_flat_set&& _Other) noexcept(
+        is_nothrow_move_assignable_v<container_type>&& is_nothrow_copy_assignable_v<key_compare>) // strengthened
+    {
+        if (this != _STD addressof(_Other)) {
+            _Clear_guard<_Base_flat_set> _Guard{this};
+            _Clear_guard<_Base_flat_set> _Always_clear{_STD addressof(_Other)};
+            _Mycont        = _STD move(_Other._Mycont);
+            _Mycomp        = _Other._Mycomp; // intentionally copy comparator, see LWG-2227
+            _Guard._Target = nullptr;
+        }
+        return *this;
+    }
+
     _Deriv& operator=(initializer_list<_Kty> _Ilist) {
         _Clear_guard<_Base_flat_set> _Guard{this};
         _Mycont.assign(_Ilist);
@@ -288,7 +314,7 @@ public:
     _NODISCARD container_type extract() && noexcept(
         is_nothrow_move_constructible_v<container_type>) /* strengthened */ {
         // always clears the container (N4950 [flat.set.modifiers]/14 and [flat.multiset.modifiers]/10)
-        _Clear_guard<_Base_flat_set> _Guard{this};
+        _Clear_guard<_Base_flat_set> _Always_clear{this};
         return _STD move(_Mycont);
     }
     void replace(container_type&& _Cont) {
@@ -711,7 +737,12 @@ private:
 
 public:
     using _Mybase::_Mybase;
+    flat_set(const flat_set&) = default;
+    flat_set(flat_set&&)      = default;
+
     using _Mybase::operator=;
+    flat_set& operator=(const flat_set&) = default;
+    flat_set& operator=(flat_set&&)      = default;
 };
 
 _EXPORT_STD template <class _Kty, class _Keylt = less<_Kty>, class _Container = vector<_Kty>>
@@ -722,7 +753,12 @@ private:
 
 public:
     using _Mybase::_Mybase;
+    flat_multiset(const flat_multiset&) = default;
+    flat_multiset(flat_multiset&&)      = default;
+
     using _Mybase::operator=;
+    flat_multiset& operator=(const flat_multiset&) = default;
+    flat_multiset& operator=(flat_multiset&&)      = default;
 };
 
 _EXPORT_STD template <class _Kty, class _Keylt, class _Container, class _Pred>
diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index e0dad813302..e045438b952 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -3,6 +3,7 @@
 
 #include <algorithm>
 #include <cassert>
+#include <climits>
 #include <deque>
 #include <flat_set>
 #include <functional>
@@ -69,10 +70,14 @@ void assert_reversible_container_requirements(const T& s) {
 }
 
 template <class T>
-void assert_all_requirements_and_equals(const T& s, const initializer_list<typename T::value_type>& il) {
+void assert_all_requirements(const T& s) {
     assert_container_requirements(s);
     assert_reversible_container_requirements(s);
 
+    // FIXME, in GH-4084
+    // assert_noexcept_requirements(s);
+    // assert_noexcept_requirements(const_cast<T&>(s));
+
     auto val_comp = s.value_comp();
     auto begin_it = s.cbegin();
     auto end_it   = s.cend();
@@ -85,6 +90,11 @@ void assert_all_requirements_and_equals(const T& s, const initializer_list<typen
             }
         }
     }
+}
+
+template <class T>
+void assert_all_requirements_and_equals(const T& s, const initializer_list<typename T::value_type>& il) {
+    assert_all_requirements(s);
 
     if (!std::equal(s.begin(), s.end(), il.begin(), il.end())) {
         cout << "Expected: {";
@@ -467,6 +477,151 @@ void test_extract_2() {
     assert_all_requirements_and_equals(fs, {}); // assert empty
 }
 
+void test_invariant_robustness() {
+    static int copy_limit   = 2;
+    constexpr int unlimited = INT_MAX;
+
+    struct odd_key {
+        static void countdown() {
+            if (copy_limit == unlimited) {
+                return;
+            }
+
+            if (--copy_limit < 0) {
+                throw 0; // will be caught by "catch (...)".
+            }
+        }
+
+        int key;
+
+        odd_key(int k = 0) : key(k) {}
+
+        bool operator==(const odd_key&) const = default;
+
+        odd_key(const odd_key& other) {
+            countdown();
+            key = other.key;
+        }
+
+        odd_key(odd_key&& other) {
+            countdown();
+            key = exchange(other.key, 0);
+        }
+
+        odd_key& operator=(const odd_key& other) {
+            countdown();
+            key = other.key;
+            return *this;
+        }
+
+        odd_key& operator=(odd_key&& other) {
+            countdown();
+            key = exchange(other.key, 0);
+            return *this;
+        }
+    };
+
+    class odd_container : public vector<odd_key> {
+    private:
+        using base = vector<odd_key>;
+
+    public:
+        using base::base;
+        odd_container(const odd_container&) = default;
+
+        // this copy-assignment cannot provide strong-guarantee for `this`:
+        odd_container& operator=(const odd_container& other) {
+            resize(other.size());
+            std::copy(other.begin(), other.end(), begin());
+            return *this;
+        }
+
+        // this move-ctor cannot provide strong-guarantee for `other`, and even successful, will leave elements of
+        // `other` in moved-from state:
+        odd_container(odd_container&& other) {
+            reserve(other.size());
+            for (auto& e : other) {
+                push_back(std::move(e));
+            }
+        }
+
+        // this move-assignment cannot provide strong-guarantee for `this` and `other`, and even successful, will leave
+        // elements of `other` in moved-from state:
+        odd_container& operator=(odd_container&& other) {
+            resize(other.size());
+            std::move(other.begin(), other.end(), begin());
+            return *this;
+        }
+    };
+
+    using SetT = flat_set<odd_key, key_comparer, odd_container>;
+
+    // copy-assignment
+    {
+        copy_limit = unlimited;
+        SetT fs1{0, 1, 2, 3, 4};
+        SetT fs2{5, 6, 7, 8, 9};
+
+        assert(ranges::equal(fs1, vector{0, 1, 2, 3, 4}, {}, &odd_key::key));
+        assert(ranges::equal(fs2, vector{5, 6, 7, 8, 9}, {}, &odd_key::key));
+
+        bool caught = false;
+        try {
+            copy_limit = 2;
+            fs1        = fs2; // will throw after copying 2 odd_key.
+        } catch (...) {
+            copy_limit = unlimited;
+            assert_all_requirements(fs1);
+            caught = true;
+        }
+        assert(caught);
+    }
+    // move-ctor
+    {
+        copy_limit = unlimited;
+        SetT fs1{0, 1, 2, 3, 4};
+        SetT fs2{std::move(fs1)};
+
+        assert_all_requirements(fs1);
+        assert(ranges::equal(fs2, vector{0, 1, 2, 3, 4}, {}, &odd_key::key));
+
+        bool caught = false;
+        try {
+            copy_limit = 2;
+            SetT fs3{std::move(fs2)}; // will throw after moving 2 odd_key.
+        } catch (...) {
+            copy_limit = unlimited;
+            assert_all_requirements(fs2);
+            caught = true;
+        }
+        assert(caught);
+    }
+    // move-assignment
+    {
+        copy_limit = unlimited;
+        SetT fs1{0, 1, 2, 3, 4};
+        SetT fs2;
+        SetT fs3{5, 6, 7, 8, 9};
+        fs2 = std::move(fs1);
+
+        assert_all_requirements(fs1);
+        assert(ranges::equal(fs2, vector{0, 1, 2, 3, 4}, {}, &odd_key::key));
+        assert(ranges::equal(fs3, vector{5, 6, 7, 8, 9}, {}, &odd_key::key));
+
+        bool caught = false;
+        try {
+            copy_limit = 2;
+            fs2        = std::move(fs3); // will throw after moving 2 odd_key.
+        } catch (...) {
+            copy_limit = unlimited;
+            assert_all_requirements(fs2);
+            assert_all_requirements(fs3);
+            caught = true;
+        }
+        assert(caught);
+    }
+}
+
 // TRANSITION, too simple
 void test_erase_1() {
     flat_set<int> fs{1};
@@ -544,6 +699,7 @@ int main() {
 
     test_erase_1();
     test_erase_2();
+    test_invariant_robustness();
 
     test_erase_if<flat_set<int>>();
     test_erase_if<flat_multiset<int>>();

From b07c9db9e4e6fad7447bf628e1cd05444b17270b Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Fri, 20 Oct 2023 15:57:56 -0700
Subject: [PATCH 012/134] Update and fix the feature-test macro test.

This was damaged like `__cpp_lib_containers_ranges` was.
---
 .../test.compile.pass.cpp                              | 10 +---------
 1 file changed, 1 insertion(+), 9 deletions(-)

diff --git a/tests/std/tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp b/tests/std/tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp
index 06efdf67b72..df7bafe58dd 100644
--- a/tests/std/tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp
+++ b/tests/std/tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp
@@ -356,18 +356,10 @@ STATIC_ASSERT(__cpp_lib_filesystem == 201703L);
 #endif
 
 #if _HAS_CXX23 && defined(__cpp_lib_concepts) // TRANSITION, GH-395
-#ifndef __cpp_lib_flat_set
-#error __cpp_lib_flat_set is not defined
-#elif __cpp_lib_flat_set != 202207L
-#error __cpp_lib_flat_set is not 202207L
-#else
 STATIC_ASSERT(__cpp_lib_flat_set == 202207L);
-#endif
-#else
-#if _HAS_CXX23 && defined(__cpp_lib_concepts) // TRANSITION, GH-395
+#elif defined(__cpp_lib_flat_set)
 #error __cpp_lib_flat_set is defined
 #endif
-#endif
 
 #ifdef __cpp_lib_concepts
 STATIC_ASSERT(__cpp_lib_format == 202207L);

From a75edc9fc97f1987f48cb15dfad317cbc9cf820f Mon Sep 17 00:00:00 2001
From: achabense <60953653+achabense@users.noreply.github.com>
Date: Tue, 24 Oct 2023 04:29:13 +0800
Subject: [PATCH 013/134] `<flat_set>`: Test transparent insertion and more
 (#4084)

Co-authored-by: Stephan T. Lavavej <stl@nuwen.net>
Co-authored-by: Jakub Mazurkiewicz <mazkuba3@gmail.com>
---
 stl/inc/flat_set                          |  28 +--
 tests/std/tests/P1222R4_flat_set/test.cpp | 219 +++++++++++++++++++++-
 2 files changed, 225 insertions(+), 22 deletions(-)

diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index 3503f01d9f9..d31bf71ce01 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -101,7 +101,7 @@ public:
     template <_Allocator_for<container_type> _Alloc>
     explicit _Base_flat_set(const _Alloc& _Al) : _Mycont(_Al), _Mycomp() {}
 
-    // TRANSITION, an allocator-aware container may not support "C(_First, _Last, _Al)".
+    // FIXME, an allocator-aware container may not support "C(_First, _Last, _Al)".
     template <input_iterator _Iter>
     _Base_flat_set(_Iter _First, _Iter _Last, const key_compare& _Comp = key_compare())
         : _Base_flat_set(container_type(_First, _Last), _Comp) {}
@@ -111,7 +111,7 @@ public:
     template <input_iterator _Iter, _Allocator_for<container_type> _Alloc>
     _Base_flat_set(_Iter _First, _Iter _Last, const _Alloc& _Al) : _Base_flat_set(container_type(_First, _Last, _Al)) {}
 
-    // TRANSITION, an allocator-aware container may not support "C(from_range, _STD forward<_Rng>(_Range), _Al)".
+    // FIXME, an allocator-aware container may not support "C(from_range, _STD forward<_Rng>(_Range), _Al)".
     template <_Container_compatible_range<_Kty> _Rng>
     _Base_flat_set(from_range_t, _Rng&& _Range)
         : _Base_flat_set(container_type(from_range, _STD forward<_Rng>(_Range))) {}
@@ -135,7 +135,7 @@ public:
     _Base_flat_set(_Tsorted _Tsort, _Iter _First, _Iter _Last, const _Alloc& _Al)
         : _Base_flat_set(_Tsort, container_type(_First, _Last, _Al)) {}
 
-    // TRANSITION, an allocator-aware container may not support "C(_Ilist, _Al)".
+    // FIXME, an allocator-aware container may not support "C(_Ilist, _Al)".
     _Base_flat_set(initializer_list<_Kty> _Ilist, const key_compare& _Comp = key_compare())
         : _Base_flat_set(container_type(_Ilist), _Comp) {}
     template <_Allocator_for<container_type> _Alloc>
@@ -239,7 +239,7 @@ public:
     }
 
     // modifiers
-    // TRANSITION, the "insert" and "erase" methods may not be able to restore the invariant, if the underlying
+    // FIXME, the "insert" and "erase" methods may not be able to restore the invariant, if the underlying
     // container is unable to provide strong guarantee for "erase" and "insert" methods.
     template <class... _Args>
     auto emplace(_Args&&... _Vals) {
@@ -513,24 +513,27 @@ private:
 
     template <class _Ty>
         requires _Multi // flat_multiset
-    iterator _Emplace(_Ty&& _Val) {
+    _NODISCARD iterator _Emplace(_Ty&& _Val) {
         _STL_INTERNAL_STATIC_ASSERT(is_same_v<remove_cvref_t<_Ty>, _Kty>);
         return _Mycont.emplace(upper_bound(_Val), _STD forward<_Ty>(_Val));
     }
 
     template <class _Ty>
         requires (!_Multi) // flat_set
-    pair<iterator, bool> _Emplace(_Ty&& _Val) {
+    _NODISCARD pair<iterator, bool> _Emplace(_Ty&& _Val) {
         const iterator _Where = lower_bound(_Val);
         if (_Where != end() && !_Compare(_Val, *_Where)) {
+            // *_Where is equivalent to _Val.
             return pair{_Where, false};
         }
 
         if constexpr (is_same_v<remove_cvref_t<_Ty>, _Kty>) {
+            _STL_INTERNAL_CHECK(_Can_insert(_Where, _Val));
             return pair{_Mycont.emplace(_Where, _STD forward<_Ty>(_Val)), true};
         } else {
             // heterogeneous insertion
-            // TRANSITION, the requirements may be stricter than needed by the standard.
+            // FIXME: The standard only requires `find(_Val) == find(_Keyval)` (per N4958 [flat.set.modifiers]/2),
+            // which cannot guarantee `_Can_insert(_Where, _Keyval)`.
             _STL_INTERNAL_STATIC_ASSERT(_Keylt_transparent && is_constructible_v<_Kty, _Ty>);
             _Kty _Keyval(_STD forward<_Ty>(_Val));
             _STL_ASSERT(_Can_insert(_Where, _Keyval), "The conversion from the heterogeneous key to key_type should "
@@ -541,7 +544,7 @@ private:
 
     template <class _Ty>
         requires _Multi // flat_multiset
-    iterator _Emplace_hint(const_iterator _Where, _Ty&& _Val) {
+    _NODISCARD iterator _Emplace_hint(const_iterator _Where, _Ty&& _Val) {
         _STL_INTERNAL_STATIC_ASSERT(is_same_v<remove_cvref_t<_Ty>, _Kty>);
 
         const const_iterator _Begin = cbegin();
@@ -567,7 +570,7 @@ private:
 
     template <class _Ty>
         requires (!_Multi) // flat_set
-    iterator _Emplace_hint(const_iterator _Where, _Ty&& _Val) {
+    _NODISCARD iterator _Emplace_hint(const_iterator _Where, _Ty&& _Val) {
         const const_iterator _Begin = cbegin();
         const const_iterator _End   = cend();
 
@@ -586,7 +589,7 @@ private:
         }
 
         if (_Where != _End && !_Compare(_Val, *_Where)) {
-            // convert const_iterator to iterator
+            // *_Where is equivalent to _Val; convert _Where to iterator type.
             return _Mycont.begin() + (_Where - _Begin);
         }
 
@@ -595,7 +598,8 @@ private:
             return _Mycont.emplace(_Where, _STD forward<_Ty>(_Val));
         } else {
             // heterogeneous insertion
-            // TRANSITION, the requirements may be stricter than needed by the standard.
+            // FIXME: The standard only requires `find(_Val) == find(_Keyval)` (per N4958 [flat.set.modifiers]/2),
+            // which cannot guarantee `_Can_insert(_Where, _Keyval)`.
             _STL_INTERNAL_STATIC_ASSERT(_Keylt_transparent && is_constructible_v<_Kty, _Ty>);
             _Kty _Keyval(_STD forward<_Ty>(_Val));
             _STL_ASSERT(_Can_insert(_Where, _Keyval), "The conversion from the heterogeneous key to key_type should "
@@ -612,7 +616,7 @@ private:
     }
 
     template <class _Ty>
-    size_type _Erase(const _Ty& _Val) {
+    _NODISCARD size_type _Erase(const _Ty& _Val) {
         _STL_INTERNAL_STATIC_ASSERT(_Keylt_transparent || is_same_v<_Ty, _Kty>);
 
         if constexpr (!_Multi && is_same_v<_Ty, _Kty>) {
diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index e045438b952..e1976302b37 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -4,12 +4,14 @@
 #include <algorithm>
 #include <cassert>
 #include <climits>
+#include <cstdlib>
 #include <deque>
 #include <flat_set>
 #include <functional>
 #include <iostream>
 #include <memory>
 #include <random>
+#include <tuple>
 #include <utility>
 #include <vector>
 
@@ -64,19 +66,42 @@ void assert_reversible_container_requirements(const T& s) {
     static_assert(is_same_v<reverse_iterator<typename T::const_iterator>, typename T::const_reverse_iterator>);
     static_assert(is_same_v<decltype(T{}.rbegin()), typename T::reverse_iterator>);
     static_assert(is_same_v<decltype(T{}.rend()), typename T::reverse_iterator>);
+    static_assert(is_same_v<decltype(s.rbegin()), typename T::const_reverse_iterator>);
+    static_assert(is_same_v<decltype(s.rend()), typename T::const_reverse_iterator>);
     static_assert(is_same_v<decltype(s.crbegin()), typename T::const_reverse_iterator>);
     static_assert(is_same_v<decltype(s.crend()), typename T::const_reverse_iterator>);
     static_assert(is_convertible_v<typename T::reverse_iterator, typename T::const_reverse_iterator>);
 }
 
+template <class T>
+void assert_noexcept_requirements(T& s) {
+    static_assert(noexcept(s.begin()));
+    static_assert(noexcept(s.end()));
+    static_assert(noexcept(s.cbegin()));
+    static_assert(noexcept(s.cend()));
+    static_assert(noexcept(s.rbegin()));
+    static_assert(noexcept(s.rend()));
+    static_assert(noexcept(s.crbegin()));
+    static_assert(noexcept(s.crend()));
+
+    static_assert(noexcept(s.empty()));
+    static_assert(noexcept(s.size()));
+    static_assert(noexcept(s.max_size()));
+
+    if constexpr (!is_const_v<T>) {
+        static_assert(noexcept(s.swap(s)));
+        static_assert(noexcept(ranges::swap(s, s))); // using ADL-swap
+        static_assert(noexcept(s.clear()));
+    }
+}
+
 template <class T>
 void assert_all_requirements(const T& s) {
     assert_container_requirements(s);
     assert_reversible_container_requirements(s);
 
-    // FIXME, in GH-4084
-    // assert_noexcept_requirements(s);
-    // assert_noexcept_requirements(const_cast<T&>(s));
+    assert_noexcept_requirements(s);
+    assert_noexcept_requirements(const_cast<T&>(s));
 
     auto val_comp = s.value_comp();
     auto begin_it = s.cbegin();
@@ -141,6 +166,30 @@ void test_constructors() {
     assert_all_requirements_and_equals(flat_multiset<int>(std::move(b), allocator<int>{}), {-1, 1, 2, 7, 7, 7, 100});
 }
 
+template <template <class...> class Set>
+void test_always_reversible() {
+    // Test that flat_meow is unconditionally reversible.
+    class not_reversible : public vector<int> {
+    private:
+        using base = vector<int>;
+
+        using base::const_reverse_iterator;
+        using base::crbegin;
+        using base::crend;
+        using base::rbegin;
+        using base::rend;
+        using base::reverse_iterator;
+
+    public:
+        using base::base;
+    };
+
+    Set<int, std::greater<int>, not_reversible> fs({1, 2, 3});
+    assert_all_requirements_and_equals(fs, {3, 2, 1});
+    assert(fs.rbegin() + 3 == fs.rend());
+    assert(fs.crend() - fs.crbegin() == 3);
+}
+
 template <class C>
 void test_insert_1() {
     using lt = std::less<int>;
@@ -352,6 +401,33 @@ void test_insert_using_invalid_hint() {
     }
 }
 
+void test_insert_upper_bound() {
+    // For flat_multiset's single-element insertion, the key should be inserted before the upper_bound.
+    struct test_position {
+        int key;
+        int extra;
+        bool operator==(const test_position&) const = default;
+    };
+
+    mt19937 eng(24);
+    uniform_int_distribution<int> dist_seq(0, 20);
+
+    vector<test_position> seq(200);
+    for (int e = 0; auto& [key, extra] : seq) {
+        key   = dist_seq(eng);
+        extra = e++;
+    }
+
+    flat_multiset<test_position, key_comparer> fs;
+    for (const auto& val : seq) {
+        fs.insert(val);
+    }
+
+    // The result should be identical to as if doing stable_sort on seq.
+    ranges::stable_sort(seq, key_comparer{});
+    assert(ranges::equal(fs, seq));
+}
+
 template <class T>
 void test_spaceship_operator() {
     static constexpr bool multi  = _Is_specialization_v<T, flat_multiset>;
@@ -660,13 +736,126 @@ void test_erase_if() {
     assert(ranges::equal(fs, erased_result));
 }
 
-// TRANSITION, too simple
-void test_count() {
-    flat_set<int> fs{2};
-    assert(fs.count(1) == 0);
+template <template <class...> class Set>
+void test_observers() {
+    struct lt_with_state {
+        int state = 0;
+        bool operator()(int l, int r) const {
+            return l < r;
+        }
+    };
 
-    flat_multiset<int> fs2{10, 20, 20, 30};
-    assert(fs2.count(20) == 2);
+    using SetT = Set<int, lt_with_state>;
+
+    SetT fs;
+    static_assert(is_same_v<typename SetT::key_compare, typename SetT::value_compare>);
+    static_assert(is_same_v<decltype(as_const(fs).key_comp()), typename SetT::key_compare>);
+    static_assert(is_same_v<decltype(as_const(fs).value_comp()), typename SetT::value_compare>);
+    assert(fs.key_comp().state == 0);
+    assert(fs.value_comp().state == 0);
+
+    SetT fs2(lt_with_state{2});
+    assert(fs2.key_comp().state == 2);
+    assert(fs2.value_comp().state == 2);
+}
+
+template <template <class...> class Set>
+void test_set_operations() {
+    using SetT           = Set<int>;
+    using iterator       = SetT::iterator;
+    using const_iterator = SetT::const_iterator;
+
+    SetT fs{3, 2, 11, 11, 3, 8, 11, 20};
+
+    static_assert(is_same_v<decltype(fs.find(0)), iterator>);
+    static_assert(is_same_v<decltype(as_const(fs).find(0)), const_iterator>);
+
+    static_assert(is_same_v<decltype(as_const(fs).count(0)), typename SetT::size_type>);
+    static_assert(is_same_v<decltype(as_const(fs).contains(0)), bool>);
+
+    static_assert(is_same_v<decltype(fs.lower_bound(0)), iterator>);
+    static_assert(is_same_v<decltype(as_const(fs).lower_bound(0)), const_iterator>);
+    static_assert(is_same_v<decltype(fs.upper_bound(0)), iterator>);
+    static_assert(is_same_v<decltype(as_const(fs).upper_bound(0)), const_iterator>);
+
+    static_assert(is_same_v<decltype(fs.equal_range(0)), pair<iterator, iterator>>);
+    static_assert(is_same_v<decltype(as_const(fs).equal_range(0)), pair<const_iterator, const_iterator>>);
+
+    if constexpr (_Is_specialization_v<SetT, flat_set>) {
+        // flat_set:
+        assert_all_requirements_and_equals(fs, {2, 3, 8, 11, 20});
+
+        assert(fs.find(3) != fs.end());
+        assert(fs.find(4) == fs.end());
+
+        assert(fs.count(1) == 0);
+        assert(fs.count(11) == 1);
+        assert(fs.contains(8));
+        assert(!fs.contains(12));
+
+        assert(fs.lower_bound(-1) == fs.begin());
+        assert(fs.lower_bound(3) == fs.find(3));
+        assert(fs.lower_bound(19) == fs.find(20));
+        assert(fs.lower_bound(20) + 1 == fs.end());
+
+        assert(fs.upper_bound(-1) == fs.begin());
+        assert(fs.upper_bound(20) == fs.end());
+        assert(fs.lower_bound(2) + 2 == fs.upper_bound(3));
+        assert(fs.upper_bound(8) == fs.find(11));
+
+        auto [first, last] = fs.equal_range(3);
+        assert(first + 1 == last);
+        tie(first, last) = fs.equal_range(12);
+        assert(first == last);
+    } else {
+        // flat_multiset:
+        assert_all_requirements_and_equals(fs, {2, 3, 3, 8, 11, 11, 11, 20});
+
+        assert(fs.find(3) != fs.end());
+        assert(fs.find(4) == fs.end());
+
+        assert(fs.count(1) == 0);
+        assert(fs.count(11) == 3);
+        assert(fs.contains(8));
+        assert(!fs.contains(12));
+
+        assert(fs.lower_bound(-1) == fs.begin());
+        assert(fs.lower_bound(3) == fs.find(3));
+        assert(fs.lower_bound(19) == fs.find(20));
+        assert(fs.lower_bound(11) + 4 == fs.end());
+
+        assert(fs.upper_bound(-1) == fs.begin());
+        assert(fs.upper_bound(20) == fs.end());
+        assert(fs.lower_bound(3) + 6 == fs.upper_bound(11));
+        assert(fs.upper_bound(11) == fs.find(20));
+
+        auto [first, last] = fs.equal_range(3);
+        assert(first + 2 == last);
+        tie(first, last) = fs.equal_range(12);
+        assert(first == last);
+    }
+}
+
+template <template <class...> class Set>
+void test_set_operations_transparent() {
+    struct shouldnt_convert {
+        int key;
+        /* implicit */ [[noreturn]] operator int() const {
+            abort();
+        }
+    };
+
+    Set<int, key_comparer> fs{0, 3, 5};
+    assert_all_requirements_and_equals(fs, {0, 3, 5});
+
+    assert(fs.find(shouldnt_convert{0}) != fs.end());
+    assert(fs.count(shouldnt_convert{3}) == 1);
+    assert(!fs.contains(shouldnt_convert{1}));
+    assert(fs.lower_bound(shouldnt_convert{-1}) == fs.begin());
+    assert(fs.lower_bound(shouldnt_convert{8}) == fs.end());
+    assert(fs.upper_bound(shouldnt_convert{2}) == fs.find(3));
+    auto [first, last] = fs.equal_range(shouldnt_convert{5});
+    assert(first + 1 == last);
 }
 
 int main() {
@@ -682,12 +871,16 @@ int main() {
     test_constructors<vector<int>>();
     test_constructors<deque<int>>();
 
+    test_always_reversible<flat_set>();
+    test_always_reversible<flat_multiset>();
+
     test_insert_1<vector<int>>();
     test_insert_1<deque<int>>();
     test_insert_2<vector<int>>();
     test_insert_2<deque<int>>();
     test_insert_transparent();
     test_insert_using_invalid_hint();
+    test_insert_upper_bound();
 
     test_comparer_application();
     test_non_static_comparer();
@@ -704,5 +897,11 @@ int main() {
     test_erase_if<flat_set<int>>();
     test_erase_if<flat_multiset<int>>();
 
-    test_count();
+    test_observers<flat_set>();
+    test_observers<flat_multiset>();
+
+    test_set_operations<flat_set>();
+    test_set_operations<flat_multiset>();
+    test_set_operations_transparent<flat_set>();
+    test_set_operations_transparent<flat_multiset>();
 }

From cf59a1610a0c19af76b5b2be7a88022fc583bc3a Mon Sep 17 00:00:00 2001
From: achabense <60953653+achabense@users.noreply.github.com>
Date: Wed, 8 Nov 2023 02:22:13 +0800
Subject: [PATCH 014/134] `<flat_set>`: `flat_(multi)set`'s `iterator` type
 should be constant iterator (#4132)

Co-authored-by: Casey Carter <cartec69@gmail.com>
---
 stl/inc/flat_set                          | 128 ++++++----------------
 tests/std/tests/P1222R4_flat_set/test.cpp |  19 +++-
 2 files changed, 53 insertions(+), 94 deletions(-)

diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index d31bf71ce01..99eb74870eb 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -56,10 +56,10 @@ public:
     using const_reference        = const value_type&;
     using size_type              = _Container::size_type;
     using difference_type        = _Container::difference_type;
-    using iterator               = _Container::iterator;
     using const_iterator         = _Container::const_iterator;
-    using reverse_iterator       = _STD reverse_iterator<iterator>;
+    using iterator               = const_iterator;
     using const_reverse_iterator = _STD reverse_iterator<const_iterator>;
+    using reverse_iterator       = const_reverse_iterator;
     using container_type         = _Container;
 
     static_assert(random_access_iterator<iterator>, "The C++ Standard forbids containers without random "
@@ -160,7 +160,7 @@ public:
     {}
 
     _Base_flat_set& operator=(const _Base_flat_set& _Other) {
-        _Clear_guard<_Base_flat_set> _Guard{this};
+        _Clear_guard<container_type> _Guard{_STD addressof(_Mycont)};
         _Mycont        = _Other._Mycont;
         _Mycomp        = _Other._Mycomp;
         _Guard._Target = nullptr;
@@ -170,8 +170,8 @@ public:
         is_nothrow_move_assignable_v<container_type>&& is_nothrow_copy_assignable_v<key_compare>) // strengthened
     {
         if (this != _STD addressof(_Other)) {
-            _Clear_guard<_Base_flat_set> _Guard{this};
-            _Clear_guard<_Base_flat_set> _Always_clear{_STD addressof(_Other)};
+            _Clear_guard<container_type> _Guard{_STD addressof(_Mycont)};
+            _Clear_guard<container_type> _Always_clear{_STD addressof(_Other._Mycont)};
             _Mycont        = _STD move(_Other._Mycont);
             _Mycomp        = _Other._Mycomp; // intentionally copy comparator, see LWG-2227
             _Guard._Target = nullptr;
@@ -180,7 +180,7 @@ public:
     }
 
     _Deriv& operator=(initializer_list<_Kty> _Ilist) {
-        _Clear_guard<_Base_flat_set> _Guard{this};
+        _Clear_guard<container_type> _Guard{_STD addressof(_Mycont)};
         _Mycont.assign(_Ilist);
         _Make_invariants_fulfilled();
         _Guard._Target = nullptr;
@@ -188,28 +188,17 @@ public:
     }
 
     // iterators
-    _NODISCARD iterator begin() noexcept {
-        return _Mycont.begin();
-    }
+    // NB: The non-const overloads are intentionally removed for brevity. This will not result in behavioral changes.
     _NODISCARD const_iterator begin() const noexcept {
         return _Mycont.begin();
     }
-    _NODISCARD iterator end() noexcept {
-        return _Mycont.end();
-    }
     _NODISCARD const_iterator end() const noexcept {
         return _Mycont.end();
     }
 
-    _NODISCARD reverse_iterator rbegin() noexcept {
-        return reverse_iterator(end());
-    }
     _NODISCARD const_reverse_iterator rbegin() const noexcept {
         return const_reverse_iterator(end());
     }
-    _NODISCARD reverse_iterator rend() noexcept {
-        return reverse_iterator(begin());
-    }
     _NODISCARD const_reverse_iterator rend() const noexcept {
         return const_reverse_iterator(begin());
     }
@@ -314,19 +303,17 @@ public:
     _NODISCARD container_type extract() && noexcept(
         is_nothrow_move_constructible_v<container_type>) /* strengthened */ {
         // always clears the container (N4950 [flat.set.modifiers]/14 and [flat.multiset.modifiers]/10)
-        _Clear_guard<_Base_flat_set> _Always_clear{this};
+        _Clear_guard<container_type> _Always_clear{_STD addressof(_Mycont)};
         return _STD move(_Mycont);
     }
     void replace(container_type&& _Cont) {
         _STL_ASSERT(_Is_sorted(_Cont), _Msg_not_sorted);
-        _Clear_guard<_Base_flat_set> _Guard{this};
+        _Clear_guard<container_type> _Guard{_STD addressof(_Mycont)};
         _Mycont        = _STD move(_Cont);
         _Guard._Target = nullptr;
     }
 
-    iterator erase(iterator _Where) {
-        return _Mycont.erase(_Where);
-    }
+    // NB: `erase(iterator)` is identical to `erase(const_iterator)`
     iterator erase(const_iterator _Where) {
         return _Mycont.erase(_Where);
     }
@@ -334,8 +321,7 @@ public:
         return _Erase(_Val);
     }
     template <_Different_from<_Kty> _Other>
-        requires (
-            _Keylt_transparent && !is_convertible_v<_Other, iterator> && !is_convertible_v<_Other, const_iterator>)
+        requires (_Keylt_transparent && !is_convertible_v<_Other, const_iterator>)
     size_type erase(_Other&& _Val) {
         return _Erase(_Val);
     }
@@ -359,17 +345,13 @@ public:
         return _Mycomp;
     }
 
-    // set operations
-    _NODISCARD iterator find(const _Kty& _Val) {
-        return _Find(_Val);
-    }
-    _NODISCARD const_iterator find(const _Kty& _Val) const {
-        return _Find(_Val);
+    _NODISCARD container_type& _Get_container_for_erase_if() noexcept {
+        return _Mycont;
     }
 
-    template <class _Other>
-        requires _Keylt_transparent
-    _NODISCARD iterator find(const _Other& _Val) {
+    // set operations
+    // NB: The non-const overloads are intentionally removed for brevity. This will not result in behavioral changes.
+    _NODISCARD const_iterator find(const _Kty& _Val) const {
         return _Find(_Val);
     }
     template <class _Other>
@@ -402,54 +384,27 @@ public:
         return _STD binary_search(cbegin(), cend(), _Val, _Pass_comp());
     }
 
-    _NODISCARD iterator lower_bound(const _Kty& _Val) {
-        return _STD lower_bound(begin(), end(), _Val, _Pass_comp());
-    }
     _NODISCARD const_iterator lower_bound(const _Kty& _Val) const {
         return _STD lower_bound(cbegin(), cend(), _Val, _Pass_comp());
     }
-
-    template <class _Other>
-        requires _Keylt_transparent
-    _NODISCARD iterator lower_bound(const _Other& _Val) {
-        return _STD lower_bound(begin(), end(), _Val, _Pass_comp());
-    }
     template <class _Other>
         requires _Keylt_transparent
     _NODISCARD const_iterator lower_bound(const _Other& _Val) const {
         return _STD lower_bound(cbegin(), cend(), _Val, _Pass_comp());
     }
 
-    _NODISCARD iterator upper_bound(const _Kty& _Val) {
-        return _STD upper_bound(begin(), end(), _Val, _Pass_comp());
-    }
     _NODISCARD const_iterator upper_bound(const _Kty& _Val) const {
         return _STD upper_bound(cbegin(), cend(), _Val, _Pass_comp());
     }
-
-    template <class _Other>
-        requires _Keylt_transparent
-    _NODISCARD iterator upper_bound(const _Other& _Val) {
-        return _STD upper_bound(begin(), end(), _Val, _Pass_comp());
-    }
     template <class _Other>
         requires _Keylt_transparent
     _NODISCARD const_iterator upper_bound(const _Other& _Val) const {
         return _STD upper_bound(cbegin(), cend(), _Val, _Pass_comp());
     }
 
-    _NODISCARD pair<iterator, iterator> equal_range(const _Kty& _Val) {
-        return _STD equal_range(begin(), end(), _Val, _Pass_comp());
-    }
     _NODISCARD pair<const_iterator, const_iterator> equal_range(const _Kty& _Val) const {
         return _STD equal_range(cbegin(), cend(), _Val, _Pass_comp());
     }
-
-    template <class _Other>
-        requires _Keylt_transparent
-    _NODISCARD pair<iterator, iterator> equal_range(const _Other& _Val) {
-        return _STD equal_range(begin(), end(), _Val, _Pass_comp());
-    }
     template <class _Other>
         requires _Keylt_transparent
     _NODISCARD pair<const_iterator, const_iterator> equal_range(const _Other& _Val) const {
@@ -521,9 +476,8 @@ private:
     template <class _Ty>
         requires (!_Multi) // flat_set
     _NODISCARD pair<iterator, bool> _Emplace(_Ty&& _Val) {
-        const iterator _Where = lower_bound(_Val);
-        if (_Where != end() && !_Compare(_Val, *_Where)) {
-            // *_Where is equivalent to _Val.
+        const const_iterator _Where = lower_bound(_Val);
+        if (_Where != cend() && !_Compare(_Val, *_Where)) {
             return pair{_Where, false};
         }
 
@@ -589,8 +543,7 @@ private:
         }
 
         if (_Where != _End && !_Compare(_Val, *_Where)) {
-            // *_Where is equivalent to _Val; convert _Where to iterator type.
-            return _Mycont.begin() + (_Where - _Begin);
+            return _Where;
         }
 
         if constexpr (is_same_v<remove_cvref_t<_Ty>, _Kty>) {
@@ -620,8 +573,8 @@ private:
         _STL_INTERNAL_STATIC_ASSERT(_Keylt_transparent || is_same_v<_Ty, _Kty>);
 
         if constexpr (!_Multi && is_same_v<_Ty, _Kty>) {
-            const iterator _Where = lower_bound(_Val);
-            if (_Where != end() && !_Compare(_Val, *_Where)) {
+            const const_iterator _Where = lower_bound(_Val);
+            if (_Where != cend() && !_Compare(_Val, *_Where)) {
                 _Mycont.erase(_Where);
                 return 1;
             }
@@ -635,19 +588,6 @@ private:
         }
     }
 
-    template <class _Ty>
-    _NODISCARD iterator _Find(const _Ty& _Val) {
-        _STL_INTERNAL_STATIC_ASSERT(_Keylt_transparent || is_same_v<_Ty, _Kty>);
-
-        const iterator _End   = end();
-        const iterator _Where = lower_bound(_Val);
-        if (_Where != _End && !_Compare(_Val, *_Where)) {
-            return _Where;
-        } else {
-            return _End;
-        }
-    }
-
     template <class _Ty>
     _NODISCARD const_iterator _Find(const _Ty& _Val) const {
         _STL_INTERNAL_STATIC_ASSERT(_Keylt_transparent || is_same_v<_Ty, _Kty>);
@@ -666,16 +606,16 @@ private:
             const auto _Equivalent = [this](const _Kty& _Lhs, const _Kty& _Rhs) {
                 return !_Compare(_Lhs, _Rhs) && !_Compare(_Rhs, _Lhs);
             };
-            const iterator _End = end();
-            _Mycont.erase(_STD unique(begin(), _End, _Equivalent), _End);
+            const auto _End = _Mycont.end();
+            _Mycont.erase(_STD unique(_Mycont.begin(), _End, _Equivalent), _End);
         }
     }
 
     template <bool _Presorted>
     void _Restore_invariants_after_insert(const size_type _Old_size) {
-        const iterator _Begin   = begin();
-        const iterator _Old_end = _Begin + static_cast<difference_type>(_Old_size);
-        const iterator _End     = end();
+        const auto _Begin   = _Mycont.begin();
+        const auto _Old_end = _Begin + static_cast<difference_type>(_Old_size);
+        const auto _End     = _Mycont.end();
 
         if constexpr (!_Presorted) {
             _STD sort(_Old_end, _End, _Pass_comp());
@@ -690,15 +630,15 @@ private:
     }
 
     void _Make_invariants_fulfilled() {
-        const iterator _Begin = begin();
-        const iterator _End   = end();
+        const auto _Begin = _Mycont.begin();
+        const auto _End   = _Mycont.end();
 
         if (_Begin == _End) {
             return;
         }
 
         // O(N) if already sorted.
-        const iterator _Begin_unsorted = _STD is_sorted_until(_Begin, _End, _Pass_comp());
+        const auto _Begin_unsorted = _STD is_sorted_until(_Begin, _End, _Pass_comp());
 
         _STD sort(_Begin_unsorted, _End, _Pass_comp());
         _STD inplace_merge(_Begin, _Begin_unsorted, _End, _Pass_comp());
@@ -768,8 +708,9 @@ public:
 _EXPORT_STD template <class _Kty, class _Keylt, class _Container, class _Pred>
 _Container::size_type erase_if(flat_set<_Kty, _Keylt, _Container>& _Val, _Pred _Predicate) {
     // clears the container to maintain the invariants when an exception is thrown (N4950 [flat.set.erasure]/5)
-    _Clear_guard<flat_set<_Kty, _Keylt, _Container>> _Guard{_STD addressof(_Val)};
-    const auto _Erased_count = _STD _Erase_remove_if(_Val, _STD _Pass_fn(_Predicate));
+    _Container& _Cont = _Val._Get_container_for_erase_if();
+    _Clear_guard<_Container> _Guard{_STD addressof(_Cont)};
+    const auto _Erased_count = _STD _Erase_remove_if(_Cont, _STD _Pass_fn(_Predicate));
     _Guard._Target           = nullptr;
     return _Erased_count;
 }
@@ -777,8 +718,9 @@ _Container::size_type erase_if(flat_set<_Kty, _Keylt, _Container>& _Val, _Pred _
 _EXPORT_STD template <class _Kty, class _Keylt, class _Container, class _Pred>
 _Container::size_type erase_if(flat_multiset<_Kty, _Keylt, _Container>& _Val, _Pred _Predicate) {
     // clears the container to maintain the invariants when an exception is thrown (N4950 [flat.multiset.erasure]/5)
-    _Clear_guard<flat_multiset<_Kty, _Keylt, _Container>> _Guard{_STD addressof(_Val)};
-    const auto _Erased_count = _STD _Erase_remove_if(_Val, _STD _Pass_fn(_Predicate));
+    _Container& _Cont = _Val._Get_container_for_erase_if();
+    _Clear_guard<_Container> _Guard{_STD addressof(_Cont)};
+    const auto _Erased_count = _STD _Erase_remove_if(_Cont, _STD _Pass_fn(_Predicate));
     _Guard._Target           = nullptr;
     return _Erased_count;
 }
diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index e1976302b37..4f423920c67 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -33,7 +33,7 @@ void assert_container_requirements(const T& s) {
     static_assert(is_same_v<decltype(m.begin() <=> m.end()), strong_ordering>);
     static_assert(is_same_v<decltype(s.size()), typename T::size_type>);
     static_assert(is_same_v<decltype(s.max_size()), typename T::size_type>);
-    static_assert(is_same_v<decltype(*m.begin()), typename T::value_type&>);
+    static_assert(is_same_v<decltype(*m.begin()), const typename T::value_type&>);
     static_assert(is_same_v<decltype(*m.cbegin()), const typename T::value_type&>);
 
     T my_moved = std::move(m);
@@ -73,6 +73,22 @@ void assert_reversible_container_requirements(const T& s) {
     static_assert(is_convertible_v<typename T::reverse_iterator, typename T::const_reverse_iterator>);
 }
 
+template <class T>
+void assert_set_requirements() {
+    using iterator       = T::iterator;
+    using const_iterator = T::const_iterator;
+    using key_type       = T::key_type;
+    using value_type     = T::value_type;
+
+    static_assert(same_as<std::const_iterator<const_iterator>, const_iterator>);
+    static_assert(is_convertible_v<iterator, const_iterator>);
+
+    // additionally:
+    static_assert(is_same_v<key_type, value_type>);
+    static_assert(same_as<std::const_iterator<iterator>, iterator>);
+    static_assert(is_convertible_v<const_iterator, iterator>);
+}
+
 template <class T>
 void assert_noexcept_requirements(T& s) {
     static_assert(noexcept(s.begin()));
@@ -99,6 +115,7 @@ template <class T>
 void assert_all_requirements(const T& s) {
     assert_container_requirements(s);
     assert_reversible_container_requirements(s);
+    assert_set_requirements<T>();
 
     assert_noexcept_requirements(s);
     assert_noexcept_requirements(const_cast<T&>(s));

From 5960f7961ade0f5696613019c0f3a17890b0d3d8 Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34@live.cn>
Date: Sat, 11 Nov 2023 03:21:38 +0800
Subject: [PATCH 015/134] `<flat_set>`: Correct allocator-extended constructors
 for `flat_(multi)set` (#4148)

Co-authored-by: Stephan T. Lavavej <stl@nuwen.net>
---
 stl/inc/flat_set                          |  54 ++++---
 tests/std/tests/P1222R4_flat_set/test.cpp | 187 ++++++++++++++++++++++
 2 files changed, 220 insertions(+), 21 deletions(-)

diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index 99eb74870eb..4b715db0d77 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -68,10 +68,12 @@ public:
     _Base_flat_set() : _Mycont(), _Mycomp() {}
 
     template <_Allocator_for<container_type> _Alloc>
-    _Base_flat_set(const _Deriv& _Set, const _Alloc& _Al) : _Mycont(_Set._Mycont, _Al), _Mycomp(_Set._Mycomp) {}
+    _Base_flat_set(const _Deriv& _Set, const _Alloc& _Al)
+        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al, _Set._Mycont)), _Mycomp(_Set._Mycomp) {}
     template <_Allocator_for<container_type> _Alloc>
     _Base_flat_set(_Deriv&& _Set, const _Alloc& _Al)
-        : _Mycont(_STD move(_Set).extract(), _Al), _Mycomp(_Set._Mycomp) // intentionally copy comparator, see LWG-2227
+        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al, _STD move(_Set).extract())),
+          _Mycomp(_Set._Mycomp) // intentionally copy comparator, see LWG-2227
     {}
 
     explicit _Base_flat_set(container_type _Cont, const key_compare& _Comp = key_compare())
@@ -79,10 +81,11 @@ public:
         _Make_invariants_fulfilled();
     }
     template <_Allocator_for<container_type> _Alloc>
-    _Base_flat_set(const container_type& _Cont, const _Alloc& _Al) : _Base_flat_set(container_type(_Cont, _Al)) {}
+    _Base_flat_set(const container_type& _Cont, const _Alloc& _Al)
+        : _Base_flat_set(_STD make_obj_using_allocator<container_type>(_Al, _Cont)) {}
     template <_Allocator_for<container_type> _Alloc>
     _Base_flat_set(const container_type& _Cont, const key_compare& _Comp, const _Alloc& _Al)
-        : _Base_flat_set(container_type(_Cont, _Al), _Comp) {}
+        : _Base_flat_set(_STD make_obj_using_allocator<container_type>(_Al, _Cont), _Comp) {}
 
     _Base_flat_set(_Tsorted, container_type _Cont, const key_compare& _Comp = key_compare())
         : _Mycont(_STD move(_Cont)), _Mycomp(_Comp) {
@@ -90,68 +93,77 @@ public:
     }
     template <_Allocator_for<container_type> _Alloc>
     _Base_flat_set(_Tsorted _Tsort, const container_type& _Cont, const _Alloc& _Al)
-        : _Base_flat_set(_Tsort, container_type(_Cont, _Al)) {}
+        : _Base_flat_set(_Tsort, _STD make_obj_using_allocator<container_type>(_Al, _Cont)) {}
     template <_Allocator_for<container_type> _Alloc>
     _Base_flat_set(_Tsorted _Tsort, const container_type& _Cont, const key_compare& _Comp, const _Alloc& _Al)
-        : _Base_flat_set(_Tsort, container_type(_Cont, _Al), _Comp) {}
+        : _Base_flat_set(_Tsort, _STD make_obj_using_allocator<container_type>(_Al, _Cont), _Comp) {}
 
     explicit _Base_flat_set(const key_compare& _Comp) : _Mycont(), _Mycomp(_Comp) {}
     template <_Allocator_for<container_type> _Alloc>
-    _Base_flat_set(const key_compare& _Comp, const _Alloc& _Al) : _Mycont(_Al), _Mycomp(_Comp) {}
+    _Base_flat_set(const key_compare& _Comp, const _Alloc& _Al)
+        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al)), _Mycomp(_Comp) {}
     template <_Allocator_for<container_type> _Alloc>
-    explicit _Base_flat_set(const _Alloc& _Al) : _Mycont(_Al), _Mycomp() {}
+    explicit _Base_flat_set(const _Alloc& _Al)
+        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al)), _Mycomp() {}
 
-    // FIXME, an allocator-aware container may not support "C(_First, _Last, _Al)".
     template <input_iterator _Iter>
     _Base_flat_set(_Iter _First, _Iter _Last, const key_compare& _Comp = key_compare())
         : _Base_flat_set(container_type(_First, _Last), _Comp) {}
     template <input_iterator _Iter, _Allocator_for<container_type> _Alloc>
     _Base_flat_set(_Iter _First, _Iter _Last, const key_compare& _Comp, const _Alloc& _Al)
-        : _Base_flat_set(container_type(_First, _Last, _Al), _Comp) {}
+        : _Base_flat_set(_STD make_obj_using_allocator<container_type>(_Al), _Comp) {
+        insert(_First, _Last);
+    }
     template <input_iterator _Iter, _Allocator_for<container_type> _Alloc>
-    _Base_flat_set(_Iter _First, _Iter _Last, const _Alloc& _Al) : _Base_flat_set(container_type(_First, _Last, _Al)) {}
+    _Base_flat_set(_Iter _First, _Iter _Last, const _Alloc& _Al)
+        : _Base_flat_set(_STD make_obj_using_allocator<container_type>(_Al)) {
+        insert(_First, _Last);
+    }
 
-    // FIXME, an allocator-aware container may not support "C(from_range, _STD forward<_Rng>(_Range), _Al)".
     template <_Container_compatible_range<_Kty> _Rng>
     _Base_flat_set(from_range_t, _Rng&& _Range)
         : _Base_flat_set(container_type(from_range, _STD forward<_Rng>(_Range))) {}
     template <_Container_compatible_range<_Kty> _Rng, _Allocator_for<container_type> _Alloc>
     _Base_flat_set(from_range_t, _Rng&& _Range, const _Alloc& _Al)
-        : _Base_flat_set(container_type(from_range, _STD forward<_Rng>(_Range), _Al)) {}
+        : _Base_flat_set(_STD make_obj_using_allocator<container_type>(_Al)) {
+        insert_range(_STD forward<_Rng>(_Range));
+    }
     template <_Container_compatible_range<_Kty> _Rng>
     _Base_flat_set(from_range_t, _Rng&& _Range, const key_compare& _Comp)
         : _Base_flat_set(container_type(from_range, _STD forward<_Rng>(_Range)), _Comp) {}
     template <_Container_compatible_range<_Kty> _Rng, _Allocator_for<container_type> _Alloc>
     _Base_flat_set(from_range_t, _Rng&& _Range, const key_compare& _Comp, const _Alloc& _Al)
-        : _Base_flat_set(container_type(from_range, _STD forward<_Rng>(_Range), _Al), _Comp) {}
+        : _Base_flat_set(_STD make_obj_using_allocator<container_type>(_Al), _Comp) {
+        insert_range(_STD forward<_Rng>(_Range));
+    }
 
     template <input_iterator _Iter>
     _Base_flat_set(_Tsorted _Tsort, _Iter _First, _Iter _Last, const key_compare& _Comp = key_compare())
         : _Base_flat_set(_Tsort, container_type(_First, _Last), _Comp) {}
     template <input_iterator _Iter, _Allocator_for<container_type> _Alloc>
     _Base_flat_set(_Tsorted _Tsort, _Iter _First, _Iter _Last, const key_compare& _Comp, const _Alloc& _Al)
-        : _Base_flat_set(_Tsort, container_type(_First, _Last, _Al), _Comp) {}
+        : _Base_flat_set(_Tsort, _STD make_obj_using_allocator<container_type>(_Al, _First, _Last), _Comp) {}
     template <input_iterator _Iter, _Allocator_for<container_type> _Alloc>
     _Base_flat_set(_Tsorted _Tsort, _Iter _First, _Iter _Last, const _Alloc& _Al)
-        : _Base_flat_set(_Tsort, container_type(_First, _Last, _Al)) {}
+        : _Base_flat_set(_Tsort, _STD make_obj_using_allocator<container_type>(_Al, _First, _Last)) {}
 
-    // FIXME, an allocator-aware container may not support "C(_Ilist, _Al)".
     _Base_flat_set(initializer_list<_Kty> _Ilist, const key_compare& _Comp = key_compare())
         : _Base_flat_set(container_type(_Ilist), _Comp) {}
     template <_Allocator_for<container_type> _Alloc>
     _Base_flat_set(initializer_list<_Kty> _Ilist, const key_compare& _Comp, const _Alloc& _Al)
-        : _Base_flat_set(container_type(_Ilist, _Al), _Comp) {}
+        : _Base_flat_set(_Ilist.begin(), _Ilist.end(), _Comp, _Al) {}
     template <_Allocator_for<container_type> _Alloc>
-    _Base_flat_set(initializer_list<_Kty> _Ilist, const _Alloc& _Al) : _Base_flat_set(container_type(_Ilist, _Al)) {}
+    _Base_flat_set(initializer_list<_Kty> _Ilist, const _Alloc& _Al)
+        : _Base_flat_set(_Ilist.begin(), _Ilist.end(), _Al) {}
 
     _Base_flat_set(_Tsorted _Tsort, initializer_list<_Kty> _Ilist, const key_compare& _Comp = key_compare())
         : _Base_flat_set(_Tsort, container_type(_Ilist), _Comp) {}
     template <_Allocator_for<container_type> _Alloc>
     _Base_flat_set(_Tsorted _Tsort, initializer_list<_Kty> _Ilist, const key_compare& _Comp, const _Alloc& _Al)
-        : _Base_flat_set(_Tsort, container_type(_Ilist, _Al), _Comp) {}
+        : _Base_flat_set(_Tsort, _Ilist.begin(), _Ilist.end(), _Comp, _Al) {}
     template <_Allocator_for<container_type> _Alloc>
     _Base_flat_set(_Tsorted _Tsort, initializer_list<_Kty> _Ilist, const _Alloc& _Al)
-        : _Base_flat_set(_Tsort, container_type(_Ilist, _Al)) {}
+        : _Base_flat_set(_Tsort, _Ilist.begin(), _Ilist.end(), _Al) {}
 
     _Base_flat_set(const _Base_flat_set&) = default;
     _Base_flat_set(_Base_flat_set&& _Other) noexcept(
diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index 4f423920c67..4617fb2bc2b 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -11,13 +11,121 @@
 #include <iostream>
 #include <memory>
 #include <random>
+#include <ranges>
 #include <tuple>
+#include <type_traits>
 #include <utility>
 #include <vector>
 
+#define TEST_ASSERT(...) assert((__VA_ARGS__))
+
 using namespace std;
 using namespace ranges;
 
+enum class iterator_pair_construction : bool { no_allocator, with_allocator };
+
+template <class R, class T>
+concept container_compatible_range = input_range<R> && convertible_to<range_reference_t<R>, T>;
+
+template <class T, class Alloc = allocator<T>,
+    iterator_pair_construction Choice = iterator_pair_construction::with_allocator>
+class alternative_vector : private vector<T, Alloc> { // not allocator-aware, but can be uses-allocator constructed
+private:
+    using base_type = vector<T, Alloc>;
+
+public:
+    using typename base_type::allocator_type;
+    using typename base_type::const_iterator;
+    using typename base_type::const_pointer;
+    using typename base_type::const_reference;
+    using typename base_type::const_reverse_iterator;
+    using typename base_type::difference_type;
+    using typename base_type::iterator;
+    using typename base_type::pointer;
+    using typename base_type::reference;
+    using typename base_type::reverse_iterator;
+    using typename base_type::size_type;
+    using typename base_type::value_type;
+
+    constexpr alternative_vector() noexcept(noexcept(Alloc())) : base_type(Alloc()) {}
+    constexpr alternative_vector(allocator_arg_t, const Alloc& a) : base_type(a) {}
+    constexpr explicit alternative_vector(size_type n) : base_type(n) {}
+    constexpr explicit alternative_vector(size_type n, const T& v) : base_type(n, v) {}
+    template <class InputIt>
+    constexpr explicit alternative_vector(InputIt first, InputIt last) : base_type(first, last) {}
+    template <class InputIt>
+        requires (Choice == iterator_pair_construction::with_allocator)
+    constexpr explicit alternative_vector(allocator_arg_t, const Alloc& a, InputIt first, InputIt last)
+        : base_type(first, last, a) {}
+
+    template <container_compatible_range<T> R>
+    constexpr explicit alternative_vector(from_range_t, R&& rg) : base_type(from_range, forward<R>(rg)) {}
+
+    constexpr alternative_vector(allocator_arg_t, const type_identity_t<Alloc>& a, const alternative_vector& other)
+        : base_type(other, a) {}
+    constexpr alternative_vector(allocator_arg_t, const type_identity_t<Alloc>& a, alternative_vector&& other)
+        : base_type(std::move(other), a) {}
+    constexpr explicit alternative_vector(initializer_list<T> il) : base_type(il) {}
+
+    alternative_vector(const alternative_vector&) = default;
+    alternative_vector(alternative_vector&&)      = default;
+
+    alternative_vector& operator=(const alternative_vector&) = default;
+    alternative_vector& operator=(alternative_vector&&)      = default;
+    constexpr alternative_vector& operator=(initializer_list<T> il) {
+        base_type::operator=(il);
+        return *this;
+    }
+
+    using base_type::assign;
+    using base_type::assign_range;
+    using base_type::get_allocator;
+
+    using base_type::begin;
+    using base_type::end;
+    using base_type::rbegin;
+    using base_type::rend;
+
+    using base_type::cbegin;
+    using base_type::cend;
+    using base_type::crbegin;
+    using base_type::crend;
+
+    using base_type::capacity;
+    using base_type::empty;
+    using base_type::max_size;
+    using base_type::reserve;
+    using base_type::resize;
+    using base_type::shrink_to_fit;
+    using base_type::size;
+
+    using base_type::operator[];
+    using base_type::at;
+    using base_type::back;
+    using base_type::front;
+
+    using base_type::data;
+
+    using base_type::append_range;
+    using base_type::emplace_back;
+    using base_type::pop_back;
+    using base_type::push_back;
+
+    using base_type::emplace;
+    using base_type::erase;
+    using base_type::insert;
+    using base_type::insert_range;
+    using base_type::swap;
+
+    using base_type::clear;
+
+    friend auto operator<=>(const alternative_vector&, const alternative_vector&) = default;
+
+    friend constexpr void swap(alternative_vector& lhs, alternative_vector& rhs) noexcept(noexcept(lhs.swap(rhs))) {
+        lhs.swap(rhs);
+    }
+};
+
 template <class T>
 void assert_container_requirements(const T& s) {
     T m = s;
@@ -183,6 +291,83 @@ void test_constructors() {
     assert_all_requirements_and_equals(flat_multiset<int>(std::move(b), allocator<int>{}), {-1, 1, 2, 7, 7, 7, 100});
 }
 
+template <iterator_pair_construction Choice>
+void test_allocator_extended_constructors() {
+    using vec = alternative_vector<int, allocator<int>, Choice>;
+    constexpr allocator<int> ator;
+    constexpr std::less<int> comp;
+    {
+        using fs = flat_set<int, std::less<int>, vec>;
+
+        fs s{3, 7, 1, 85, 222, 1};
+        fs s_expected{1, 3, 7, 85, 222};
+        vec v_raw{3, 7, 1, 85, 222, 1};
+        vec v_sorted_unique{1, 3, 7, 85, 222};
+
+        TEST_ASSERT(fs{comp, ator} == fs{});
+
+        TEST_ASSERT(fs{s, ator} == s_expected);
+        TEST_ASSERT(fs{s_expected, ator} == s_expected);
+        TEST_ASSERT(fs{std::move(s), ator} == s_expected);
+        TEST_ASSERT(fs{fs{s_expected}, ator} == s_expected);
+
+        TEST_ASSERT(fs{v_raw, ator} == s_expected);
+        TEST_ASSERT(fs{{3, 7, 1, 85, 222, 1}, ator} == s_expected);
+        TEST_ASSERT(fs{v_raw.begin(), v_raw.end(), ator} == s_expected);
+        TEST_ASSERT(fs{from_range, v_raw, ator} == s_expected);
+
+        TEST_ASSERT(fs{v_raw, comp, ator} == s_expected);
+        TEST_ASSERT(fs{{3, 7, 1, 85, 222, 1}, comp, ator} == s_expected);
+        TEST_ASSERT(fs{v_raw.begin(), v_raw.end(), comp, ator} == s_expected);
+        TEST_ASSERT(fs{from_range, v_raw, comp, ator} == s_expected);
+
+        TEST_ASSERT(fs{sorted_unique, v_sorted_unique, ator} == s_expected);
+        TEST_ASSERT(fs{sorted_unique, v_sorted_unique, comp, ator} == s_expected);
+        if constexpr (Choice == iterator_pair_construction::with_allocator) {
+            TEST_ASSERT(fs{sorted_unique, {1, 3, 7, 85, 222}, ator} == s_expected);
+            TEST_ASSERT(fs{sorted_unique, {1, 3, 7, 85, 222}, comp, ator} == s_expected);
+
+            TEST_ASSERT(fs{sorted_unique, v_sorted_unique.begin(), v_sorted_unique.end(), ator} == s_expected);
+            TEST_ASSERT(fs{sorted_unique, v_sorted_unique.begin(), v_sorted_unique.end(), comp, ator} == s_expected);
+        }
+    }
+    {
+        using fms = flat_multiset<int, std::less<int>, vec>;
+
+        fms s{3, 7, 1, 85, 222, 1};
+        fms s_expected{1, 1, 3, 7, 85, 222};
+        vec v_raw{3, 7, 1, 85, 222, 1};
+        vec v_sorted_eq{1, 1, 3, 7, 85, 222};
+
+        TEST_ASSERT(fms{comp, ator} == fms{});
+
+        TEST_ASSERT(fms{s, ator} == s_expected);
+        TEST_ASSERT(fms{s_expected, ator} == s_expected);
+        TEST_ASSERT(fms{std::move(s), ator} == s_expected);
+        TEST_ASSERT(fms{fms{s_expected}, ator} == s_expected);
+
+        TEST_ASSERT(fms{v_raw, ator} == s_expected);
+        TEST_ASSERT(fms{{3, 7, 1, 85, 222, 1}, ator} == s_expected);
+        TEST_ASSERT(fms{v_raw.begin(), v_raw.end(), ator} == s_expected);
+        TEST_ASSERT(fms{from_range, v_raw, ator} == s_expected);
+
+        TEST_ASSERT(fms{v_raw, comp, ator} == s_expected);
+        TEST_ASSERT(fms{{3, 7, 1, 85, 222, 1}, comp, ator} == s_expected);
+        TEST_ASSERT(fms{v_raw.begin(), v_raw.end(), comp, ator} == s_expected);
+        TEST_ASSERT(fms{from_range, v_raw, comp, ator} == s_expected);
+
+        TEST_ASSERT(fms{sorted_equivalent, v_sorted_eq, ator} == s_expected);
+        TEST_ASSERT(fms{sorted_equivalent, v_sorted_eq, comp, ator} == s_expected);
+        if constexpr (Choice == iterator_pair_construction::with_allocator) {
+            TEST_ASSERT(fms{sorted_equivalent, {1, 1, 3, 7, 85, 222}, ator} == s_expected);
+            TEST_ASSERT(fms{sorted_equivalent, {1, 1, 3, 7, 85, 222}, comp, ator} == s_expected);
+
+            TEST_ASSERT(fms{sorted_equivalent, v_sorted_eq.begin(), v_sorted_eq.end(), ator} == s_expected);
+            TEST_ASSERT(fms{sorted_equivalent, v_sorted_eq.begin(), v_sorted_eq.end(), comp, ator} == s_expected);
+        }
+    }
+}
+
 template <template <class...> class Set>
 void test_always_reversible() {
     // Test that flat_meow is unconditionally reversible.
@@ -887,6 +1072,8 @@ int main() {
 
     test_constructors<vector<int>>();
     test_constructors<deque<int>>();
+    test_allocator_extended_constructors<iterator_pair_construction::no_allocator>();
+    test_allocator_extended_constructors<iterator_pair_construction::with_allocator>();
 
     test_always_reversible<flat_set>();
     test_always_reversible<flat_multiset>();

From ff90852226c152aa248c83eee0540f3fa8ae8ba9 Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34@live.cn>
Date: Tue, 14 Nov 2023 05:32:15 +0800
Subject: [PATCH 016/134] `<flat_set>`: Restore insertion in
 `flat_(multi)set`'s iterator-pair/range constructors (#4156)

---
 stl/inc/flat_set | 20 ++++++++++++--------
 1 file changed, 12 insertions(+), 8 deletions(-)

diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index 4b715db0d77..f64c1674697 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -111,13 +111,15 @@ public:
         : _Base_flat_set(container_type(_First, _Last), _Comp) {}
     template <input_iterator _Iter, _Allocator_for<container_type> _Alloc>
     _Base_flat_set(_Iter _First, _Iter _Last, const key_compare& _Comp, const _Alloc& _Al)
-        : _Base_flat_set(_STD make_obj_using_allocator<container_type>(_Al), _Comp) {
-        insert(_First, _Last);
+        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al)), _Mycomp(_Comp) {
+        _Mycont.assign(_First, _Last);
+        _Make_invariants_fulfilled();
     }
     template <input_iterator _Iter, _Allocator_for<container_type> _Alloc>
     _Base_flat_set(_Iter _First, _Iter _Last, const _Alloc& _Al)
-        : _Base_flat_set(_STD make_obj_using_allocator<container_type>(_Al)) {
-        insert(_First, _Last);
+        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al)), _Mycomp() {
+        _Mycont.assign(_First, _Last);
+        _Make_invariants_fulfilled();
     }
 
     template <_Container_compatible_range<_Kty> _Rng>
@@ -125,16 +127,18 @@ public:
         : _Base_flat_set(container_type(from_range, _STD forward<_Rng>(_Range))) {}
     template <_Container_compatible_range<_Kty> _Rng, _Allocator_for<container_type> _Alloc>
     _Base_flat_set(from_range_t, _Rng&& _Range, const _Alloc& _Al)
-        : _Base_flat_set(_STD make_obj_using_allocator<container_type>(_Al)) {
-        insert_range(_STD forward<_Rng>(_Range));
+        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al)), _Mycomp() {
+        _Mycont.assign_range(_STD forward<_Rng>(_Range));
+        _Make_invariants_fulfilled();
     }
     template <_Container_compatible_range<_Kty> _Rng>
     _Base_flat_set(from_range_t, _Rng&& _Range, const key_compare& _Comp)
         : _Base_flat_set(container_type(from_range, _STD forward<_Rng>(_Range)), _Comp) {}
     template <_Container_compatible_range<_Kty> _Rng, _Allocator_for<container_type> _Alloc>
     _Base_flat_set(from_range_t, _Rng&& _Range, const key_compare& _Comp, const _Alloc& _Al)
-        : _Base_flat_set(_STD make_obj_using_allocator<container_type>(_Al), _Comp) {
-        insert_range(_STD forward<_Rng>(_Range));
+        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al)), _Mycomp(_Comp) {
+        _Mycont.assign_range(_STD forward<_Rng>(_Range));
+        _Make_invariants_fulfilled();
     }
 
     template <input_iterator _Iter>

From bd59fb7b64db67e1dad41087445ab685fd6650b6 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Thu, 14 Dec 2023 14:40:32 -0800
Subject: [PATCH 017/134] clang-format, no manual changes.

---
 stl/inc/flat_set | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index f64c1674697..83f6e9d1f03 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -171,7 +171,7 @@ public:
 
     _Base_flat_set(const _Base_flat_set&) = default;
     _Base_flat_set(_Base_flat_set&& _Other) noexcept(
-        is_nothrow_move_constructible_v<container_type>&& is_nothrow_copy_constructible_v<key_compare>) // strengthened
+        is_nothrow_move_constructible_v<container_type> && is_nothrow_copy_constructible_v<key_compare>) // strengthened
         : _Mycont(_STD move(_Other).extract()), _Mycomp(_Other._Mycomp) // intentionally copy comparator, see LWG-2227
     {}
 
@@ -183,7 +183,7 @@ public:
         return *this;
     }
     _Base_flat_set& operator=(_Base_flat_set&& _Other) noexcept(
-        is_nothrow_move_assignable_v<container_type>&& is_nothrow_copy_assignable_v<key_compare>) // strengthened
+        is_nothrow_move_assignable_v<container_type> && is_nothrow_copy_assignable_v<key_compare>) // strengthened
     {
         if (this != _STD addressof(_Other)) {
             _Clear_guard<container_type> _Guard{_STD addressof(_Mycont)};

From 8e0f0155c9579e1b25151bf94421b507fb8a33ed Mon Sep 17 00:00:00 2001
From: Qingnan Duan <duanqn_own_1@yeah.net>
Date: Fri, 12 Jan 2024 13:59:38 +0800
Subject: [PATCH 018/134] [WIP] Implementation of <flat_map> (#3896)

Co-authored-by: A. Jiang <de34@live.cn>
Co-authored-by: Stephan T. Lavavej <stl@nuwen.net>
---
 stl/CMakeLists.txt                            |    1 +
 stl/inc/__msvc_all_public_headers.hpp         |    1 +
 stl/inc/flat_map                              | 1163 +++++++++++++++++
 stl/inc/header-units.json                     |    1 +
 stl/inc/yvals_core.h                          |    2 +
 stl/modules/std.ixx                           |    1 +
 .../include/test_header_units_and_modules.hpp |   12 +
 tests/std/test.lst                            |    1 +
 tests/std/tests/P0429R9_flat_map/env.lst      |    4 +
 tests/std/tests/P0429R9_flat_map/test.cpp     |  281 ++++
 10 files changed, 1467 insertions(+)
 create mode 100644 stl/inc/flat_map
 create mode 100644 tests/std/tests/P0429R9_flat_map/env.lst
 create mode 100644 tests/std/tests/P0429R9_flat_map/test.cpp

diff --git a/stl/CMakeLists.txt b/stl/CMakeLists.txt
index f82705a800b..369957a3310 100644
--- a/stl/CMakeLists.txt
+++ b/stl/CMakeLists.txt
@@ -157,6 +157,7 @@ set(HEADERS
     ${CMAKE_CURRENT_LIST_DIR}/inc/experimental/unordered_set
     ${CMAKE_CURRENT_LIST_DIR}/inc/experimental/vector
     ${CMAKE_CURRENT_LIST_DIR}/inc/filesystem
+    ${CMAKE_CURRENT_LIST_DIR}/inc/flat_map
     ${CMAKE_CURRENT_LIST_DIR}/inc/format
     ${CMAKE_CURRENT_LIST_DIR}/inc/forward_list
     ${CMAKE_CURRENT_LIST_DIR}/inc/fstream
diff --git a/stl/inc/__msvc_all_public_headers.hpp b/stl/inc/__msvc_all_public_headers.hpp
index 268f3a862f6..0ef854b2036 100644
--- a/stl/inc/__msvc_all_public_headers.hpp
+++ b/stl/inc/__msvc_all_public_headers.hpp
@@ -92,6 +92,7 @@
 #include <exception>
 #include <expected>
 #include <filesystem>
+#include <flat_map>
 #include <format>
 #include <forward_list>
 #include <fstream>
diff --git a/stl/inc/flat_map b/stl/inc/flat_map
new file mode 100644
index 00000000000..52e35f8a7bf
--- /dev/null
+++ b/stl/inc/flat_map
@@ -0,0 +1,1163 @@
+// flat_map standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _FLAT_MAP_
+#define _FLAT_MAP_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+#if !_HAS_CXX23 || !defined(__cpp_lib_concepts) // TRANSITION, GH-395
+_EMIT_STL_WARNING(STL4038, "The contents of <flat_map> are available only with C++23 or later.");
+#else // ^^^ not supported / supported language mode vvv
+
+#include <algorithm>
+#include <compare>
+#include <concepts>
+#include <cstdint>
+#include <initializer_list>
+#include <memory>
+#include <ranges>
+#include <type_traits>
+#include <utility>
+#include <vector>
+#include <xmemory>
+#include <xutility>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+_STD_BEGIN
+
+template <class _FlatMap_Key, class _FlatMap_T, class _FlatMap_Compare, class _FlatMap_KeyContainer,
+    class _FlatMap_MappedContainer, bool _Is_Multi, class _Derived>
+    requires same_as<_FlatMap_Key, typename _FlatMap_KeyContainer::value_type>
+          && same_as<_FlatMap_T, typename _FlatMap_MappedContainer::value_type>
+class _Flat_Map_Base;
+
+template <class _Key, class _Mapped, class _Compare = less<_Key>, class _KeyContainer = vector<_Key>,
+    class _MappedContainer = vector<_Mapped>>
+class flat_map;
+
+template <class _Key, class _Mapped, class _Compare = less<_Key>, class _KeyContainer = vector<_Key>,
+    class _MappedContainer = vector<_Mapped>>
+class flat_multimap;
+
+struct sorted_unique_t {
+    explicit sorted_unique_t() = default;
+};
+inline constexpr sorted_unique_t sorted_unique{};
+
+struct sorted_equivalent_t {
+    explicit sorted_equivalent_t() = default;
+};
+inline constexpr sorted_equivalent_t sorted_equivalent{};
+
+template <class _Alloc, class _Key_container, class _Mapped_container>
+concept _Valid_Allocator_for_flat_map =
+    uses_allocator_v<_Key_container, _Alloc> && uses_allocator_v<_Mapped_container, _Alloc>;
+
+template <class _Compare, class _Key_container>
+concept _Valid_Compare_for_container = is_invocable_v<const _Compare&, const typename _Key_container::value_type&,
+    const typename _Key_container::value_type&>;
+
+template <class _Key, class _T, class _Key_compare>
+struct _Flat_value_compare {
+    struct value_compare {
+    public:
+        bool operator()(pair<const _Key&, const _T&> _X, pair<const _Key&, const _T&> _Y) const {
+            return _Key_compare_for_val(_X.first, _Y.first);
+        }
+
+        value_compare(_Key_compare _Comp) : _Key_compare_for_val(_Comp) {}
+
+    private:
+        _Key_compare _Key_compare_for_val;
+    };
+};
+
+template <class _Key_container, class _Mapped_container>
+struct _Flat_Container {
+    struct container {
+        _Key_container keys;
+        _Mapped_container values;
+    };
+};
+
+template <class _Ty>
+struct _NODISCARD _Clear_flat_map_scope_guard {
+    _Ty* _Clearable;
+    _Clear_flat_map_scope_guard(_Ty* _Clearable) : _Clearable(_Clearable) {}
+
+    ~_Clear_flat_map_scope_guard() {
+        if (_Clearable) {
+            _Clearable->clear();
+        }
+    }
+};
+
+// Implementation
+
+template <class _KeyContainer, class _MappedContainer, bool _IsConst>
+class _Flat_map_iterator_Impl {
+public:
+    using _Key_iterator_t = typename _KeyContainer::const_iterator;
+    using _Mapped_iterator_t =
+        conditional_t<_IsConst, typename _MappedContainer::const_iterator, typename _MappedContainer::iterator>;
+    class type {
+    public:
+        template <class _FlatMap_Key, class _FlatMap_T, class _FlatMap_Compare, class _FlatMap_KeyContainer,
+            class _FlatMap_MappedContainer, bool _Is_Multi, class _Derived>
+            requires same_as<_FlatMap_Key, typename _FlatMap_KeyContainer::value_type>
+                  && same_as<_FlatMap_T, typename _FlatMap_MappedContainer::value_type>
+        friend class _Flat_Map_Base;
+        type() = default;
+        type(_Key_iterator_t _Key_it, _Mapped_iterator_t _Mapped_it) : _Key_it(_Key_it), _Mapped_it(_Mapped_it) {}
+
+        using iterator_category = input_iterator_tag;
+        using iterator_concept  = random_access_iterator_tag;
+        using difference_type   = ptrdiff_t;
+        using value_type        = pair<iter_value_t<_Key_iterator_t>, iter_value_t<_Mapped_iterator_t>>;
+        using reference         = pair<iter_const_reference_t<_Key_iterator_t>, iter_reference_t<_Mapped_iterator_t>>;
+
+    private:
+        class _Arrow_proxy {
+        public:
+            explicit _Arrow_proxy(const reference& _Rx) noexcept : _Ref{_Rx} {}
+
+            const reference* operator->() const noexcept {
+                return _STD addressof(_Ref);
+            }
+
+        private:
+            reference _Ref;
+        };
+
+    public:
+        using pointer = _Arrow_proxy;
+
+        reference operator*() const {
+            return reference{*_Key_it, *_Mapped_it};
+        }
+
+        pointer operator->() const {
+            return pointer{*(*this)};
+        }
+
+        type& operator++() {
+            ++_Key_it;
+            ++_Mapped_it;
+            return *this;
+        }
+
+        type operator++(int) {
+            type _Tmp = *this;
+            ++*this;
+            return _Tmp;
+        }
+
+        bool operator==(const type& _Right) const {
+            return _Key_it == _Right._Key_it;
+        }
+
+        auto operator<=>(const type& _Right) const {
+            return _Key_it <=> _Right._Key_it;
+        }
+
+        type& operator--() {
+            --_Key_it;
+            --_Mapped_it;
+            return *this;
+        }
+
+        type operator--(int) {
+            type _Tmp = *this;
+            --*this;
+            return _Tmp;
+        }
+
+        type& operator+=(difference_type _Off) {
+            _Key_it += _Off;
+            _Mapped_it += _Off;
+            return *this;
+        }
+
+        type& operator-=(difference_type _Off) {
+            _Key_it -= _Off;
+            _Mapped_it -= _Off;
+            return *this;
+        }
+
+        type operator+(difference_type _Off) const {
+            type _Tmp = *this;
+            return _Tmp += _Off;
+        }
+
+        type operator-(difference_type _Off) const {
+            type _Tmp = *this;
+            return _Tmp -= _Off;
+        }
+
+        reference operator[](difference_type _Off) const {
+            return *(*this + _Off);
+        }
+
+        difference_type operator-(const type& _Right) const {
+            return _Key_it - _Right._Key_it;
+        }
+
+        friend type operator+(difference_type _Off, const type& _Right) {
+            return _Right + _Off;
+        }
+
+        operator typename _Flat_map_iterator_Impl<_KeyContainer, _MappedContainer, true>::type() const
+            requires (!_IsConst)
+        {
+            return typename _Flat_map_iterator_Impl<_KeyContainer, _MappedContainer, true>::type{_Key_it, _Mapped_it};
+        }
+
+    private:
+        _Key_iterator_t _Key_it;
+        _Mapped_iterator_t _Mapped_it;
+    };
+
+    static_assert(swappable<type>);
+};
+
+_EXPORT_STD
+template <class _FlatMap_Key, class _FlatMap_T, class _FlatMap_Compare, class _FlatMap_KeyContainer,
+    class _FlatMap_MappedContainer, bool _Is_Multi, class _Derived>
+    requires same_as<_FlatMap_Key, typename _FlatMap_KeyContainer::value_type>
+          && same_as<_FlatMap_T, typename _FlatMap_MappedContainer::value_type>
+class _Flat_Map_Base {
+private:
+    using _Sorted_t = conditional_t<_Is_Multi, sorted_equivalent_t, sorted_unique_t>;
+
+public:
+    using key_type               = _FlatMap_Key;
+    using mapped_type            = _FlatMap_T;
+    using value_type             = pair<key_type, mapped_type>;
+    using key_compare            = _FlatMap_Compare;
+    using reference              = pair<const key_type&, mapped_type&>;
+    using const_reference        = pair<const key_type&, const mapped_type&>;
+    using size_type              = size_t;
+    using difference_type        = ptrdiff_t;
+    using key_container_type     = _FlatMap_KeyContainer;
+    using mapped_container_type  = _FlatMap_MappedContainer;
+    using iterator               = _Flat_map_iterator_Impl<key_container_type, mapped_container_type, false>::type;
+    using const_iterator         = _Flat_map_iterator_Impl<key_container_type, mapped_container_type, true>::type;
+    using reverse_iterator       = _STD reverse_iterator<iterator>;
+    using const_reverse_iterator = _STD reverse_iterator<const_iterator>;
+
+    static_assert(random_access_iterator<iterator>);
+    static_assert(convertible_to<iterator, const_iterator>);
+
+    using value_compare = _Flat_value_compare<key_type, mapped_type, key_compare>::value_compare;
+    using containers    = _Flat_Container<key_container_type, mapped_container_type>::container;
+
+public:
+    // [flat.map.cons] Constructors
+    explicit _Flat_Map_Base(const key_compare& _Comp) : _Key_compare(_Comp), _Data() {}
+    _Flat_Map_Base() : _Flat_Map_Base(key_compare()) {}
+
+    template <_Valid_Allocator_for_flat_map<key_container_type, mapped_container_type> Allocator>
+    explicit _Flat_Map_Base(const Allocator& _Alloc) : _Flat_Map_Base(key_compare(), _Alloc) {}
+
+    template <_Valid_Allocator_for_flat_map<key_container_type, mapped_container_type> Allocator>
+    explicit _Flat_Map_Base(const key_compare& _Comp, const Allocator& _Alloc)
+        : _Key_compare(_Comp), _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Alloc),
+                                   .values = _STD make_obj_using_allocator<mapped_container_type>(_Alloc)} {}
+
+    _Flat_Map_Base(
+        key_container_type _Key_cont, mapped_container_type _Mapped_cont, const key_compare& _Comp = key_compare())
+        : _Flat_Map_Base(_Sorted_t(), _Key_cont, _Mapped_cont, _Comp) {
+        _Sort();
+        if constexpr (!_Is_Multi) {
+            _Dedup();
+        }
+    }
+
+    template <_Valid_Allocator_for_flat_map<key_container_type, mapped_container_type> Allocator>
+    _Flat_Map_Base(
+        const key_container_type& _Key_cont, const mapped_container_type& _Mapped_cont, const Allocator& _Alloc)
+        : _Flat_Map_Base(_Sorted_t(), _Key_cont, _Mapped_cont, _Alloc) {
+        _Sort();
+        if constexpr (!_Is_Multi) {
+            _Dedup();
+        }
+    }
+
+    template <_Valid_Allocator_for_flat_map<key_container_type, mapped_container_type> Allocator>
+    _Flat_Map_Base(const key_container_type& _Key_cont, const mapped_container_type& _Mapped_cont,
+        const key_compare& _Comp, const Allocator& _Alloc)
+        : _Flat_Map_Base(_Sorted_t(), _Key_cont, _Mapped_cont, _Comp, _Alloc) {
+        _Sort();
+        if constexpr (!_Is_Multi) {
+            _Dedup();
+        }
+    }
+
+    _Flat_Map_Base(_Sorted_t, key_container_type _Key_cont, mapped_container_type _Mapped_cont,
+        const key_compare& _Comp = key_compare())
+        : _Key_compare(_Comp), _Data{.keys = _STD move(_Key_cont), .values = _STD move(_Mapped_cont)} {}
+
+    template <_Valid_Allocator_for_flat_map<key_container_type, mapped_container_type> Allocator>
+    _Flat_Map_Base(_Sorted_t, const key_container_type& _Key_cont, const mapped_container_type& _Mapped_cont,
+        const Allocator& _Alloc)
+        : _Key_compare(key_compare()),
+          _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Alloc, _Key_cont),
+              .values = _STD make_obj_using_allocator<mapped_container_type>(_Alloc, _Mapped_cont)} {}
+
+    template <_Valid_Allocator_for_flat_map<key_container_type, mapped_container_type> Allocator>
+    _Flat_Map_Base(_Sorted_t, const key_container_type& _Key_cont, const mapped_container_type& _Mapped_cont,
+        const key_compare& _Comp, const Allocator& _Alloc)
+        : _Key_compare(_Comp),
+          _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Alloc, _Key_cont),
+              .values = _STD make_obj_using_allocator<mapped_container_type>(_Alloc, _Mapped_cont)} {}
+
+    template <class _InputIterator>
+        requires _Is_iterator_v<_InputIterator>
+    _Flat_Map_Base(_InputIterator _First, _InputIterator _Last, const key_compare& _Comp = key_compare())
+        : _Flat_Map_Base(_Comp) {
+        insert(_First, _Last);
+    }
+
+    template <class _InputIterator, _Valid_Allocator_for_flat_map<key_container_type, mapped_container_type> Allocator>
+        requires _Is_iterator_v<_InputIterator>
+    _Flat_Map_Base(_InputIterator _First, _InputIterator _Last, const key_compare& _Comp, const Allocator& _Alloc)
+        : _Flat_Map_Base(_Comp, _Alloc) {
+        insert(_First, _Last);
+    }
+
+    template <_Container_compatible_range<value_type> R>
+    _Flat_Map_Base(from_range_t _From_range, R&& _Range)
+        : _Flat_Map_Base(_From_range, _STD forward<R>(_Range), key_compare()) {}
+
+    template <_Container_compatible_range<value_type> R,
+        _Valid_Allocator_for_flat_map<key_container_type, mapped_container_type> Allocator>
+    _Flat_Map_Base(from_range_t _From_range, R&& _Range, const Allocator& _Alloc)
+        : _Flat_Map_Base(_From_range, _STD forward<R>(_Range), key_compare(), _Alloc) {}
+
+    template <_Container_compatible_range<value_type> R>
+    _Flat_Map_Base(from_range_t, R&& _Range, const key_compare& _Comp) : _Flat_Map_Base(_Comp) {
+        insert_range(_STD forward<R>(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> R,
+        _Valid_Allocator_for_flat_map<key_container_type, mapped_container_type> Allocator>
+    _Flat_Map_Base(from_range_t, R&& _Range, const key_compare& _Comp, const Allocator& _Alloc)
+        : _Flat_Map_Base(_Comp, _Alloc) {
+        insert_range(_STD forward<R>(_Range));
+    }
+
+    template <class _InputIterator>
+        requires _Is_iterator_v<_InputIterator>
+    _Flat_Map_Base(_Sorted_t _S, _InputIterator _First, _InputIterator _Last, const key_compare& _Comp = key_compare())
+        : _Flat_Map_Base(_Comp) {
+        insert(_S, _First, _Last);
+    }
+
+    template <class _InputIterator, _Valid_Allocator_for_flat_map<key_container_type, mapped_container_type> Allocator>
+        requires _Is_iterator_v<_InputIterator>
+    _Flat_Map_Base(
+        _Sorted_t _S, _InputIterator _First, _InputIterator _Last, const key_compare& _Comp, const Allocator& _Alloc)
+        : _Flat_Map_Base(_Comp, _Alloc) {
+        insert(_S, _First, _Last);
+    }
+
+    template <class _InputIterator, _Valid_Allocator_for_flat_map<key_container_type, mapped_container_type> Allocator>
+        requires _Is_iterator_v<_InputIterator>
+    _Flat_Map_Base(_Sorted_t _S, _InputIterator _First, _InputIterator _Last, const Allocator& _Alloc)
+        : _Flat_Map_Base(_S, _First, _Last, key_compare(), _Alloc) {}
+
+    _Flat_Map_Base(initializer_list<value_type> _I, const key_compare& _Comp = key_compare())
+        : _Flat_Map_Base(_I.begin(), _I.end(), _Comp) {}
+
+    template <_Valid_Allocator_for_flat_map<key_container_type, mapped_container_type> Allocator>
+    _Flat_Map_Base(initializer_list<value_type> _I, const key_compare& _Comp, const Allocator& _Alloc)
+        : _Flat_Map_Base(_I.begin(), _I.end(), _Comp, _Alloc) {}
+
+    template <_Valid_Allocator_for_flat_map<key_container_type, mapped_container_type> Allocator>
+    _Flat_Map_Base(initializer_list<value_type> _I, const Allocator& _Alloc)
+        : _Flat_Map_Base(_I, key_compare(), _Alloc) {}
+
+    _Flat_Map_Base(_Sorted_t _S, initializer_list<value_type> _I, const key_compare& _Comp = key_compare())
+        : _Flat_Map_Base(_S, _I.begin(), _I.end(), _Comp) {}
+
+    template <_Valid_Allocator_for_flat_map<key_container_type, mapped_container_type> Allocator>
+    _Flat_Map_Base(_Sorted_t _S, initializer_list<value_type> _I, const key_compare& _Comp, const Allocator& _Alloc)
+        : _Flat_Map_Base(_S, _I.begin(), _I.end(), _Comp, _Alloc) {}
+
+    template <_Valid_Allocator_for_flat_map<key_container_type, mapped_container_type> Allocator>
+    _Flat_Map_Base(_Sorted_t _S, initializer_list<value_type> _I, const Allocator& _Alloc)
+        : _Flat_Map_Base(_S, _I, key_compare(), _Alloc) {}
+
+    // Copy constructors
+    _Flat_Map_Base(const _Derived& _Other) : _Key_compare(_Other._Key_compare), _Data(_Other._Data) {}
+
+    template <_Valid_Allocator_for_flat_map<key_container_type, mapped_container_type> _Allocator>
+    _Flat_Map_Base(const _Derived& _Other, const _Allocator& _Alloc)
+        : _Key_compare(_Other._Key_compare),
+          _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Alloc, _Other._Data.keys),
+              .values = _STD make_obj_using_allocator<mapped_container_type>(_Alloc, _Other._Data.values)} {}
+
+    // Move constructors
+    _Flat_Map_Base(_Derived&& _Other) noexcept(_STD is_nothrow_move_constructible_v<key_compare>
+                                               && _STD is_nothrow_move_constructible_v<key_container_type>
+                                               && _STD is_nothrow_move_constructible_v<mapped_container_type>)
+        : _Key_compare(move(_Other._Key_compare)), _Data(move(_Other).extract()) {}
+
+    template <_Valid_Allocator_for_flat_map<key_container_type, mapped_container_type> _Allocator>
+    _Flat_Map_Base(_Derived&& _Other, const _Allocator& _Alloc) noexcept(
+        _STD is_nothrow_move_constructible_v<key_compare> && _STD is_nothrow_move_constructible_v<key_container_type>
+        && _STD is_nothrow_move_constructible_v<mapped_container_type>)
+        : _Key_compare(move(_Other._Key_compare)),
+          _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Alloc, move(_Other._Data.keys)),
+              .values = _STD make_obj_using_allocator<mapped_container_type>(_Alloc, move(_Other._Data.values))} {}
+
+    _Derived& operator=(initializer_list<value_type> _I) {
+        clear();
+        insert(_I.begin(), _I.end());
+        return static_cast<_Derived&>(*this); // Use "deducing this" when it is supported
+    }
+
+    // [container.reqmts] iterators
+    _NODISCARD iterator begin() noexcept {
+        return iterator{_Data.keys.cbegin(), _Data.values.begin()};
+    }
+
+    _NODISCARD const_iterator begin() const noexcept {
+        return const_iterator{_Data.keys.cbegin(), _Data.values.begin()};
+    }
+
+    _NODISCARD iterator end() noexcept {
+        return iterator{_Data.keys.cend(), _Data.values.end()};
+    }
+
+    _NODISCARD const_iterator end() const noexcept {
+        return const_iterator{_Data.keys.cend(), _Data.values.end()};
+    }
+
+    _NODISCARD reverse_iterator rbegin() noexcept {
+        return _STD make_reverse_iterator(end());
+    }
+
+    _NODISCARD const_reverse_iterator rbegin() const noexcept {
+        return _STD make_reverse_iterator(end());
+    }
+
+    _NODISCARD reverse_iterator rend() noexcept {
+        return _STD make_reverse_iterator(begin());
+    }
+
+    _NODISCARD const_reverse_iterator rend() const noexcept {
+        return _STD make_reverse_iterator(begin());
+    }
+
+    _NODISCARD const_iterator cbegin() const noexcept {
+        return const_iterator{_Data.keys.cbegin(), _Data.values.cbegin()};
+    }
+
+    _NODISCARD const_iterator cend() const noexcept {
+        return const_iterator{_Data.keys.cend(), _Data.values.cend()};
+    }
+
+    _NODISCARD const_reverse_iterator crbegin() const noexcept {
+        return _STD make_reverse_iterator(cend());
+    }
+
+    _NODISCARD const_reverse_iterator crend() const noexcept {
+        return _STD make_reverse_iterator(cbegin());
+    }
+
+    void swap(_Derived& _Other) noexcept {
+        _RANGES swap(_Key_compare, _Other._Key_compare);
+        _RANGES swap(_Data.keys, _Other._Data.keys);
+        _RANGES swap(_Data.values, _Other._Data.values);
+    }
+
+    // [container.reqmts] clear
+    void clear() noexcept {
+        _Data.keys.clear();
+        _Data.values.clear();
+    }
+
+    // [flat.map.capacity] Capacity
+    _NODISCARD_EMPTY_MEMBER bool empty() const noexcept {
+        return _Data.keys.empty();
+    }
+
+    _NODISCARD size_type size() const noexcept {
+        return _Data.keys.size();
+    }
+
+    _NODISCARD size_type max_size() const noexcept {
+        return _STD min(_Data.keys.max_size(), _Data.values.max_size());
+    }
+
+    // [flat.map.access] Access
+    template <class _K>
+    _NODISCARD mapped_type& operator[](_K&& _Key_val)
+        requires same_as<remove_cvref_t<_K>, key_type>
+              || (_Is_transparent_v<key_compare> && constructible_from<key_type, _K &&>)
+    {
+        return try_emplace(_STD forward<_K>(_Key_val)).first->second;
+    }
+
+    _NODISCARD mapped_type& at(const key_type& _Key_val) {
+        return _At(_Key_val);
+    }
+
+    template <class _K>
+    _NODISCARD const mapped_type& at(const _K& _Key_val) const
+        requires _Is_transparent_v<key_compare>
+    {
+        return _At(_Key_val);
+    }
+
+    // [flat.map.modifiers] Modifiers
+    template <class... _Args_t>
+    pair<iterator, bool> emplace(_Args_t&&... _Args)
+        requires is_constructible_v<value_type, _Args_t...>
+    {
+        value_type _Val(_STD forward<_Args_t>(_Args)...);
+        return try_emplace(_STD move(_Val.first), _STD move(_Val.second));
+    }
+
+    template <class... _Args_t>
+    iterator emplace_hint(const_iterator _Position, _Args_t&&... _Args)
+        requires is_constructible_v<value_type, _Args_t...>
+    {
+        value_type _Val(_STD forward<_Args_t>(_Args)...);
+
+        return _Emplace_hint<false, false>(_Position, _STD move(_Val.first), _STD move(_Val.second));
+    }
+
+    template <class _V>
+    pair<iterator, bool> insert(_V&& _X)
+        requires (same_as<remove_cvref_t<_V &&>, value_type> || constructible_from<value_type, _V &&>)
+    {
+        return emplace(_STD forward<_V>(_X));
+    }
+
+    template <class _V>
+    iterator insert(const_iterator _Position, _V&& _X)
+        requires (same_as<remove_cvref_t<_V &&>, value_type> || constructible_from<value_type, _V &&>)
+    {
+        return emplace_hint(_Position, _STD forward<_V>(_X));
+    }
+
+    template <class _InputIterator>
+        requires _Is_iterator_v<_InputIterator>
+    void insert(_InputIterator _First, _InputIterator _Last) {
+        _Insert_range<true, !_Is_Multi>(_First, _Last);
+    }
+
+    template <class _InputIterator>
+        requires _Is_iterator_v<_InputIterator>
+    void insert(_Sorted_t, _InputIterator _First, _InputIterator _Last) {
+        _Insert_range<false, !_Is_Multi>(_First, _Last);
+    }
+
+    template <_Container_compatible_range<value_type> R>
+    void insert_range(R&& _Range) {
+        insert(_RANGES begin(_Range), _RANGES end(_Range));
+    }
+
+    void insert(initializer_list<value_type> _I) {
+        insert(_I.begin(), _I.end());
+    }
+
+    void insert(_Sorted_t _S, initializer_list<value_type> _I) {
+        insert(_S, _I.begin(), _I.end());
+    }
+
+    template <class _Key_constructible_t, class... _Args_t>
+    pair<iterator, bool> try_emplace(_Key_constructible_t&& _Key_constructible, _Args_t&&... _Args)
+        requires constructible_from<mapped_type, _Args_t&&...>
+              && (same_as<remove_cvref_t<_Key_constructible_t &&>, key_type>
+                  || (constructible_from<key_type, _Key_constructible_t &&> && _Is_transparent_v<key_compare>
+                      && !convertible_to<_Key_constructible_t &&, const_iterator>
+                      && !convertible_to<_Key_constructible_t &&, iterator>) )
+    {
+        auto _Key_It = _STD lower_bound(_Data.keys.begin(), _Data.keys.end(), _Key_constructible, _Key_compare);
+        if (_Key_It != _Data.keys.end()
+            && _Key_equal(*_Key_It, _STD forward<_Key_constructible_t>(_Key_constructible))) {
+            // Already exists
+            return {begin() + _STD distance(_Data.keys.begin(), _Key_It), false};
+        } else {
+            // Need to insert
+            auto _Index = _STD distance(_Data.keys.begin(), _Key_It);
+            _Insert_exact(cbegin() + _Index, key_type{_STD forward<_Key_constructible_t>(_Key_constructible)},
+                mapped_type{_STD forward<_Args_t>(_Args)...});
+            return {begin() + _Index, true};
+        }
+    }
+
+    template <class _K, class... _Args_t>
+    iterator try_emplace(const_iterator _Position, _K&& _Key_val, _Args_t&&... _Args)
+        requires constructible_from<mapped_type, _Args_t&&...>
+              && (same_as<remove_cvref_t<_K &&>, key_type>
+                  || (constructible_from<key_type, _K &&> && _Is_transparent_v<key_compare>) )
+    {
+        return _Emplace_hint<false, false>(_Position, _STD forward<_K>(_Key_val), _STD forward<_Args_t>(_Args)...);
+    }
+
+    template <class _M, class _K>
+    pair<iterator, bool> insert_or_assign(_K&& _Key_val, _M&& _Obj)
+        requires assignable_from<mapped_type&, _M&&> && constructible_from<mapped_type, _M&&>
+              && (same_as<remove_cvref_t<_K &&>, key_type>
+                  || (constructible_from<key_type, _K &&> && _Is_transparent_v<key_compare>) )
+    {
+        auto _Res = try_emplace(_STD forward<_K>(_Key_val), _STD forward<_M>(_Obj));
+        if (_Res.second) {
+            // Insertion took place
+            return _Res;
+        } else {
+            // Already exists
+            *(_Res.first._Mapped_it) = _STD forward<_M>(_Obj);
+            return _Res;
+        }
+    }
+
+    template <class _M, class _K>
+    iterator insert_or_assign(const_iterator _Position, _K&& _Key_val, _M&& _Obj)
+        requires assignable_from<mapped_type&, _M&&> && constructible_from<mapped_type, _M&&>
+              && (same_as<remove_cvref_t<_K &&>, key_type>
+                  || (constructible_from<key_type, _K &&> && _Is_transparent_v<key_compare>) )
+    {
+        return _Emplace_hint<false, true>(_Position, _STD forward<_K>(_Key_val), _STD forward<_M>(_Obj));
+    }
+
+    iterator erase(iterator _Position) {
+        return erase(static_cast<const_iterator>(_Position));
+    }
+
+    iterator erase(const_iterator _Position) {
+        _Clear_flat_map_scope_guard _Guard{this};
+        auto _Key_it      = _Data.keys.erase(_Position._Key_it);
+        auto _Val_it      = _Data.values.erase(_Position._Mapped_it);
+        _Guard._Clearable = nullptr;
+        return iterator{_STD move(_Key_it), _STD move(_Val_it)};
+    }
+
+    iterator erase(const_iterator _First, const_iterator _Last) {
+        _Clear_flat_map_scope_guard _Guard{this};
+        auto _Key_it      = _Data.keys.erase(_First._Key_it, _Last._Key_it);
+        auto _Val_it      = _Data.values.erase(_First._Mapped_it, _Last._Mapped_it);
+        _Guard._Clearable = nullptr;
+        return iterator{_STD move(_Key_it), _STD move(_Val_it)};
+    }
+
+    template <class _K>
+    size_type erase(_K&& _Key_val)
+        requires convertible_to<_K&&, const key_type&>
+              || (_Is_transparent_v<key_compare> && !convertible_to<_K &&, iterator>
+                  && !convertible_to<_K &&, const_iterator>)
+    {
+        const_iterator _Pos_begin = lower_bound(_STD forward<_K>(_Key_val));
+        const_iterator _Pos_end   = upper_bound(_STD forward<_K>(_Key_val));
+        size_type _Count          = _Pos_end - _Pos_begin;
+        erase(_Pos_begin, _Pos_end);
+        return _Count;
+    }
+
+    containers extract() && {
+        _Clear_flat_map_scope_guard _Guard{this};
+        return _STD move(_Data);
+    }
+
+    void replace(key_container_type&& _Key_cont, mapped_container_type&& _Mapped_cont) {
+        _Clear_flat_map_scope_guard _Guard{this};
+        _Data.keys        = _STD move(_Key_cont);
+        _Data.values      = _STD move(_Mapped_cont);
+        _Guard._Clearable = nullptr;
+    }
+
+    // observers
+    key_compare key_comp() const {
+        return _Key_compare;
+    }
+
+    value_compare value_comp() const {
+        return value_compare(_Key_compare);
+    }
+
+    const key_container_type& keys() const noexcept {
+        return _Data.keys;
+    }
+
+    const mapped_container_type& values() const noexcept {
+        return _Data.values;
+    }
+
+    // map operations
+    iterator find(const key_type& _X) {
+        return _Find(_X);
+    }
+
+    template <class _K>
+    iterator find(const _K& _X)
+        requires _Is_transparent_v<key_compare>
+    {
+        return _Find(_X);
+    }
+
+    const_iterator find(const key_type& _X) const {
+        return _Find(_X);
+    }
+
+    template <class _K>
+    const_iterator find(const _K& _X) const
+        requires _Is_transparent_v<key_compare>
+    {
+        return _Find(_X);
+    }
+
+    size_type count(const key_type& _X) const {
+        return _Count(_X);
+    }
+
+    template <class _K>
+    size_type count(const _K& _X) const
+        requires _Is_transparent_v<key_compare>
+    {
+        return _Count(_X);
+    }
+
+    bool contains(const key_type& _X) const {
+        return _Contains(_X);
+    }
+
+    template <class _K>
+    bool contains(const _K& _X) const
+        requires _Is_transparent_v<key_compare>
+    {
+        return _Contains(_X);
+    }
+
+    iterator lower_bound(const key_type& _X) {
+        return _Lower_bound(_X);
+    }
+
+    template <class _K>
+    iterator lower_bound(const _K& _X)
+        requires _Is_transparent_v<key_compare>
+    {
+        return _Lower_bound(_X);
+    }
+
+    const_iterator lower_bound(const key_type& _X) const {
+        return _Lower_bound(_X);
+    }
+
+    template <class _K>
+    const_iterator lower_bound(const _K& _X) const
+        requires _Is_transparent_v<key_compare>
+    {
+        return _Lower_bound(_X);
+    }
+
+    iterator upper_bound(const key_type& _X) {
+        return _Upper_bound(_X);
+    }
+
+    template <class _K>
+    iterator upper_bound(const _K& _X)
+        requires _Is_transparent_v<key_compare>
+    {
+        return _Upper_bound(_X);
+    }
+
+    const_iterator upper_bound(const key_type& _X) const {
+        return _Upper_bound(_X);
+    }
+
+    template <class _K>
+    const_iterator upper_bound(const _K& _X) const
+        requires _Is_transparent_v<key_compare>
+    {
+        return _Upper_bound(_X);
+    }
+
+    pair<iterator, iterator> equal_range(const key_type& _X) {
+        return _Equal_range(_X);
+    }
+
+    template <class _K>
+    pair<iterator, iterator> equal_range(const _K& _X)
+        requires _Is_transparent_v<key_compare>
+    {
+        return _Equal_range(_X);
+    }
+
+    pair<const_iterator, const_iterator> equal_range(const key_type& _X) const {
+        return _Equal_range(_X);
+    }
+
+    template <class _K>
+    pair<const_iterator, const_iterator> equal_range(const _K& _X) const
+        requires _Is_transparent_v<key_compare>
+    {
+        return _Equal_range(_X);
+    }
+
+    friend bool operator==(const _Derived& _X, const _Derived& _Y) {
+        return _RANGES equal(_X._Data.keys, _Y._Data.keys) && _RANGES equal(_X._Data.values, _Y._Data.values);
+    }
+
+    friend auto operator<=>(const _Derived& _X, const _Derived& _Y) {
+        return _STD lexicographical_compare_three_way(
+            _X.cbegin(), _X.cend(), _Y.cbegin(), _Y.cend(), _Synth_three_way{});
+    }
+
+    friend void swap(_Derived& _X, _Derived& _Y) noexcept {
+        _X.swap(_Y);
+    }
+
+
+private:
+    key_compare _Key_compare;
+    containers _Data;
+
+    template <class _K1, class _K2>
+        requires (same_as<remove_cvref_t<_K1 &&>, key_type> && same_as<remove_cvref_t<_K2 &&>, key_type>)
+              || (constructible_from<key_type, _K1 &&> && constructible_from<key_type, _K2 &&>
+                  && _Is_transparent_v<key_compare>)
+    bool _Key_equal(_K1&& _X, _K2&& _Y) const {
+        return !_Key_compare(_STD forward<_K1>(_X), _STD forward<_K2>(_Y))
+            && !_Key_compare(_STD forward<_K2>(_Y), _STD forward<_K1>(_X));
+    }
+
+    void _Sort() {
+        _Clear_flat_map_scope_guard _Guard{this};
+        auto _Zip_view = _RANGES views::zip(_Data.keys, _Data.values);
+        _RANGES sort(_Zip_view, value_compare(_Key_compare));
+        _Guard._Clearable = nullptr;
+    }
+
+    void _Dedup() {
+        _Clear_flat_map_scope_guard _Guard{this};
+        auto _Zip_view = _RANGES views::zip(_Data.keys, _Data.values);
+        auto _Subrange = _RANGES unique(
+            _Zip_view, [this](const_reference _X, const_reference _Y) { return this->_Key_equal(_X.first, _Y.first); });
+        auto _Remaining_count = _STD distance(_Zip_view.begin(), _Subrange.begin());
+        _Data.keys.erase(_Data.keys.begin() + _Remaining_count, _Data.keys.end());
+        _Data.values.erase(_Data.values.begin() + _Remaining_count, _Data.values.end());
+        _Guard._Clearable = nullptr;
+    }
+
+    void _Insert_exact(const_iterator _Position, key_type&& _Key_val, mapped_type&& _Mapped) {
+        _Clear_flat_map_scope_guard _Guard{this};
+        _Data.keys.insert(_Position._Key_it, _STD move(_Key_val));
+        _Data.values.insert(_Position._Mapped_it, _STD move(_Mapped));
+        _Guard._Clearable = nullptr;
+    }
+
+    template <bool _Multi, bool _Overwrite_if_exists, class _K, class... _Mapped_args_t>
+    iterator _Emplace_hint(const_iterator _Position, _K&& _Key_val, _Mapped_args_t&&... _Args)
+        requires is_constructible_v<mapped_type, _Mapped_args_t...>
+              && (same_as<remove_cvref_t<_K &&>, key_type>
+                  || (constructible_from<key_type, _K &&> && _Is_transparent_v<key_compare>) )
+    {
+        static_assert(!(_Multi && _Overwrite_if_exists),
+            "Overwriting is not supported when the container allows multiple copies of a key.");
+        const const_iterator _Begin = cbegin();
+        const const_iterator _End   = cend();
+
+        bool _Insert_before_position        = false;
+        bool _Insert_after_position_minus_1 = false;
+        if constexpr (_Multi) {
+            _Insert_before_position        = (_Position == _End) || !_Key_compare(*(_Position._Key_it), _Key_val);
+            _Insert_after_position_minus_1 = (_Position == _Begin) || !_Key_compare(_Key_val, *(_Position._Key_it - 1));
+        } else {
+            _Insert_before_position        = (_Position == _End) || _Key_compare(_Key_val, *(_Position._Key_it));
+            _Insert_after_position_minus_1 = (_Position == _Begin) || _Key_compare(*(_Position._Key_it - 1), _Key_val);
+        }
+        bool _Hint_is_accurate = _Insert_before_position && _Insert_after_position_minus_1;
+
+        if (_Hint_is_accurate) {
+            auto _Dist = _STD distance(_Begin._Key_it, _Position._Key_it);
+            _Insert_exact(
+                _Position, key_type{_STD forward<_K>(_Key_val)}, mapped_type{_STD forward<_Mapped_args_t>(_Args)...});
+            return begin() + _Dist;
+        } else {
+            if constexpr (_Overwrite_if_exists) {
+                if (_Key_equal(_Key_val, *(_Position._Key_it))) {
+                    auto _Dist        = _STD distance(_Begin._Key_it, _Position._Key_it);
+                    auto _It          = begin() + _Dist;
+                    *(_It._Mapped_it) = mapped_type{_STD forward<_Mapped_args_t>(_Args)...};
+                    return _It;
+                }
+            }
+
+            _Position = lower_bound(_Key_val);
+            if (_Overwrite_if_exists && _Position != _End && _Key_equal(_Key_val, *(_Position._Key_it))) {
+                auto _Dist        = _STD distance(_Begin._Key_it, _Position._Key_it);
+                auto _It          = begin() + _Dist;
+                *(_It._Mapped_it) = mapped_type{_STD forward<_Mapped_args_t>(_Args)...};
+                return _It;
+            } else {
+                auto _Dist = _STD distance(_Begin._Key_it, _Position._Key_it);
+                _Insert_exact(_Position, key_type{_STD forward<_K>(_Key_val)},
+                    mapped_type{_STD forward<_Mapped_args_t>(_Args)...});
+                return begin() + _Dist;
+            }
+        }
+    }
+
+    template <bool _NeedSorting, bool _NeedDeduping, class _InputIterator>
+        requires _Is_iterator_v<_InputIterator>
+    void _Insert_range(_InputIterator _First, _InputIterator _Last) {
+        _Clear_flat_map_scope_guard _Guard{this};
+
+        // Insert the new elements at the end
+        size_type _OldSize = size();
+        size_type _NewSize = _STD distance(_First, _Last);
+
+        _Data.keys.reserve(_Data.keys.size() + _NewSize);
+        _Data.values.reserve(_Data.values.size() + _NewSize);
+
+        for (; _First != _Last; ++_First) {
+            _Data.keys.emplace_back(_STD move(_First->first));
+            _Data.values.emplace_back(_STD move(_First->second));
+        }
+
+        // Sort the newly inserted elements
+        auto _Zip_view = _RANGES views::zip(_Data.keys, _Data.values);
+        if constexpr (_NeedSorting) {
+            auto _Zip_view_new_elements = _Zip_view | _RANGES views::drop(_OldSize);
+            _RANGES sort(_Zip_view_new_elements, value_compare(_Key_compare));
+        }
+
+        // Merge the newly inserted elements with the existing elements
+        _RANGES inplace_merge(_Zip_view, _Zip_view.begin() + _OldSize, value_compare(_Key_compare));
+
+        if constexpr (_NeedDeduping) {
+            _Dedup();
+        }
+
+        _Guard._Clearable = nullptr;
+    }
+
+    template <class _K>
+    _NODISCARD mapped_type& _At(const _K& _Key_val)
+        requires same_as<_K, key_type> || _Is_transparent_v<key_compare>
+    {
+        iterator _Position = find(_Key_val);
+        if (_Position == end()) {
+            _Xout_of_range("std::flat_map::at: the specified key does not exist.");
+        } else {
+            return _Position->second;
+        }
+    }
+
+    template <class _K>
+    iterator _Find(const _K& _X)
+        requires same_as<_K, key_type> || _Is_transparent_v<key_compare>
+    {
+        iterator _Position = lower_bound(_X);
+        if (_Position != end() && _Key_equal(_Position->first, _X)) {
+            return _Position;
+        } else {
+            return end();
+        }
+    }
+
+    template <class _K>
+    const_iterator _Find(const _K& _X) const
+        requires same_as<_K, key_type> || _Is_transparent_v<key_compare>
+    {
+        const_iterator _Position = lower_bound(_X);
+        if (_Position != cend() && _Key_equal(_Position->first, _X)) {
+            return _Position;
+        } else {
+            return cend();
+        }
+    }
+
+    template <class _K>
+    size_type _Count(const _K& _X) const
+        requires same_as<_K, key_type> || _Is_transparent_v<key_compare>
+    {
+        return upper_bound(_X) - lower_bound(_X);
+    }
+
+    template <class _K>
+    bool _Contains(const _K& _X) const
+        requires same_as<_K, key_type> || _Is_transparent_v<key_compare>
+    {
+        return find(_X) != cend();
+    }
+
+    template <class _K>
+    iterator _Lower_bound(const _K& _X)
+        requires same_as<_K, key_type> || _Is_transparent_v<key_compare>
+    {
+        typename key_container_type::const_iterator _Key_it =
+            _STD lower_bound(_Data.keys.cbegin(), _Data.keys.cend(), _X, _Key_compare);
+        auto _Dist                                       = _STD distance(_Data.keys.cbegin(), _Key_it);
+        typename mapped_container_type::iterator _Val_it = _Data.values.begin() + _Dist;
+        return iterator{_STD move(_Key_it), _STD move(_Val_it)};
+    }
+
+    template <class _K>
+    const_iterator _Lower_bound(const _K& _X) const
+        requires same_as<_K, key_type> || _Is_transparent_v<key_compare>
+    {
+        typename key_container_type::const_iterator _Key_it =
+            _STD lower_bound(_Data.keys.cbegin(), _Data.keys.cend(), _X, _Key_compare);
+        auto _Dist                                             = _STD distance(_Data.keys.cbegin(), _Key_it);
+        typename mapped_container_type::const_iterator _Val_it = _Data.values.cbegin() + _Dist;
+        return const_iterator{_STD move(_Key_it), _STD move(_Val_it)};
+    }
+
+    template <class _K>
+    iterator _Upper_bound(const _K& _X)
+        requires same_as<_K, key_type> || _Is_transparent_v<key_compare>
+    {
+        typename key_container_type::const_iterator _Key_it =
+            _STD upper_bound(_Data.keys.cbegin(), _Data.keys.cend(), _X, _Key_compare);
+        auto _Dist                                       = _STD distance(_Data.keys.cbegin(), _Key_it);
+        typename mapped_container_type::iterator _Val_it = _Data.values.begin() + _Dist;
+        return iterator{_STD move(_Key_it), _STD move(_Val_it)};
+    }
+
+    template <class _K>
+    const_iterator _Upper_bound(const _K& _X) const
+        requires same_as<_K, key_type> || _Is_transparent_v<key_compare>
+    {
+        typename key_container_type::const_iterator _Key_it =
+            _STD upper_bound(_Data.keys.cbegin(), _Data.keys.cend(), _X, _Key_compare);
+        auto _Dist                                             = _STD distance(_Data.keys.cbegin(), _Key_it);
+        typename mapped_container_type::const_iterator _Val_it = _Data.values.cbegin() + _Dist;
+        return const_iterator{_STD move(_Key_it), _STD move(_Val_it)};
+    }
+
+    template <class _K>
+    pair<iterator, iterator> _Equal_range(const _K& _X)
+        requires same_as<_K, key_type> || _Is_transparent_v<key_compare>
+    {
+        return {lower_bound(_X), upper_bound(_X)};
+    }
+
+    template <class _K>
+    pair<const_iterator, const_iterator> _Equal_range(const _K& _X) const
+        requires same_as<_K, key_type> || _Is_transparent_v<key_compare>
+    {
+        return {lower_bound(_X), upper_bound(_X)};
+    }
+};
+
+template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer>
+class flat_map : public _Flat_Map_Base<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer, false,
+                     flat_map<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>> {
+private:
+    using _MyBase = _Flat_Map_Base<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer, false,
+        flat_map<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>>;
+
+public:
+    using _MyBase::_MyBase;
+    using _MyBase::operator=;
+};
+
+template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer>
+class flat_multimap : public _Flat_Map_Base<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer, true,
+                          flat_multimap<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>> {
+private:
+    using _MyBase = _Flat_Map_Base<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer, true,
+        flat_multimap<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>>;
+
+public:
+    using _MyBase::_MyBase;
+    using _MyBase::operator=;
+};
+
+template <class _KeyContainer, class _MappedContainer,
+    _Valid_Compare_for_container<_KeyContainer> _Compare = less<typename _KeyContainer::value_type>>
+flat_map(_KeyContainer, _MappedContainer, _Compare = _Compare()) -> flat_map<typename _KeyContainer::value_type,
+    typename _MappedContainer::value_type, _Compare, _KeyContainer, _MappedContainer>;
+
+template <class _KeyContainer, class _MappedContainer,
+    _Valid_Allocator_for_flat_map<_KeyContainer, _MappedContainer> _Allocator>
+flat_map(_KeyContainer, _MappedContainer, _Allocator) -> flat_map<typename _KeyContainer::value_type,
+    typename _MappedContainer::value_type, less<typename _KeyContainer::value_type>, _KeyContainer, _MappedContainer>;
+
+template <class _KeyContainer, class _MappedContainer, _Valid_Compare_for_container<_KeyContainer> _Compare,
+    _Valid_Allocator_for_flat_map<_KeyContainer, _MappedContainer> _Allocator>
+flat_map(_KeyContainer, _MappedContainer, _Compare, _Allocator) -> flat_map<typename _KeyContainer::value_type,
+    typename _MappedContainer::value_type, _Compare, _KeyContainer, _MappedContainer>;
+
+template <class _KeyContainer, class _MappedContainer,
+    _Valid_Compare_for_container<_KeyContainer> _Compare = less<typename _KeyContainer::value_type>>
+flat_map(sorted_unique_t, _KeyContainer, _MappedContainer, _Compare = _Compare())
+    -> flat_map<typename _KeyContainer::value_type, typename _MappedContainer::value_type, _Compare, _KeyContainer,
+        _MappedContainer>;
+
+template <class _KeyContainer, class _MappedContainer,
+    _Valid_Allocator_for_flat_map<_KeyContainer, _MappedContainer> _Allocator>
+flat_map(sorted_unique_t, _KeyContainer, _MappedContainer, _Allocator) -> flat_map<typename _KeyContainer::value_type,
+    typename _MappedContainer::value_type, less<typename _KeyContainer::value_type>, _KeyContainer, _MappedContainer>;
+
+template <class _KeyContainer, class _MappedContainer, _Valid_Compare_for_container<_KeyContainer> _Compare,
+    _Valid_Allocator_for_flat_map<_KeyContainer, _MappedContainer> _Allocator>
+flat_map(sorted_unique_t, _KeyContainer, _MappedContainer, _Compare, _Allocator)
+    -> flat_map<typename _KeyContainer::value_type, typename _MappedContainer::value_type, _Compare, _KeyContainer,
+        _MappedContainer>;
+
+template <class _InputIterator, class _Compare = less<typename iter_value_t<_InputIterator>::first_type>>
+flat_map(_InputIterator, _InputIterator, _Compare = _Compare())
+    -> flat_map<typename iter_value_t<_InputIterator>::first_type, typename iter_value_t<_InputIterator>::second_type,
+        _Compare>;
+
+template <class _InputIterator, class _Compare = less<typename iter_value_t<_InputIterator>::first_type>>
+flat_map(sorted_unique_t, _InputIterator, _InputIterator, _Compare = _Compare())
+    -> flat_map<typename iter_value_t<_InputIterator>::first_type, typename iter_value_t<_InputIterator>::second_type,
+        _Compare>;
+
+template <_RANGES input_range _R, class _Compare = less<typename _RANGES range_value_t<_R>::first_type>,
+    class _Allocator = allocator<byte>>
+flat_map(from_range_t, _R&&, _Compare = _Compare(), _Allocator = _Allocator())
+    -> flat_map<typename _RANGES range_value_t<_R>::first_type, typename _RANGES range_value_t<_R>::second_type,
+        _Compare,
+        vector<typename _RANGES range_value_t<_R>::first_type,
+            _Rebind_alloc_t<_Allocator, typename _RANGES range_value_t<_R>::first_type>>,
+        vector<typename _RANGES range_value_t<_R>::second_type,
+            _Rebind_alloc_t<_Allocator, typename _RANGES range_value_t<_R>::second_type>>>;
+
+template <_RANGES input_range _R, class _Allocator>
+flat_map(from_range_t, _R&&, _Allocator) -> flat_map<typename _RANGES range_value_t<_R>::first_type,
+    typename _RANGES range_value_t<_R>::second_type, less<typename _RANGES range_value_t<_R>::first_type>,
+    vector<typename _RANGES range_value_t<_R>::first_type,
+        _Rebind_alloc_t<_Allocator, typename _RANGES range_value_t<_R>::first_type>>,
+    vector<typename _RANGES range_value_t<_R>::second_type,
+        _Rebind_alloc_t<_Allocator, typename _RANGES range_value_t<_R>::second_type>>>;
+
+template <class _Key, class _T, class _Compare = less<_Key>>
+flat_map(initializer_list<pair<_Key, _T>>, _Compare = _Compare()) -> flat_map<_Key, _T, _Compare>;
+
+template <class _Key, class _T, class _Compare = less<_Key>>
+flat_map(sorted_unique_t, initializer_list<pair<_Key, _T>>, _Compare = _Compare()) -> flat_map<_Key, _T, _Compare>;
+
+// Specialization of uses_allocator
+template <class _Key, class _T, class _Compare, class _KeyContainer, class _MappedContainer, class _Allocator>
+struct uses_allocator<flat_map<_Key, _T, _Compare, _KeyContainer, _MappedContainer>, _Allocator>
+    : bool_constant<uses_allocator_v<_KeyContainer, _Allocator> && uses_allocator_v<_MappedContainer, _Allocator>> {};
+
+template <class _Key, class _T, class _Compare, class _KeyContainer, class _MappedContainer, class _Allocator>
+struct uses_allocator<flat_multimap<_Key, _T, _Compare, _KeyContainer, _MappedContainer>, _Allocator>
+    : bool_constant<uses_allocator_v<_KeyContainer, _Allocator> && uses_allocator_v<_MappedContainer, _Allocator>> {};
+
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // ^^^ supported language mode ^^^
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _FLAT_MAP_
diff --git a/stl/inc/header-units.json b/stl/inc/header-units.json
index 74d6d4699e5..9d7610eaed0 100644
--- a/stl/inc/header-units.json
+++ b/stl/inc/header-units.json
@@ -64,6 +64,7 @@
         "execution",
         "expected",
         "filesystem",
+        "flat_map",
         "format",
         "forward_list",
         "fstream",
diff --git a/stl/inc/yvals_core.h b/stl/inc/yvals_core.h
index 922a71948d8..63bfcc46785 100644
--- a/stl/inc/yvals_core.h
+++ b/stl/inc/yvals_core.h
@@ -324,6 +324,7 @@
 // P0288R9 move_only_function
 // P0323R12 <expected>
 // P0401R6 Providing Size Feedback In The Allocator Interface
+// P0429R9 <flat_map>
 // P0448R4 <spanstream>
 // P0627R6 unreachable()
 // P0798R8 Monadic Operations For optional
@@ -1820,6 +1821,7 @@ _EMIT_STL_ERROR(STL1004, "C++98 unexpected() is incompatible with C++23 unexpect
 #ifdef __cpp_lib_concepts
 #define __cpp_lib_containers_ranges 202202L
 #define __cpp_lib_expected          202211L
+#define __cpp_lib_flat_map          202207L
 #define __cpp_lib_formatters        202302L
 #endif // defined(__cpp_lib_concepts)
 
diff --git a/stl/modules/std.ixx b/stl/modules/std.ixx
index 7a5fdbf7cef..36bd4afbdbf 100644
--- a/stl/modules/std.ixx
+++ b/stl/modules/std.ixx
@@ -61,6 +61,7 @@ export module std;
 #include <expected>
 #endif // _HAS_CXX23
 #include <filesystem>
+#include <flat_map>
 #include <format>
 #include <forward_list>
 #include <fstream>
diff --git a/tests/std/include/test_header_units_and_modules.hpp b/tests/std/include/test_header_units_and_modules.hpp
index ae0e81eda4e..da06e630897 100644
--- a/tests/std/include/test_header_units_and_modules.hpp
+++ b/tests/std/include/test_header_units_and_modules.hpp
@@ -236,6 +236,15 @@ void test_filesystem() {
     assert(info.capacity != static_cast<decltype(info.capacity)>(-1));
 }
 
+#if TEST_STANDARD >= 23
+void test_flat_map() {
+    using namespace std;
+    puts("Testing <flat_map>.");
+
+    // FIXME! ADD TEST COVERAGE HERE!
+}
+#endif // TEST_STANDARD >= 23
+
 void test_format() {
     using namespace std;
     puts("Testing <format>.");
@@ -1140,6 +1149,9 @@ void all_cpp_header_tests() {
     test_expected();
 #endif // TEST_STANDARD >= 23
     test_filesystem();
+#if TEST_STANDARD >= 23
+    test_flat_map();
+#endif // TEST_STANDARD >= 23
     test_format();
     test_forward_list();
     test_fstream();
diff --git a/tests/std/test.lst b/tests/std/test.lst
index 1cb0e33f917..e4d6b362292 100644
--- a/tests/std/test.lst
+++ b/tests/std/test.lst
@@ -331,6 +331,7 @@ tests\P0408R7_efficient_access_to_stringbuf_buffer
 tests\P0414R2_shared_ptr_for_arrays
 tests\P0415R1_constexpr_complex
 tests\P0426R1_constexpr_char_traits
+tests\P0429R9_flat_map
 tests\P0433R2_deduction_guides
 tests\P0448R4_iosfwd
 tests\P0448R4_spanstream
diff --git a/tests/std/tests/P0429R9_flat_map/env.lst b/tests/std/tests/P0429R9_flat_map/env.lst
new file mode 100644
index 00000000000..8ac7033b206
--- /dev/null
+++ b/tests/std/tests/P0429R9_flat_map/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
new file mode 100644
index 00000000000..d3d10569eab
--- /dev/null
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -0,0 +1,281 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <atomic>
+#include <cassert>
+#include <concepts>
+#include <flat_map>
+#include <functional>
+#include <memory>
+#include <type_traits>
+#include <vector>
+
+using namespace std;
+
+template <typename T>
+concept IsFlatMap = _Is_specialization_v<remove_cvref_t<T&&>, flat_map>;
+
+template <IsFlatMap T>
+bool check_container_requirements(T&&) {
+    return true;
+}
+
+template <IsFlatMap T>
+consteval bool check_reversible_container_requirements()
+    requires _Is_specialization_v<remove_cvref_t<T>, flat_map>
+{
+    using map_t = remove_cvref_t<T>;
+    bool result = true;
+    result &= is_same_v<std::reverse_iterator<typename map_t::iterator>, typename map_t::reverse_iterator>;
+    result &= is_same_v<std::reverse_iterator<typename map_t::const_iterator>, typename map_t::const_reverse_iterator>;
+    result &= is_same_v<decltype(declval<map_t>().begin()), typename map_t::iterator>;
+    result &= is_same_v<decltype(declval<map_t>().end()), typename map_t::iterator>;
+    result &= is_same_v<decltype(declval<map_t>().cbegin()), typename map_t::const_iterator>;
+    result &= is_same_v<decltype(declval<map_t>().cend()), typename map_t::const_iterator>;
+    result &= is_same_v<decltype(declval<map_t>().rbegin()), typename map_t::reverse_iterator>;
+    result &= is_same_v<decltype(declval<map_t>().rend()), typename map_t::reverse_iterator>;
+    result &= is_same_v<decltype(declval<map_t>().crbegin()), typename map_t::const_reverse_iterator>;
+    result &= is_same_v<decltype(declval<map_t>().crend()), typename map_t::const_reverse_iterator>;
+    result &= is_convertible_v<typename map_t::iterator, typename map_t::const_iterator>;
+    result &= is_convertible_v<typename map_t::reverse_iterator, typename map_t::const_reverse_iterator>;
+    return result;
+}
+
+template <IsFlatMap T>
+constexpr bool check_reversible_container_requirements(T&&)
+    requires _Is_specialization_v<remove_cvref_t<T&&>, flat_map>
+{
+    return check_reversible_container_requirements<T&&>();
+}
+
+template <IsFlatMap T>
+bool check_requirements(T&& obj) {
+    return check_container_requirements(forward<T>(obj)) && check_reversible_container_requirements(forward<T>(obj));
+}
+
+template <IsFlatMap T>
+bool check_key_content(const T& obj, const typename T::key_container_type& expected) {
+    const auto& actual = obj.keys();
+    if (actual.size() != expected.size()) {
+        return false;
+    }
+    return std::ranges::equal(actual, expected);
+}
+
+template <IsFlatMap T>
+bool check_value_content(const T& obj, const typename T::mapped_container_type& expected) {
+    const auto& actual = obj.values();
+    if (actual.size() != expected.size()) {
+        return false;
+    }
+    return std::ranges::equal(actual, expected);
+}
+
+template <typename T>
+class MyAllocator : public std::allocator<T> {
+public:
+    using value_type = T;
+    using std::allocator<T>::allocator;
+
+    static size_t getActiveAllocationCount() {
+        return s_allocations.load();
+    }
+
+    T* allocate(size_t n) {
+        ++s_allocations;
+        return std::allocator<T>::allocate(n);
+    }
+
+    T* allocate_at_least(size_t n) {
+        ++s_allocations;
+        return std::allocator<T>::allocate_at_least(n);
+    }
+
+    void deallocate(T* p, size_t n) noexcept {
+        --s_allocations;
+        std::allocator<T>::deallocate(p, n);
+    }
+
+private:
+    static std::atomic<size_t> s_allocations;
+};
+
+template <typename T>
+class Packaged {
+private:
+    T value;
+
+public:
+    Packaged() : value() {}
+    template <typename U>
+        requires std::constructible_from<T, U&&>
+    Packaged(U&& u) : value(std::forward<U>(u)) {}
+
+    T get() const {
+        return value;
+    }
+
+    void set(T t) {
+        value = t;
+    }
+
+    friend bool operator==(const Packaged& lhs, const Packaged& rhs) {
+        return lhs.value == rhs.value;
+    }
+
+    friend bool operator==(const Packaged& lhs, const T& rhs) {
+        return lhs.value == rhs;
+    }
+
+    friend bool operator==(const T& lhs, const Packaged& rhs) {
+        return lhs == rhs.value;
+    }
+
+    friend auto operator<=>(const Packaged& lhs, const Packaged& rhs) {
+        return lhs.value <=> rhs.value;
+    }
+};
+
+template <typename T>
+class PackagedCompare : public std::less<Packaged<T>> {
+public:
+    using std::less<Packaged<T>>::less;
+};
+
+template <typename T>
+class TransparentPackagedCompare : public PackagedCompare<T> {
+public:
+    using PackagedCompare<T>::PackagedCompare;
+    using is_transparent = void;
+
+    bool operator()(const Packaged<T>& lhs, const Packaged<T>& rhs) const {
+        return PackagedCompare<T>::operator()(lhs, rhs);
+    }
+
+    bool operator()(const T& lhs, const Packaged<T>& rhs) const {
+        return lhs < rhs.get();
+    }
+
+    bool operator()(const Packaged<T>& lhs, const T& rhs) const {
+        return lhs.get() < rhs;
+    }
+};
+
+template <typename T>
+std::atomic<size_t> MyAllocator<T>::s_allocations = 0;
+
+void test_construction() {
+    {
+        std::flat_map<int, int> map;
+        assert(check_requirements(map));
+        assert(check_key_content(map, {}));
+        assert(check_value_content(map, {}));
+    }
+    {
+        std::vector<int> keys = {0, 1, 2, 3, 4, 2};
+        std::vector<int> vals = {44, 2324, 635462, 433, 5, 7};
+        std::flat_map map(keys, vals);
+        assert(check_requirements(map));
+        assert(check_key_content(map, {0, 1, 2, 3, 4}));
+        assert(check_value_content(map, {44, 2324, 635462, 433, 5}));
+    }
+    {
+        std::vector<int, MyAllocator<int>> keys = {0, 1, 2, 3, 4, 2};
+        std::vector<int, MyAllocator<int>> vals = {44, 2324, 635462, 433, 5, 7};
+        size_t activeAllocations                = MyAllocator<int>::getActiveAllocationCount();
+        std::flat_map map(keys, vals, MyAllocator<int>());
+        assert(check_key_content(map, {0, 1, 2, 3, 4}));
+        assert(check_value_content(map, {44, 2324, 635462, 433, 5}));
+        assert(MyAllocator<int>::getActiveAllocationCount() > activeAllocations);
+    }
+    {
+        std::vector<int> keys = {0, 1, 2, 3, 38, 242};
+        std::vector<int> vals = {44, 2324, 635462, 433, 5, 7};
+        std::flat_map map(std::sorted_unique, keys, vals);
+        assert(check_requirements(map));
+        assert(check_key_content(map, {0, 1, 2, 3, 38, 242}));
+        assert(check_value_content(map, {44, 2324, 635462, 433, 5, 7}));
+    }
+    {
+        PackagedCompare<int> comp;
+        std::flat_map<Packaged<int>, int, PackagedCompare<int>> map(comp);
+        assert(check_requirements(map));
+        assert(check_key_content(map, {}));
+        assert(check_value_content(map, {}));
+    }
+    {
+        PackagedCompare<int> comp;
+        MyAllocator<Packaged<int>> alloc;
+        std::flat_map<Packaged<int>, Packaged<int>, PackagedCompare<int>,
+            std::vector<Packaged<int>, MyAllocator<Packaged<int>>>,
+            std::vector<Packaged<int>, MyAllocator<Packaged<int>>>>
+            map(comp, alloc);
+        assert(check_requirements(map));
+        assert(check_key_content(map, {}));
+        assert(check_value_content(map, {}));
+    }
+    {
+        MyAllocator<Packaged<int>> alloc;
+        std::flat_map<Packaged<int>, Packaged<int>, PackagedCompare<int>,
+            std::vector<Packaged<int>, MyAllocator<Packaged<int>>>,
+            std::vector<Packaged<int>, MyAllocator<Packaged<int>>>>
+            map(alloc);
+        assert(check_requirements(map));
+        assert(check_key_content(map, {}));
+        assert(check_value_content(map, {}));
+    }
+    {
+        MyAllocator<Packaged<int>> alloc;
+        std::flat_map<Packaged<int>, int, PackagedCompare<int>, std::vector<Packaged<int>, MyAllocator<Packaged<int>>>,
+            std::vector<int, MyAllocator<int>>>
+            map(alloc);
+        assert(check_requirements(map));
+        assert(check_key_content(map, {}));
+        assert(check_value_content(map, {}));
+    }
+    {
+        PackagedCompare<int> comp;
+        MyAllocator<int> alloc;
+        std::vector<Packaged<int>, MyAllocator<Packaged<int>>> keys = {0, 1, 2, 3, 4, 2};
+        std::vector<int, MyAllocator<int>> vals                     = {44, 2324, 635462, 433, 5, 7};
+        std::flat_map map(keys, vals, comp, alloc);
+        assert(check_requirements(map));
+        assert(check_key_content(map, {0, 1, 2, 3, 4}));
+        assert(check_value_content(map, {44, 2324, 635462, 433, 5}));
+    }
+    {
+        TransparentPackagedCompare<int> comp;
+        MyAllocator<int> alloc;
+        std::vector<Packaged<int>, MyAllocator<Packaged<int>>> keys = {0, 1, 2, 3, 4, 2};
+        std::vector<int, MyAllocator<int>> vals                     = {44, 2324, 635462, 433, 5, 7};
+        std::flat_map map(keys, vals, comp, alloc);
+        assert(check_requirements(map));
+        assert(check_key_content(map, {0, 1, 2, 3, 4}));
+        assert(check_value_content(map, {44, 2324, 635462, 433, 5}));
+    }
+}
+
+
+struct Incomplete;
+template <class T>
+struct MyType {
+    T* ptr;
+
+    bool operator==(const MyType&) const  = default;
+    auto operator<=>(const MyType&) const = default;
+};
+
+void test_pointer_to_incomplete_type() {
+    struct Test {
+        std::unique_ptr<std::flat_map<Test, Test>> ptr;
+    };
+
+    Test t;
+    std::flat_map<MyType<Incomplete>, std::shared_ptr<MyType<Incomplete>>> map;
+}
+
+int main() {
+    test_construction();
+    test_pointer_to_incomplete_type();
+    return 0;
+}

From 2355b8c67089929eaa66d9d5e9d6630219967cb3 Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34@live.cn>
Date: Wed, 17 Jan 2024 04:32:23 +0800
Subject: [PATCH 019/134] `<flat_map>`: Remove `zip_view` dependency and other
 cleanups (#4315)

---
 stl/inc/flat_map                          | 180 ++++++++++++----------
 tests/std/tests/P0429R9_flat_map/env.lst  |   2 +-
 tests/std/tests/P0429R9_flat_map/test.cpp | 170 ++++++++++----------
 3 files changed, 177 insertions(+), 175 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index 52e35f8a7bf..facdd5474e5 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -14,15 +14,11 @@ _EMIT_STL_WARNING(STL4038, "The contents of <flat_map> are available only with C
 #include <algorithm>
 #include <compare>
 #include <concepts>
-#include <cstdint>
 #include <initializer_list>
-#include <memory>
-#include <ranges>
 #include <type_traits>
 #include <utility>
 #include <vector>
 #include <xmemory>
-#include <xutility>
 
 #pragma pack(push, _CRT_PACKING)
 #pragma warning(push, _STL_WARNING_LEVEL)
@@ -102,27 +98,34 @@ struct _NODISCARD _Clear_flat_map_scope_guard {
 
 // Implementation
 
-template <class _KeyContainer, class _MappedContainer, bool _IsConst>
-class _Flat_map_iterator_Impl {
-public:
-    using _Key_iterator_t = typename _KeyContainer::const_iterator;
-    using _Mapped_iterator_t =
-        conditional_t<_IsConst, typename _MappedContainer::const_iterator, typename _MappedContainer::iterator>;
-    class type {
+enum class _Paring_iterator_kind : unsigned char {
+    _Sort,
+    _Mutable,
+    _Const,
+};
+
+template <class _KeyContainer, class _MappedContainer, _Paring_iterator_kind _Kind>
+struct _Paring_iterator_provider {
+    using _Key_iterator_t    = conditional_t<_Kind == _Paring_iterator_kind::_Sort, typename _KeyContainer::iterator,
+        typename _KeyContainer::const_iterator>;
+    using _Mapped_iterator_t = conditional_t<_Kind == _Paring_iterator_kind::_Const,
+        typename _MappedContainer::const_iterator, typename _MappedContainer::iterator>;
+
+    class _Iterator {
     public:
         template <class _FlatMap_Key, class _FlatMap_T, class _FlatMap_Compare, class _FlatMap_KeyContainer,
             class _FlatMap_MappedContainer, bool _Is_Multi, class _Derived>
             requires same_as<_FlatMap_Key, typename _FlatMap_KeyContainer::value_type>
                   && same_as<_FlatMap_T, typename _FlatMap_MappedContainer::value_type>
         friend class _Flat_Map_Base;
-        type() = default;
-        type(_Key_iterator_t _Key_it, _Mapped_iterator_t _Mapped_it) : _Key_it(_Key_it), _Mapped_it(_Mapped_it) {}
+        _Iterator() = default;
+        _Iterator(_Key_iterator_t _Key_it, _Mapped_iterator_t _Mapped_it) : _Key_it(_Key_it), _Mapped_it(_Mapped_it) {}
 
         using iterator_category = input_iterator_tag;
         using iterator_concept  = random_access_iterator_tag;
         using difference_type   = ptrdiff_t;
         using value_type        = pair<iter_value_t<_Key_iterator_t>, iter_value_t<_Mapped_iterator_t>>;
-        using reference         = pair<iter_const_reference_t<_Key_iterator_t>, iter_reference_t<_Mapped_iterator_t>>;
+        using reference         = pair<iter_reference_t<_Key_iterator_t>, iter_reference_t<_Mapped_iterator_t>>;
 
     private:
         class _Arrow_proxy {
@@ -148,76 +151,80 @@ public:
             return pointer{*(*this)};
         }
 
-        type& operator++() {
+        _Iterator& operator++() {
             ++_Key_it;
             ++_Mapped_it;
             return *this;
         }
 
-        type operator++(int) {
-            type _Tmp = *this;
+        _Iterator operator++(int) {
+            auto _Old = *this;
             ++*this;
-            return _Tmp;
+            return _Old;
         }
 
-        bool operator==(const type& _Right) const {
+        bool operator==(const _Iterator& _Right) const {
             return _Key_it == _Right._Key_it;
         }
 
-        auto operator<=>(const type& _Right) const {
+        auto operator<=>(const _Iterator& _Right) const {
             return _Key_it <=> _Right._Key_it;
         }
 
-        type& operator--() {
+        _Iterator& operator--() {
             --_Key_it;
             --_Mapped_it;
             return *this;
         }
 
-        type operator--(int) {
-            type _Tmp = *this;
+        _Iterator operator--(int) {
+            auto _Old = *this;
             --*this;
-            return _Tmp;
+            return _Old;
         }
 
-        type& operator+=(difference_type _Off) {
+        _Iterator& operator+=(const difference_type _Off) {
             _Key_it += _Off;
             _Mapped_it += _Off;
             return *this;
         }
 
-        type& operator-=(difference_type _Off) {
+        _Iterator& operator-=(const difference_type _Off) {
             _Key_it -= _Off;
             _Mapped_it -= _Off;
             return *this;
         }
 
-        type operator+(difference_type _Off) const {
-            type _Tmp = *this;
-            return _Tmp += _Off;
+        _Iterator operator+(const difference_type _Off) const {
+            auto _Old = *this;
+            _Old += _Off;
+            return _Old;
         }
 
-        type operator-(difference_type _Off) const {
-            type _Tmp = *this;
-            return _Tmp -= _Off;
+        _Iterator operator-(const difference_type _Off) const {
+            auto _Old = *this;
+            _Old -= _Off;
+            return _Old;
         }
 
-        reference operator[](difference_type _Off) const {
+        reference operator[](const difference_type _Off) const {
             return *(*this + _Off);
         }
 
-        difference_type operator-(const type& _Right) const {
+        difference_type operator-(const _Iterator& _Right) const {
             return _Key_it - _Right._Key_it;
         }
 
-        friend type operator+(difference_type _Off, const type& _Right) {
+        friend _Iterator operator+(const difference_type _Off, const _Iterator& _Right) {
             return _Right + _Off;
         }
 
-        operator typename _Flat_map_iterator_Impl<_KeyContainer, _MappedContainer, true>::type() const
-            requires (!_IsConst)
+        operator typename _Paring_iterator_provider<_KeyContainer, _MappedContainer,
+            _Paring_iterator_kind::_Const>::_Iterator() const
+            requires (_Kind == _Paring_iterator_kind::_Mutable)
         {
-            return typename _Flat_map_iterator_Impl<_KeyContainer, _MappedContainer, true>::type{_Key_it, _Mapped_it};
+            return typename _Paring_iterator_provider<_KeyContainer, _MappedContainer,
+                _Paring_iterator_kind::_Const>::_Iterator{_Key_it, _Mapped_it};
         }
 
     private:
@@ -225,7 +232,7 @@ public:
         _Mapped_iterator_t _Mapped_it;
     };
 
-    static_assert(swappable<type>);
+    _STL_INTERNAL_STATIC_ASSERT(swappable<_Iterator>);
 };
 
 _EXPORT_STD
@@ -238,23 +245,25 @@ private:
     using _Sorted_t = conditional_t<_Is_Multi, sorted_equivalent_t, sorted_unique_t>;
 
 public:
-    using key_type               = _FlatMap_Key;
-    using mapped_type            = _FlatMap_T;
-    using value_type             = pair<key_type, mapped_type>;
-    using key_compare            = _FlatMap_Compare;
-    using reference              = pair<const key_type&, mapped_type&>;
-    using const_reference        = pair<const key_type&, const mapped_type&>;
-    using size_type              = size_t;
-    using difference_type        = ptrdiff_t;
-    using key_container_type     = _FlatMap_KeyContainer;
-    using mapped_container_type  = _FlatMap_MappedContainer;
-    using iterator               = _Flat_map_iterator_Impl<key_container_type, mapped_container_type, false>::type;
-    using const_iterator         = _Flat_map_iterator_Impl<key_container_type, mapped_container_type, true>::type;
+    using key_type              = _FlatMap_Key;
+    using mapped_type           = _FlatMap_T;
+    using value_type            = pair<key_type, mapped_type>;
+    using key_compare           = _FlatMap_Compare;
+    using reference             = pair<const key_type&, mapped_type&>;
+    using const_reference       = pair<const key_type&, const mapped_type&>;
+    using size_type             = size_t;
+    using difference_type       = ptrdiff_t;
+    using key_container_type    = _FlatMap_KeyContainer;
+    using mapped_container_type = _FlatMap_MappedContainer;
+    using iterator              = _Paring_iterator_provider<key_container_type, mapped_container_type,
+        _Paring_iterator_kind::_Mutable>::_Iterator;
+    using const_iterator =
+        _Paring_iterator_provider<key_container_type, mapped_container_type, _Paring_iterator_kind::_Const>::_Iterator;
     using reverse_iterator       = _STD reverse_iterator<iterator>;
     using const_reverse_iterator = _STD reverse_iterator<const_iterator>;
 
-    static_assert(random_access_iterator<iterator>);
-    static_assert(convertible_to<iterator, const_iterator>);
+    _STL_INTERNAL_STATIC_ASSERT(random_access_iterator<iterator>);
+    _STL_INTERNAL_STATIC_ASSERT(convertible_to<iterator, const_iterator>);
 
     using value_compare = _Flat_value_compare<key_type, mapped_type, key_compare>::value_compare;
     using containers    = _Flat_Container<key_container_type, mapped_container_type>::container;
@@ -406,15 +415,15 @@ public:
               .values = _STD make_obj_using_allocator<mapped_container_type>(_Alloc, _Other._Data.values)} {}
 
     // Move constructors
-    _Flat_Map_Base(_Derived&& _Other) noexcept(_STD is_nothrow_move_constructible_v<key_compare>
-                                               && _STD is_nothrow_move_constructible_v<key_container_type>
-                                               && _STD is_nothrow_move_constructible_v<mapped_container_type>)
+    _Flat_Map_Base(_Derived&& _Other) noexcept(is_nothrow_move_constructible_v<key_compare>
+                                               && is_nothrow_move_constructible_v<key_container_type>
+                                               && is_nothrow_move_constructible_v<mapped_container_type>)
         : _Key_compare(move(_Other._Key_compare)), _Data(move(_Other).extract()) {}
 
     template <_Valid_Allocator_for_flat_map<key_container_type, mapped_container_type> _Allocator>
     _Flat_Map_Base(_Derived&& _Other, const _Allocator& _Alloc) noexcept(
-        _STD is_nothrow_move_constructible_v<key_compare> && _STD is_nothrow_move_constructible_v<key_container_type>
-        && _STD is_nothrow_move_constructible_v<mapped_container_type>)
+        is_nothrow_move_constructible_v<key_compare> && is_nothrow_move_constructible_v<key_container_type>
+        && is_nothrow_move_constructible_v<mapped_container_type>)
         : _Key_compare(move(_Other._Key_compare)),
           _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Alloc, move(_Other._Data.keys)),
               .values = _STD make_obj_using_allocator<mapped_container_type>(_Alloc, move(_Other._Data.values))} {}
@@ -833,19 +842,25 @@ private:
             && !_Key_compare(_STD forward<_K2>(_Y), _STD forward<_K1>(_X));
     }
 
+    auto _View_to_sort() {
+        using _Sorting_iterator = _Paring_iterator_provider<key_container_type, mapped_container_type,
+            _Paring_iterator_kind::_Sort>::_Iterator;
+        return _RANGES subrange<_Sorting_iterator>{_Sorting_iterator{_Data.keys.begin(), _Data.values.begin()},
+            _Sorting_iterator{_Data.keys.end(), _Data.values.end()}};
+    }
+
     void _Sort() {
         _Clear_flat_map_scope_guard _Guard{this};
-        auto _Zip_view = _RANGES views::zip(_Data.keys, _Data.values);
-        _RANGES sort(_Zip_view, value_compare(_Key_compare));
+        _RANGES sort(_View_to_sort(), value_compare(_Key_compare));
         _Guard._Clearable = nullptr;
     }
 
     void _Dedup() {
         _Clear_flat_map_scope_guard _Guard{this};
-        auto _Zip_view = _RANGES views::zip(_Data.keys, _Data.values);
-        auto _Subrange = _RANGES unique(
-            _Zip_view, [this](const_reference _X, const_reference _Y) { return this->_Key_equal(_X.first, _Y.first); });
-        auto _Remaining_count = _STD distance(_Zip_view.begin(), _Subrange.begin());
+        auto _Sorted_view     = _View_to_sort();
+        auto _Subrange        = _RANGES unique(_Sorted_view,
+                   [this](const_reference _X, const_reference _Y) { return this->_Key_equal(_X.first, _Y.first); });
+        auto _Remaining_count = _STD distance(_Sorted_view.begin(), _Subrange.begin());
         _Data.keys.erase(_Data.keys.begin() + _Remaining_count, _Data.keys.end());
         _Data.values.erase(_Data.values.begin() + _Remaining_count, _Data.values.end());
         _Guard._Clearable = nullptr;
@@ -928,14 +943,15 @@ private:
         }
 
         // Sort the newly inserted elements
-        auto _Zip_view = _RANGES views::zip(_Data.keys, _Data.values);
+        auto _Sorted_view = _View_to_sort();
         if constexpr (_NeedSorting) {
-            auto _Zip_view_new_elements = _Zip_view | _RANGES views::drop(_OldSize);
-            _RANGES sort(_Zip_view_new_elements, value_compare(_Key_compare));
+            auto _Sorted_new_elements = _Sorted_view;
+            _Sorted_new_elements.advance(_OldSize);
+            _RANGES sort(_Sorted_new_elements, value_compare(_Key_compare));
         }
 
         // Merge the newly inserted elements with the existing elements
-        _RANGES inplace_merge(_Zip_view, _Zip_view.begin() + _OldSize, value_compare(_Key_compare));
+        _RANGES inplace_merge(_Sorted_view, _Sorted_view.begin() + _OldSize, value_compare(_Key_compare));
 
         if constexpr (_NeedDeduping) {
             _Dedup();
@@ -998,10 +1014,9 @@ private:
     iterator _Lower_bound(const _K& _X)
         requires same_as<_K, key_type> || _Is_transparent_v<key_compare>
     {
-        typename key_container_type::const_iterator _Key_it =
-            _STD lower_bound(_Data.keys.cbegin(), _Data.keys.cend(), _X, _Key_compare);
-        auto _Dist                                       = _STD distance(_Data.keys.cbegin(), _Key_it);
-        typename mapped_container_type::iterator _Val_it = _Data.values.begin() + _Dist;
+        auto _Key_it = _STD lower_bound(_Data.keys.cbegin(), _Data.keys.cend(), _X, _Key_compare);
+        auto _Dist   = _STD distance(_Data.keys.cbegin(), _Key_it);
+        auto _Val_it = _Data.values.begin() + _Dist;
         return iterator{_STD move(_Key_it), _STD move(_Val_it)};
     }
 
@@ -1009,10 +1024,9 @@ private:
     const_iterator _Lower_bound(const _K& _X) const
         requires same_as<_K, key_type> || _Is_transparent_v<key_compare>
     {
-        typename key_container_type::const_iterator _Key_it =
-            _STD lower_bound(_Data.keys.cbegin(), _Data.keys.cend(), _X, _Key_compare);
-        auto _Dist                                             = _STD distance(_Data.keys.cbegin(), _Key_it);
-        typename mapped_container_type::const_iterator _Val_it = _Data.values.cbegin() + _Dist;
+        auto _Key_it = _STD lower_bound(_Data.keys.cbegin(), _Data.keys.cend(), _X, _Key_compare);
+        auto _Dist   = _STD distance(_Data.keys.cbegin(), _Key_it);
+        auto _Val_it = _Data.values.cbegin() + _Dist;
         return const_iterator{_STD move(_Key_it), _STD move(_Val_it)};
     }
 
@@ -1020,10 +1034,9 @@ private:
     iterator _Upper_bound(const _K& _X)
         requires same_as<_K, key_type> || _Is_transparent_v<key_compare>
     {
-        typename key_container_type::const_iterator _Key_it =
-            _STD upper_bound(_Data.keys.cbegin(), _Data.keys.cend(), _X, _Key_compare);
-        auto _Dist                                       = _STD distance(_Data.keys.cbegin(), _Key_it);
-        typename mapped_container_type::iterator _Val_it = _Data.values.begin() + _Dist;
+        auto _Key_it = _STD upper_bound(_Data.keys.cbegin(), _Data.keys.cend(), _X, _Key_compare);
+        auto _Dist   = _STD distance(_Data.keys.cbegin(), _Key_it);
+        auto _Val_it = _Data.values.begin() + _Dist;
         return iterator{_STD move(_Key_it), _STD move(_Val_it)};
     }
 
@@ -1031,10 +1044,9 @@ private:
     const_iterator _Upper_bound(const _K& _X) const
         requires same_as<_K, key_type> || _Is_transparent_v<key_compare>
     {
-        typename key_container_type::const_iterator _Key_it =
-            _STD upper_bound(_Data.keys.cbegin(), _Data.keys.cend(), _X, _Key_compare);
-        auto _Dist                                             = _STD distance(_Data.keys.cbegin(), _Key_it);
-        typename mapped_container_type::const_iterator _Val_it = _Data.values.cbegin() + _Dist;
+        auto _Key_it = _STD upper_bound(_Data.keys.cbegin(), _Data.keys.cend(), _X, _Key_compare);
+        auto _Dist   = _STD distance(_Data.keys.cbegin(), _Key_it);
+        auto _Val_it = _Data.values.cbegin() + _Dist;
         return const_iterator{_STD move(_Key_it), _STD move(_Val_it)};
     }
 
diff --git a/tests/std/tests/P0429R9_flat_map/env.lst b/tests/std/tests/P0429R9_flat_map/env.lst
index 8ac7033b206..18e2d7c71ec 100644
--- a/tests/std/tests/P0429R9_flat_map/env.lst
+++ b/tests/std/tests/P0429R9_flat_map/env.lst
@@ -1,4 +1,4 @@
 # Copyright (c) Microsoft Corporation.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
+RUNALL_INCLUDE ..\concepts_latest_matrix.lst
diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index d3d10569eab..b5cfda070f3 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -12,8 +12,13 @@
 
 using namespace std;
 
+template <class T, template <class...> class Tmpl>
+constexpr bool is_specialization_v = false;
+template <template <class...> class Tmpl, class... Ts>
+constexpr bool is_specialization_v<Tmpl<Ts...>, Tmpl> = true;
+
 template <typename T>
-concept IsFlatMap = _Is_specialization_v<remove_cvref_t<T&&>, flat_map>;
+concept IsFlatMap = is_specialization_v<remove_cvref_t<T>, flat_map>;
 
 template <IsFlatMap T>
 bool check_container_requirements(T&&) {
@@ -21,13 +26,11 @@ bool check_container_requirements(T&&) {
 }
 
 template <IsFlatMap T>
-consteval bool check_reversible_container_requirements()
-    requires _Is_specialization_v<remove_cvref_t<T>, flat_map>
-{
+consteval bool check_reversible_container_requirements() {
     using map_t = remove_cvref_t<T>;
     bool result = true;
-    result &= is_same_v<std::reverse_iterator<typename map_t::iterator>, typename map_t::reverse_iterator>;
-    result &= is_same_v<std::reverse_iterator<typename map_t::const_iterator>, typename map_t::const_reverse_iterator>;
+    result &= is_same_v<reverse_iterator<typename map_t::iterator>, typename map_t::reverse_iterator>;
+    result &= is_same_v<reverse_iterator<typename map_t::const_iterator>, typename map_t::const_reverse_iterator>;
     result &= is_same_v<decltype(declval<map_t>().begin()), typename map_t::iterator>;
     result &= is_same_v<decltype(declval<map_t>().end()), typename map_t::iterator>;
     result &= is_same_v<decltype(declval<map_t>().cbegin()), typename map_t::const_iterator>;
@@ -42,9 +45,7 @@ consteval bool check_reversible_container_requirements()
 }
 
 template <IsFlatMap T>
-constexpr bool check_reversible_container_requirements(T&&)
-    requires _Is_specialization_v<remove_cvref_t<T&&>, flat_map>
-{
+constexpr bool check_reversible_container_requirements(T&&) {
     return check_reversible_container_requirements<T&&>();
 }
 
@@ -59,7 +60,7 @@ bool check_key_content(const T& obj, const typename T::key_container_type& expec
     if (actual.size() != expected.size()) {
         return false;
     }
-    return std::ranges::equal(actual, expected);
+    return ranges::equal(actual, expected);
 }
 
 template <IsFlatMap T>
@@ -68,14 +69,14 @@ bool check_value_content(const T& obj, const typename T::mapped_container_type&
     if (actual.size() != expected.size()) {
         return false;
     }
-    return std::ranges::equal(actual, expected);
+    return ranges::equal(actual, expected);
 }
 
 template <typename T>
-class MyAllocator : public std::allocator<T> {
+class MyAllocator : public allocator<T> {
 public:
     using value_type = T;
-    using std::allocator<T>::allocator;
+    using allocator<T>::allocator;
 
     static size_t getActiveAllocationCount() {
         return s_allocations.load();
@@ -83,21 +84,21 @@ class MyAllocator : public std::allocator<T> {
 
     T* allocate(size_t n) {
         ++s_allocations;
-        return std::allocator<T>::allocate(n);
+        return allocator<T>::allocate(n);
     }
 
     T* allocate_at_least(size_t n) {
         ++s_allocations;
-        return std::allocator<T>::allocate_at_least(n);
+        return allocator<T>::allocate_at_least(n);
     }
 
     void deallocate(T* p, size_t n) noexcept {
         --s_allocations;
-        std::allocator<T>::deallocate(p, n);
+        allocator<T>::deallocate(p, n);
     }
 
 private:
-    static std::atomic<size_t> s_allocations;
+    static inline atomic<size_t> s_allocations{0};
 };
 
 template <typename T>
@@ -108,8 +109,8 @@ class Packaged {
 public:
     Packaged() : value() {}
     template <typename U>
-        requires std::constructible_from<T, U&&>
-    Packaged(U&& u) : value(std::forward<U>(u)) {}
+        requires constructible_from<T, U&&>
+    Packaged(U&& u) : value(forward<U>(u)) {}
 
     T get() const {
         return value;
@@ -137,15 +138,10 @@ class Packaged {
 };
 
 template <typename T>
-class PackagedCompare : public std::less<Packaged<T>> {
-public:
-    using std::less<Packaged<T>>::less;
-};
+struct PackagedCompare : less<Packaged<T>> {};
 
 template <typename T>
-class TransparentPackagedCompare : public PackagedCompare<T> {
-public:
-    using PackagedCompare<T>::PackagedCompare;
+struct TransparentPackagedCompare : PackagedCompare<T> {
     using is_transparent = void;
 
     bool operator()(const Packaged<T>& lhs, const Packaged<T>& rhs) const {
@@ -161,97 +157,92 @@ class TransparentPackagedCompare : public PackagedCompare<T> {
     }
 };
 
-template <typename T>
-std::atomic<size_t> MyAllocator<T>::s_allocations = 0;
-
 void test_construction() {
     {
-        std::flat_map<int, int> map;
-        assert(check_requirements(map));
-        assert(check_key_content(map, {}));
-        assert(check_value_content(map, {}));
+        flat_map<int, int> fmap;
+        assert(check_requirements(fmap));
+        assert(check_key_content(fmap, {}));
+        assert(check_value_content(fmap, {}));
     }
     {
-        std::vector<int> keys = {0, 1, 2, 3, 4, 2};
-        std::vector<int> vals = {44, 2324, 635462, 433, 5, 7};
-        std::flat_map map(keys, vals);
-        assert(check_requirements(map));
-        assert(check_key_content(map, {0, 1, 2, 3, 4}));
-        assert(check_value_content(map, {44, 2324, 635462, 433, 5}));
+        vector<int> keys = {0, 1, 2, 3, 4, 2};
+        vector<int> vals = {44, 2324, 635462, 433, 5, 7};
+        flat_map fmap(keys, vals);
+        assert(check_requirements(fmap));
+        assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
+        assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
     }
     {
-        std::vector<int, MyAllocator<int>> keys = {0, 1, 2, 3, 4, 2};
-        std::vector<int, MyAllocator<int>> vals = {44, 2324, 635462, 433, 5, 7};
-        size_t activeAllocations                = MyAllocator<int>::getActiveAllocationCount();
-        std::flat_map map(keys, vals, MyAllocator<int>());
-        assert(check_key_content(map, {0, 1, 2, 3, 4}));
-        assert(check_value_content(map, {44, 2324, 635462, 433, 5}));
+        vector<int, MyAllocator<int>> keys = {0, 1, 2, 3, 4, 2};
+        vector<int, MyAllocator<int>> vals = {44, 2324, 635462, 433, 5, 7};
+        size_t activeAllocations           = MyAllocator<int>::getActiveAllocationCount();
+        flat_map fmap(keys, vals, MyAllocator<int>());
+        assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
+        assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
         assert(MyAllocator<int>::getActiveAllocationCount() > activeAllocations);
     }
     {
-        std::vector<int> keys = {0, 1, 2, 3, 38, 242};
-        std::vector<int> vals = {44, 2324, 635462, 433, 5, 7};
-        std::flat_map map(std::sorted_unique, keys, vals);
-        assert(check_requirements(map));
-        assert(check_key_content(map, {0, 1, 2, 3, 38, 242}));
-        assert(check_value_content(map, {44, 2324, 635462, 433, 5, 7}));
+        vector<int> keys = {0, 1, 2, 3, 38, 242};
+        vector<int> vals = {44, 2324, 635462, 433, 5, 7};
+        flat_map fmap(sorted_unique, keys, vals);
+        assert(check_requirements(fmap));
+        assert(check_key_content(fmap, {0, 1, 2, 3, 38, 242}));
+        assert(check_value_content(fmap, {44, 2324, 635462, 433, 5, 7}));
     }
     {
         PackagedCompare<int> comp;
-        std::flat_map<Packaged<int>, int, PackagedCompare<int>> map(comp);
-        assert(check_requirements(map));
-        assert(check_key_content(map, {}));
-        assert(check_value_content(map, {}));
+        flat_map<Packaged<int>, int, PackagedCompare<int>> fmap(comp);
+        assert(check_requirements(fmap));
+        assert(check_key_content(fmap, {}));
+        assert(check_value_content(fmap, {}));
     }
     {
         PackagedCompare<int> comp;
         MyAllocator<Packaged<int>> alloc;
-        std::flat_map<Packaged<int>, Packaged<int>, PackagedCompare<int>,
-            std::vector<Packaged<int>, MyAllocator<Packaged<int>>>,
-            std::vector<Packaged<int>, MyAllocator<Packaged<int>>>>
-            map(comp, alloc);
-        assert(check_requirements(map));
-        assert(check_key_content(map, {}));
-        assert(check_value_content(map, {}));
+        flat_map<Packaged<int>, Packaged<int>, PackagedCompare<int>, vector<Packaged<int>, MyAllocator<Packaged<int>>>,
+            vector<Packaged<int>, MyAllocator<Packaged<int>>>>
+            fmap(comp, alloc);
+        assert(check_requirements(fmap));
+        assert(check_key_content(fmap, {}));
+        assert(check_value_content(fmap, {}));
     }
     {
         MyAllocator<Packaged<int>> alloc;
-        std::flat_map<Packaged<int>, Packaged<int>, PackagedCompare<int>,
-            std::vector<Packaged<int>, MyAllocator<Packaged<int>>>,
-            std::vector<Packaged<int>, MyAllocator<Packaged<int>>>>
-            map(alloc);
-        assert(check_requirements(map));
-        assert(check_key_content(map, {}));
-        assert(check_value_content(map, {}));
+        flat_map<Packaged<int>, Packaged<int>, PackagedCompare<int>, vector<Packaged<int>, MyAllocator<Packaged<int>>>,
+            vector<Packaged<int>, MyAllocator<Packaged<int>>>>
+            fmap(alloc);
+        assert(check_requirements(fmap));
+        assert(check_key_content(fmap, {}));
+        assert(check_value_content(fmap, {}));
     }
     {
         MyAllocator<Packaged<int>> alloc;
-        std::flat_map<Packaged<int>, int, PackagedCompare<int>, std::vector<Packaged<int>, MyAllocator<Packaged<int>>>,
-            std::vector<int, MyAllocator<int>>>
-            map(alloc);
-        assert(check_requirements(map));
-        assert(check_key_content(map, {}));
-        assert(check_value_content(map, {}));
+        flat_map<Packaged<int>, int, PackagedCompare<int>, vector<Packaged<int>, MyAllocator<Packaged<int>>>,
+            vector<int, MyAllocator<int>>>
+            fmap(alloc);
+        assert(check_requirements(fmap));
+        assert(check_key_content(fmap, {}));
+        assert(check_value_content(fmap, {}));
     }
     {
         PackagedCompare<int> comp;
         MyAllocator<int> alloc;
-        std::vector<Packaged<int>, MyAllocator<Packaged<int>>> keys = {0, 1, 2, 3, 4, 2};
-        std::vector<int, MyAllocator<int>> vals                     = {44, 2324, 635462, 433, 5, 7};
-        std::flat_map map(keys, vals, comp, alloc);
-        assert(check_requirements(map));
-        assert(check_key_content(map, {0, 1, 2, 3, 4}));
-        assert(check_value_content(map, {44, 2324, 635462, 433, 5}));
+        vector<Packaged<int>, MyAllocator<Packaged<int>>> keys = {0, 1, 2, 3, 4, 2};
+        vector<int, MyAllocator<int>> vals                     = {44, 2324, 635462, 433, 5, 7};
+        flat_map fmap(keys, vals, comp, alloc);
+        assert(check_requirements(fmap));
+        assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
+        assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
     }
     {
         TransparentPackagedCompare<int> comp;
         MyAllocator<int> alloc;
-        std::vector<Packaged<int>, MyAllocator<Packaged<int>>> keys = {0, 1, 2, 3, 4, 2};
-        std::vector<int, MyAllocator<int>> vals                     = {44, 2324, 635462, 433, 5, 7};
-        std::flat_map map(keys, vals, comp, alloc);
-        assert(check_requirements(map));
-        assert(check_key_content(map, {0, 1, 2, 3, 4}));
-        assert(check_value_content(map, {44, 2324, 635462, 433, 5}));
+        vector<Packaged<int>, MyAllocator<Packaged<int>>> keys = {0, 1, 2, 3, 4, 2};
+        vector<int, MyAllocator<int>> vals                     = {44, 2324, 635462, 433, 5, 7};
+        flat_map fmap(keys, vals, comp, alloc);
+        assert(check_requirements(fmap));
+        assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
+        assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
     }
 }
 
@@ -267,15 +258,14 @@ struct MyType {
 
 void test_pointer_to_incomplete_type() {
     struct Test {
-        std::unique_ptr<std::flat_map<Test, Test>> ptr;
+        unique_ptr<flat_map<Test, Test>> ptr;
     };
 
     Test t;
-    std::flat_map<MyType<Incomplete>, std::shared_ptr<MyType<Incomplete>>> map;
+    flat_map<MyType<Incomplete>, shared_ptr<MyType<Incomplete>>> fmap;
 }
 
 int main() {
     test_construction();
     test_pointer_to_incomplete_type();
-    return 0;
 }

From 00c23249b9580512990722e3a0494fe61866c3fe Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34@live.cn>
Date: Thu, 25 Jan 2024 19:57:28 +0800
Subject: [PATCH 020/134] `<flat_map>`: Fix overloads and complete deduction
 guides and `erase_if`, with cleanups (#4337)

---
 stl/inc/flat_map                          | 1170 +++++++++++++--------
 tests/std/tests/P0429R9_flat_map/test.cpp |   84 +-
 2 files changed, 768 insertions(+), 486 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index facdd5474e5..c73b25e9e1b 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -29,11 +29,11 @@ _STL_DISABLE_CLANG_WARNINGS
 
 _STD_BEGIN
 
-template <class _FlatMap_Key, class _FlatMap_T, class _FlatMap_Compare, class _FlatMap_KeyContainer,
-    class _FlatMap_MappedContainer, bool _Is_Multi, class _Derived>
-    requires same_as<_FlatMap_Key, typename _FlatMap_KeyContainer::value_type>
-          && same_as<_FlatMap_T, typename _FlatMap_MappedContainer::value_type>
-class _Flat_Map_Base;
+template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer, bool _IsMulti,
+    class _Derived>
+    requires same_as<_Key, typename _KeyContainer::value_type>
+          && same_as<_Mapped, typename _MappedContainer::value_type>
+class _Flat_map_base;
 
 template <class _Key, class _Mapped, class _Compare = less<_Key>, class _KeyContainer = vector<_Key>,
     class _MappedContainer = vector<_Mapped>>
@@ -54,33 +54,33 @@ struct sorted_equivalent_t {
 inline constexpr sorted_equivalent_t sorted_equivalent{};
 
 template <class _Alloc, class _Key_container, class _Mapped_container>
-concept _Valid_Allocator_for_flat_map =
+concept _Valid_allocator_for_flat_map =
     uses_allocator_v<_Key_container, _Alloc> && uses_allocator_v<_Mapped_container, _Alloc>;
 
 template <class _Compare, class _Key_container>
-concept _Valid_Compare_for_container = is_invocable_v<const _Compare&, const typename _Key_container::value_type&,
+concept _Valid_compare_for_container = is_invocable_v<const _Compare&, const typename _Key_container::value_type&,
     const typename _Key_container::value_type&>;
 
-template <class _Key, class _T, class _Key_compare>
-struct _Flat_value_compare {
+template <class _Key, class _Mapped, class _KeyCompare>
+struct _Flat_map_value_compare_provider {
     struct value_compare {
     public:
-        bool operator()(pair<const _Key&, const _T&> _X, pair<const _Key&, const _T&> _Y) const {
-            return _Key_compare_for_val(_X.first, _Y.first);
+        bool operator()(pair<const _Key&, const _Mapped&> _Left, pair<const _Key&, const _Mapped&> _Right) const {
+            return _Key_comparator(_Left.first, _Right.first);
         }
 
-        value_compare(_Key_compare _Comp) : _Key_compare_for_val(_Comp) {}
+        value_compare(_KeyCompare _Comp) : _Key_comparator(_Comp) {}
 
     private:
-        _Key_compare _Key_compare_for_val;
+        _KeyCompare _Key_comparator;
     };
 };
 
-template <class _Key_container, class _Mapped_container>
-struct _Flat_Container {
-    struct container {
-        _Key_container keys;
-        _Mapped_container values;
+template <class _KeyContainer, class _MappedContainer>
+struct _Flat_map_container_provider {
+    struct containers {
+        _KeyContainer keys;
+        _MappedContainer values;
     };
 };
 
@@ -98,36 +98,29 @@ struct _NODISCARD _Clear_flat_map_scope_guard {
 
 // Implementation
 
-enum class _Paring_iterator_kind : unsigned char {
-    _Sort,
-    _Mutable,
-    _Const,
-};
-
-template <class _KeyContainer, class _MappedContainer, _Paring_iterator_kind _Kind>
-struct _Paring_iterator_provider {
-    using _Key_iterator_t    = conditional_t<_Kind == _Paring_iterator_kind::_Sort, typename _KeyContainer::iterator,
-        typename _KeyContainer::const_iterator>;
-    using _Mapped_iterator_t = conditional_t<_Kind == _Paring_iterator_kind::_Const,
-        typename _MappedContainer::const_iterator, typename _MappedContainer::iterator>;
-
+template <class _KeyIter, class _MappedIter, class _MappedConvIter>
+struct _Pairing_iterator_provider {
     class _Iterator {
     public:
-        template <class _FlatMap_Key, class _FlatMap_T, class _FlatMap_Compare, class _FlatMap_KeyContainer,
-            class _FlatMap_MappedContainer, bool _Is_Multi, class _Derived>
-            requires same_as<_FlatMap_Key, typename _FlatMap_KeyContainer::value_type>
-                  && same_as<_FlatMap_T, typename _FlatMap_MappedContainer::value_type>
-        friend class _Flat_Map_Base;
+        template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer, bool _IsMulti,
+            class _Derived>
+            requires same_as<_Key, typename _KeyContainer::value_type>
+                  && same_as<_Mapped, typename _MappedContainer::value_type>
+        friend class _Flat_map_base;
+
         _Iterator() = default;
-        _Iterator(_Key_iterator_t _Key_it, _Mapped_iterator_t _Mapped_it) : _Key_it(_Key_it), _Mapped_it(_Mapped_it) {}
+        _Iterator(_KeyIter _Key_iter, _MappedIter _Mapped_iter) : _Key_it(_Key_iter), _Mapped_it(_Mapped_iter) {}
 
         using iterator_category = input_iterator_tag;
         using iterator_concept  = random_access_iterator_tag;
         using difference_type   = ptrdiff_t;
-        using value_type        = pair<iter_value_t<_Key_iterator_t>, iter_value_t<_Mapped_iterator_t>>;
-        using reference         = pair<iter_reference_t<_Key_iterator_t>, iter_reference_t<_Mapped_iterator_t>>;
+        using value_type        = pair<iter_value_t<_KeyIter>, iter_value_t<_MappedIter>>;
+        using reference         = pair<iter_reference_t<_KeyIter>, iter_reference_t<_MappedIter>>;
 
     private:
+        using _Const_iterator =
+            typename _Pairing_iterator_provider<_KeyIter, _MappedConvIter, _MappedConvIter>::_Iterator;
+
         class _Arrow_proxy {
         public:
             explicit _Arrow_proxy(const reference& _Rx) noexcept : _Ref{_Rx} {}
@@ -219,218 +212,218 @@ struct _Paring_iterator_provider {
             return _Right + _Off;
         }
 
-        operator typename _Paring_iterator_provider<_KeyContainer, _MappedContainer,
-            _Paring_iterator_kind::_Const>::_Iterator() const
-            requires (_Kind == _Paring_iterator_kind::_Mutable)
+        operator _Const_iterator() const
+            requires (!is_same_v<_MappedIter, _MappedConvIter>)
         {
-            return typename _Paring_iterator_provider<_KeyContainer, _MappedContainer,
-                _Paring_iterator_kind::_Const>::_Iterator{_Key_it, _Mapped_it};
+            return _Const_iterator{_Key_it, _Mapped_it};
         }
 
     private:
-        _Key_iterator_t _Key_it;
-        _Mapped_iterator_t _Mapped_it;
+        _KeyIter _Key_it;
+        _MappedIter _Mapped_it;
     };
 
     _STL_INTERNAL_STATIC_ASSERT(swappable<_Iterator>);
 };
 
 _EXPORT_STD
-template <class _FlatMap_Key, class _FlatMap_T, class _FlatMap_Compare, class _FlatMap_KeyContainer,
-    class _FlatMap_MappedContainer, bool _Is_Multi, class _Derived>
-    requires same_as<_FlatMap_Key, typename _FlatMap_KeyContainer::value_type>
-          && same_as<_FlatMap_T, typename _FlatMap_MappedContainer::value_type>
-class _Flat_Map_Base {
+template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer, bool _IsMulti,
+    class _Derived>
+    requires same_as<_Key, typename _KeyContainer::value_type>
+          && same_as<_Mapped, typename _MappedContainer::value_type>
+class _Flat_map_base {
 private:
-    using _Sorted_t = conditional_t<_Is_Multi, sorted_equivalent_t, sorted_unique_t>;
+    using _Sorted_t = conditional_t<_IsMulti, sorted_equivalent_t, sorted_unique_t>;
 
 public:
-    using key_type              = _FlatMap_Key;
-    using mapped_type           = _FlatMap_T;
-    using value_type            = pair<key_type, mapped_type>;
-    using key_compare           = _FlatMap_Compare;
-    using reference             = pair<const key_type&, mapped_type&>;
-    using const_reference       = pair<const key_type&, const mapped_type&>;
-    using size_type             = size_t;
-    using difference_type       = ptrdiff_t;
-    using key_container_type    = _FlatMap_KeyContainer;
-    using mapped_container_type = _FlatMap_MappedContainer;
-    using iterator              = _Paring_iterator_provider<key_container_type, mapped_container_type,
-        _Paring_iterator_kind::_Mutable>::_Iterator;
-    using const_iterator =
-        _Paring_iterator_provider<key_container_type, mapped_container_type, _Paring_iterator_kind::_Const>::_Iterator;
+    using key_type               = _Key;
+    using mapped_type            = _Mapped;
+    using value_type             = pair<key_type, mapped_type>;
+    using key_compare            = _Compare;
+    using reference              = pair<const key_type&, mapped_type&>;
+    using const_reference        = pair<const key_type&, const mapped_type&>;
+    using size_type              = size_t;
+    using difference_type        = ptrdiff_t;
+    using key_container_type     = _KeyContainer;
+    using mapped_container_type  = _MappedContainer;
+    using iterator               = _Pairing_iterator_provider<typename key_container_type::const_iterator,
+        typename mapped_container_type::iterator, typename mapped_container_type::const_iterator>::_Iterator;
+    using const_iterator         = _Pairing_iterator_provider<typename key_container_type::const_iterator,
+        typename mapped_container_type::const_iterator, typename mapped_container_type::const_iterator>::_Iterator;
     using reverse_iterator       = _STD reverse_iterator<iterator>;
     using const_reverse_iterator = _STD reverse_iterator<const_iterator>;
 
     _STL_INTERNAL_STATIC_ASSERT(random_access_iterator<iterator>);
     _STL_INTERNAL_STATIC_ASSERT(convertible_to<iterator, const_iterator>);
 
-    using value_compare = _Flat_value_compare<key_type, mapped_type, key_compare>::value_compare;
-    using containers    = _Flat_Container<key_container_type, mapped_container_type>::container;
+    using value_compare = _Flat_map_value_compare_provider<key_type, mapped_type, key_compare>::value_compare;
+    using containers    = _Flat_map_container_provider<key_container_type, mapped_container_type>::containers;
 
 public:
     // [flat.map.cons] Constructors
-    explicit _Flat_Map_Base(const key_compare& _Comp) : _Key_compare(_Comp), _Data() {}
-    _Flat_Map_Base() : _Flat_Map_Base(key_compare()) {}
+    explicit _Flat_map_base(const key_compare& _Comp) : _Key_compare(_Comp), _Data() {}
+    _Flat_map_base() : _Flat_map_base(key_compare()) {}
 
-    template <_Valid_Allocator_for_flat_map<key_container_type, mapped_container_type> Allocator>
-    explicit _Flat_Map_Base(const Allocator& _Alloc) : _Flat_Map_Base(key_compare(), _Alloc) {}
+    template <_Valid_allocator_for_flat_map<key_container_type, mapped_container_type> _Allocator>
+    explicit _Flat_map_base(const _Allocator& _Alloc) : _Flat_map_base(key_compare(), _Alloc) {}
 
-    template <_Valid_Allocator_for_flat_map<key_container_type, mapped_container_type> Allocator>
-    explicit _Flat_Map_Base(const key_compare& _Comp, const Allocator& _Alloc)
+    template <_Valid_allocator_for_flat_map<key_container_type, mapped_container_type> _Allocator>
+    explicit _Flat_map_base(const key_compare& _Comp, const _Allocator& _Alloc)
         : _Key_compare(_Comp), _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Alloc),
                                    .values = _STD make_obj_using_allocator<mapped_container_type>(_Alloc)} {}
 
-    _Flat_Map_Base(
+    _Flat_map_base(
         key_container_type _Key_cont, mapped_container_type _Mapped_cont, const key_compare& _Comp = key_compare())
-        : _Flat_Map_Base(_Sorted_t(), _Key_cont, _Mapped_cont, _Comp) {
+        : _Flat_map_base(_Sorted_t(), _Key_cont, _Mapped_cont, _Comp) {
         _Sort();
-        if constexpr (!_Is_Multi) {
+        if constexpr (!_IsMulti) {
             _Dedup();
         }
     }
 
-    template <_Valid_Allocator_for_flat_map<key_container_type, mapped_container_type> Allocator>
-    _Flat_Map_Base(
-        const key_container_type& _Key_cont, const mapped_container_type& _Mapped_cont, const Allocator& _Alloc)
-        : _Flat_Map_Base(_Sorted_t(), _Key_cont, _Mapped_cont, _Alloc) {
+    template <_Valid_allocator_for_flat_map<key_container_type, mapped_container_type> _Allocator>
+    _Flat_map_base(
+        const key_container_type& _Key_cont, const mapped_container_type& _Mapped_cont, const _Allocator& _Alloc)
+        : _Flat_map_base(_Sorted_t(), _Key_cont, _Mapped_cont, _Alloc) {
         _Sort();
-        if constexpr (!_Is_Multi) {
+        if constexpr (!_IsMulti) {
             _Dedup();
         }
     }
 
-    template <_Valid_Allocator_for_flat_map<key_container_type, mapped_container_type> Allocator>
-    _Flat_Map_Base(const key_container_type& _Key_cont, const mapped_container_type& _Mapped_cont,
-        const key_compare& _Comp, const Allocator& _Alloc)
-        : _Flat_Map_Base(_Sorted_t(), _Key_cont, _Mapped_cont, _Comp, _Alloc) {
+    template <_Valid_allocator_for_flat_map<key_container_type, mapped_container_type> _Allocator>
+    _Flat_map_base(const key_container_type& _Key_cont, const mapped_container_type& _Mapped_cont,
+        const key_compare& _Comp, const _Allocator& _Alloc)
+        : _Flat_map_base(_Sorted_t(), _Key_cont, _Mapped_cont, _Comp, _Alloc) {
         _Sort();
-        if constexpr (!_Is_Multi) {
+        if constexpr (!_IsMulti) {
             _Dedup();
         }
     }
 
-    _Flat_Map_Base(_Sorted_t, key_container_type _Key_cont, mapped_container_type _Mapped_cont,
+    _Flat_map_base(_Sorted_t, key_container_type _Key_cont, mapped_container_type _Mapped_cont,
         const key_compare& _Comp = key_compare())
         : _Key_compare(_Comp), _Data{.keys = _STD move(_Key_cont), .values = _STD move(_Mapped_cont)} {}
 
-    template <_Valid_Allocator_for_flat_map<key_container_type, mapped_container_type> Allocator>
-    _Flat_Map_Base(_Sorted_t, const key_container_type& _Key_cont, const mapped_container_type& _Mapped_cont,
-        const Allocator& _Alloc)
+    template <_Valid_allocator_for_flat_map<key_container_type, mapped_container_type> _Allocator>
+    _Flat_map_base(_Sorted_t, const key_container_type& _Key_cont, const mapped_container_type& _Mapped_cont,
+        const _Allocator& _Alloc)
         : _Key_compare(key_compare()),
           _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Alloc, _Key_cont),
               .values = _STD make_obj_using_allocator<mapped_container_type>(_Alloc, _Mapped_cont)} {}
 
-    template <_Valid_Allocator_for_flat_map<key_container_type, mapped_container_type> Allocator>
-    _Flat_Map_Base(_Sorted_t, const key_container_type& _Key_cont, const mapped_container_type& _Mapped_cont,
-        const key_compare& _Comp, const Allocator& _Alloc)
+    template <_Valid_allocator_for_flat_map<key_container_type, mapped_container_type> _Allocator>
+    _Flat_map_base(_Sorted_t, const key_container_type& _Key_cont, const mapped_container_type& _Mapped_cont,
+        const key_compare& _Comp, const _Allocator& _Alloc)
         : _Key_compare(_Comp),
           _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Alloc, _Key_cont),
               .values = _STD make_obj_using_allocator<mapped_container_type>(_Alloc, _Mapped_cont)} {}
 
     template <class _InputIterator>
         requires _Is_iterator_v<_InputIterator>
-    _Flat_Map_Base(_InputIterator _First, _InputIterator _Last, const key_compare& _Comp = key_compare())
-        : _Flat_Map_Base(_Comp) {
+    _Flat_map_base(_InputIterator _First, _InputIterator _Last, const key_compare& _Comp = key_compare())
+        : _Flat_map_base(_Comp) {
         insert(_First, _Last);
     }
 
-    template <class _InputIterator, _Valid_Allocator_for_flat_map<key_container_type, mapped_container_type> Allocator>
+    template <class _InputIterator, _Valid_allocator_for_flat_map<key_container_type, mapped_container_type> _Allocator>
         requires _Is_iterator_v<_InputIterator>
-    _Flat_Map_Base(_InputIterator _First, _InputIterator _Last, const key_compare& _Comp, const Allocator& _Alloc)
-        : _Flat_Map_Base(_Comp, _Alloc) {
+    _Flat_map_base(_InputIterator _First, _InputIterator _Last, const key_compare& _Comp, const _Allocator& _Alloc)
+        : _Flat_map_base(_Comp, _Alloc) {
         insert(_First, _Last);
     }
 
-    template <_Container_compatible_range<value_type> R>
-    _Flat_Map_Base(from_range_t _From_range, R&& _Range)
-        : _Flat_Map_Base(_From_range, _STD forward<R>(_Range), key_compare()) {}
+    template <_Container_compatible_range<value_type> _Rng>
+    _Flat_map_base(from_range_t _From_range, _Rng&& _Range)
+        : _Flat_map_base(_From_range, _STD forward<_Rng>(_Range), key_compare()) {}
 
-    template <_Container_compatible_range<value_type> R,
-        _Valid_Allocator_for_flat_map<key_container_type, mapped_container_type> Allocator>
-    _Flat_Map_Base(from_range_t _From_range, R&& _Range, const Allocator& _Alloc)
-        : _Flat_Map_Base(_From_range, _STD forward<R>(_Range), key_compare(), _Alloc) {}
+    template <_Container_compatible_range<value_type> _Rng,
+        _Valid_allocator_for_flat_map<key_container_type, mapped_container_type> _Allocator>
+    _Flat_map_base(from_range_t _From_range, _Rng&& _Range, const _Allocator& _Alloc)
+        : _Flat_map_base(_From_range, _STD forward<_Rng>(_Range), key_compare(), _Alloc) {}
 
-    template <_Container_compatible_range<value_type> R>
-    _Flat_Map_Base(from_range_t, R&& _Range, const key_compare& _Comp) : _Flat_Map_Base(_Comp) {
-        insert_range(_STD forward<R>(_Range));
+    template <_Container_compatible_range<value_type> _Rng>
+    _Flat_map_base(from_range_t, _Rng&& _Range, const key_compare& _Comp) : _Flat_map_base(_Comp) {
+        insert_range(_STD forward<_Rng>(_Range));
     }
 
-    template <_Container_compatible_range<value_type> R,
-        _Valid_Allocator_for_flat_map<key_container_type, mapped_container_type> Allocator>
-    _Flat_Map_Base(from_range_t, R&& _Range, const key_compare& _Comp, const Allocator& _Alloc)
-        : _Flat_Map_Base(_Comp, _Alloc) {
-        insert_range(_STD forward<R>(_Range));
+    template <_Container_compatible_range<value_type> _Rng,
+        _Valid_allocator_for_flat_map<key_container_type, mapped_container_type> _Allocator>
+    _Flat_map_base(from_range_t, _Rng&& _Range, const key_compare& _Comp, const _Allocator& _Alloc)
+        : _Flat_map_base(_Comp, _Alloc) {
+        insert_range(_STD forward<_Rng>(_Range));
     }
 
     template <class _InputIterator>
         requires _Is_iterator_v<_InputIterator>
-    _Flat_Map_Base(_Sorted_t _S, _InputIterator _First, _InputIterator _Last, const key_compare& _Comp = key_compare())
-        : _Flat_Map_Base(_Comp) {
-        insert(_S, _First, _Last);
+    _Flat_map_base(
+        _Sorted_t _Tag, _InputIterator _First, _InputIterator _Last, const key_compare& _Comp = key_compare())
+        : _Flat_map_base(_Comp) {
+        insert(_Tag, _First, _Last);
     }
 
-    template <class _InputIterator, _Valid_Allocator_for_flat_map<key_container_type, mapped_container_type> Allocator>
+    template <class _InputIterator, _Valid_allocator_for_flat_map<key_container_type, mapped_container_type> _Allocator>
         requires _Is_iterator_v<_InputIterator>
-    _Flat_Map_Base(
-        _Sorted_t _S, _InputIterator _First, _InputIterator _Last, const key_compare& _Comp, const Allocator& _Alloc)
-        : _Flat_Map_Base(_Comp, _Alloc) {
-        insert(_S, _First, _Last);
+    _Flat_map_base(
+        _Sorted_t _Tag, _InputIterator _First, _InputIterator _Last, const key_compare& _Comp, const _Allocator& _Alloc)
+        : _Flat_map_base(_Comp, _Alloc) {
+        insert(_Tag, _First, _Last);
     }
 
-    template <class _InputIterator, _Valid_Allocator_for_flat_map<key_container_type, mapped_container_type> Allocator>
+    template <class _InputIterator, _Valid_allocator_for_flat_map<key_container_type, mapped_container_type> _Allocator>
         requires _Is_iterator_v<_InputIterator>
-    _Flat_Map_Base(_Sorted_t _S, _InputIterator _First, _InputIterator _Last, const Allocator& _Alloc)
-        : _Flat_Map_Base(_S, _First, _Last, key_compare(), _Alloc) {}
+    _Flat_map_base(_Sorted_t _Tag, _InputIterator _First, _InputIterator _Last, const _Allocator& _Alloc)
+        : _Flat_map_base(_Tag, _First, _Last, key_compare(), _Alloc) {}
 
-    _Flat_Map_Base(initializer_list<value_type> _I, const key_compare& _Comp = key_compare())
-        : _Flat_Map_Base(_I.begin(), _I.end(), _Comp) {}
+    _Flat_map_base(initializer_list<value_type> _Ilist, const key_compare& _Comp = key_compare())
+        : _Flat_map_base(_Ilist.begin(), _Ilist.end(), _Comp) {}
 
-    template <_Valid_Allocator_for_flat_map<key_container_type, mapped_container_type> Allocator>
-    _Flat_Map_Base(initializer_list<value_type> _I, const key_compare& _Comp, const Allocator& _Alloc)
-        : _Flat_Map_Base(_I.begin(), _I.end(), _Comp, _Alloc) {}
+    template <_Valid_allocator_for_flat_map<key_container_type, mapped_container_type> _Allocator>
+    _Flat_map_base(initializer_list<value_type> _Ilist, const key_compare& _Comp, const _Allocator& _Alloc)
+        : _Flat_map_base(_Ilist.begin(), _Ilist.end(), _Comp, _Alloc) {}
 
-    template <_Valid_Allocator_for_flat_map<key_container_type, mapped_container_type> Allocator>
-    _Flat_Map_Base(initializer_list<value_type> _I, const Allocator& _Alloc)
-        : _Flat_Map_Base(_I, key_compare(), _Alloc) {}
+    template <_Valid_allocator_for_flat_map<key_container_type, mapped_container_type> _Allocator>
+    _Flat_map_base(initializer_list<value_type> _Ilist, const _Allocator& _Alloc)
+        : _Flat_map_base(_Ilist, key_compare(), _Alloc) {}
 
-    _Flat_Map_Base(_Sorted_t _S, initializer_list<value_type> _I, const key_compare& _Comp = key_compare())
-        : _Flat_Map_Base(_S, _I.begin(), _I.end(), _Comp) {}
+    _Flat_map_base(_Sorted_t _Tag, initializer_list<value_type> _Ilist, const key_compare& _Comp = key_compare())
+        : _Flat_map_base(_Tag, _Ilist.begin(), _Ilist.end(), _Comp) {}
 
-    template <_Valid_Allocator_for_flat_map<key_container_type, mapped_container_type> Allocator>
-    _Flat_Map_Base(_Sorted_t _S, initializer_list<value_type> _I, const key_compare& _Comp, const Allocator& _Alloc)
-        : _Flat_Map_Base(_S, _I.begin(), _I.end(), _Comp, _Alloc) {}
+    template <_Valid_allocator_for_flat_map<key_container_type, mapped_container_type> _Allocator>
+    _Flat_map_base(
+        _Sorted_t _Tag, initializer_list<value_type> _Ilist, const key_compare& _Comp, const _Allocator& _Alloc)
+        : _Flat_map_base(_Tag, _Ilist.begin(), _Ilist.end(), _Comp, _Alloc) {}
 
-    template <_Valid_Allocator_for_flat_map<key_container_type, mapped_container_type> Allocator>
-    _Flat_Map_Base(_Sorted_t _S, initializer_list<value_type> _I, const Allocator& _Alloc)
-        : _Flat_Map_Base(_S, _I, key_compare(), _Alloc) {}
+    template <_Valid_allocator_for_flat_map<key_container_type, mapped_container_type> _Allocator>
+    _Flat_map_base(_Sorted_t _Tag, initializer_list<value_type> _Ilist, const _Allocator& _Alloc)
+        : _Flat_map_base(_Tag, _Ilist, key_compare(), _Alloc) {}
 
     // Copy constructors
-    _Flat_Map_Base(const _Derived& _Other) : _Key_compare(_Other._Key_compare), _Data(_Other._Data) {}
+    _Flat_map_base(const _Derived& _Other) : _Key_compare(_Other._Key_compare), _Data(_Other._Data) {}
 
-    template <_Valid_Allocator_for_flat_map<key_container_type, mapped_container_type> _Allocator>
-    _Flat_Map_Base(const _Derived& _Other, const _Allocator& _Alloc)
+    template <_Valid_allocator_for_flat_map<key_container_type, mapped_container_type> _Allocator>
+    _Flat_map_base(const _Derived& _Other, const _Allocator& _Alloc)
         : _Key_compare(_Other._Key_compare),
           _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Alloc, _Other._Data.keys),
               .values = _STD make_obj_using_allocator<mapped_container_type>(_Alloc, _Other._Data.values)} {}
 
     // Move constructors
-    _Flat_Map_Base(_Derived&& _Other) noexcept(is_nothrow_move_constructible_v<key_compare>
+    _Flat_map_base(_Derived&& _Other) noexcept(is_nothrow_move_constructible_v<key_compare>
                                                && is_nothrow_move_constructible_v<key_container_type>
                                                && is_nothrow_move_constructible_v<mapped_container_type>)
         : _Key_compare(move(_Other._Key_compare)), _Data(move(_Other).extract()) {}
 
-    template <_Valid_Allocator_for_flat_map<key_container_type, mapped_container_type> _Allocator>
-    _Flat_Map_Base(_Derived&& _Other, const _Allocator& _Alloc) noexcept(
+    template <_Valid_allocator_for_flat_map<key_container_type, mapped_container_type> _Allocator>
+    _Flat_map_base(_Derived&& _Other, const _Allocator& _Alloc) noexcept(
         is_nothrow_move_constructible_v<key_compare> && is_nothrow_move_constructible_v<key_container_type>
         && is_nothrow_move_constructible_v<mapped_container_type>)
         : _Key_compare(move(_Other._Key_compare)),
           _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Alloc, move(_Other._Data.keys)),
               .values = _STD make_obj_using_allocator<mapped_container_type>(_Alloc, move(_Other._Data.values))} {}
 
-    _Derived& operator=(initializer_list<value_type> _I) {
+    _Derived& operator=(initializer_list<value_type> _Ilist) {
         clear();
-        insert(_I.begin(), _I.end());
+        insert(_Ilist.begin(), _Ilist.end());
         return static_cast<_Derived&>(*this); // Use "deducing this" when it is supported
     }
 
@@ -508,138 +501,52 @@ public:
         return _STD min(_Data.keys.max_size(), _Data.values.max_size());
     }
 
-    // [flat.map.access] Access
-    template <class _K>
-    _NODISCARD mapped_type& operator[](_K&& _Key_val)
-        requires same_as<remove_cvref_t<_K>, key_type>
-              || (_Is_transparent_v<key_compare> && constructible_from<key_type, _K &&>)
+    template <class... _ArgTypes>
+    iterator emplace_hint(const_iterator _Position, _ArgTypes&&... _Args)
+        requires is_constructible_v<value_type, _ArgTypes...>
     {
-        return try_emplace(_STD forward<_K>(_Key_val)).first->second;
+        value_type _Val(_STD forward<_ArgTypes>(_Args)...);
+        return _Emplace_hint<false>(_Position, _STD move(_Val.first), _STD move(_Val.second));
     }
 
-    _NODISCARD mapped_type& at(const key_type& _Key_val) {
-        return _At(_Key_val);
+    iterator insert(const_iterator _Position, const value_type& _Pair_val) {
+        return emplace_hint(_Position, _Pair_val);
     }
 
-    template <class _K>
-    _NODISCARD const mapped_type& at(const _K& _Key_val) const
-        requires _Is_transparent_v<key_compare>
-    {
-        return _At(_Key_val);
+    iterator insert(const_iterator _Position, value_type&& _Pair_val) {
+        return emplace_hint(_Position, _STD move(_Pair_val));
     }
 
-    // [flat.map.modifiers] Modifiers
-    template <class... _Args_t>
-    pair<iterator, bool> emplace(_Args_t&&... _Args)
-        requires is_constructible_v<value_type, _Args_t...>
+    template <class _PairValTy>
+    iterator insert(const_iterator _Position, _PairValTy&& _Pair_val)
+        requires is_constructible_v<value_type, _PairValTy>
     {
-        value_type _Val(_STD forward<_Args_t>(_Args)...);
-        return try_emplace(_STD move(_Val.first), _STD move(_Val.second));
-    }
-
-    template <class... _Args_t>
-    iterator emplace_hint(const_iterator _Position, _Args_t&&... _Args)
-        requires is_constructible_v<value_type, _Args_t...>
-    {
-        value_type _Val(_STD forward<_Args_t>(_Args)...);
-
-        return _Emplace_hint<false, false>(_Position, _STD move(_Val.first), _STD move(_Val.second));
-    }
-
-    template <class _V>
-    pair<iterator, bool> insert(_V&& _X)
-        requires (same_as<remove_cvref_t<_V &&>, value_type> || constructible_from<value_type, _V &&>)
-    {
-        return emplace(_STD forward<_V>(_X));
-    }
-
-    template <class _V>
-    iterator insert(const_iterator _Position, _V&& _X)
-        requires (same_as<remove_cvref_t<_V &&>, value_type> || constructible_from<value_type, _V &&>)
-    {
-        return emplace_hint(_Position, _STD forward<_V>(_X));
+        return emplace_hint(_Position, _STD forward<_PairValTy>(_Pair_val));
     }
 
     template <class _InputIterator>
         requires _Is_iterator_v<_InputIterator>
     void insert(_InputIterator _First, _InputIterator _Last) {
-        _Insert_range<true, !_Is_Multi>(_First, _Last);
+        _Insert_range<true, !_IsMulti>(_First, _Last);
     }
 
     template <class _InputIterator>
         requires _Is_iterator_v<_InputIterator>
     void insert(_Sorted_t, _InputIterator _First, _InputIterator _Last) {
-        _Insert_range<false, !_Is_Multi>(_First, _Last);
+        _Insert_range<false, !_IsMulti>(_First, _Last);
     }
 
-    template <_Container_compatible_range<value_type> R>
-    void insert_range(R&& _Range) {
+    template <_Container_compatible_range<value_type> _Rng>
+    void insert_range(_Rng&& _Range) {
         insert(_RANGES begin(_Range), _RANGES end(_Range));
     }
 
-    void insert(initializer_list<value_type> _I) {
-        insert(_I.begin(), _I.end());
-    }
-
-    void insert(_Sorted_t _S, initializer_list<value_type> _I) {
-        insert(_S, _I.begin(), _I.end());
-    }
-
-    template <class _Key_constructible_t, class... _Args_t>
-    pair<iterator, bool> try_emplace(_Key_constructible_t&& _Key_constructible, _Args_t&&... _Args)
-        requires constructible_from<mapped_type, _Args_t&&...>
-              && (same_as<remove_cvref_t<_Key_constructible_t &&>, key_type>
-                  || (constructible_from<key_type, _Key_constructible_t &&> && _Is_transparent_v<key_compare>
-                      && !convertible_to<_Key_constructible_t &&, const_iterator>
-                      && !convertible_to<_Key_constructible_t &&, iterator>) )
-    {
-        auto _Key_It = _STD lower_bound(_Data.keys.begin(), _Data.keys.end(), _Key_constructible, _Key_compare);
-        if (_Key_It != _Data.keys.end()
-            && _Key_equal(*_Key_It, _STD forward<_Key_constructible_t>(_Key_constructible))) {
-            // Already exists
-            return {begin() + _STD distance(_Data.keys.begin(), _Key_It), false};
-        } else {
-            // Need to insert
-            auto _Index = _STD distance(_Data.keys.begin(), _Key_It);
-            _Insert_exact(cbegin() + _Index, key_type{_STD forward<_Key_constructible_t>(_Key_constructible)},
-                mapped_type{_STD forward<_Args_t>(_Args)...});
-            return {begin() + _Index, true};
-        }
-    }
-
-    template <class _K, class... _Args_t>
-    iterator try_emplace(const_iterator _Position, _K&& _Key_val, _Args_t&&... _Args)
-        requires constructible_from<mapped_type, _Args_t&&...>
-              && (same_as<remove_cvref_t<_K &&>, key_type>
-                  || (constructible_from<key_type, _K &&> && _Is_transparent_v<key_compare>) )
-    {
-        return _Emplace_hint<false, false>(_Position, _STD forward<_K>(_Key_val), _STD forward<_Args_t>(_Args)...);
+    void insert(initializer_list<value_type> _Ilist) {
+        insert(_Ilist.begin(), _Ilist.end());
     }
 
-    template <class _M, class _K>
-    pair<iterator, bool> insert_or_assign(_K&& _Key_val, _M&& _Obj)
-        requires assignable_from<mapped_type&, _M&&> && constructible_from<mapped_type, _M&&>
-              && (same_as<remove_cvref_t<_K &&>, key_type>
-                  || (constructible_from<key_type, _K &&> && _Is_transparent_v<key_compare>) )
-    {
-        auto _Res = try_emplace(_STD forward<_K>(_Key_val), _STD forward<_M>(_Obj));
-        if (_Res.second) {
-            // Insertion took place
-            return _Res;
-        } else {
-            // Already exists
-            *(_Res.first._Mapped_it) = _STD forward<_M>(_Obj);
-            return _Res;
-        }
-    }
-
-    template <class _M, class _K>
-    iterator insert_or_assign(const_iterator _Position, _K&& _Key_val, _M&& _Obj)
-        requires assignable_from<mapped_type&, _M&&> && constructible_from<mapped_type, _M&&>
-              && (same_as<remove_cvref_t<_K &&>, key_type>
-                  || (constructible_from<key_type, _K &&> && _Is_transparent_v<key_compare>) )
-    {
-        return _Emplace_hint<false, true>(_Position, _STD forward<_K>(_Key_val), _STD forward<_M>(_Obj));
+    void insert(_Sorted_t _Tag, initializer_list<value_type> _Ilist) {
+        insert(_Tag, _Ilist.begin(), _Ilist.end());
     }
 
     iterator erase(iterator _Position) {
@@ -662,17 +569,15 @@ public:
         return iterator{_STD move(_Key_it), _STD move(_Val_it)};
     }
 
-    template <class _K>
-    size_type erase(_K&& _Key_val)
-        requires convertible_to<_K&&, const key_type&>
-              || (_Is_transparent_v<key_compare> && !convertible_to<_K &&, iterator>
-                  && !convertible_to<_K &&, const_iterator>)
-    {
-        const_iterator _Pos_begin = lower_bound(_STD forward<_K>(_Key_val));
-        const_iterator _Pos_end   = upper_bound(_STD forward<_K>(_Key_val));
-        size_type _Count          = _Pos_end - _Pos_begin;
-        erase(_Pos_begin, _Pos_end);
-        return _Count;
+    size_type erase(const key_type& _Key_val) {
+        return _Erase_key(_Key_val);
+    }
+
+    template <class _OtherKey>
+        requires _Is_transparent_v<key_compare>
+              && (!is_convertible_v<_OtherKey, iterator>) && (!is_convertible_v<_OtherKey, const_iterator>)
+    size_type erase(_OtherKey&& _Key_val) {
+        return _Erase_key(_STD forward<_OtherKey>(_Key_val));
     }
 
     containers extract() && {
@@ -705,188 +610,209 @@ public:
     }
 
     // map operations
-    iterator find(const key_type& _X) {
-        return _Find(_X);
+    iterator find(const key_type& _Key_val) {
+        return _Find(_Key_val);
     }
 
-    template <class _K>
-    iterator find(const _K& _X)
+    template <class _OtherKey>
+    iterator find(const _OtherKey& _Key_val)
         requires _Is_transparent_v<key_compare>
     {
-        return _Find(_X);
+        return _Find(_Key_val);
     }
 
-    const_iterator find(const key_type& _X) const {
-        return _Find(_X);
+    const_iterator find(const key_type& _Key_val) const {
+        return _Find(_Key_val);
     }
 
-    template <class _K>
-    const_iterator find(const _K& _X) const
+    template <class _OtherKey>
+    const_iterator find(const _OtherKey& _Key_val) const
         requires _Is_transparent_v<key_compare>
     {
-        return _Find(_X);
+        return _Find(_Key_val);
     }
 
-    size_type count(const key_type& _X) const {
-        return _Count(_X);
+    size_type count(const key_type& _Key_val) const {
+        return _Count(_Key_val);
     }
 
-    template <class _K>
-    size_type count(const _K& _X) const
+    template <class _OtherKey>
+    size_type count(const _OtherKey& _Key_val) const
         requires _Is_transparent_v<key_compare>
     {
-        return _Count(_X);
+        return _Count(_Key_val);
     }
 
-    bool contains(const key_type& _X) const {
-        return _Contains(_X);
+    bool contains(const key_type& _Key_val) const {
+        return _Contains(_Key_val);
     }
 
-    template <class _K>
-    bool contains(const _K& _X) const
+    template <class _OtherKey>
+    bool contains(const _OtherKey& _Key_val) const
         requires _Is_transparent_v<key_compare>
     {
-        return _Contains(_X);
+        return _Contains(_Key_val);
     }
 
-    iterator lower_bound(const key_type& _X) {
-        return _Lower_bound(_X);
+    iterator lower_bound(const key_type& _Key_val) {
+        return _Lower_bound(_Key_val);
     }
 
-    template <class _K>
-    iterator lower_bound(const _K& _X)
+    template <class _OtherKey>
+    iterator lower_bound(const _OtherKey& _Key_val)
         requires _Is_transparent_v<key_compare>
     {
-        return _Lower_bound(_X);
+        return _Lower_bound(_Key_val);
     }
 
-    const_iterator lower_bound(const key_type& _X) const {
-        return _Lower_bound(_X);
+    const_iterator lower_bound(const key_type& _Key_val) const {
+        return _Lower_bound(_Key_val);
     }
 
-    template <class _K>
-    const_iterator lower_bound(const _K& _X) const
+    template <class _OtherKey>
+    const_iterator lower_bound(const _OtherKey& _Key_val) const
         requires _Is_transparent_v<key_compare>
     {
-        return _Lower_bound(_X);
+        return _Lower_bound(_Key_val);
     }
 
-    iterator upper_bound(const key_type& _X) {
-        return _Upper_bound(_X);
+    iterator upper_bound(const key_type& _Key_val) {
+        return _Upper_bound(_Key_val);
     }
 
-    template <class _K>
-    iterator upper_bound(const _K& _X)
+    template <class _OtherKey>
+    iterator upper_bound(const _OtherKey& _Key_val)
         requires _Is_transparent_v<key_compare>
     {
-        return _Upper_bound(_X);
+        return _Upper_bound(_Key_val);
     }
 
-    const_iterator upper_bound(const key_type& _X) const {
-        return _Upper_bound(_X);
+    const_iterator upper_bound(const key_type& _Key_val) const {
+        return _Upper_bound(_Key_val);
     }
 
-    template <class _K>
-    const_iterator upper_bound(const _K& _X) const
+    template <class _OtherKey>
+    const_iterator upper_bound(const _OtherKey& _Key_val) const
         requires _Is_transparent_v<key_compare>
     {
-        return _Upper_bound(_X);
+        return _Upper_bound(_Key_val);
     }
 
-    pair<iterator, iterator> equal_range(const key_type& _X) {
-        return _Equal_range(_X);
+    pair<iterator, iterator> equal_range(const key_type& _Key_val) {
+        return _Equal_range(_Key_val);
     }
 
-    template <class _K>
-    pair<iterator, iterator> equal_range(const _K& _X)
+    template <class _OtherKey>
+    pair<iterator, iterator> equal_range(const _OtherKey& _Key_val)
         requires _Is_transparent_v<key_compare>
     {
-        return _Equal_range(_X);
+        return _Equal_range(_Key_val);
     }
 
-    pair<const_iterator, const_iterator> equal_range(const key_type& _X) const {
-        return _Equal_range(_X);
+    pair<const_iterator, const_iterator> equal_range(const key_type& _Key_val) const {
+        return _Equal_range(_Key_val);
     }
 
-    template <class _K>
-    pair<const_iterator, const_iterator> equal_range(const _K& _X) const
+    template <class _OtherKey>
+    pair<const_iterator, const_iterator> equal_range(const _OtherKey& _Key_val) const
         requires _Is_transparent_v<key_compare>
     {
-        return _Equal_range(_X);
+        return _Equal_range(_Key_val);
     }
 
-    friend bool operator==(const _Derived& _X, const _Derived& _Y) {
-        return _RANGES equal(_X._Data.keys, _Y._Data.keys) && _RANGES equal(_X._Data.values, _Y._Data.values);
+    friend bool operator==(const _Derived& _Left, const _Derived& _Right) {
+        return _RANGES equal(_Left._Data.keys, _Right._Data.keys)
+            && _RANGES equal(_Left._Data.values, _Right._Data.values);
     }
 
-    friend auto operator<=>(const _Derived& _X, const _Derived& _Y) {
+    friend auto operator<=>(const _Derived& _Left, const _Derived& _Right) {
         return _STD lexicographical_compare_three_way(
-            _X.cbegin(), _X.cend(), _Y.cbegin(), _Y.cend(), _Synth_three_way{});
+            _Left.cbegin(), _Left.cend(), _Right.cbegin(), _Right.cend(), _Synth_three_way{});
     }
 
-    friend void swap(_Derived& _X, _Derived& _Y) noexcept {
-        _X.swap(_Y);
+    friend void swap(_Derived& _Left, _Derived& _Right) noexcept {
+        _Left.swap(_Right);
     }
 
 
-private:
+protected:
     key_compare _Key_compare;
     containers _Data;
 
-    template <class _K1, class _K2>
-        requires (same_as<remove_cvref_t<_K1 &&>, key_type> && same_as<remove_cvref_t<_K2 &&>, key_type>)
-              || (constructible_from<key_type, _K1 &&> && constructible_from<key_type, _K2 &&>
+    template <class _Predicate>
+    size_type _Erase_if(_Predicate _Pred) {
+        _Clear_flat_map_scope_guard<_Flat_map_base> _Guard{this};
+
+        auto _View           = _View_to_mutate();
+        auto _Mut_first      = _View.begin();
+        auto _Mut_last       = _View.end();
+        const auto _Old_size = size();
+
+        _STD _Seek_wrapped(_Mut_first, _RANGES remove_if(_View, _Pred).begin());
+
+        erase(const_iterator{_Mut_first._Key_it, _Mut_first._Mapped_it},
+            const_iterator{_Mut_last._Key_it, _Mut_last._Mapped_it});
+
+        _Guard._Clearable = nullptr;
+        return _Old_size - size();
+    }
+
+private:
+    template <class _KeyTy1, class _KeyTy2>
+        requires (same_as<remove_cvref_t<_KeyTy1 &&>, key_type> && same_as<remove_cvref_t<_KeyTy2 &&>, key_type>)
+              || (constructible_from<key_type, _KeyTy1 &&> && constructible_from<key_type, _KeyTy2 &&>
                   && _Is_transparent_v<key_compare>)
-    bool _Key_equal(_K1&& _X, _K2&& _Y) const {
-        return !_Key_compare(_STD forward<_K1>(_X), _STD forward<_K2>(_Y))
-            && !_Key_compare(_STD forward<_K2>(_Y), _STD forward<_K1>(_X));
+    bool _Key_equal(_KeyTy1&& _Left, _KeyTy2&& _Right) const {
+        return !_Key_compare(_STD forward<_KeyTy1>(_Left), _STD forward<_KeyTy2>(_Right))
+            && !_Key_compare(_STD forward<_KeyTy2>(_Right), _STD forward<_KeyTy1>(_Left));
     }
 
-    auto _View_to_sort() {
-        using _Sorting_iterator = _Paring_iterator_provider<key_container_type, mapped_container_type,
-            _Paring_iterator_kind::_Sort>::_Iterator;
-        return _RANGES subrange<_Sorting_iterator>{_Sorting_iterator{_Data.keys.begin(), _Data.values.begin()},
-            _Sorting_iterator{_Data.keys.end(), _Data.values.end()}};
+    auto _View_to_mutate() {
+        using _Mutating_iterator = _Pairing_iterator_provider<typename key_container_type::iterator,
+            typename mapped_container_type::iterator, typename mapped_container_type::iterator>::_Iterator;
+        return _RANGES subrange<_Mutating_iterator>{_Mutating_iterator{_Data.keys.begin(), _Data.values.begin()},
+            _Mutating_iterator{_Data.keys.end(), _Data.values.end()}};
     }
 
     void _Sort() {
         _Clear_flat_map_scope_guard _Guard{this};
-        _RANGES sort(_View_to_sort(), value_compare(_Key_compare));
+        _RANGES sort(_View_to_mutate(), value_compare(_Key_compare));
         _Guard._Clearable = nullptr;
     }
 
     void _Dedup() {
         _Clear_flat_map_scope_guard _Guard{this};
-        auto _Sorted_view     = _View_to_sort();
-        auto _Subrange        = _RANGES unique(_Sorted_view,
-                   [this](const_reference _X, const_reference _Y) { return this->_Key_equal(_X.first, _Y.first); });
+        auto _Sorted_view     = _View_to_mutate();
+        auto _Subrange        = _RANGES unique(_Sorted_view, [this](const_reference _Left, const_reference _Right) {
+            return this->_Key_equal(_Left.first, _Right.first);
+        });
         auto _Remaining_count = _STD distance(_Sorted_view.begin(), _Subrange.begin());
         _Data.keys.erase(_Data.keys.begin() + _Remaining_count, _Data.keys.end());
         _Data.values.erase(_Data.values.begin() + _Remaining_count, _Data.values.end());
         _Guard._Clearable = nullptr;
     }
 
-    void _Insert_exact(const_iterator _Position, key_type&& _Key_val, mapped_type&& _Mapped) {
+    void _Insert_exact(const_iterator _Position, key_type&& _Key_val, mapped_type&& _Mapped_val) {
         _Clear_flat_map_scope_guard _Guard{this};
         _Data.keys.insert(_Position._Key_it, _STD move(_Key_val));
-        _Data.values.insert(_Position._Mapped_it, _STD move(_Mapped));
+        _Data.values.insert(_Position._Mapped_it, _STD move(_Mapped_val));
         _Guard._Clearable = nullptr;
     }
 
-    template <bool _Multi, bool _Overwrite_if_exists, class _K, class... _Mapped_args_t>
-    iterator _Emplace_hint(const_iterator _Position, _K&& _Key_val, _Mapped_args_t&&... _Args)
-        requires is_constructible_v<mapped_type, _Mapped_args_t...>
-              && (same_as<remove_cvref_t<_K &&>, key_type>
-                  || (constructible_from<key_type, _K &&> && _Is_transparent_v<key_compare>) )
+    template <bool _OverwriteIfExists, class _OtherKey, class... _MappedArgTypes>
+    iterator _Emplace_hint(const_iterator _Position, _OtherKey&& _Key_val, _MappedArgTypes&&... _Args)
+        requires is_constructible_v<mapped_type, _MappedArgTypes...>
+              && (same_as<remove_cvref_t<_OtherKey &&>, key_type>
+                  || (constructible_from<key_type, _OtherKey &&> && _Is_transparent_v<key_compare>) )
     {
-        static_assert(!(_Multi && _Overwrite_if_exists),
+        static_assert(!(_IsMulti && _OverwriteIfExists),
             "Overwriting is not supported when the container allows multiple copies of a key.");
         const const_iterator _Begin = cbegin();
         const const_iterator _End   = cend();
 
         bool _Insert_before_position        = false;
         bool _Insert_after_position_minus_1 = false;
-        if constexpr (_Multi) {
+        if constexpr (_IsMulti) {
             _Insert_before_position        = (_Position == _End) || !_Key_compare(*(_Position._Key_it), _Key_val);
             _Insert_after_position_minus_1 = (_Position == _Begin) || !_Key_compare(_Key_val, *(_Position._Key_it - 1));
         } else {
@@ -897,29 +823,29 @@ private:
 
         if (_Hint_is_accurate) {
             auto _Dist = _STD distance(_Begin._Key_it, _Position._Key_it);
-            _Insert_exact(
-                _Position, key_type{_STD forward<_K>(_Key_val)}, mapped_type{_STD forward<_Mapped_args_t>(_Args)...});
+            _Insert_exact(_Position, key_type{_STD forward<_OtherKey>(_Key_val)},
+                mapped_type{_STD forward<_MappedArgTypes>(_Args)...});
             return begin() + _Dist;
         } else {
-            if constexpr (_Overwrite_if_exists) {
+            if constexpr (_OverwriteIfExists) {
                 if (_Key_equal(_Key_val, *(_Position._Key_it))) {
                     auto _Dist        = _STD distance(_Begin._Key_it, _Position._Key_it);
                     auto _It          = begin() + _Dist;
-                    *(_It._Mapped_it) = mapped_type{_STD forward<_Mapped_args_t>(_Args)...};
+                    *(_It._Mapped_it) = mapped_type{_STD forward<_MappedArgTypes>(_Args)...};
                     return _It;
                 }
             }
 
             _Position = lower_bound(_Key_val);
-            if (_Overwrite_if_exists && _Position != _End && _Key_equal(_Key_val, *(_Position._Key_it))) {
+            if (_OverwriteIfExists && _Position != _End && _Key_equal(_Key_val, *(_Position._Key_it))) {
                 auto _Dist        = _STD distance(_Begin._Key_it, _Position._Key_it);
                 auto _It          = begin() + _Dist;
-                *(_It._Mapped_it) = mapped_type{_STD forward<_Mapped_args_t>(_Args)...};
+                *(_It._Mapped_it) = mapped_type{_STD forward<_MappedArgTypes>(_Args)...};
                 return _It;
             } else {
                 auto _Dist = _STD distance(_Begin._Key_it, _Position._Key_it);
-                _Insert_exact(_Position, key_type{_STD forward<_K>(_Key_val)},
-                    mapped_type{_STD forward<_Mapped_args_t>(_Args)...});
+                _Insert_exact(_Position, key_type{_STD forward<_OtherKey>(_Key_val)},
+                    mapped_type{_STD forward<_MappedArgTypes>(_Args)...});
                 return begin() + _Dist;
             }
         }
@@ -943,7 +869,7 @@ private:
         }
 
         // Sort the newly inserted elements
-        auto _Sorted_view = _View_to_sort();
+        auto _Sorted_view = _View_to_mutate();
         if constexpr (_NeedSorting) {
             auto _Sorted_new_elements = _Sorted_view;
             _Sorted_new_elements.advance(_OldSize);
@@ -960,210 +886,530 @@ private:
         _Guard._Clearable = nullptr;
     }
 
-    template <class _K>
-    _NODISCARD mapped_type& _At(const _K& _Key_val)
-        requires same_as<_K, key_type> || _Is_transparent_v<key_compare>
-    {
-        iterator _Position = find(_Key_val);
-        if (_Position == end()) {
-            _Xout_of_range("std::flat_map::at: the specified key does not exist.");
-        } else {
-            return _Position->second;
-        }
+    template <class _KeyTy>
+    size_type _Erase_key(_KeyTy&& _Key_val) {
+        const_iterator _Pos_begin = lower_bound(_STD forward<_KeyTy>(_Key_val));
+        const_iterator _Pos_end   = upper_bound(_STD forward<_KeyTy>(_Key_val));
+        size_type _Count          = _Pos_end - _Pos_begin;
+        erase(_Pos_begin, _Pos_end);
+        return _Count;
     }
 
-    template <class _K>
-    iterator _Find(const _K& _X)
-        requires same_as<_K, key_type> || _Is_transparent_v<key_compare>
+    template <class _KeyTy>
+    iterator _Find(const _KeyTy& _Key_val)
+        requires same_as<_KeyTy, key_type> || _Is_transparent_v<key_compare>
     {
-        iterator _Position = lower_bound(_X);
-        if (_Position != end() && _Key_equal(_Position->first, _X)) {
+        iterator _Position = lower_bound(_Key_val);
+        if (_Position != end() && _Key_equal(_Position->first, _Key_val)) {
             return _Position;
         } else {
             return end();
         }
     }
 
-    template <class _K>
-    const_iterator _Find(const _K& _X) const
-        requires same_as<_K, key_type> || _Is_transparent_v<key_compare>
+    template <class _KeyTy>
+    const_iterator _Find(const _KeyTy& _Key_val) const
+        requires same_as<_KeyTy, key_type> || _Is_transparent_v<key_compare>
     {
-        const_iterator _Position = lower_bound(_X);
-        if (_Position != cend() && _Key_equal(_Position->first, _X)) {
+        const_iterator _Position = lower_bound(_Key_val);
+        if (_Position != cend() && _Key_equal(_Position->first, _Key_val)) {
             return _Position;
         } else {
             return cend();
         }
     }
 
-    template <class _K>
-    size_type _Count(const _K& _X) const
-        requires same_as<_K, key_type> || _Is_transparent_v<key_compare>
+    template <class _KeyTy>
+    size_type _Count(const _KeyTy& _Key_val) const
+        requires same_as<_KeyTy, key_type> || _Is_transparent_v<key_compare>
     {
-        return upper_bound(_X) - lower_bound(_X);
+        return upper_bound(_Key_val) - lower_bound(_Key_val);
     }
 
-    template <class _K>
-    bool _Contains(const _K& _X) const
-        requires same_as<_K, key_type> || _Is_transparent_v<key_compare>
+    template <class _KeyTy>
+    bool _Contains(const _KeyTy& _Key_val) const
+        requires same_as<_KeyTy, key_type> || _Is_transparent_v<key_compare>
     {
-        return find(_X) != cend();
+        return find(_Key_val) != cend();
     }
 
-    template <class _K>
-    iterator _Lower_bound(const _K& _X)
-        requires same_as<_K, key_type> || _Is_transparent_v<key_compare>
+    template <class _KeyTy>
+    iterator _Lower_bound(const _KeyTy& _Key_val)
+        requires same_as<_KeyTy, key_type> || _Is_transparent_v<key_compare>
     {
-        auto _Key_it = _STD lower_bound(_Data.keys.cbegin(), _Data.keys.cend(), _X, _Key_compare);
+        auto _Key_it = _STD lower_bound(_Data.keys.cbegin(), _Data.keys.cend(), _Key_val, _Key_compare);
         auto _Dist   = _STD distance(_Data.keys.cbegin(), _Key_it);
         auto _Val_it = _Data.values.begin() + _Dist;
         return iterator{_STD move(_Key_it), _STD move(_Val_it)};
     }
 
-    template <class _K>
-    const_iterator _Lower_bound(const _K& _X) const
-        requires same_as<_K, key_type> || _Is_transparent_v<key_compare>
+    template <class _KeyTy>
+    const_iterator _Lower_bound(const _KeyTy& _Key_val) const
+        requires same_as<_KeyTy, key_type> || _Is_transparent_v<key_compare>
     {
-        auto _Key_it = _STD lower_bound(_Data.keys.cbegin(), _Data.keys.cend(), _X, _Key_compare);
+        auto _Key_it = _STD lower_bound(_Data.keys.cbegin(), _Data.keys.cend(), _Key_val, _Key_compare);
         auto _Dist   = _STD distance(_Data.keys.cbegin(), _Key_it);
         auto _Val_it = _Data.values.cbegin() + _Dist;
         return const_iterator{_STD move(_Key_it), _STD move(_Val_it)};
     }
 
-    template <class _K>
-    iterator _Upper_bound(const _K& _X)
-        requires same_as<_K, key_type> || _Is_transparent_v<key_compare>
+    template <class _KeyTy>
+    iterator _Upper_bound(const _KeyTy& _Key_val)
+        requires same_as<_KeyTy, key_type> || _Is_transparent_v<key_compare>
     {
-        auto _Key_it = _STD upper_bound(_Data.keys.cbegin(), _Data.keys.cend(), _X, _Key_compare);
+        auto _Key_it = _STD upper_bound(_Data.keys.cbegin(), _Data.keys.cend(), _Key_val, _Key_compare);
         auto _Dist   = _STD distance(_Data.keys.cbegin(), _Key_it);
         auto _Val_it = _Data.values.begin() + _Dist;
         return iterator{_STD move(_Key_it), _STD move(_Val_it)};
     }
 
-    template <class _K>
-    const_iterator _Upper_bound(const _K& _X) const
-        requires same_as<_K, key_type> || _Is_transparent_v<key_compare>
+    template <class _KeyTy>
+    const_iterator _Upper_bound(const _KeyTy& _Key_val) const
+        requires same_as<_KeyTy, key_type> || _Is_transparent_v<key_compare>
     {
-        auto _Key_it = _STD upper_bound(_Data.keys.cbegin(), _Data.keys.cend(), _X, _Key_compare);
+        auto _Key_it = _STD upper_bound(_Data.keys.cbegin(), _Data.keys.cend(), _Key_val, _Key_compare);
         auto _Dist   = _STD distance(_Data.keys.cbegin(), _Key_it);
         auto _Val_it = _Data.values.cbegin() + _Dist;
         return const_iterator{_STD move(_Key_it), _STD move(_Val_it)};
     }
 
-    template <class _K>
-    pair<iterator, iterator> _Equal_range(const _K& _X)
-        requires same_as<_K, key_type> || _Is_transparent_v<key_compare>
+    template <class _KeyTy>
+    pair<iterator, iterator> _Equal_range(const _KeyTy& _Key_val)
+        requires same_as<_KeyTy, key_type> || _Is_transparent_v<key_compare>
     {
-        return {lower_bound(_X), upper_bound(_X)};
+        return {lower_bound(_Key_val), upper_bound(_Key_val)};
     }
 
-    template <class _K>
-    pair<const_iterator, const_iterator> _Equal_range(const _K& _X) const
-        requires same_as<_K, key_type> || _Is_transparent_v<key_compare>
+    template <class _KeyTy>
+    pair<const_iterator, const_iterator> _Equal_range(const _KeyTy& _Key_val) const
+        requires same_as<_KeyTy, key_type> || _Is_transparent_v<key_compare>
     {
-        return {lower_bound(_X), upper_bound(_X)};
+        return {lower_bound(_Key_val), upper_bound(_Key_val)};
     }
 };
 
 template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer>
-class flat_map : public _Flat_Map_Base<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer, false,
+class flat_map : public _Flat_map_base<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer, false,
                      flat_map<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>> {
 private:
-    using _MyBase = _Flat_Map_Base<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer, false,
+    using _MyBase = _Flat_map_base<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer, false,
         flat_map<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>>;
 
+    using _MyBase::_Data;
+    using _MyBase::_Key_compare;
+
 public:
+    using typename _MyBase::const_iterator;
+    using typename _MyBase::iterator;
+    using typename _MyBase::key_compare;
+    using typename _MyBase::key_type;
+    using typename _MyBase::mapped_type;
+    using typename _MyBase::value_type;
+
     using _MyBase::_MyBase;
     using _MyBase::operator=;
-};
 
-template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer>
-class flat_multimap : public _Flat_Map_Base<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer, true,
-                          flat_multimap<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>> {
+    // [flat.map.access] Access
+    _NODISCARD mapped_type& operator[](const key_type& _Key_val) {
+        return this->try_emplace(_Key_val).first->second;
+    }
+    _NODISCARD mapped_type& operator[](key_type&& _Key_val) {
+        return this->try_emplace(_STD move(_Key_val)).first->second;
+    }
+
+    template <class _OtherKey>
+    _NODISCARD mapped_type& operator[](_OtherKey&& _Key_val)
+        requires _Is_transparent_v<key_compare>
+    {
+        return this->try_emplace(_STD forward<_OtherKey>(_Key_val)).first->second;
+    }
+
+    _NODISCARD mapped_type& at(const key_type& _Key_val) {
+        return _At(_Key_val);
+    }
+
+    _NODISCARD const mapped_type& at(const key_type& _Key_val) const {
+        return _At(_Key_val);
+    }
+
+    template <class _OtherKey>
+    _NODISCARD mapped_type& at(const _OtherKey& _Key_val)
+        requires _Is_transparent_v<key_compare>
+    {
+        return _At(_Key_val);
+    }
+
+    template <class _OtherKey>
+    _NODISCARD const mapped_type& at(const _OtherKey& _Key_val) const
+        requires _Is_transparent_v<key_compare>
+    {
+        return _At(_Key_val);
+    }
+
+    // [flat.map.modifiers] Modifiers
+    template <class... _ArgTypes>
+    pair<iterator, bool> emplace(_ArgTypes&&... _Args)
+        requires is_constructible_v<value_type, _ArgTypes...>
+    {
+        value_type _Val(_STD forward<_ArgTypes>(_Args)...);
+        return try_emplace(_STD move(_Val.first), _STD move(_Val.second));
+    }
+
+    pair<iterator, bool> insert(const value_type& _Pair_val) {
+        return try_emplace(_Pair_val.first, _Pair_val.second);
+    }
+
+    pair<iterator, bool> insert(value_type&& _Pair_val) {
+        return try_emplace(_STD move(_Pair_val.first), _STD move(_Pair_val.second));
+    }
+
+    template <class _PairValTy>
+    pair<iterator, bool> insert(_PairValTy&& _Pair_val)
+        requires is_constructible_v<value_type, _PairValTy>
+    {
+        return emplace(_STD forward<_PairValTy>(_Pair_val));
+    }
+
+    template <class... _MappedArgTypes>
+        requires is_constructible_v<mapped_type, _MappedArgTypes&&...>
+    pair<iterator, bool> try_emplace(const key_type& _Key_val, _MappedArgTypes&&... _Mapped_args) {
+        return _Try_emplace(_Key_val, _STD forward<_MappedArgTypes>(_Mapped_args)...);
+    }
+
+    template <class... _MappedArgTypes>
+        requires is_constructible_v<mapped_type, _MappedArgTypes&&...>
+    pair<iterator, bool> try_emplace(key_type&& _Key_val, _MappedArgTypes&&... _Mapped_args) {
+        return _Try_emplace(_STD move(_Key_val), _STD forward<_MappedArgTypes>(_Mapped_args)...);
+    }
+
+    template <class _OtherKey, class... _MappedArgTypes>
+        requires _Is_transparent_v<key_compare> && is_constructible_v<key_type, _OtherKey>
+              && is_constructible_v<mapped_type, _MappedArgTypes&&...>
+              && (!is_convertible_v<_OtherKey, const_iterator>) && (!is_convertible_v<_OtherKey, iterator>)
+    pair<iterator, bool> try_emplace(_OtherKey&& _Key_val, _MappedArgTypes&&... _Mapped_args) {
+        return _Try_emplace(_STD forward<_OtherKey>(_Key_val), _STD forward<_MappedArgTypes>(_Mapped_args)...);
+    }
+
+    template <class... _MappedArgTypes>
+    iterator try_emplace(const_iterator _Position, const key_type& _Key_val, _MappedArgTypes&&... _Mapped_args)
+        requires is_constructible_v<mapped_type, _MappedArgTypes&&...>
+    {
+        return this->template _Emplace_hint<false>(_Position, _Key_val, _STD forward<_MappedArgTypes>(_Mapped_args)...);
+    }
+
+    template <class... _MappedArgTypes>
+    iterator try_emplace(const_iterator _Position, key_type&& _Key_val, _MappedArgTypes&&... _Mapped_args)
+        requires is_constructible_v<mapped_type, _MappedArgTypes&&...>
+    {
+        return this->template _Emplace_hint<false>(
+            _Position, _STD move(_Key_val), _STD forward<_MappedArgTypes>(_Mapped_args)...);
+    }
+
+    template <class _OtherKey, class... _MappedArgTypes>
+    iterator try_emplace(const_iterator _Position, _OtherKey&& _Key_val, _MappedArgTypes&&... _Mapped_args)
+        requires _Is_transparent_v<key_compare> && is_constructible_v<key_type, _OtherKey>
+              && is_constructible_v<mapped_type, _MappedArgTypes&&...>
+    {
+        return this->template _Emplace_hint<false>(
+            _Position, _STD forward<_OtherKey>(_Key_val), _STD forward<_MappedArgTypes>(_Mapped_args)...);
+    }
+
+    template <class _MappedTy>
+    pair<iterator, bool> insert_or_assign(const key_type& _Key_val, _MappedTy&& _Mapped_val)
+        requires is_assignable_v<mapped_type&, _MappedTy> && is_constructible_v<mapped_type, _MappedTy>
+    {
+        return _Insert_or_assign(_Key_val, _STD forward<_MappedTy>(_Mapped_val));
+    }
+
+    template <class _MappedTy>
+    pair<iterator, bool> insert_or_assign(key_type&& _Key_val, _MappedTy&& _Mapped_val)
+        requires is_assignable_v<mapped_type&, _MappedTy> && is_constructible_v<mapped_type, _MappedTy>
+    {
+        return _Insert_or_assign(_STD move(_Key_val), _STD forward<_MappedTy>(_Mapped_val));
+    }
+
+    template <class _OtherKey, class _MappedTy>
+    pair<iterator, bool> insert_or_assign(_OtherKey&& _Key_val, _MappedTy&& _Mapped_val)
+        requires _Is_transparent_v<key_compare> && is_constructible_v<key_type, _OtherKey>
+              && is_assignable_v<mapped_type&, _MappedTy> && is_constructible_v<mapped_type, _MappedTy>
+    {
+        return _Insert_or_assign(_STD forward<_OtherKey>(_Key_val), _STD forward<_MappedTy>(_Mapped_val));
+    }
+
+    template <class _MappedTy>
+    iterator insert_or_assign(const_iterator _Position, const key_type& _Key_val, _MappedTy&& _Mapped_val)
+        requires is_assignable_v<mapped_type&, _MappedTy> && is_constructible_v<mapped_type, _MappedTy>
+    {
+        return this->_Emplace_hint<true>(_Position, _Key_val, _STD forward<_MappedTy>(_Mapped_val));
+    }
+
+    template <class _MappedTy>
+    iterator insert_or_assign(const_iterator _Position, key_type&& _Key_val, _MappedTy&& _Mapped_val)
+        requires is_assignable_v<mapped_type&, _MappedTy> && is_constructible_v<mapped_type, _MappedTy>
+    {
+        return this->_Emplace_hint<true>(_Position, _STD move(_Key_val), _STD forward<_MappedTy>(_Mapped_val));
+    }
+
+    template <class _OtherKey, class _MappedTy>
+    iterator insert_or_assign(const_iterator _Position, _OtherKey&& _Key_val, _MappedTy&& _Mapped_val)
+        requires _Is_transparent_v<key_compare> && is_constructible_v<key_type, _OtherKey>
+              && is_assignable_v<mapped_type&, _MappedTy> && is_constructible_v<mapped_type, _MappedTy>
+    {
+        return this->_Emplace_hint<true>(
+            _Position, _STD forward<_OtherKey>(_Key_val), _STD forward<_MappedTy>(_Mapped_val));
+    }
+
 private:
-    using _MyBase = _Flat_Map_Base<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer, true,
-        flat_multimap<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>>;
+    using _MyBase::_Erase_if;
 
-public:
-    using _MyBase::_MyBase;
-    using _MyBase::operator=;
+    template <class _KTy, class _MTy, class _Comp, class _KeyCont, class _MappedCont, class _Pred>
+    friend typename flat_map<_KTy, _MTy, _Comp, _KeyCont, _MappedCont>::size_type erase_if(
+        flat_map<_KTy, _MTy, _Comp, _KeyCont, _MappedCont>&, _Pred);
+
+    template <class _KeyTy>
+    _NODISCARD mapped_type& _At(const _KeyTy& _Key_val)
+        requires same_as<_KeyTy, key_type> || _Is_transparent_v<key_compare>
+    {
+        const auto _Position = this->find(_Key_val);
+        if (_Position == this->end()) {
+            _Xout_of_range("std::flat_map::at: the specified key does not exist.");
+        } else {
+            return _Position->second;
+        }
+    }
+
+    template <class _KeyTy>
+    _NODISCARD const mapped_type& _At(const _KeyTy& _Key_val) const
+        requires same_as<_KeyTy, key_type> || _Is_transparent_v<key_compare>
+    {
+        const auto _Position = this->find(_Key_val);
+        if (_Position == this->end()) {
+            _Xout_of_range("std::flat_map::at: the specified key does not exist.");
+        } else {
+            return _Position->second;
+        }
+    }
+
+    template <class _KeyTy, class... _MappedArgTypes>
+    pair<iterator, bool> _Try_emplace(_KeyTy&& _Key_val, _MappedArgTypes&&... _Mapped_args) {
+        auto _Key_it = _STD lower_bound(_Data.keys.begin(), _Data.keys.end(), _Key_val, _Key_compare);
+        if (_Key_it != _Data.keys.end() && _Key_equal(*_Key_it, _STD forward<_KeyTy>(_Key_val))) {
+            // Already exists
+            return {this->begin() + _STD distance(_Data.keys.begin(), _Key_it), false};
+        } else {
+            // Need to insert
+            auto _Index = _STD distance(_Data.keys.begin(), _Key_it);
+            this->_Insert_exact(this->cbegin() + _Index, key_type{_STD forward<_KeyTy>(_Key_val)},
+                mapped_type{_STD forward<_MappedArgTypes>(_Mapped_args)...});
+            return {this->begin() + _Index, true};
+        }
+    }
+
+    template <class _KeyTy, class _MappedTy>
+    pair<iterator, bool> _Insert_or_assign(_KeyTy&& _Key_val, _MappedTy&& _Mapped_val) {
+        auto _Res = _Try_emplace(_STD forward<_KeyTy>(_Key_val), _STD forward<_MappedTy>(_Mapped_val));
+        if (!_Res.second) { // Already exists
+            _Res.first->second = _STD forward<_MappedTy>(_Mapped_val);
+        }
+        return _Res;
+    }
 };
 
 template <class _KeyContainer, class _MappedContainer,
-    _Valid_Compare_for_container<_KeyContainer> _Compare = less<typename _KeyContainer::value_type>>
+    _Valid_compare_for_container<_KeyContainer> _Compare = less<typename _KeyContainer::value_type>>
 flat_map(_KeyContainer, _MappedContainer, _Compare = _Compare()) -> flat_map<typename _KeyContainer::value_type,
     typename _MappedContainer::value_type, _Compare, _KeyContainer, _MappedContainer>;
 
 template <class _KeyContainer, class _MappedContainer,
-    _Valid_Allocator_for_flat_map<_KeyContainer, _MappedContainer> _Allocator>
+    _Valid_allocator_for_flat_map<_KeyContainer, _MappedContainer> _Allocator>
 flat_map(_KeyContainer, _MappedContainer, _Allocator) -> flat_map<typename _KeyContainer::value_type,
     typename _MappedContainer::value_type, less<typename _KeyContainer::value_type>, _KeyContainer, _MappedContainer>;
 
-template <class _KeyContainer, class _MappedContainer, _Valid_Compare_for_container<_KeyContainer> _Compare,
-    _Valid_Allocator_for_flat_map<_KeyContainer, _MappedContainer> _Allocator>
+template <class _KeyContainer, class _MappedContainer, _Valid_compare_for_container<_KeyContainer> _Compare,
+    _Valid_allocator_for_flat_map<_KeyContainer, _MappedContainer> _Allocator>
 flat_map(_KeyContainer, _MappedContainer, _Compare, _Allocator) -> flat_map<typename _KeyContainer::value_type,
     typename _MappedContainer::value_type, _Compare, _KeyContainer, _MappedContainer>;
 
 template <class _KeyContainer, class _MappedContainer,
-    _Valid_Compare_for_container<_KeyContainer> _Compare = less<typename _KeyContainer::value_type>>
+    _Valid_compare_for_container<_KeyContainer> _Compare = less<typename _KeyContainer::value_type>>
 flat_map(sorted_unique_t, _KeyContainer, _MappedContainer, _Compare = _Compare())
     -> flat_map<typename _KeyContainer::value_type, typename _MappedContainer::value_type, _Compare, _KeyContainer,
         _MappedContainer>;
 
 template <class _KeyContainer, class _MappedContainer,
-    _Valid_Allocator_for_flat_map<_KeyContainer, _MappedContainer> _Allocator>
+    _Valid_allocator_for_flat_map<_KeyContainer, _MappedContainer> _Allocator>
 flat_map(sorted_unique_t, _KeyContainer, _MappedContainer, _Allocator) -> flat_map<typename _KeyContainer::value_type,
     typename _MappedContainer::value_type, less<typename _KeyContainer::value_type>, _KeyContainer, _MappedContainer>;
 
-template <class _KeyContainer, class _MappedContainer, _Valid_Compare_for_container<_KeyContainer> _Compare,
-    _Valid_Allocator_for_flat_map<_KeyContainer, _MappedContainer> _Allocator>
+template <class _KeyContainer, class _MappedContainer, _Valid_compare_for_container<_KeyContainer> _Compare,
+    _Valid_allocator_for_flat_map<_KeyContainer, _MappedContainer> _Allocator>
 flat_map(sorted_unique_t, _KeyContainer, _MappedContainer, _Compare, _Allocator)
     -> flat_map<typename _KeyContainer::value_type, typename _MappedContainer::value_type, _Compare, _KeyContainer,
         _MappedContainer>;
 
-template <class _InputIterator, class _Compare = less<typename iter_value_t<_InputIterator>::first_type>>
+template <class _InputIterator, class _Compare = less<_Guide_key_t<_InputIterator>>>
 flat_map(_InputIterator, _InputIterator, _Compare = _Compare())
-    -> flat_map<typename iter_value_t<_InputIterator>::first_type, typename iter_value_t<_InputIterator>::second_type,
-        _Compare>;
+    -> flat_map<_Guide_key_t<_InputIterator>, _Guide_val_t<_InputIterator>, _Compare>;
 
-template <class _InputIterator, class _Compare = less<typename iter_value_t<_InputIterator>::first_type>>
+template <class _InputIterator, class _Compare = less<_Guide_key_t<_InputIterator>>>
 flat_map(sorted_unique_t, _InputIterator, _InputIterator, _Compare = _Compare())
-    -> flat_map<typename iter_value_t<_InputIterator>::first_type, typename iter_value_t<_InputIterator>::second_type,
-        _Compare>;
-
-template <_RANGES input_range _R, class _Compare = less<typename _RANGES range_value_t<_R>::first_type>,
-    class _Allocator = allocator<byte>>
-flat_map(from_range_t, _R&&, _Compare = _Compare(), _Allocator = _Allocator())
-    -> flat_map<typename _RANGES range_value_t<_R>::first_type, typename _RANGES range_value_t<_R>::second_type,
-        _Compare,
-        vector<typename _RANGES range_value_t<_R>::first_type,
-            _Rebind_alloc_t<_Allocator, typename _RANGES range_value_t<_R>::first_type>>,
-        vector<typename _RANGES range_value_t<_R>::second_type,
-            _Rebind_alloc_t<_Allocator, typename _RANGES range_value_t<_R>::second_type>>>;
-
-template <_RANGES input_range _R, class _Allocator>
-flat_map(from_range_t, _R&&, _Allocator) -> flat_map<typename _RANGES range_value_t<_R>::first_type,
-    typename _RANGES range_value_t<_R>::second_type, less<typename _RANGES range_value_t<_R>::first_type>,
-    vector<typename _RANGES range_value_t<_R>::first_type,
-        _Rebind_alloc_t<_Allocator, typename _RANGES range_value_t<_R>::first_type>>,
-    vector<typename _RANGES range_value_t<_R>::second_type,
-        _Rebind_alloc_t<_Allocator, typename _RANGES range_value_t<_R>::second_type>>>;
-
-template <class _Key, class _T, class _Compare = less<_Key>>
-flat_map(initializer_list<pair<_Key, _T>>, _Compare = _Compare()) -> flat_map<_Key, _T, _Compare>;
-
-template <class _Key, class _T, class _Compare = less<_Key>>
-flat_map(sorted_unique_t, initializer_list<pair<_Key, _T>>, _Compare = _Compare()) -> flat_map<_Key, _T, _Compare>;
+    -> flat_map<_Guide_key_t<_InputIterator>, _Guide_val_t<_InputIterator>, _Compare>;
+
+#ifdef __cpp_lib_byte
+template <_RANGES input_range _Rng, class _Compare = less<_Range_key_type<_Rng>>, class _Allocator = allocator<byte>>
+flat_map(from_range_t, _Rng&&, _Compare = _Compare(), _Allocator = _Allocator())
+    -> flat_map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, _Compare,
+        vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_key_type<_Rng>>>,
+        vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_mapped_type<_Rng>>>>;
+#endif // defined(__cpp_lib_byte)
+
+template <_RANGES input_range _Rng, class _Allocator>
+flat_map(from_range_t, _Rng&&, _Allocator) -> flat_map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>,
+    less<_Range_key_type<_Rng>>, vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_key_type<_Rng>>>,
+    vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_mapped_type<_Rng>>>>;
+
+template <class _Key, class _Mapped, class _Compare = less<_Key>>
+flat_map(initializer_list<pair<_Key, _Mapped>>, _Compare = _Compare()) -> flat_map<_Key, _Mapped, _Compare>;
+
+template <class _Key, class _Mapped, class _Compare = less<_Key>>
+flat_map(sorted_unique_t, initializer_list<pair<_Key, _Mapped>>, _Compare = _Compare())
+    -> flat_map<_Key, _Mapped, _Compare>;
 
 // Specialization of uses_allocator
-template <class _Key, class _T, class _Compare, class _KeyContainer, class _MappedContainer, class _Allocator>
-struct uses_allocator<flat_map<_Key, _T, _Compare, _KeyContainer, _MappedContainer>, _Allocator>
+template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer, class _Allocator>
+struct uses_allocator<flat_map<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>, _Allocator>
     : bool_constant<uses_allocator_v<_KeyContainer, _Allocator> && uses_allocator_v<_MappedContainer, _Allocator>> {};
 
-template <class _Key, class _T, class _Compare, class _KeyContainer, class _MappedContainer, class _Allocator>
-struct uses_allocator<flat_multimap<_Key, _T, _Compare, _KeyContainer, _MappedContainer>, _Allocator>
+_EXPORT_STD template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer,
+    class _Predicate>
+typename flat_map<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>::size_type erase_if(
+    flat_map<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>& _Cont, _Predicate _Pred) {
+    return _Cont._Erase_if(_STD _Pass_fn(_Pred));
+}
+
+template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer>
+class flat_multimap : public _Flat_map_base<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer, true,
+                          flat_multimap<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>> {
+private:
+    using _MyBase = _Flat_map_base<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer, true,
+        flat_multimap<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>>;
+
+    using _MyBase::_Data;
+    using _MyBase::_Key_compare;
+
+public:
+    using typename _MyBase::iterator;
+    using typename _MyBase::value_type;
+
+    using _MyBase::_MyBase;
+    using _MyBase::operator=;
+
+    // [flat.multimap.modifiers] Modifiers
+    template <class... _ArgTypes>
+    iterator emplace(_ArgTypes&&... _Args) {
+        value_type _Val(_STD forward<_ArgTypes>(_Args)...);
+        return _Emplace_key_mapped(_STD move(_Val.first), _STD move(_Val.second));
+    }
+
+    iterator insert(const value_type& _Px) {
+        return _Emplace_key_mapped(_Px.first, _Px.second);
+    }
+
+    iterator insert(value_type&& _Px) {
+        return _Emplace_key_mapped(_STD move(_Px.first), _STD move(_Px.second));
+    }
+
+    template <class _PairValTy>
+    iterator insert(_PairValTy&& _Pair_val)
+        requires is_constructible_v<value_type, _PairValTy>
+    {
+        return emplace(_STD forward<_PairValTy>(_Pair_val));
+    }
+
+private:
+    using _MyBase::_Erase_if;
+
+    template <class _KTy, class _MTy, class _Comp, class _KeyCont, class _MappedCont, class _Pred>
+    friend typename flat_multimap<_KTy, _MTy, _Comp, _KeyCont, _MappedCont>::size_type erase_if(
+        flat_multimap<_KTy, _MTy, _Comp, _KeyCont, _MappedCont>&, _Pred);
+
+    template <class _KeyTy, class _MappedTy>
+    iterator _Emplace_key_mapped(_KeyTy&& _Key_val, _MappedTy&& _Mapped_val) {
+        auto _Key_it = _STD lower_bound(_Data.keys.begin(), _Data.keys.end(), _Key_val, _Key_compare);
+        auto _Index  = _STD distance(_Data.keys.begin(), _Key_it);
+
+        this->_Insert_exact(
+            this->cbegin() + _Index, _STD forward<_KeyTy>(_Key_val), _STD forward<_MappedTy>(_Mapped_val));
+        return this->begin() + _Index;
+    }
+};
+
+template <class _KeyContainer, class _MappedContainer, class _Compare = less<typename _KeyContainer::value_type>>
+flat_multimap(_KeyContainer, _MappedContainer, _Compare = _Compare())
+    -> flat_multimap<typename _KeyContainer::value_type, typename _MappedContainer::value_type, _Compare, _KeyContainer,
+        _MappedContainer>;
+
+template <class _KeyContainer, class _MappedContainer, class _Allocator>
+flat_multimap(_KeyContainer, _MappedContainer, _Allocator) -> flat_multimap<typename _KeyContainer::value_type,
+    typename _MappedContainer::value_type, less<typename _KeyContainer::value_type>, _KeyContainer, _MappedContainer>;
+template <class _KeyContainer, class _MappedContainer, class _Compare, class _Allocator>
+flat_multimap(_KeyContainer, _MappedContainer, _Compare, _Allocator)
+    -> flat_multimap<typename _KeyContainer::value_type, typename _MappedContainer::value_type, _Compare, _KeyContainer,
+        _MappedContainer>;
+
+template <class _KeyContainer, class _MappedContainer, class _Compare = less<typename _KeyContainer::value_type>>
+flat_multimap(sorted_equivalent_t, _KeyContainer, _MappedContainer, _Compare = _Compare())
+    -> flat_multimap<typename _KeyContainer::value_type, typename _MappedContainer::value_type, _Compare, _KeyContainer,
+        _MappedContainer>;
+
+template <class _KeyContainer, class _MappedContainer, class _Allocator>
+flat_multimap(sorted_equivalent_t, _KeyContainer, _MappedContainer, _Allocator)
+    -> flat_multimap<typename _KeyContainer::value_type, typename _MappedContainer::value_type,
+        less<typename _KeyContainer::value_type>, _KeyContainer, _MappedContainer>;
+template <class _KeyContainer, class _MappedContainer, class _Compare, class _Allocator>
+flat_multimap(sorted_equivalent_t, _KeyContainer, _MappedContainer, _Compare, _Allocator)
+    -> flat_multimap<typename _KeyContainer::value_type, typename _MappedContainer::value_type, _Compare, _KeyContainer,
+        _MappedContainer>;
+
+template <class _InputIterator, class _Compare = less<_Guide_key_t<_InputIterator>>>
+flat_multimap(_InputIterator, _InputIterator, _Compare = _Compare())
+    -> flat_multimap<_Guide_key_t<_InputIterator>, _Guide_val_t<_InputIterator>, _Compare>;
+
+template <class _InputIterator, class _Compare = less<_Guide_key_t<_InputIterator>>>
+flat_multimap(sorted_equivalent_t, _InputIterator, _InputIterator, _Compare = _Compare())
+    -> flat_multimap<_Guide_key_t<_InputIterator>, _Guide_val_t<_InputIterator>, _Compare>;
+
+#ifdef __cpp_lib_byte
+template <_RANGES input_range _Rng, class _Compare = less<_Range_key_type<_Rng>>, class _Allocator = allocator<byte>>
+flat_multimap(from_range_t, _Rng&&, _Compare = _Compare(), _Allocator = _Allocator())
+    -> flat_multimap<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, _Compare,
+        vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_key_type<_Rng>>>,
+        vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_mapped_type<_Rng>>>>;
+#endif // defined(__cpp_lib_byte)
+
+template <_RANGES input_range _Rng, class _Allocator>
+flat_multimap(from_range_t, _Rng&&, _Allocator) -> flat_multimap<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>,
+    less<_Range_key_type<_Rng>>, vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_key_type<_Rng>>>,
+    vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_mapped_type<_Rng>>>>;
+
+template <class _Key, class _Mapped, class _Compare = less<_Key>>
+flat_multimap(initializer_list<pair<_Key, _Mapped>>, _Compare = _Compare()) -> flat_multimap<_Key, _Mapped, _Compare>;
+
+template <class _Key, class _Mapped, class _Compare = less<_Key>>
+flat_multimap(sorted_equivalent_t, initializer_list<pair<_Key, _Mapped>>, _Compare = _Compare())
+    -> flat_multimap<_Key, _Mapped, _Compare>;
+
+// Specialization of uses_allocator
+template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer, class _Allocator>
+struct uses_allocator<flat_multimap<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>, _Allocator>
     : bool_constant<uses_allocator_v<_KeyContainer, _Allocator> && uses_allocator_v<_MappedContainer, _Allocator>> {};
 
+_EXPORT_STD template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer,
+    class _Predicate>
+typename flat_multimap<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>::size_type erase_if(
+    flat_multimap<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>& _Cont, _Predicate _Pred) {
+    return _Cont._Erase_if(_STD _Pass_fn(_Pred));
+}
 _STD_END
 
 #pragma pop_macro("new")
diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index b5cfda070f3..428855a4849 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -28,20 +28,18 @@ bool check_container_requirements(T&&) {
 template <IsFlatMap T>
 consteval bool check_reversible_container_requirements() {
     using map_t = remove_cvref_t<T>;
-    bool result = true;
-    result &= is_same_v<reverse_iterator<typename map_t::iterator>, typename map_t::reverse_iterator>;
-    result &= is_same_v<reverse_iterator<typename map_t::const_iterator>, typename map_t::const_reverse_iterator>;
-    result &= is_same_v<decltype(declval<map_t>().begin()), typename map_t::iterator>;
-    result &= is_same_v<decltype(declval<map_t>().end()), typename map_t::iterator>;
-    result &= is_same_v<decltype(declval<map_t>().cbegin()), typename map_t::const_iterator>;
-    result &= is_same_v<decltype(declval<map_t>().cend()), typename map_t::const_iterator>;
-    result &= is_same_v<decltype(declval<map_t>().rbegin()), typename map_t::reverse_iterator>;
-    result &= is_same_v<decltype(declval<map_t>().rend()), typename map_t::reverse_iterator>;
-    result &= is_same_v<decltype(declval<map_t>().crbegin()), typename map_t::const_reverse_iterator>;
-    result &= is_same_v<decltype(declval<map_t>().crend()), typename map_t::const_reverse_iterator>;
-    result &= is_convertible_v<typename map_t::iterator, typename map_t::const_iterator>;
-    result &= is_convertible_v<typename map_t::reverse_iterator, typename map_t::const_reverse_iterator>;
-    return result;
+    return is_same_v<reverse_iterator<typename map_t::iterator>, typename map_t::reverse_iterator>
+        && is_same_v<reverse_iterator<typename map_t::const_iterator>, typename map_t::const_reverse_iterator>
+        && is_same_v<decltype(declval<map_t>().begin()), typename map_t::iterator>
+        && is_same_v<decltype(declval<map_t>().end()), typename map_t::iterator>
+        && is_same_v<decltype(declval<map_t>().cbegin()), typename map_t::const_iterator>
+        && is_same_v<decltype(declval<map_t>().cend()), typename map_t::const_iterator>
+        && is_same_v<decltype(declval<map_t>().rbegin()), typename map_t::reverse_iterator>
+        && is_same_v<decltype(declval<map_t>().rend()), typename map_t::reverse_iterator>
+        && is_same_v<decltype(declval<map_t>().crbegin()), typename map_t::const_reverse_iterator>
+        && is_same_v<decltype(declval<map_t>().crend()), typename map_t::const_reverse_iterator>
+        && is_convertible_v<typename map_t::iterator, typename map_t::const_iterator>
+        && is_convertible_v<typename map_t::reverse_iterator, typename map_t::const_reverse_iterator>;
 }
 
 template <IsFlatMap T>
@@ -120,21 +118,13 @@ class Packaged {
         value = t;
     }
 
-    friend bool operator==(const Packaged& lhs, const Packaged& rhs) {
-        return lhs.value == rhs.value;
-    }
+    friend bool operator==(const Packaged&, const Packaged&) = default;
 
     friend bool operator==(const Packaged& lhs, const T& rhs) {
         return lhs.value == rhs;
     }
 
-    friend bool operator==(const T& lhs, const Packaged& rhs) {
-        return lhs == rhs.value;
-    }
-
-    friend auto operator<=>(const Packaged& lhs, const Packaged& rhs) {
-        return lhs.value <=> rhs.value;
-    }
+    friend auto operator<=>(const Packaged&, const Packaged&) = default;
 };
 
 template <typename T>
@@ -246,6 +236,19 @@ void test_construction() {
     }
 }
 
+void test_erase_if() {
+    {
+        vector<int> keys = {0, 1, 2, 3, 4, 2};
+        vector<int> vals = {44, 2324, 635462, 433, 5, 7};
+        flat_map fmap(keys, vals);
+        const auto erased_num = erase_if(
+            fmap, [](pair<const int&, const int&> refpr) { return refpr.first % 2 == 0 && refpr.second % 2 != 0; });
+        assert(erased_num == 1);
+        assert(fmap.size() == 4);
+        assert(check_key_content(fmap, {0, 1, 2, 3}));
+        assert(check_value_content(fmap, {44, 2324, 635462, 433}));
+    }
+}
 
 struct Incomplete;
 template <class T>
@@ -265,7 +268,40 @@ void test_pointer_to_incomplete_type() {
     flat_map<MyType<Incomplete>, shared_ptr<MyType<Incomplete>>> fmap;
 }
 
+// Test MSVC STL-specific SCARY-ness
+namespace scary_test {
+    static_assert(is_same_v<flat_map<int, int>::iterator, flat_map<int, int, greater<int>>::iterator>);
+    static_assert(is_same_v<flat_map<int, int>::iterator,
+        flat_map<int, int, less<>, vector<int, MyAllocator<int>>, vector<int, MyAllocator<int>>>::iterator>);
+    static_assert(is_same_v<flat_map<int, int>::const_iterator, flat_map<int, int, greater<int>>::const_iterator>);
+    static_assert(is_same_v<flat_map<int, int>::const_iterator,
+        flat_map<int, int, less<>, vector<int, MyAllocator<int>>, vector<int, MyAllocator<int>>>::const_iterator>);
+
+    static_assert(is_same_v<flat_multimap<int, int>::iterator, flat_multimap<int, int, greater<int>>::iterator>);
+    static_assert(is_same_v<flat_multimap<int, int>::iterator,
+        flat_multimap<int, int, less<>, vector<int, MyAllocator<int>>, vector<int, MyAllocator<int>>>::iterator>);
+    static_assert(
+        is_same_v<flat_multimap<int, int>::const_iterator, flat_multimap<int, int, greater<int>>::const_iterator>);
+    static_assert(is_same_v<flat_multimap<int, int>::const_iterator,
+        flat_multimap<int, int, less<>, vector<int, MyAllocator<int>>, vector<int, MyAllocator<int>>>::const_iterator>);
+
+    static_assert(is_same_v<flat_map<int, int>::iterator, flat_multimap<int, int>::iterator>);
+    static_assert(is_same_v<flat_map<int, int>::const_iterator, flat_multimap<int, int>::const_iterator>);
+
+    static_assert(is_same_v<flat_map<int, int>::containers, flat_map<int, int, greater<int>>::containers>);
+    static_assert(is_same_v<flat_multimap<int, int>::containers, flat_multimap<int, int, greater<int>>::containers>);
+    static_assert(is_same_v<flat_map<int, int>::containers, flat_multimap<int, int>::containers>);
+
+    static_assert(is_same_v<flat_map<int, int>::value_compare,
+        flat_map<int, int, less<int>, vector<int, MyAllocator<int>>, vector<int, MyAllocator<int>>>::value_compare>);
+    static_assert(is_same_v<flat_multimap<int, int>::value_compare,
+        flat_multimap<int, int, less<int>, vector<int, MyAllocator<int>>,
+            vector<int, MyAllocator<int>>>::value_compare>);
+    static_assert(is_same_v<flat_map<int, int>::value_compare, flat_multimap<int, int>::value_compare>);
+} // namespace scary_test
+
 int main() {
     test_construction();
     test_pointer_to_incomplete_type();
+    test_erase_if();
 }

From 176ceee64f74f4b488874bb91f1aab6e21c97156 Mon Sep 17 00:00:00 2001
From: Jelle <duckdoom5@users.noreply.github.com>
Date: Mon, 29 Jan 2024 23:01:49 +0100
Subject: [PATCH 021/134] `<flat_map>` Fix compile errors (#4344)

Co-authored-by: Stephan T. Lavavej <stl@nuwen.net>
---
 stl/inc/flat_map                          | 46 ++++++++++++-----------
 tests/std/tests/P0429R9_flat_map/env.lst  |  2 +-
 tests/std/tests/P0429R9_flat_map/test.cpp | 34 +++++++++++++++++
 3 files changed, 59 insertions(+), 23 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index c73b25e9e1b..bae20ca1f16 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -757,6 +757,28 @@ protected:
         return _Old_size - size();
     }
 
+    template <class _KeyTy, class... _MappedArgTypes>
+    pair<iterator, bool> _Try_emplace(_KeyTy&& _Key_val, _MappedArgTypes&&... _Mapped_args) {
+        auto _Key_it = _STD lower_bound(_Data.keys.begin(), _Data.keys.end(), _Key_val, _Key_compare);
+        if (_Key_it != _Data.keys.end() && _Key_equal(*_Key_it, _STD forward<_KeyTy>(_Key_val))) {
+            // Already exists
+            return {this->begin() + _STD distance(_Data.keys.begin(), _Key_it), false};
+        } else {
+            // Need to insert
+            auto _Index = _STD distance(_Data.keys.begin(), _Key_it);
+            this->_Insert_exact(this->cbegin() + _Index, key_type{_STD forward<_KeyTy>(_Key_val)},
+                mapped_type{_STD forward<_MappedArgTypes>(_Mapped_args)...});
+            return {this->begin() + _Index, true};
+        }
+    }
+
+    void _Insert_exact(const_iterator _Position, key_type&& _Key_val, mapped_type&& _Mapped_val) {
+        _Clear_flat_map_scope_guard _Guard{this};
+        _Data.keys.insert(_Position._Key_it, _STD move(_Key_val));
+        _Data.values.insert(_Position._Mapped_it, _STD move(_Mapped_val));
+        _Guard._Clearable = nullptr;
+    }
+
 private:
     template <class _KeyTy1, class _KeyTy2>
         requires (same_as<remove_cvref_t<_KeyTy1 &&>, key_type> && same_as<remove_cvref_t<_KeyTy2 &&>, key_type>)
@@ -792,13 +814,6 @@ private:
         _Guard._Clearable = nullptr;
     }
 
-    void _Insert_exact(const_iterator _Position, key_type&& _Key_val, mapped_type&& _Mapped_val) {
-        _Clear_flat_map_scope_guard _Guard{this};
-        _Data.keys.insert(_Position._Key_it, _STD move(_Key_val));
-        _Data.values.insert(_Position._Mapped_it, _STD move(_Mapped_val));
-        _Guard._Clearable = nullptr;
-    }
-
     template <bool _OverwriteIfExists, class _OtherKey, class... _MappedArgTypes>
     iterator _Emplace_hint(const_iterator _Position, _OtherKey&& _Key_val, _MappedArgTypes&&... _Args)
         requires is_constructible_v<mapped_type, _MappedArgTypes...>
@@ -1161,6 +1176,7 @@ public:
 
 private:
     using _MyBase::_Erase_if;
+    using _MyBase::_Try_emplace;
 
     template <class _KTy, class _MTy, class _Comp, class _KeyCont, class _MappedCont, class _Pred>
     friend typename flat_map<_KTy, _MTy, _Comp, _KeyCont, _MappedCont>::size_type erase_if(
@@ -1190,21 +1206,6 @@ private:
         }
     }
 
-    template <class _KeyTy, class... _MappedArgTypes>
-    pair<iterator, bool> _Try_emplace(_KeyTy&& _Key_val, _MappedArgTypes&&... _Mapped_args) {
-        auto _Key_it = _STD lower_bound(_Data.keys.begin(), _Data.keys.end(), _Key_val, _Key_compare);
-        if (_Key_it != _Data.keys.end() && _Key_equal(*_Key_it, _STD forward<_KeyTy>(_Key_val))) {
-            // Already exists
-            return {this->begin() + _STD distance(_Data.keys.begin(), _Key_it), false};
-        } else {
-            // Need to insert
-            auto _Index = _STD distance(_Data.keys.begin(), _Key_it);
-            this->_Insert_exact(this->cbegin() + _Index, key_type{_STD forward<_KeyTy>(_Key_val)},
-                mapped_type{_STD forward<_MappedArgTypes>(_Mapped_args)...});
-            return {this->begin() + _Index, true};
-        }
-    }
-
     template <class _KeyTy, class _MappedTy>
     pair<iterator, bool> _Insert_or_assign(_KeyTy&& _Key_val, _MappedTy&& _Mapped_val) {
         auto _Res = _Try_emplace(_STD forward<_KeyTy>(_Key_val), _STD forward<_MappedTy>(_Mapped_val));
@@ -1328,6 +1329,7 @@ public:
 
 private:
     using _MyBase::_Erase_if;
+    using _MyBase::_Insert_exact;
 
     template <class _KTy, class _MTy, class _Comp, class _KeyCont, class _MappedCont, class _Pred>
     friend typename flat_multimap<_KTy, _MTy, _Comp, _KeyCont, _MappedCont>::size_type erase_if(
diff --git a/tests/std/tests/P0429R9_flat_map/env.lst b/tests/std/tests/P0429R9_flat_map/env.lst
index 18e2d7c71ec..8ac7033b206 100644
--- a/tests/std/tests/P0429R9_flat_map/env.lst
+++ b/tests/std/tests/P0429R9_flat_map/env.lst
@@ -1,4 +1,4 @@
 # Copyright (c) Microsoft Corporation.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-RUNALL_INCLUDE ..\concepts_latest_matrix.lst
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index 428855a4849..11bdfb3a8c7 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -300,8 +300,42 @@ namespace scary_test {
     static_assert(is_same_v<flat_map<int, int>::value_compare, flat_multimap<int, int>::value_compare>);
 } // namespace scary_test
 
+// GH-4344 <flat_map> Fix compile errors
+void test_gh_4344() {
+    flat_map<int, char> fm;
+
+    const auto p1 = fm.try_emplace(10, 'm');
+    assert(p1.first->first == 10);
+    assert(p1.first->second == 'm');
+    assert(p1.second);
+
+    const auto p2 = fm.try_emplace(70, 'e');
+    assert(p2.first->first == 70);
+    assert(p2.first->second == 'e');
+    assert(p2.second);
+
+    const auto p3 = fm.try_emplace(20, 'o');
+    assert(p3.first->first == 20);
+    assert(p3.first->second == 'o');
+    assert(p3.second);
+
+    const auto p4 = fm.try_emplace(90, 'w');
+    assert(p4.first->first == 90);
+    assert(p4.first->second == 'w');
+    assert(p4.second);
+
+    const auto p5 = fm.try_emplace(70, 'X');
+    assert(p5.first->first == 70);
+    assert(p5.first->second == 'e');
+    assert(!p5.second);
+
+    assert(check_key_content(fm, {10, 20, 70, 90}));
+    assert(check_value_content(fm, {'m', 'o', 'e', 'w'}));
+}
+
 int main() {
     test_construction();
     test_pointer_to_incomplete_type();
     test_erase_if();
+    test_gh_4344();
 }

From 510c1eba544ca286c44f8cb3a21eb563a8125beb Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Tue, 6 Feb 2024 12:14:42 -0800
Subject: [PATCH 022/134] Update `_HAS_CXX23` guard in `<flat_map>`.

---
 stl/inc/flat_map | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index bae20ca1f16..d2e5ce636c9 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -7,9 +7,9 @@
 #define _FLAT_MAP_
 #include <yvals_core.h>
 #if _STL_COMPILER_PREPROCESSOR
-#if !_HAS_CXX23 || !defined(__cpp_lib_concepts) // TRANSITION, GH-395
+#if !_HAS_CXX23
 _EMIT_STL_WARNING(STL4038, "The contents of <flat_map> are available only with C++23 or later.");
-#else // ^^^ not supported / supported language mode vvv
+#else // ^^^ !_HAS_CXX23 / _HAS_CXX23 vvv
 
 #include <algorithm>
 #include <compare>
@@ -1418,6 +1418,6 @@ _STD_END
 _STL_RESTORE_CLANG_WARNINGS
 #pragma warning(pop)
 #pragma pack(pop)
-#endif // ^^^ supported language mode ^^^
+#endif // ^^^ _HAS_CXX23 ^^^
 #endif // _STL_COMPILER_PREPROCESSOR
 #endif // _FLAT_MAP_

From 99a19de1b9ca2d40c70cb06aea3310b9d5055dc5 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Tue, 6 Feb 2024 12:17:55 -0800
Subject: [PATCH 023/134] Add a feature-test macro test.

---
 .../VSO_0157762_feature_test_macros/test.compile.pass.cpp   | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/tests/std/tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp b/tests/std/tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp
index db4e6c54a76..c6a3ff87308 100644
--- a/tests/std/tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp
+++ b/tests/std/tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp
@@ -355,6 +355,12 @@ STATIC_ASSERT(__cpp_lib_filesystem == 201703L);
 #error __cpp_lib_filesystem is defined
 #endif
 
+#if _HAS_CXX23
+STATIC_ASSERT(__cpp_lib_flat_map == 202207L);
+#elif defined(__cpp_lib_flat_map)
+#error __cpp_lib_flat_map is defined
+#endif
+
 #if _HAS_CXX20
 STATIC_ASSERT(__cpp_lib_format == 202304L);
 #elif defined(__cpp_lib_format)

From d5d65bcb7b0e0c351ee6058348c49f36b17621ae Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Tue, 6 Feb 2024 12:23:50 -0800
Subject: [PATCH 024/134] `concepts_latest_matrix.lst` =>
 `usual_latest_matrix.lst`

---
 tests/std/tests/P1222R4_flat_set/env.lst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/std/tests/P1222R4_flat_set/env.lst b/tests/std/tests/P1222R4_flat_set/env.lst
index 18e2d7c71ec..642f530ffad 100644
--- a/tests/std/tests/P1222R4_flat_set/env.lst
+++ b/tests/std/tests/P1222R4_flat_set/env.lst
@@ -1,4 +1,4 @@
 # Copyright (c) Microsoft Corporation.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-RUNALL_INCLUDE ..\concepts_latest_matrix.lst
+RUNALL_INCLUDE ..\usual_latest_matrix.lst

From 132f64ca59c642289df2892c2414d79351de8036 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Tue, 6 Feb 2024 12:26:06 -0800
Subject: [PATCH 025/134] Update `_HAS_CXX23` guard in `<flat_set>`.

---
 stl/inc/flat_set | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index 83f6e9d1f03..4ec260e41a6 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -7,9 +7,9 @@
 #define _FLAT_SET_
 #include <yvals_core.h>
 #if _STL_COMPILER_PREPROCESSOR
-#if !_HAS_CXX23 || !defined(__cpp_lib_concepts) // TRANSITION, GH-395
+#if !_HAS_CXX23
 _EMIT_STL_WARNING(STL4038, "The contents of <flat_set> are available only with C++23 or later.");
-#else // ^^^ not supported / supported language mode vvv
+#else // ^^^ !_HAS_CXX23 / _HAS_CXX23 vvv
 #include <algorithm>
 #include <compare>
 #include <initializer_list>
@@ -827,6 +827,6 @@ _STL_RESTORE_CLANG_WARNINGS
 #pragma warning(pop)
 #pragma pack(pop)
 
-#endif // ^^^ supported language mode ^^^
+#endif // ^^^ _HAS_CXX23 ^^^
 #endif // _STL_COMPILER_PREPROCESSOR
 #endif // _FLAT_SET_

From 8a2cec757250a09e323a5a38f9140a56b912a37e Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Tue, 6 Feb 2024 14:05:51 -0800
Subject: [PATCH 026/134] Add `flat_map` to
 P1502R1_standard_library_header_units.

---
 .../importable_cxx_library_headers.jsonc                       | 1 +
 tests/std/tests/P1502R1_standard_library_header_units/test.cpp | 3 +++
 2 files changed, 4 insertions(+)

diff --git a/tests/std/tests/P1502R1_standard_library_header_units/importable_cxx_library_headers.jsonc b/tests/std/tests/P1502R1_standard_library_header_units/importable_cxx_library_headers.jsonc
index d4960889f74..9d86d337445 100644
--- a/tests/std/tests/P1502R1_standard_library_header_units/importable_cxx_library_headers.jsonc
+++ b/tests/std/tests/P1502R1_standard_library_header_units/importable_cxx_library_headers.jsonc
@@ -23,6 +23,7 @@
     "execution",
     "expected",
     "filesystem",
+    "flat_map",
     "format",
     "forward_list",
     "fstream",
diff --git a/tests/std/tests/P1502R1_standard_library_header_units/test.cpp b/tests/std/tests/P1502R1_standard_library_header_units/test.cpp
index 1617b5e2859..095c350d416 100644
--- a/tests/std/tests/P1502R1_standard_library_header_units/test.cpp
+++ b/tests/std/tests/P1502R1_standard_library_header_units/test.cpp
@@ -31,6 +31,9 @@ import <execution>;
 import <expected>;
 #endif // TEST_STANDARD >= 23
 import <filesystem>;
+#if TEST_STANDARD >= 23
+import <flat_map>;
+#endif // TEST_STANDARD >= 23
 import <format>;
 import <forward_list>;
 import <fstream>;

From 76d9b2070e774f1e8e568a12aecc1a855395232f Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Tue, 6 Feb 2024 14:28:37 -0800
Subject: [PATCH 027/134] std.ixx: Guard `<flat_map>` with `_HAS_CXX23`.

---
 stl/modules/std.ixx | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/stl/modules/std.ixx b/stl/modules/std.ixx
index 36bd4afbdbf..3ef92f83711 100644
--- a/stl/modules/std.ixx
+++ b/stl/modules/std.ixx
@@ -61,7 +61,9 @@ export module std;
 #include <expected>
 #endif // _HAS_CXX23
 #include <filesystem>
+#if _HAS_CXX23
 #include <flat_map>
+#endif // _HAS_CXX23
 #include <format>
 #include <forward_list>
 #include <fstream>

From 3fb0e897963ba46007da11663891a9f8ae2f5ea8 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Tue, 6 Feb 2024 14:29:35 -0800
Subject: [PATCH 028/134] Add flat_map to include_each_header_alone_matrix.lst.

---
 tests/std/tests/include_each_header_alone_matrix.lst | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/std/tests/include_each_header_alone_matrix.lst b/tests/std/tests/include_each_header_alone_matrix.lst
index 4d07f7d8bba..9fddca27906 100644
--- a/tests/std/tests/include_each_header_alone_matrix.lst
+++ b/tests/std/tests/include_each_header_alone_matrix.lst
@@ -26,6 +26,7 @@ PM_CL="/DMEOW_HEADER=exception"
 PM_CL="/DMEOW_HEADER=execution"
 PM_CL="/DMEOW_HEADER=expected"
 PM_CL="/DMEOW_HEADER=filesystem"
+PM_CL="/DMEOW_HEADER=flat_map"
 PM_CL="/DMEOW_HEADER=format"
 PM_CL="/DMEOW_HEADER=forward_list"
 PM_CL="/DMEOW_HEADER=fstream"

From 56870990afbe7a0991a5836ba786703d0494c592 Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34@live.cn>
Date: Tue, 13 Feb 2024 01:40:11 +0800
Subject: [PATCH 029/134] `<flat_map>`: Re-enable `/permissive` with
 miscellaneous fixes and test coverage (#4386)

---
 stl/inc/flat_map                              | 382 +++++++++---------
 .../include/test_header_units_and_modules.hpp |  19 +-
 tests/std/tests/P0429R9_flat_map/env.lst      |   2 +-
 tests/std/tests/P0429R9_flat_map/test.cpp     | 166 ++++++--
 4 files changed, 343 insertions(+), 226 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index d2e5ce636c9..5391ac79285 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -28,30 +28,15 @@ _STL_DISABLE_CLANG_WARNINGS
 #undef new
 
 _STD_BEGIN
-
-template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer, bool _IsMulti,
-    class _Derived>
-    requires same_as<_Key, typename _KeyContainer::value_type>
-          && same_as<_Mapped, typename _MappedContainer::value_type>
-class _Flat_map_base;
-
-template <class _Key, class _Mapped, class _Compare = less<_Key>, class _KeyContainer = vector<_Key>,
-    class _MappedContainer = vector<_Mapped>>
-class flat_map;
-
-template <class _Key, class _Mapped, class _Compare = less<_Key>, class _KeyContainer = vector<_Key>,
-    class _MappedContainer = vector<_Mapped>>
-class flat_multimap;
-
-struct sorted_unique_t {
+_EXPORT_STD struct sorted_unique_t {
     explicit sorted_unique_t() = default;
 };
-inline constexpr sorted_unique_t sorted_unique{};
+_EXPORT_STD inline constexpr sorted_unique_t sorted_unique{};
 
-struct sorted_equivalent_t {
+_EXPORT_STD struct sorted_equivalent_t {
     explicit sorted_equivalent_t() = default;
 };
-inline constexpr sorted_equivalent_t sorted_equivalent{};
+_EXPORT_STD inline constexpr sorted_equivalent_t sorted_equivalent{};
 
 template <class _Alloc, class _Key_container, class _Mapped_container>
 concept _Valid_allocator_for_flat_map =
@@ -98,14 +83,15 @@ struct _NODISCARD _Clear_flat_map_scope_guard {
 
 // Implementation
 
+template <bool _IsUnique, class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer>
+class _Flat_map_base;
+
 template <class _KeyIter, class _MappedIter, class _MappedConvIter>
 struct _Pairing_iterator_provider {
     class _Iterator {
     public:
-        template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer, bool _IsMulti,
-            class _Derived>
-            requires same_as<_Key, typename _KeyContainer::value_type>
-                  && same_as<_Mapped, typename _MappedContainer::value_type>
+        template <bool _IsUnique, class _Key, class _Mapped, class _Compare, class _KeyContainer,
+            class _MappedContainer>
         friend class _Flat_map_base;
 
         _Iterator() = default;
@@ -118,8 +104,7 @@ struct _Pairing_iterator_provider {
         using reference         = pair<iter_reference_t<_KeyIter>, iter_reference_t<_MappedIter>>;
 
     private:
-        using _Const_iterator =
-            typename _Pairing_iterator_provider<_KeyIter, _MappedConvIter, _MappedConvIter>::_Iterator;
+        using _Const_iterator = _Pairing_iterator_provider<_KeyIter, _MappedConvIter, _MappedConvIter>::_Iterator;
 
         class _Arrow_proxy {
         public:
@@ -226,14 +211,20 @@ struct _Pairing_iterator_provider {
     _STL_INTERNAL_STATIC_ASSERT(swappable<_Iterator>);
 };
 
-_EXPORT_STD
-template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer, bool _IsMulti,
-    class _Derived>
-    requires same_as<_Key, typename _KeyContainer::value_type>
-          && same_as<_Mapped, typename _MappedContainer::value_type>
+_EXPORT_STD template <class _Key, class _Mapped, class _Compare = less<_Key>, class _KeyContainer = vector<_Key>,
+    class _MappedContainer = vector<_Mapped>>
+class flat_map;
+
+_EXPORT_STD template <class _Key, class _Mapped, class _Compare = less<_Key>, class _KeyContainer = vector<_Key>,
+    class _MappedContainer = vector<_Mapped>>
+class flat_multimap;
+
+template <bool _IsUnique, class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer>
 class _Flat_map_base {
 private:
-    using _Sorted_t = conditional_t<_IsMulti, sorted_equivalent_t, sorted_unique_t>;
+    using _Sorted_t = conditional_t<_IsUnique, sorted_unique_t, sorted_equivalent_t>;
+    using _Derived  = conditional_t<_IsUnique, flat_map<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>,
+        flat_multimap<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>>;
 
 public:
     using key_type               = _Key;
@@ -253,6 +244,11 @@ public:
     using reverse_iterator       = _STD reverse_iterator<iterator>;
     using const_reverse_iterator = _STD reverse_iterator<const_iterator>;
 
+    static_assert(is_same_v<key_type, typename key_container_type::value_type>,
+        "key_type should be the element type of key_container_type");
+    static_assert(is_same_v<mapped_type, typename mapped_container_type::value_type>,
+        "mapped_type should be the element type of mapped_container_type");
+
     _STL_INTERNAL_STATIC_ASSERT(random_access_iterator<iterator>);
     _STL_INTERNAL_STATIC_ASSERT(convertible_to<iterator, const_iterator>);
 
@@ -276,7 +272,7 @@ public:
         key_container_type _Key_cont, mapped_container_type _Mapped_cont, const key_compare& _Comp = key_compare())
         : _Flat_map_base(_Sorted_t(), _Key_cont, _Mapped_cont, _Comp) {
         _Sort();
-        if constexpr (!_IsMulti) {
+        if constexpr (_IsUnique) {
             _Dedup();
         }
     }
@@ -286,7 +282,7 @@ public:
         const key_container_type& _Key_cont, const mapped_container_type& _Mapped_cont, const _Allocator& _Alloc)
         : _Flat_map_base(_Sorted_t(), _Key_cont, _Mapped_cont, _Alloc) {
         _Sort();
-        if constexpr (!_IsMulti) {
+        if constexpr (_IsUnique) {
             _Dedup();
         }
     }
@@ -296,7 +292,7 @@ public:
         const key_compare& _Comp, const _Allocator& _Alloc)
         : _Flat_map_base(_Sorted_t(), _Key_cont, _Mapped_cont, _Comp, _Alloc) {
         _Sort();
-        if constexpr (!_IsMulti) {
+        if constexpr (_IsUnique) {
             _Dedup();
         }
     }
@@ -424,7 +420,7 @@ public:
     _Derived& operator=(initializer_list<value_type> _Ilist) {
         clear();
         insert(_Ilist.begin(), _Ilist.end());
-        return static_cast<_Derived&>(*this); // Use "deducing this" when it is supported
+        return static_cast<_Derived&>(*this); // TRANSITION, P0847R7, should use explicit object parameter
     }
 
     // [container.reqmts] iterators
@@ -527,13 +523,13 @@ public:
     template <class _InputIterator>
         requires _Is_iterator_v<_InputIterator>
     void insert(_InputIterator _First, _InputIterator _Last) {
-        _Insert_range<true, !_IsMulti>(_First, _Last);
+        _Insert_range<true, _IsUnique>(_First, _Last);
     }
 
     template <class _InputIterator>
         requires _Is_iterator_v<_InputIterator>
     void insert(_Sorted_t, _InputIterator _First, _InputIterator _Last) {
-        _Insert_range<false, !_IsMulti>(_First, _Last);
+        _Insert_range<false, _IsUnique>(_First, _Last);
     }
 
     template <_Container_compatible_range<value_type> _Rng>
@@ -610,122 +606,122 @@ public:
     }
 
     // map operations
-    iterator find(const key_type& _Key_val) {
+    _NODISCARD iterator find(const key_type& _Key_val) {
         return _Find(_Key_val);
     }
 
     template <class _OtherKey>
-    iterator find(const _OtherKey& _Key_val)
+    _NODISCARD iterator find(const _OtherKey& _Key_val)
         requires _Is_transparent_v<key_compare>
     {
         return _Find(_Key_val);
     }
 
-    const_iterator find(const key_type& _Key_val) const {
+    _NODISCARD const_iterator find(const key_type& _Key_val) const {
         return _Find(_Key_val);
     }
 
     template <class _OtherKey>
-    const_iterator find(const _OtherKey& _Key_val) const
+    _NODISCARD const_iterator find(const _OtherKey& _Key_val) const
         requires _Is_transparent_v<key_compare>
     {
         return _Find(_Key_val);
     }
 
-    size_type count(const key_type& _Key_val) const {
+    _NODISCARD size_type count(const key_type& _Key_val) const {
         return _Count(_Key_val);
     }
 
     template <class _OtherKey>
-    size_type count(const _OtherKey& _Key_val) const
+    _NODISCARD size_type count(const _OtherKey& _Key_val) const
         requires _Is_transparent_v<key_compare>
     {
         return _Count(_Key_val);
     }
 
-    bool contains(const key_type& _Key_val) const {
+    _NODISCARD bool contains(const key_type& _Key_val) const {
         return _Contains(_Key_val);
     }
 
     template <class _OtherKey>
-    bool contains(const _OtherKey& _Key_val) const
+    _NODISCARD bool contains(const _OtherKey& _Key_val) const
         requires _Is_transparent_v<key_compare>
     {
         return _Contains(_Key_val);
     }
 
-    iterator lower_bound(const key_type& _Key_val) {
+    _NODISCARD iterator lower_bound(const key_type& _Key_val) {
         return _Lower_bound(_Key_val);
     }
 
     template <class _OtherKey>
-    iterator lower_bound(const _OtherKey& _Key_val)
+    _NODISCARD iterator lower_bound(const _OtherKey& _Key_val)
         requires _Is_transparent_v<key_compare>
     {
         return _Lower_bound(_Key_val);
     }
 
-    const_iterator lower_bound(const key_type& _Key_val) const {
+    _NODISCARD const_iterator lower_bound(const key_type& _Key_val) const {
         return _Lower_bound(_Key_val);
     }
 
     template <class _OtherKey>
-    const_iterator lower_bound(const _OtherKey& _Key_val) const
+    _NODISCARD const_iterator lower_bound(const _OtherKey& _Key_val) const
         requires _Is_transparent_v<key_compare>
     {
         return _Lower_bound(_Key_val);
     }
 
-    iterator upper_bound(const key_type& _Key_val) {
+    _NODISCARD iterator upper_bound(const key_type& _Key_val) {
         return _Upper_bound(_Key_val);
     }
 
     template <class _OtherKey>
-    iterator upper_bound(const _OtherKey& _Key_val)
+    _NODISCARD iterator upper_bound(const _OtherKey& _Key_val)
         requires _Is_transparent_v<key_compare>
     {
         return _Upper_bound(_Key_val);
     }
 
-    const_iterator upper_bound(const key_type& _Key_val) const {
+    _NODISCARD const_iterator upper_bound(const key_type& _Key_val) const {
         return _Upper_bound(_Key_val);
     }
 
     template <class _OtherKey>
-    const_iterator upper_bound(const _OtherKey& _Key_val) const
+    _NODISCARD const_iterator upper_bound(const _OtherKey& _Key_val) const
         requires _Is_transparent_v<key_compare>
     {
         return _Upper_bound(_Key_val);
     }
 
-    pair<iterator, iterator> equal_range(const key_type& _Key_val) {
+    _NODISCARD pair<iterator, iterator> equal_range(const key_type& _Key_val) {
         return _Equal_range(_Key_val);
     }
 
     template <class _OtherKey>
-    pair<iterator, iterator> equal_range(const _OtherKey& _Key_val)
+    _NODISCARD pair<iterator, iterator> equal_range(const _OtherKey& _Key_val)
         requires _Is_transparent_v<key_compare>
     {
         return _Equal_range(_Key_val);
     }
 
-    pair<const_iterator, const_iterator> equal_range(const key_type& _Key_val) const {
+    _NODISCARD pair<const_iterator, const_iterator> equal_range(const key_type& _Key_val) const {
         return _Equal_range(_Key_val);
     }
 
     template <class _OtherKey>
-    pair<const_iterator, const_iterator> equal_range(const _OtherKey& _Key_val) const
+    _NODISCARD pair<const_iterator, const_iterator> equal_range(const _OtherKey& _Key_val) const
         requires _Is_transparent_v<key_compare>
     {
         return _Equal_range(_Key_val);
     }
 
-    friend bool operator==(const _Derived& _Left, const _Derived& _Right) {
+    _NODISCARD_FRIEND bool operator==(const _Derived& _Left, const _Derived& _Right) {
         return _RANGES equal(_Left._Data.keys, _Right._Data.keys)
             && _RANGES equal(_Left._Data.values, _Right._Data.values);
     }
 
-    friend auto operator<=>(const _Derived& _Left, const _Derived& _Right) {
+    _NODISCARD_FRIEND auto operator<=>(const _Derived& _Left, const _Derived& _Right) {
         return _STD lexicographical_compare_three_way(
             _Left.cbegin(), _Left.cend(), _Right.cbegin(), _Right.cend(), _Synth_three_way{});
     }
@@ -741,34 +737,79 @@ protected:
 
     template <class _Predicate>
     size_type _Erase_if(_Predicate _Pred) {
-        _Clear_flat_map_scope_guard<_Flat_map_base> _Guard{this};
 
         auto _View           = _View_to_mutate();
         auto _Mut_first      = _View.begin();
         auto _Mut_last       = _View.end();
         const auto _Old_size = size();
 
-        _STD _Seek_wrapped(_Mut_first, _RANGES remove_if(_View, _Pred).begin());
+        _Clear_flat_map_scope_guard<_Flat_map_base> _Guard{this};
 
-        erase(const_iterator{_Mut_first._Key_it, _Mut_first._Mapped_it},
-            const_iterator{_Mut_last._Key_it, _Mut_last._Mapped_it});
+        _STD _Seek_wrapped(_Mut_first, _RANGES remove_if(_View, _Pred).begin());
+        (void) _Data.keys.erase(_Mut_first._Key_it, _Mut_last._Key_it);
+        (void) _Data.values.erase(_Mut_first._Mapped_it, _Mut_last._Mapped_it);
 
         _Guard._Clearable = nullptr;
         return _Old_size - size();
     }
 
-    template <class _KeyTy, class... _MappedArgTypes>
-    pair<iterator, bool> _Try_emplace(_KeyTy&& _Key_val, _MappedArgTypes&&... _Mapped_args) {
-        auto _Key_it = _STD lower_bound(_Data.keys.begin(), _Data.keys.end(), _Key_val, _Key_compare);
-        if (_Key_it != _Data.keys.end() && _Key_equal(*_Key_it, _STD forward<_KeyTy>(_Key_val))) {
-            // Already exists
-            return {this->begin() + _STD distance(_Data.keys.begin(), _Key_it), false};
+    template <bool _OverwriteIfExists, class _OtherKey, class... _MappedArgTypes>
+    iterator _Emplace_hint(const_iterator _Position, _OtherKey&& _Key_val, _MappedArgTypes&&... _Args) {
+        _STL_INTERNAL_STATIC_ASSERT(
+            is_constructible_v<mapped_type, _MappedArgTypes...>
+            && (is_same_v<remove_cvref_t<_OtherKey>, key_type>
+                || (is_constructible_v<key_type, _OtherKey> && _Is_transparent_v<key_compare>) ));
+        static_assert(_IsUnique || !_OverwriteIfExists,
+            "Overwriting is not supported when the container allows multiple copies of a key.");
+        const const_iterator _Begin = cbegin();
+        const const_iterator _End   = cend();
+
+        bool _Insert_before_position        = false;
+        bool _Insert_after_position_minus_1 = false;
+        if constexpr (_IsUnique) {
+            _Insert_before_position        = (_Position == _End) || _Key_compare(_Key_val, *(_Position._Key_it));
+            _Insert_after_position_minus_1 = (_Position == _Begin) || _Key_compare(*(_Position._Key_it - 1), _Key_val);
         } else {
-            // Need to insert
-            auto _Index = _STD distance(_Data.keys.begin(), _Key_it);
-            this->_Insert_exact(this->cbegin() + _Index, key_type{_STD forward<_KeyTy>(_Key_val)},
-                mapped_type{_STD forward<_MappedArgTypes>(_Mapped_args)...});
-            return {this->begin() + _Index, true};
+            _Insert_before_position        = (_Position == _End) || !_Key_compare(*(_Position._Key_it), _Key_val);
+            _Insert_after_position_minus_1 = (_Position == _Begin) || !_Key_compare(_Key_val, *(_Position._Key_it - 1));
+        }
+        bool _Hint_is_accurate = _Insert_before_position && _Insert_after_position_minus_1;
+
+        if (_Hint_is_accurate) {
+            auto _Dist = _STD distance(_Begin._Key_it, _Position._Key_it);
+            {
+                key_type _Key_to_insert(_STD forward<_OtherKey>(_Key_val));
+                mapped_type _Mapped_to_insert(_STD forward<_MappedArgTypes>(_Args)...);
+                _Insert_exact(_Position, _STD move(_Key_to_insert), _STD move(_Mapped_to_insert));
+            }
+            return begin() + _Dist;
+        } else {
+            if constexpr (_OverwriteIfExists) {
+                if (_Key_equal(_Key_val, *(_Position._Key_it))) {
+                    auto _Dist        = _STD distance(_Begin._Key_it, _Position._Key_it);
+                    auto _It          = begin() + _Dist;
+                    *(_It._Mapped_it) = mapped_type{_STD forward<_MappedArgTypes>(_Args)...};
+                    return _It;
+                }
+
+                _Position = lower_bound(_Key_val);
+                if (_Position != _End && _Key_equal(_Key_val, *(_Position._Key_it))) {
+                    auto _Dist        = _STD distance(_Begin._Key_it, _Position._Key_it);
+                    auto _It          = begin() + _Dist;
+                    *(_It._Mapped_it) = mapped_type{_STD forward<_MappedArgTypes>(_Args)...};
+                    return _It;
+                }
+            } else {
+                _Position = lower_bound(_Key_val);
+            }
+
+            const auto _Dist = _STD distance(_Begin._Key_it, _Position._Key_it);
+            {
+                key_type _Key_to_insert(_STD forward<_OtherKey>(_Key_val));
+                mapped_type _Mapped_to_insert(_STD forward<_MappedArgTypes>(_Args)...);
+                _Insert_exact(_Position, _STD move(_Key_to_insert), _STD move(_Mapped_to_insert));
+            }
+            return begin() + _Dist;
         }
     }
 
@@ -779,16 +820,17 @@ protected:
         _Guard._Clearable = nullptr;
     }
 
-private:
     template <class _KeyTy1, class _KeyTy2>
-        requires (same_as<remove_cvref_t<_KeyTy1 &&>, key_type> && same_as<remove_cvref_t<_KeyTy2 &&>, key_type>)
-              || (constructible_from<key_type, _KeyTy1 &&> && constructible_from<key_type, _KeyTy2 &&>
-                  && _Is_transparent_v<key_compare>)
     bool _Key_equal(_KeyTy1&& _Left, _KeyTy2&& _Right) const {
+        _STL_INTERNAL_STATIC_ASSERT(
+            (is_same_v<remove_cvref_t<_KeyTy1>, key_type> && is_same_v<remove_cvref_t<_KeyTy2>, key_type>)
+            || (is_constructible_v<key_type, _KeyTy1> && is_constructible_v<key_type, _KeyTy2>
+                && _Is_transparent_v<key_compare>) );
         return !_Key_compare(_STD forward<_KeyTy1>(_Left), _STD forward<_KeyTy2>(_Right))
             && !_Key_compare(_STD forward<_KeyTy2>(_Right), _STD forward<_KeyTy1>(_Left));
     }
 
+private:
     auto _View_to_mutate() {
         using _Mutating_iterator = _Pairing_iterator_provider<typename key_container_type::iterator,
             typename mapped_container_type::iterator, typename mapped_container_type::iterator>::_Iterator;
@@ -814,58 +856,6 @@ private:
         _Guard._Clearable = nullptr;
     }
 
-    template <bool _OverwriteIfExists, class _OtherKey, class... _MappedArgTypes>
-    iterator _Emplace_hint(const_iterator _Position, _OtherKey&& _Key_val, _MappedArgTypes&&... _Args)
-        requires is_constructible_v<mapped_type, _MappedArgTypes...>
-              && (same_as<remove_cvref_t<_OtherKey &&>, key_type>
-                  || (constructible_from<key_type, _OtherKey &&> && _Is_transparent_v<key_compare>) )
-    {
-        static_assert(!(_IsMulti && _OverwriteIfExists),
-            "Overwriting is not supported when the container allows multiple copies of a key.");
-        const const_iterator _Begin = cbegin();
-        const const_iterator _End   = cend();
-
-        bool _Insert_before_position        = false;
-        bool _Insert_after_position_minus_1 = false;
-        if constexpr (_IsMulti) {
-            _Insert_before_position        = (_Position == _End) || !_Key_compare(*(_Position._Key_it), _Key_val);
-            _Insert_after_position_minus_1 = (_Position == _Begin) || !_Key_compare(_Key_val, *(_Position._Key_it - 1));
-        } else {
-            _Insert_before_position        = (_Position == _End) || _Key_compare(_Key_val, *(_Position._Key_it));
-            _Insert_after_position_minus_1 = (_Position == _Begin) || _Key_compare(*(_Position._Key_it - 1), _Key_val);
-        }
-        bool _Hint_is_accurate = _Insert_before_position && _Insert_after_position_minus_1;
-
-        if (_Hint_is_accurate) {
-            auto _Dist = _STD distance(_Begin._Key_it, _Position._Key_it);
-            _Insert_exact(_Position, key_type{_STD forward<_OtherKey>(_Key_val)},
-                mapped_type{_STD forward<_MappedArgTypes>(_Args)...});
-            return begin() + _Dist;
-        } else {
-            if constexpr (_OverwriteIfExists) {
-                if (_Key_equal(_Key_val, *(_Position._Key_it))) {
-                    auto _Dist        = _STD distance(_Begin._Key_it, _Position._Key_it);
-                    auto _It          = begin() + _Dist;
-                    *(_It._Mapped_it) = mapped_type{_STD forward<_MappedArgTypes>(_Args)...};
-                    return _It;
-                }
-            }
-
-            _Position = lower_bound(_Key_val);
-            if (_OverwriteIfExists && _Position != _End && _Key_equal(_Key_val, *(_Position._Key_it))) {
-                auto _Dist        = _STD distance(_Begin._Key_it, _Position._Key_it);
-                auto _It          = begin() + _Dist;
-                *(_It._Mapped_it) = mapped_type{_STD forward<_MappedArgTypes>(_Args)...};
-                return _It;
-            } else {
-                auto _Dist = _STD distance(_Begin._Key_it, _Position._Key_it);
-                _Insert_exact(_Position, key_type{_STD forward<_OtherKey>(_Key_val)},
-                    mapped_type{_STD forward<_MappedArgTypes>(_Args)...});
-                return begin() + _Dist;
-            }
-        }
-    }
-
     template <bool _NeedSorting, bool _NeedDeduping, class _InputIterator>
         requires _Is_iterator_v<_InputIterator>
     void _Insert_range(_InputIterator _First, _InputIterator _Last) {
@@ -903,17 +893,15 @@ private:
 
     template <class _KeyTy>
     size_type _Erase_key(_KeyTy&& _Key_val) {
-        const_iterator _Pos_begin = lower_bound(_STD forward<_KeyTy>(_Key_val));
-        const_iterator _Pos_end   = upper_bound(_STD forward<_KeyTy>(_Key_val));
-        size_type _Count          = _Pos_end - _Pos_begin;
-        erase(_Pos_begin, _Pos_end);
+        const auto _Equal_pos = equal_range(_STD forward<_KeyTy>(_Key_val));
+        const auto _Count     = static_cast<size_type>(_Equal_pos.second - _Equal_pos.first);
+        erase(_Equal_pos.second, _Equal_pos.first);
         return _Count;
     }
 
     template <class _KeyTy>
-    iterator _Find(const _KeyTy& _Key_val)
-        requires same_as<_KeyTy, key_type> || _Is_transparent_v<key_compare>
-    {
+    _NODISCARD iterator _Find(const _KeyTy& _Key_val) {
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Is_transparent_v<key_compare>);
         iterator _Position = lower_bound(_Key_val);
         if (_Position != end() && _Key_equal(_Position->first, _Key_val)) {
             return _Position;
@@ -923,9 +911,8 @@ private:
     }
 
     template <class _KeyTy>
-    const_iterator _Find(const _KeyTy& _Key_val) const
-        requires same_as<_KeyTy, key_type> || _Is_transparent_v<key_compare>
-    {
+    _NODISCARD const_iterator _Find(const _KeyTy& _Key_val) const {
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Is_transparent_v<key_compare>);
         const_iterator _Position = lower_bound(_Key_val);
         if (_Position != cend() && _Key_equal(_Position->first, _Key_val)) {
             return _Position;
@@ -935,23 +922,20 @@ private:
     }
 
     template <class _KeyTy>
-    size_type _Count(const _KeyTy& _Key_val) const
-        requires same_as<_KeyTy, key_type> || _Is_transparent_v<key_compare>
-    {
+    _NODISCARD size_type _Count(const _KeyTy& _Key_val) const {
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Is_transparent_v<key_compare>);
         return upper_bound(_Key_val) - lower_bound(_Key_val);
     }
 
     template <class _KeyTy>
-    bool _Contains(const _KeyTy& _Key_val) const
-        requires same_as<_KeyTy, key_type> || _Is_transparent_v<key_compare>
-    {
+    _NODISCARD bool _Contains(const _KeyTy& _Key_val) const {
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Is_transparent_v<key_compare>);
         return find(_Key_val) != cend();
     }
 
     template <class _KeyTy>
-    iterator _Lower_bound(const _KeyTy& _Key_val)
-        requires same_as<_KeyTy, key_type> || _Is_transparent_v<key_compare>
-    {
+    _NODISCARD iterator _Lower_bound(const _KeyTy& _Key_val) {
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Is_transparent_v<key_compare>);
         auto _Key_it = _STD lower_bound(_Data.keys.cbegin(), _Data.keys.cend(), _Key_val, _Key_compare);
         auto _Dist   = _STD distance(_Data.keys.cbegin(), _Key_it);
         auto _Val_it = _Data.values.begin() + _Dist;
@@ -959,9 +943,8 @@ private:
     }
 
     template <class _KeyTy>
-    const_iterator _Lower_bound(const _KeyTy& _Key_val) const
-        requires same_as<_KeyTy, key_type> || _Is_transparent_v<key_compare>
-    {
+    _NODISCARD const_iterator _Lower_bound(const _KeyTy& _Key_val) const {
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Is_transparent_v<key_compare>);
         auto _Key_it = _STD lower_bound(_Data.keys.cbegin(), _Data.keys.cend(), _Key_val, _Key_compare);
         auto _Dist   = _STD distance(_Data.keys.cbegin(), _Key_it);
         auto _Val_it = _Data.values.cbegin() + _Dist;
@@ -969,9 +952,8 @@ private:
     }
 
     template <class _KeyTy>
-    iterator _Upper_bound(const _KeyTy& _Key_val)
-        requires same_as<_KeyTy, key_type> || _Is_transparent_v<key_compare>
-    {
+    _NODISCARD iterator _Upper_bound(const _KeyTy& _Key_val) {
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Is_transparent_v<key_compare>);
         auto _Key_it = _STD upper_bound(_Data.keys.cbegin(), _Data.keys.cend(), _Key_val, _Key_compare);
         auto _Dist   = _STD distance(_Data.keys.cbegin(), _Key_it);
         auto _Val_it = _Data.values.begin() + _Dist;
@@ -979,9 +961,8 @@ private:
     }
 
     template <class _KeyTy>
-    const_iterator _Upper_bound(const _KeyTy& _Key_val) const
-        requires same_as<_KeyTy, key_type> || _Is_transparent_v<key_compare>
-    {
+    _NODISCARD const_iterator _Upper_bound(const _KeyTy& _Key_val) const {
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Is_transparent_v<key_compare>);
         auto _Key_it = _STD upper_bound(_Data.keys.cbegin(), _Data.keys.cend(), _Key_val, _Key_compare);
         auto _Dist   = _STD distance(_Data.keys.cbegin(), _Key_it);
         auto _Val_it = _Data.values.cbegin() + _Dist;
@@ -989,26 +970,22 @@ private:
     }
 
     template <class _KeyTy>
-    pair<iterator, iterator> _Equal_range(const _KeyTy& _Key_val)
-        requires same_as<_KeyTy, key_type> || _Is_transparent_v<key_compare>
-    {
+    _NODISCARD pair<iterator, iterator> _Equal_range(const _KeyTy& _Key_val) {
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Is_transparent_v<key_compare>);
         return {lower_bound(_Key_val), upper_bound(_Key_val)};
     }
 
     template <class _KeyTy>
-    pair<const_iterator, const_iterator> _Equal_range(const _KeyTy& _Key_val) const
-        requires same_as<_KeyTy, key_type> || _Is_transparent_v<key_compare>
-    {
+    _NODISCARD pair<const_iterator, const_iterator> _Equal_range(const _KeyTy& _Key_val) const {
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Is_transparent_v<key_compare>);
         return {lower_bound(_Key_val), upper_bound(_Key_val)};
     }
 };
 
-template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer>
-class flat_map : public _Flat_map_base<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer, false,
-                     flat_map<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>> {
+_EXPORT_STD template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer>
+class flat_map : public _Flat_map_base<true, _Key, _Mapped, _Compare, _KeyContainer, _MappedContainer> {
 private:
-    using _MyBase = _Flat_map_base<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer, false,
-        flat_map<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>>;
+    using _MyBase = _Flat_map_base<true, _Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>;
 
     using _MyBase::_Data;
     using _MyBase::_Key_compare;
@@ -1099,7 +1076,7 @@ public:
 
     template <class _OtherKey, class... _MappedArgTypes>
         requires _Is_transparent_v<key_compare> && is_constructible_v<key_type, _OtherKey>
-              && is_constructible_v<mapped_type, _MappedArgTypes&&...>
+              && is_constructible_v<mapped_type, _MappedArgTypes...>
               && (!is_convertible_v<_OtherKey, const_iterator>) && (!is_convertible_v<_OtherKey, iterator>)
     pair<iterator, bool> try_emplace(_OtherKey&& _Key_val, _MappedArgTypes&&... _Mapped_args) {
         return _Try_emplace(_STD forward<_OtherKey>(_Key_val), _STD forward<_MappedArgTypes>(_Mapped_args)...);
@@ -1107,7 +1084,7 @@ public:
 
     template <class... _MappedArgTypes>
     iterator try_emplace(const_iterator _Position, const key_type& _Key_val, _MappedArgTypes&&... _Mapped_args)
-        requires is_constructible_v<mapped_type, _MappedArgTypes&&...>
+        requires is_constructible_v<mapped_type, _MappedArgTypes...>
     {
         return this->template _Emplace_hint<false>(_Position, _Key_val, _STD forward<_MappedArgTypes>(_Mapped_args)...);
     }
@@ -1155,14 +1132,14 @@ public:
     iterator insert_or_assign(const_iterator _Position, const key_type& _Key_val, _MappedTy&& _Mapped_val)
         requires is_assignable_v<mapped_type&, _MappedTy> && is_constructible_v<mapped_type, _MappedTy>
     {
-        return this->_Emplace_hint<true>(_Position, _Key_val, _STD forward<_MappedTy>(_Mapped_val));
+        return this->template _Emplace_hint<true>(_Position, _Key_val, _STD forward<_MappedTy>(_Mapped_val));
     }
 
     template <class _MappedTy>
     iterator insert_or_assign(const_iterator _Position, key_type&& _Key_val, _MappedTy&& _Mapped_val)
         requires is_assignable_v<mapped_type&, _MappedTy> && is_constructible_v<mapped_type, _MappedTy>
     {
-        return this->_Emplace_hint<true>(_Position, _STD move(_Key_val), _STD forward<_MappedTy>(_Mapped_val));
+        return this->template _Emplace_hint<true>(_Position, _STD move(_Key_val), _STD forward<_MappedTy>(_Mapped_val));
     }
 
     template <class _OtherKey, class _MappedTy>
@@ -1170,22 +1147,23 @@ public:
         requires _Is_transparent_v<key_compare> && is_constructible_v<key_type, _OtherKey>
               && is_assignable_v<mapped_type&, _MappedTy> && is_constructible_v<mapped_type, _MappedTy>
     {
-        return this->_Emplace_hint<true>(
+        return this->template _Emplace_hint<true>(
             _Position, _STD forward<_OtherKey>(_Key_val), _STD forward<_MappedTy>(_Mapped_val));
     }
 
 private:
+    using _MyBase::_Emplace_hint;
     using _MyBase::_Erase_if;
-    using _MyBase::_Try_emplace;
+    using _MyBase::_Insert_exact;
+    using _MyBase::_Key_equal;
 
     template <class _KTy, class _MTy, class _Comp, class _KeyCont, class _MappedCont, class _Pred>
     friend typename flat_map<_KTy, _MTy, _Comp, _KeyCont, _MappedCont>::size_type erase_if(
         flat_map<_KTy, _MTy, _Comp, _KeyCont, _MappedCont>&, _Pred);
 
     template <class _KeyTy>
-    _NODISCARD mapped_type& _At(const _KeyTy& _Key_val)
-        requires same_as<_KeyTy, key_type> || _Is_transparent_v<key_compare>
-    {
+    _NODISCARD mapped_type& _At(const _KeyTy& _Key_val) {
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Is_transparent_v<key_compare>);
         const auto _Position = this->find(_Key_val);
         if (_Position == this->end()) {
             _Xout_of_range("std::flat_map::at: the specified key does not exist.");
@@ -1195,9 +1173,8 @@ private:
     }
 
     template <class _KeyTy>
-    _NODISCARD const mapped_type& _At(const _KeyTy& _Key_val) const
-        requires same_as<_KeyTy, key_type> || _Is_transparent_v<key_compare>
-    {
+    _NODISCARD const mapped_type& _At(const _KeyTy& _Key_val) const {
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Is_transparent_v<key_compare>);
         const auto _Position = this->find(_Key_val);
         if (_Position == this->end()) {
             _Xout_of_range("std::flat_map::at: the specified key does not exist.");
@@ -1206,6 +1183,24 @@ private:
         }
     }
 
+    template <class _KeyTy, class... _MappedArgTypes>
+    pair<iterator, bool> _Try_emplace(_KeyTy&& _Key_val, _MappedArgTypes&&... _Mapped_args) {
+        auto _Key_it = _STD lower_bound(_Data.keys.begin(), _Data.keys.end(), _Key_val, _Key_compare);
+        if (_Key_it != _Data.keys.end() && _Key_equal(*_Key_it, _STD forward<_KeyTy>(_Key_val))) {
+            // Already exists
+            return {this->begin() + _STD distance(_Data.keys.begin(), _Key_it), false};
+        } else {
+            // Need to insert
+            auto _Index = _STD distance(_Data.keys.begin(), _Key_it);
+            {
+                key_type _Key_to_insert(_STD forward<_KeyTy>(_Key_val));
+                mapped_type _Mapped_to_insert(_STD forward<_MappedArgTypes>(_Mapped_args)...);
+                this->_Insert_exact(this->cbegin() + _Index, _STD move(_Key_to_insert), _STD move(_Mapped_to_insert));
+            }
+            return {this->begin() + _Index, true};
+        }
+    }
+
     template <class _KeyTy, class _MappedTy>
     pair<iterator, bool> _Insert_or_assign(_KeyTy&& _Key_val, _MappedTy&& _Mapped_val) {
         auto _Res = _Try_emplace(_STD forward<_KeyTy>(_Key_val), _STD forward<_MappedTy>(_Mapped_val));
@@ -1283,17 +1278,15 @@ struct uses_allocator<flat_map<_Key, _Mapped, _Compare, _KeyContainer, _MappedCo
 
 _EXPORT_STD template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer,
     class _Predicate>
-typename flat_map<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>::size_type erase_if(
+flat_map<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>::size_type erase_if(
     flat_map<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>& _Cont, _Predicate _Pred) {
     return _Cont._Erase_if(_STD _Pass_fn(_Pred));
 }
 
-template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer>
-class flat_multimap : public _Flat_map_base<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer, true,
-                          flat_multimap<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>> {
+_EXPORT_STD template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer>
+class flat_multimap : public _Flat_map_base<false, _Key, _Mapped, _Compare, _KeyContainer, _MappedContainer> {
 private:
-    using _MyBase = _Flat_map_base<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer, true,
-        flat_multimap<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>>;
+    using _MyBase = _Flat_map_base<false, _Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>;
 
     using _MyBase::_Data;
     using _MyBase::_Key_compare;
@@ -1328,8 +1321,10 @@ public:
     }
 
 private:
+    using _MyBase::_Emplace_hint;
     using _MyBase::_Erase_if;
     using _MyBase::_Insert_exact;
+    using _MyBase::_Key_equal;
 
     template <class _KTy, class _MTy, class _Comp, class _KeyCont, class _MappedCont, class _Pred>
     friend typename flat_multimap<_KTy, _MTy, _Comp, _KeyCont, _MappedCont>::size_type erase_if(
@@ -1337,11 +1332,14 @@ private:
 
     template <class _KeyTy, class _MappedTy>
     iterator _Emplace_key_mapped(_KeyTy&& _Key_val, _MappedTy&& _Mapped_val) {
-        auto _Key_it = _STD lower_bound(_Data.keys.begin(), _Data.keys.end(), _Key_val, _Key_compare);
-        auto _Index  = _STD distance(_Data.keys.begin(), _Key_it);
+        const auto _Key_it = _STD lower_bound(_Data.keys.begin(), _Data.keys.end(), _Key_val, _Key_compare);
+        const auto _Index  = _STD distance(_Data.keys.begin(), _Key_it);
 
-        this->_Insert_exact(
-            this->cbegin() + _Index, _STD forward<_KeyTy>(_Key_val), _STD forward<_MappedTy>(_Mapped_val));
+        {
+            _Key _Key_to_insert(_STD forward<_KeyTy>(_Key_val));
+            _Mapped _Mapped_to_insert(_STD forward<_MappedTy>(_Mapped_val));
+            this->_Insert_exact(this->cbegin() + _Index, _STD move(_Key_to_insert), _STD move(_Mapped_to_insert));
+        }
         return this->begin() + _Index;
     }
 };
@@ -1408,7 +1406,7 @@ struct uses_allocator<flat_multimap<_Key, _Mapped, _Compare, _KeyContainer, _Map
 
 _EXPORT_STD template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer,
     class _Predicate>
-typename flat_multimap<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>::size_type erase_if(
+flat_multimap<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>::size_type erase_if(
     flat_multimap<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>& _Cont, _Predicate _Pred) {
     return _Cont._Erase_if(_STD _Pass_fn(_Pred));
 }
diff --git a/tests/std/include/test_header_units_and_modules.hpp b/tests/std/include/test_header_units_and_modules.hpp
index da06e630897..6255691ff6c 100644
--- a/tests/std/include/test_header_units_and_modules.hpp
+++ b/tests/std/include/test_header_units_and_modules.hpp
@@ -241,7 +241,24 @@ void test_flat_map() {
     using namespace std;
     puts("Testing <flat_map>.");
 
-    // FIXME! ADD TEST COVERAGE HERE!
+    [[maybe_unused]] constexpr sorted_unique_t unique_tag         = sorted_unique;
+    [[maybe_unused]] constexpr sorted_equivalent_t equivalent_tag = sorted_equivalent;
+
+    constexpr auto simple_truth = [](const auto&) { return true; };
+
+    flat_map<int, int> fm;
+    fm.emplace(1, 1);
+    fm.emplace(1, 2);
+    assert(fm.size() == 1);
+    erase_if(fm, simple_truth);
+    assert(fm.empty());
+
+    flat_multimap<int, int> fmm;
+    fmm.emplace(1, 1);
+    fmm.emplace(1, 2);
+    assert(fmm.size() == 2);
+    erase_if(fmm, simple_truth);
+    assert(fmm.empty());
 }
 #endif // TEST_STANDARD >= 23
 
diff --git a/tests/std/tests/P0429R9_flat_map/env.lst b/tests/std/tests/P0429R9_flat_map/env.lst
index 8ac7033b206..642f530ffad 100644
--- a/tests/std/tests/P0429R9_flat_map/env.lst
+++ b/tests/std/tests/P0429R9_flat_map/env.lst
@@ -1,4 +1,4 @@
 # Copyright (c) Microsoft Corporation.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
+RUNALL_INCLUDE ..\usual_latest_matrix.lst
diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index 11bdfb3a8c7..ce73a32703f 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -18,7 +18,8 @@ template <template <class...> class Tmpl, class... Ts>
 constexpr bool is_specialization_v<Tmpl<Ts...>, Tmpl> = true;
 
 template <typename T>
-concept IsFlatMap = is_specialization_v<remove_cvref_t<T>, flat_map>;
+concept IsFlatMap =
+    is_specialization_v<remove_cvref_t<T>, flat_map> || is_specialization_v<remove_cvref_t<T>, flat_multimap>;
 
 template <IsFlatMap T>
 bool check_container_requirements(T&&) {
@@ -268,37 +269,39 @@ void test_pointer_to_incomplete_type() {
     flat_map<MyType<Incomplete>, shared_ptr<MyType<Incomplete>>> fmap;
 }
 
-// Test MSVC STL-specific SCARY-ness
-namespace scary_test {
-    static_assert(is_same_v<flat_map<int, int>::iterator, flat_map<int, int, greater<int>>::iterator>);
-    static_assert(is_same_v<flat_map<int, int>::iterator,
-        flat_map<int, int, less<>, vector<int, MyAllocator<int>>, vector<int, MyAllocator<int>>>::iterator>);
-    static_assert(is_same_v<flat_map<int, int>::const_iterator, flat_map<int, int, greater<int>>::const_iterator>);
-    static_assert(is_same_v<flat_map<int, int>::const_iterator,
-        flat_map<int, int, less<>, vector<int, MyAllocator<int>>, vector<int, MyAllocator<int>>>::const_iterator>);
-
-    static_assert(is_same_v<flat_multimap<int, int>::iterator, flat_multimap<int, int, greater<int>>::iterator>);
-    static_assert(is_same_v<flat_multimap<int, int>::iterator,
-        flat_multimap<int, int, less<>, vector<int, MyAllocator<int>>, vector<int, MyAllocator<int>>>::iterator>);
-    static_assert(
-        is_same_v<flat_multimap<int, int>::const_iterator, flat_multimap<int, int, greater<int>>::const_iterator>);
-    static_assert(is_same_v<flat_multimap<int, int>::const_iterator,
-        flat_multimap<int, int, less<>, vector<int, MyAllocator<int>>, vector<int, MyAllocator<int>>>::const_iterator>);
-
-    static_assert(is_same_v<flat_map<int, int>::iterator, flat_multimap<int, int>::iterator>);
-    static_assert(is_same_v<flat_map<int, int>::const_iterator, flat_multimap<int, int>::const_iterator>);
-
-    static_assert(is_same_v<flat_map<int, int>::containers, flat_map<int, int, greater<int>>::containers>);
-    static_assert(is_same_v<flat_multimap<int, int>::containers, flat_multimap<int, int, greater<int>>::containers>);
-    static_assert(is_same_v<flat_map<int, int>::containers, flat_multimap<int, int>::containers>);
-
-    static_assert(is_same_v<flat_map<int, int>::value_compare,
-        flat_map<int, int, less<int>, vector<int, MyAllocator<int>>, vector<int, MyAllocator<int>>>::value_compare>);
-    static_assert(is_same_v<flat_multimap<int, int>::value_compare,
-        flat_multimap<int, int, less<int>, vector<int, MyAllocator<int>>,
-            vector<int, MyAllocator<int>>>::value_compare>);
-    static_assert(is_same_v<flat_map<int, int>::value_compare, flat_multimap<int, int>::value_compare>);
-} // namespace scary_test
+void test_insert_unique() {
+    flat_map<int, char> fm;
+
+    const auto p1 = fm.insert({10, 'm'});
+    assert(p1.first->first == 10);
+    assert(p1.first->second == 'm');
+    assert(p1.second);
+
+    const flat_map<int, char>::value_type val_pair{90, 'w'};
+    const auto p2 = fm.insert(val_pair);
+    assert(p2.first->first == 90);
+    assert(p2.first->second == 'w');
+    assert(p2.second);
+
+    assert(check_key_content(fm, {10, 90}));
+    assert(check_value_content(fm, {'m', 'w'}));
+}
+
+void test_insert_multi() {
+    flat_multimap<int, char> fmm;
+
+    const auto it1 = fmm.insert({10, 'm'});
+    assert(it1->first == 10);
+    assert(it1->second == 'm');
+
+    const flat_multimap<int, char>::value_type val_pair{90, 'w'};
+    const auto it2 = fmm.insert(val_pair);
+    assert(it2->first == 90);
+    assert(it2->second == 'w');
+
+    assert(check_key_content(fmm, {10, 90}));
+    assert(check_value_content(fmm, {'m', 'w'}));
+}
 
 // GH-4344 <flat_map> Fix compile errors
 void test_gh_4344() {
@@ -333,9 +336,108 @@ void test_gh_4344() {
     assert(check_value_content(fm, {'m', 'o', 'e', 'w'}));
 }
 
+void test_insert_or_assign() {
+    flat_map<int, char> fm;
+
+    const auto p1 = fm.insert_or_assign(10, 'm');
+    assert(p1.first->first == 10);
+    assert(p1.first->second == 'm');
+    assert(p1.second);
+
+    const auto p2 = fm.insert_or_assign(70, 'e');
+    assert(p2.first->first == 70);
+    assert(p2.first->second == 'e');
+    assert(p2.second);
+
+    const auto p3 = fm.insert_or_assign(20, 'o');
+    assert(p3.first->first == 20);
+    assert(p3.first->second == 'o');
+    assert(p3.second);
+
+    const auto p4 = fm.insert_or_assign(90, 'w');
+    assert(p4.first->first == 90);
+    assert(p4.first->second == 'w');
+    assert(p4.second);
+
+    const auto p5 = fm.insert_or_assign(70, 'X');
+    assert(p5.first->first == 70);
+    assert(p5.first->second == 'X');
+    assert(!p5.second);
+
+    assert(check_key_content(fm, {10, 20, 70, 90}));
+    assert(check_value_content(fm, {'m', 'o', 'X', 'w'}));
+
+    const auto it6 = fm.insert_or_assign(fm.cbegin(), 10, 'b');
+    assert(it6->first == 10);
+    assert(it6->second == 'b');
+
+    const char ch  = 'a';
+    const auto it7 = fm.insert_or_assign(fm.cbegin(), 20, ch);
+    assert(it7->first == 20);
+    assert(it7->second == 'a');
+
+    assert(check_key_content(fm, {10, 20, 70, 90}));
+    assert(check_value_content(fm, {'b', 'a', 'X', 'w'}));
+}
+
+// Test MSVC STL-specific SCARY-ness
+template <bool IsUnique, class Comparator, class Alloc1, class Alloc2>
+void test_scary_ness_one() { // COMPILE-ONLY
+    using Iter      = flat_map<int, int>::iterator;
+    using OtherIter = conditional_t<IsUnique, flat_map<int, int, Comparator, vector<int, Alloc1>, vector<int, Alloc2>>,
+        flat_multimap<int, int, Comparator, vector<int, Alloc1>, vector<int, Alloc2>>>::iterator;
+    static_assert(is_same_v<Iter, OtherIter>);
+
+    using ConstIter = flat_map<int, int>::const_iterator;
+    using OtherConstIter =
+        conditional_t<IsUnique, flat_map<int, int, Comparator, vector<int, Alloc1>, vector<int, Alloc2>>,
+            flat_multimap<int, int, Comparator, vector<int, Alloc1>, vector<int, Alloc2>>>::const_iterator;
+    static_assert(is_same_v<ConstIter, OtherConstIter>);
+
+    using Cont      = flat_map<int, int, less<int>, vector<int, Alloc1>, vector<int, Alloc2>>::containers;
+    using OtherCont = conditional_t<IsUnique, flat_map<int, int, Comparator, vector<int, Alloc1>, vector<int, Alloc2>>,
+        flat_multimap<int, int, Comparator, vector<int, Alloc1>, vector<int, Alloc2>>>::containers;
+    static_assert(is_same_v<Cont, OtherCont>);
+
+    using ValueComp = flat_map<int, int, Comparator, vector<int, Alloc1>, vector<int, Alloc2>>::value_compare;
+    using OtherValueComp =
+        conditional_t<IsUnique, flat_map<int, int, Comparator, vector<int, Alloc1>, vector<int, Alloc2>>,
+            flat_multimap<int, int, Comparator, vector<int, Alloc1>, vector<int, Alloc2>>>::value_compare;
+    static_assert(is_same_v<ValueComp, OtherValueComp>);
+}
+
+void test_scary_ness() { // COMPILE-ONLY
+    test_scary_ness_one<true, greater<int>, allocator<int>, allocator<int>>();
+    test_scary_ness_one<true, greater<int>, allocator<int>, MyAllocator<int>>();
+    test_scary_ness_one<true, greater<int>, MyAllocator<int>, allocator<int>>();
+
+    test_scary_ness_one<true, less<>, allocator<int>, allocator<int>>();
+    test_scary_ness_one<true, less<>, allocator<int>, MyAllocator<int>>();
+    test_scary_ness_one<true, less<>, MyAllocator<int>, allocator<int>>();
+
+    test_scary_ness_one<true, greater<>, allocator<int>, allocator<int>>();
+    test_scary_ness_one<true, greater<>, allocator<int>, MyAllocator<int>>();
+    test_scary_ness_one<true, greater<>, MyAllocator<int>, allocator<int>>();
+
+    test_scary_ness_one<false, greater<int>, allocator<int>, allocator<int>>();
+    test_scary_ness_one<false, greater<int>, allocator<int>, MyAllocator<int>>();
+    test_scary_ness_one<false, greater<int>, MyAllocator<int>, allocator<int>>();
+
+    test_scary_ness_one<false, less<>, allocator<int>, allocator<int>>();
+    test_scary_ness_one<false, less<>, allocator<int>, MyAllocator<int>>();
+    test_scary_ness_one<false, less<>, MyAllocator<int>, allocator<int>>();
+
+    test_scary_ness_one<false, greater<>, allocator<int>, allocator<int>>();
+    test_scary_ness_one<false, greater<>, allocator<int>, MyAllocator<int>>();
+    test_scary_ness_one<false, greater<>, MyAllocator<int>, allocator<int>>();
+}
+
 int main() {
     test_construction();
     test_pointer_to_incomplete_type();
     test_erase_if();
+    test_insert_unique();
+    test_insert_multi();
     test_gh_4344();
+    test_insert_or_assign();
 }

From a3bc9c7bd9dec461b5dd71cd0eee77cc96137714 Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34@live.cn>
Date: Wed, 13 Mar 2024 17:47:40 +0800
Subject: [PATCH 030/134] `<flat_map>`: Various cleanups and bug fixes (#4468)

---
 stl/inc/flat_map                              | 200 +++++++++++-------
 .../include/test_header_units_and_modules.hpp |  12 +-
 tests/std/tests/P0429R9_flat_map/test.cpp     | 121 ++++++++---
 3 files changed, 219 insertions(+), 114 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index 5391ac79285..bc14e268b33 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -126,7 +126,7 @@ struct _Pairing_iterator_provider {
         }
 
         pointer operator->() const {
-            return pointer{*(*this)};
+            return pointer{**this};
         }
 
         _Iterator& operator++() {
@@ -722,8 +722,9 @@ public:
     }
 
     _NODISCARD_FRIEND auto operator<=>(const _Derived& _Left, const _Derived& _Right) {
-        return _STD lexicographical_compare_three_way(
-            _Left.cbegin(), _Left.cend(), _Right.cbegin(), _Right.cend(), _Synth_three_way{});
+        return _STD lexicographical_compare_three_way(_STD _Get_unwrapped(_Left.cbegin()),
+            _STD _Get_unwrapped(_Left.cend()), _STD _Get_unwrapped(_Right.cbegin()), _STD _Get_unwrapped(_Right.cend()),
+            _Synth_three_way{});
     }
 
     friend void swap(_Derived& _Left, _Derived& _Right) noexcept {
@@ -737,7 +738,6 @@ protected:
 
     template <class _Predicate>
     size_type _Erase_if(_Predicate _Pred) {
-
         auto _View           = _View_to_mutate();
         auto _Mut_first      = _View.begin();
         auto _Mut_last       = _View.end();
@@ -764,53 +764,55 @@ protected:
         const const_iterator _Begin = cbegin();
         const const_iterator _End   = cend();
 
-        bool _Insert_before_position        = false;
-        bool _Insert_after_position_minus_1 = false;
-        if constexpr (_IsUnique) {
-            _Insert_before_position        = (_Position == _End) || _Key_compare(_Key_val, *(_Position._Key_it));
-            _Insert_after_position_minus_1 = (_Position == _Begin) || _Key_compare(*(_Position._Key_it - 1), _Key_val);
-        } else {
-            _Insert_before_position        = (_Position == _End) || !_Key_compare(*(_Position._Key_it), _Key_val);
-            _Insert_after_position_minus_1 = (_Position == _Begin) || !_Key_compare(_Key_val, *(_Position._Key_it - 1));
-        }
-        bool _Hint_is_accurate = _Insert_before_position && _Insert_after_position_minus_1;
+        const bool _Hint_is_accurate = [&] {
+            if constexpr (_IsUnique) {
+                if (_Position == _End || _Key_compare(_Key_val, *_Position._Key_it)) {
+                    return _Position == _Begin || _Key_compare(_Position._Key_it[-1], _Key_val);
+                }
+            } else {
+                if (_Position == _End || !_Key_compare(*_Position._Key_it, _Key_val)) {
+                    return _Position == _Begin || !_Key_compare(_Key_val, _Position._Key_it[-1]);
+                }
+            }
+            return false;
+        }();
 
         if (_Hint_is_accurate) {
-            auto _Dist = _STD distance(_Begin._Key_it, _Position._Key_it);
+            const auto _Dist = _Position._Key_it - _Begin._Key_it;
             {
                 key_type _Key_to_insert(_STD forward<_OtherKey>(_Key_val));
                 mapped_type _Mapped_to_insert(_STD forward<_MappedArgTypes>(_Args)...);
                 _Insert_exact(_Position, _STD move(_Key_to_insert), _STD move(_Mapped_to_insert));
             }
             return begin() + _Dist;
-        } else {
-            if constexpr (_OverwriteIfExists) {
-                if (_Key_equal(_Key_val, *(_Position._Key_it))) {
-                    auto _Dist        = _STD distance(_Begin._Key_it, _Position._Key_it);
-                    auto _It          = begin() + _Dist;
-                    *(_It._Mapped_it) = mapped_type{_STD forward<_MappedArgTypes>(_Args)...};
-                    return _It;
-                }
+        }
 
-                _Position = lower_bound(_Key_val);
-                if (_Position != _End && _Key_equal(_Key_val, *(_Position._Key_it))) {
-                    auto _Dist        = _STD distance(_Begin._Key_it, _Position._Key_it);
-                    auto _It          = begin() + _Dist;
-                    *(_It._Mapped_it) = mapped_type{_STD forward<_MappedArgTypes>(_Args)...};
-                    return _It;
-                }
-            } else {
-                _Position = lower_bound(_Key_val);
+        if constexpr (_OverwriteIfExists) {
+            if (_Key_equal(_Key_val, *_Position._Key_it)) {
+                const auto _Dist = _Position._Key_it - _Begin._Key_it;
+                const auto _It   = begin() + _Dist;
+                *_It._Mapped_it  = mapped_type(_STD forward<_MappedArgTypes>(_Args)...);
+                return _It;
             }
 
-            const auto _Dist = _STD distance(_Begin._Key_it, _Position._Key_it);
-            {
-                key_type _Key_to_insert(_STD forward<_OtherKey>(_Key_val));
-                mapped_type _Mapped_to_insert(_STD forward<_MappedArgTypes>(_Args)...);
-                _Insert_exact(_Position, _STD move(_Key_to_insert), _STD move(_Mapped_to_insert));
+            _Position = lower_bound(_Key_val);
+            if (_Position != _End && !_Key_compare(_Key_val, *_Position._Key_it)) {
+                const auto _Dist = _Position._Key_it - _Begin._Key_it;
+                auto _It         = begin() + _Dist;
+                *_It._Mapped_it  = mapped_type(_STD forward<_MappedArgTypes>(_Args)...);
+                return _It;
             }
-            return begin() + _Dist;
+        } else {
+            _Position = lower_bound(_Key_val);
+        }
+
+        const auto _Dist = _Position._Key_it - _Begin._Key_it;
+        {
+            key_type _Key_to_insert(_STD forward<_OtherKey>(_Key_val));
+            mapped_type _Mapped_to_insert(_STD forward<_MappedArgTypes>(_Args)...);
+            _Insert_exact(_Position, _STD move(_Key_to_insert), _STD move(_Mapped_to_insert));
         }
+        return begin() + _Dist;
     }
 
     void _Insert_exact(const_iterator _Position, key_type&& _Key_val, mapped_type&& _Mapped_val) {
@@ -846,11 +848,11 @@ private:
 
     void _Dedup() {
         _Clear_flat_map_scope_guard _Guard{this};
-        auto _Sorted_view     = _View_to_mutate();
-        auto _Subrange        = _RANGES unique(_Sorted_view, [this](const_reference _Left, const_reference _Right) {
+        auto _Sorted_view = _View_to_mutate();
+        auto _Subrange    = _RANGES unique(_Sorted_view, [this](const_reference _Left, const_reference _Right) {
             return this->_Key_equal(_Left.first, _Right.first);
         });
-        auto _Remaining_count = _STD distance(_Sorted_view.begin(), _Subrange.begin());
+        const auto _Remaining_count = _Subrange.begin() - _Sorted_view.begin();
         _Data.keys.erase(_Data.keys.begin() + _Remaining_count, _Data.keys.end());
         _Data.values.erase(_Data.values.begin() + _Remaining_count, _Data.values.end());
         _Guard._Clearable = nullptr;
@@ -862,27 +864,30 @@ private:
         _Clear_flat_map_scope_guard _Guard{this};
 
         // Insert the new elements at the end
-        size_type _OldSize = size();
-        size_type _NewSize = _STD distance(_First, _Last);
+        const size_type _Old_size = size();
+        if constexpr (_Is_cpp17_fwd_iter_v<_InputIterator>) {
+            const auto _New_size = static_cast<size_type>(_STD distance(_First, _Last));
 
-        _Data.keys.reserve(_Data.keys.size() + _NewSize);
-        _Data.values.reserve(_Data.values.size() + _NewSize);
+            _Data.keys.reserve(_Data.keys.size() + _New_size);
+            _Data.values.reserve(_Data.values.size() + _New_size);
+        }
 
         for (; _First != _Last; ++_First) {
-            _Data.keys.emplace_back(_STD move(_First->first));
-            _Data.values.emplace_back(_STD move(_First->second));
+            value_type _Val = *_First;
+            _Data.keys.emplace_back(_STD move(_Val.first));
+            _Data.values.emplace_back(_STD move(_Val.second));
         }
 
         // Sort the newly inserted elements
         auto _Sorted_view = _View_to_mutate();
         if constexpr (_NeedSorting) {
             auto _Sorted_new_elements = _Sorted_view;
-            _Sorted_new_elements.advance(_OldSize);
+            _Sorted_new_elements.advance(_Old_size);
             _RANGES sort(_Sorted_new_elements, value_compare(_Key_compare));
         }
 
         // Merge the newly inserted elements with the existing elements
-        _RANGES inplace_merge(_Sorted_view, _Sorted_view.begin() + _OldSize, value_compare(_Key_compare));
+        _RANGES inplace_merge(_Sorted_view, _Sorted_view.begin() + _Old_size, value_compare(_Key_compare));
 
         if constexpr (_NeedDeduping) {
             _Dedup();
@@ -903,7 +908,7 @@ private:
     _NODISCARD iterator _Find(const _KeyTy& _Key_val) {
         _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Is_transparent_v<key_compare>);
         iterator _Position = lower_bound(_Key_val);
-        if (_Position != end() && _Key_equal(_Position->first, _Key_val)) {
+        if (_Position != end() && !_Key_compare(_Key_val, _Position->first)) {
             return _Position;
         } else {
             return end();
@@ -914,7 +919,7 @@ private:
     _NODISCARD const_iterator _Find(const _KeyTy& _Key_val) const {
         _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Is_transparent_v<key_compare>);
         const_iterator _Position = lower_bound(_Key_val);
-        if (_Position != cend() && _Key_equal(_Position->first, _Key_val)) {
+        if (_Position != cend() && !_Key_compare(_Key_val, _Position->first)) {
             return _Position;
         } else {
             return cend();
@@ -936,8 +941,13 @@ private:
     template <class _KeyTy>
     _NODISCARD iterator _Lower_bound(const _KeyTy& _Key_val) {
         _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Is_transparent_v<key_compare>);
-        auto _Key_it = _STD lower_bound(_Data.keys.cbegin(), _Data.keys.cend(), _Key_val, _Key_compare);
-        auto _Dist   = _STD distance(_Data.keys.cbegin(), _Key_it);
+        const auto _Key_unchecked_begin = _STD _Get_unwrapped(_Data.keys.cbegin());
+        const auto _Key_unchecked_it =
+            _STD lower_bound(_Key_unchecked_begin, _STD _Get_unwrapped(_Data.keys.cend()), _Key_val, _Key_compare);
+        const auto _Dist = _Key_unchecked_it - _Key_unchecked_begin;
+
+        auto _Key_it = _Data.keys.cbegin();
+        _STD _Seek_wrapped(_Key_it, _Key_unchecked_it);
         auto _Val_it = _Data.values.begin() + _Dist;
         return iterator{_STD move(_Key_it), _STD move(_Val_it)};
     }
@@ -945,8 +955,13 @@ private:
     template <class _KeyTy>
     _NODISCARD const_iterator _Lower_bound(const _KeyTy& _Key_val) const {
         _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Is_transparent_v<key_compare>);
-        auto _Key_it = _STD lower_bound(_Data.keys.cbegin(), _Data.keys.cend(), _Key_val, _Key_compare);
-        auto _Dist   = _STD distance(_Data.keys.cbegin(), _Key_it);
+        const auto _Key_unchecked_begin = _STD _Get_unwrapped(_Data.keys.cbegin());
+        const auto _Key_unchecked_it =
+            _STD lower_bound(_Key_unchecked_begin, _STD _Get_unwrapped(_Data.keys.cend()), _Key_val, _Key_compare);
+        const auto _Dist = _Key_unchecked_it - _Key_unchecked_begin;
+
+        auto _Key_it = _Data.keys.cbegin();
+        _STD _Seek_wrapped(_Key_it, _Key_unchecked_it);
         auto _Val_it = _Data.values.cbegin() + _Dist;
         return const_iterator{_STD move(_Key_it), _STD move(_Val_it)};
     }
@@ -954,8 +969,13 @@ private:
     template <class _KeyTy>
     _NODISCARD iterator _Upper_bound(const _KeyTy& _Key_val) {
         _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Is_transparent_v<key_compare>);
-        auto _Key_it = _STD upper_bound(_Data.keys.cbegin(), _Data.keys.cend(), _Key_val, _Key_compare);
-        auto _Dist   = _STD distance(_Data.keys.cbegin(), _Key_it);
+        const auto _Key_unchecked_begin = _STD _Get_unwrapped(_Data.keys.cbegin());
+        const auto _Key_unchecked_it =
+            _STD upper_bound(_Key_unchecked_begin, _STD _Get_unwrapped(_Data.keys.cend()), _Key_val, _Key_compare);
+        const auto _Dist = _Key_unchecked_it - _Key_unchecked_begin;
+
+        auto _Key_it = _Data.keys.cbegin();
+        _STD _Seek_wrapped(_Key_it, _Key_unchecked_it);
         auto _Val_it = _Data.values.begin() + _Dist;
         return iterator{_STD move(_Key_it), _STD move(_Val_it)};
     }
@@ -963,8 +983,13 @@ private:
     template <class _KeyTy>
     _NODISCARD const_iterator _Upper_bound(const _KeyTy& _Key_val) const {
         _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Is_transparent_v<key_compare>);
-        auto _Key_it = _STD upper_bound(_Data.keys.cbegin(), _Data.keys.cend(), _Key_val, _Key_compare);
-        auto _Dist   = _STD distance(_Data.keys.cbegin(), _Key_it);
+        const auto _Key_unchecked_begin = _STD _Get_unwrapped(_Data.keys.cbegin());
+        const auto _Key_unchecked_it =
+            _STD upper_bound(_Key_unchecked_begin, _STD _Get_unwrapped(_Data.keys.cend()), _Key_val, _Key_compare);
+        const auto _Dist = _Key_unchecked_it - _Key_unchecked_begin;
+
+        auto _Key_it = _Data.keys.cbegin();
+        _STD _Seek_wrapped(_Key_it, _Key_unchecked_it);
         auto _Val_it = _Data.values.cbegin() + _Dist;
         return const_iterator{_STD move(_Key_it), _STD move(_Val_it)};
     }
@@ -1167,9 +1192,9 @@ private:
         const auto _Position = this->find(_Key_val);
         if (_Position == this->end()) {
             _Xout_of_range("std::flat_map::at: the specified key does not exist.");
-        } else {
-            return _Position->second;
         }
+
+        return _Position->second;
     }
 
     template <class _KeyTy>
@@ -1178,27 +1203,27 @@ private:
         const auto _Position = this->find(_Key_val);
         if (_Position == this->end()) {
             _Xout_of_range("std::flat_map::at: the specified key does not exist.");
-        } else {
-            return _Position->second;
         }
+
+        return _Position->second;
     }
 
     template <class _KeyTy, class... _MappedArgTypes>
     pair<iterator, bool> _Try_emplace(_KeyTy&& _Key_val, _MappedArgTypes&&... _Mapped_args) {
         auto _Key_it = _STD lower_bound(_Data.keys.begin(), _Data.keys.end(), _Key_val, _Key_compare);
-        if (_Key_it != _Data.keys.end() && _Key_equal(*_Key_it, _STD forward<_KeyTy>(_Key_val))) {
+        if (_Key_it != _Data.keys.end() && !_Key_compare(_STD forward<_KeyTy>(_Key_val), *_Key_it)) {
             // Already exists
-            return {this->begin() + _STD distance(_Data.keys.begin(), _Key_it), false};
-        } else {
-            // Need to insert
-            auto _Index = _STD distance(_Data.keys.begin(), _Key_it);
-            {
-                key_type _Key_to_insert(_STD forward<_KeyTy>(_Key_val));
-                mapped_type _Mapped_to_insert(_STD forward<_MappedArgTypes>(_Mapped_args)...);
-                this->_Insert_exact(this->cbegin() + _Index, _STD move(_Key_to_insert), _STD move(_Mapped_to_insert));
-            }
-            return {this->begin() + _Index, true};
+            return {this->begin() + (_Key_it - _Data.keys.begin()), false};
+        }
+
+        // Need to insert
+        const auto _Index = _Key_it - _Data.keys.begin();
+        {
+            key_type _Key_to_insert(_STD forward<_KeyTy>(_Key_val));
+            mapped_type _Mapped_to_insert(_STD forward<_MappedArgTypes>(_Mapped_args)...);
+            this->_Insert_exact(this->cbegin() + _Index, _STD move(_Key_to_insert), _STD move(_Mapped_to_insert));
         }
+        return {this->begin() + _Index, true};
     }
 
     template <class _KeyTy, class _MappedTy>
@@ -1257,7 +1282,17 @@ flat_map(from_range_t, _Rng&&, _Compare = _Compare(), _Allocator = _Allocator())
     -> flat_map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, _Compare,
         vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_key_type<_Rng>>>,
         vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_mapped_type<_Rng>>>>;
-#endif // defined(__cpp_lib_byte)
+#else // ^^^ defined(__cpp_lib_byte) / !defined(__cpp_lib_byte) vvv
+template <_RANGES input_range _Rng, class _Compare = less<_Range_key_type<_Rng>>>
+flat_map(from_range_t, _Rng&&, _Compare = _Compare()) -> flat_map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>,
+    _Compare, vector<_Range_key_type<_Rng>, allocator<_Range_key_type<_Rng>>>,
+    vector<_Range_mapped_type<_Rng>, allocator<_Range_mapped_type<_Rng>>>>;
+
+template <_RANGES input_range _Rng, class _Compare, class _Allocator>
+flat_map(from_range_t, _Rng&&, _Compare, _Allocator) -> flat_map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>,
+    _Compare, vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_key_type<_Rng>>>,
+    vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_mapped_type<_Rng>>>>;
+#endif // ^^^ !defined(__cpp_lib_byte) ^^^
 
 template <_RANGES input_range _Rng, class _Allocator>
 flat_map(from_range_t, _Rng&&, _Allocator) -> flat_map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>,
@@ -1333,7 +1368,7 @@ private:
     template <class _KeyTy, class _MappedTy>
     iterator _Emplace_key_mapped(_KeyTy&& _Key_val, _MappedTy&& _Mapped_val) {
         const auto _Key_it = _STD lower_bound(_Data.keys.begin(), _Data.keys.end(), _Key_val, _Key_compare);
-        const auto _Index  = _STD distance(_Data.keys.begin(), _Key_it);
+        const auto _Index  = _Key_it - _Data.keys.begin();
 
         {
             _Key _Key_to_insert(_STD forward<_KeyTy>(_Key_val));
@@ -1385,7 +1420,18 @@ flat_multimap(from_range_t, _Rng&&, _Compare = _Compare(), _Allocator = _Allocat
     -> flat_multimap<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, _Compare,
         vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_key_type<_Rng>>>,
         vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_mapped_type<_Rng>>>>;
-#endif // defined(__cpp_lib_byte)
+#else // ^^^ defined(__cpp_lib_byte) / !defined(__cpp_lib_byte) vvv
+template <_RANGES input_range _Rng, class _Compare = less<_Range_key_type<_Rng>>>
+flat_multimap(from_range_t, _Rng&&, _Compare = _Compare()) -> flat_multimap<_Range_key_type<_Rng>,
+    _Range_mapped_type<_Rng>, _Compare, vector<_Range_key_type<_Rng>, allocator<_Range_key_type<_Rng>>>,
+    vector<_Range_mapped_type<_Rng>, allocator<_Range_mapped_type<_Rng>>>>;
+
+template <_RANGES input_range _Rng, class _Compare, class _Allocator>
+flat_multimap(from_range_t, _Rng&&, _Compare, _Allocator)
+    -> flat_multimap<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, _Compare,
+        vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_key_type<_Rng>>>,
+        vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_mapped_type<_Rng>>>>;
+#endif // ^^^ !defined(__cpp_lib_byte) ^^^
 
 template <_RANGES input_range _Rng, class _Allocator>
 flat_multimap(from_range_t, _Rng&&, _Allocator) -> flat_multimap<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>,
diff --git a/tests/std/include/test_header_units_and_modules.hpp b/tests/std/include/test_header_units_and_modules.hpp
index 11d234a116e..667def47819 100644
--- a/tests/std/include/test_header_units_and_modules.hpp
+++ b/tests/std/include/test_header_units_and_modules.hpp
@@ -251,17 +251,17 @@ void test_flat_map() {
     constexpr auto simple_truth = [](const auto&) { return true; };
 
     flat_map<int, int> fm;
-    fm.emplace(1, 1);
-    fm.emplace(1, 2);
+    fm.emplace(42, 172);
+    fm.emplace(42, 729);
     assert(fm.size() == 1);
-    erase_if(fm, simple_truth);
+    assert(erase_if(fm, simple_truth) == 1);
     assert(fm.empty());
 
     flat_multimap<int, int> fmm;
-    fmm.emplace(1, 1);
-    fmm.emplace(1, 2);
+    fmm.emplace(42, 172);
+    fmm.emplace(42, 729);
     assert(fmm.size() == 2);
-    erase_if(fmm, simple_truth);
+    assert(erase_if(fmm, simple_truth) == 2);
     assert(fmm.empty());
 }
 #endif // TEST_STANDARD >= 23
diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index ce73a32703f..67d54f99d92 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -4,6 +4,7 @@
 #include <atomic>
 #include <cassert>
 #include <concepts>
+#include <deque>
 #include <flat_map>
 #include <functional>
 #include <memory>
@@ -269,38 +270,45 @@ void test_pointer_to_incomplete_type() {
     flat_map<MyType<Incomplete>, shared_ptr<MyType<Incomplete>>> fmap;
 }
 
-void test_insert_unique() {
+void test_insert() {
     flat_map<int, char> fm;
 
-    const auto p1 = fm.insert({10, 'm'});
-    assert(p1.first->first == 10);
-    assert(p1.first->second == 'm');
-    assert(p1.second);
+    const auto res1 = fm.insert({10, 'm'});
+    assert(res1.first->first == 10);
+    assert(res1.first->second == 'm');
+    assert(res1.second);
+
+    const auto res2 = fm.insert({10, 'n'});
+    assert(res2.first->first == 10);
+    assert(res2.first->second == 'm');
+    assert(!res2.second);
 
     const flat_map<int, char>::value_type val_pair{90, 'w'};
-    const auto p2 = fm.insert(val_pair);
-    assert(p2.first->first == 90);
-    assert(p2.first->second == 'w');
-    assert(p2.second);
+    const auto res3 = fm.insert(val_pair);
+    assert(res3.first->first == 90);
+    assert(res3.first->second == 'w');
+    assert(res3.second);
 
     assert(check_key_content(fm, {10, 90}));
     assert(check_value_content(fm, {'m', 'w'}));
-}
 
-void test_insert_multi() {
     flat_multimap<int, char> fmm;
 
     const auto it1 = fmm.insert({10, 'm'});
     assert(it1->first == 10);
     assert(it1->second == 'm');
 
-    const flat_multimap<int, char>::value_type val_pair{90, 'w'};
-    const auto it2 = fmm.insert(val_pair);
-    assert(it2->first == 90);
-    assert(it2->second == 'w');
+    const auto it2 = fmm.insert({10, 'n'});
+    assert(it2->first == 10);
+    assert(it2->second == 'n');
+
+    const flat_multimap<int, char>::value_type val_pair2{90, 'w'};
+    const auto it3 = fmm.insert(val_pair2);
+    assert(it3->first == 90);
+    assert(it3->second == 'w');
 
-    assert(check_key_content(fmm, {10, 90}));
-    assert(check_value_content(fmm, {'m', 'w'}));
+    assert(check_key_content(fmm, {10, 10, 90}));
+    assert(check_value_content(fmm, {'n', 'm', 'w'}));
 }
 
 // GH-4344 <flat_map> Fix compile errors
@@ -336,6 +344,28 @@ void test_gh_4344() {
     assert(check_value_content(fm, {'m', 'o', 'e', 'w'}));
 }
 
+class direct_init_only {
+private:
+    unsigned int n_ = 0u;
+
+public:
+    struct src_type {
+        unsigned int n_ = 0u;
+
+        friend bool operator==(const src_type&, const src_type&) = default;
+    };
+
+    explicit direct_init_only(const src_type& s) noexcept : n_(s.n_) {}
+    direct_init_only(initializer_list<src_type>) = delete;
+
+    direct_init_only& operator=(const src_type& s) noexcept {
+        n_ = s.n_;
+        return *this;
+    }
+
+    friend bool operator==(const direct_init_only&, const direct_init_only&) = default;
+};
+
 void test_insert_or_assign() {
     flat_map<int, char> fm;
 
@@ -378,32 +408,62 @@ void test_insert_or_assign() {
 
     assert(check_key_content(fm, {10, 20, 70, 90}));
     assert(check_value_content(fm, {'b', 'a', 'X', 'w'}));
+
+    // ensure direct-initialization
+    flat_map<int, direct_init_only> direct_fm;
+    direct_fm.insert_or_assign(direct_fm.end(), 0, direct_init_only::src_type{42u});
+
+    assert(check_key_content(direct_fm, {0}));
+    assert(check_value_content(direct_fm, {direct_init_only(direct_init_only::src_type{42u})}));
 }
 
 // Test MSVC STL-specific SCARY-ness
+
+template <bool>
+struct flat_map_unique_if_impl;
+template <>
+struct flat_map_unique_if_impl<true> {
+    template <class Key, class Mapped, class Comp, class KeyCont, class MappedCont>
+    using type = flat_map<Key, Mapped, Comp, KeyCont, MappedCont>;
+};
+template <>
+struct flat_map_unique_if_impl<false> {
+    template <class Key, class Mapped, class Comp, class KeyCont, class MappedCont>
+    using type = flat_multimap<Key, Mapped, Comp, KeyCont, MappedCont>;
+};
+
+template <bool IsUnique, class Key, class Mapped, class Comp, class KeyCont, class MappedCont>
+using flat_map_unique_if = flat_map_unique_if_impl<IsUnique>::template type<Key, Mapped, Comp, KeyCont, MappedCont>;
+
 template <bool IsUnique, class Comparator, class Alloc1, class Alloc2>
 void test_scary_ness_one() { // COMPILE-ONLY
-    using Iter      = flat_map<int, int>::iterator;
-    using OtherIter = conditional_t<IsUnique, flat_map<int, int, Comparator, vector<int, Alloc1>, vector<int, Alloc2>>,
-        flat_multimap<int, int, Comparator, vector<int, Alloc1>, vector<int, Alloc2>>>::iterator;
+    using Iter = flat_map<int, int>::iterator;
+    using OtherIter =
+        flat_map_unique_if<IsUnique, int, int, Comparator, vector<int, Alloc1>, vector<int, Alloc2>>::iterator;
     static_assert(is_same_v<Iter, OtherIter>);
 
     using ConstIter = flat_map<int, int>::const_iterator;
     using OtherConstIter =
-        conditional_t<IsUnique, flat_map<int, int, Comparator, vector<int, Alloc1>, vector<int, Alloc2>>,
-            flat_multimap<int, int, Comparator, vector<int, Alloc1>, vector<int, Alloc2>>>::const_iterator;
+        flat_map_unique_if<IsUnique, int, int, Comparator, vector<int, Alloc1>, vector<int, Alloc2>>::const_iterator;
     static_assert(is_same_v<ConstIter, OtherConstIter>);
 
-    using Cont      = flat_map<int, int, less<int>, vector<int, Alloc1>, vector<int, Alloc2>>::containers;
-    using OtherCont = conditional_t<IsUnique, flat_map<int, int, Comparator, vector<int, Alloc1>, vector<int, Alloc2>>,
-        flat_multimap<int, int, Comparator, vector<int, Alloc1>, vector<int, Alloc2>>>::containers;
+    using Cont = flat_map<int, int, less<int>, vector<int, Alloc1>, vector<int, Alloc2>>::containers;
+    using OtherCont =
+        flat_map_unique_if<IsUnique, int, int, Comparator, vector<int, Alloc1>, vector<int, Alloc2>>::containers;
     static_assert(is_same_v<Cont, OtherCont>);
 
     using ValueComp = flat_map<int, int, Comparator, vector<int, Alloc1>, vector<int, Alloc2>>::value_compare;
-    using OtherValueComp =
-        conditional_t<IsUnique, flat_map<int, int, Comparator, vector<int, Alloc1>, vector<int, Alloc2>>,
-            flat_multimap<int, int, Comparator, vector<int, Alloc1>, vector<int, Alloc2>>>::value_compare;
-    static_assert(is_same_v<ValueComp, OtherValueComp>);
+    using OtherValueComp1 =
+        flat_map_unique_if<IsUnique, int, int, Comparator, vector<int, Alloc1>, vector<int, Alloc2>>::value_compare;
+    using OtherValueComp2 = flat_map_unique_if<IsUnique, int, int, Comparator, vector<int>, vector<int>>::value_compare;
+    using OtherValueComp3 =
+        flat_map_unique_if<IsUnique, int, int, Comparator, vector<int, Alloc1>, deque<int, Alloc2>>::value_compare;
+    using OtherValueComp4 =
+        flat_map_unique_if<IsUnique, int, int, Comparator, deque<int, Alloc1>, vector<int, Alloc2>>::value_compare;
+    static_assert(is_same_v<ValueComp, OtherValueComp1>);
+    static_assert(is_same_v<ValueComp, OtherValueComp2>);
+    static_assert(is_same_v<ValueComp, OtherValueComp3>);
+    static_assert(is_same_v<ValueComp, OtherValueComp4>);
 }
 
 void test_scary_ness() { // COMPILE-ONLY
@@ -436,8 +496,7 @@ int main() {
     test_construction();
     test_pointer_to_incomplete_type();
     test_erase_if();
-    test_insert_unique();
-    test_insert_multi();
+    test_insert();
     test_gh_4344();
     test_insert_or_assign();
 }

From 87625637b419096122581c300ca03c06883da307 Mon Sep 17 00:00:00 2001
From: Alex Guteniev <gutenev@gmail.com>
Date: Sun, 7 Apr 2024 23:30:32 +0300
Subject: [PATCH 031/134] `<flat_map>`: flat_multimap construction test (#4566)

Co-authored-by: Stephan T. Lavavej <stl@nuwen.net>
---
 tests/std/tests/P0429R9_flat_map/test.cpp | 124 ++++++++++++++++++++--
 1 file changed, 118 insertions(+), 6 deletions(-)

diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index 67d54f99d92..333c77657ff 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -1,13 +1,16 @@
 // Copyright (c) Microsoft Corporation.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
+#include <algorithm>
 #include <atomic>
 #include <cassert>
 #include <concepts>
+#include <cstddef>
 #include <deque>
 #include <flat_map>
 #include <functional>
 #include <memory>
+#include <ranges>
 #include <type_traits>
 #include <vector>
 
@@ -56,20 +59,63 @@ bool check_requirements(T&& obj) {
 
 template <IsFlatMap T>
 bool check_key_content(const T& obj, const typename T::key_container_type& expected) {
-    const auto& actual = obj.keys();
-    if (actual.size() != expected.size()) {
-        return false;
-    }
-    return ranges::equal(actual, expected);
+    return ranges::equal(obj.keys(), expected);
 }
 
 template <IsFlatMap T>
 bool check_value_content(const T& obj, const typename T::mapped_container_type& expected) {
+    return ranges::equal(obj.values(), expected);
+}
+
+enum class subrange_type : bool {
+    equal,
+    permutation,
+};
+
+struct subrange_t { // represents a closed subrange [first_index, last_index]
+    ptrdiff_t first_index;
+    ptrdiff_t last_index;
+    subrange_type type;
+
+    subrange_t(const ptrdiff_t first_index_, const ptrdiff_t last_index_, const subrange_type type_) noexcept
+        : first_index(first_index_), last_index(last_index_), type(type_) {
+        assert(first_index <= last_index);
+    }
+};
+
+template <IsFlatMap T>
+bool check_value_content(
+    const T& obj, const typename T::mapped_container_type& expected, const vector<subrange_t>& subranges) {
     const auto& actual = obj.values();
     if (actual.size() != expected.size()) {
         return false;
     }
-    return ranges::equal(actual, expected);
+
+    // Verify that the subranges cover the entire range with no gaps or overlaps.
+    // We assert instead of returning false because any problems would be caused by the check_value_content() call.
+    if (expected.empty()) {
+        assert(subranges.empty());
+    } else {
+        assert(!subranges.empty());
+        assert(subranges.front().first_index == 0);
+        assert(subranges.back().last_index == static_cast<ptrdiff_t>(expected.size() - 1));
+        const auto is_gap_or_overlap = [](const subrange_t& sr1, const subrange_t& sr2) {
+            return sr1.last_index + 1 != sr2.first_index;
+        };
+        assert(ranges::adjacent_find(subranges, is_gap_or_overlap) == subranges.end());
+    }
+
+    return ranges::all_of(subranges, [&expected, &actual](const subrange_t& subrange) {
+        const auto& [first_index, last_index, type] = subrange;
+        const ranges::subrange actual_subrange{actual.begin() + first_index, actual.begin() + last_index + 1};
+        const ranges::subrange expected_subrange{expected.begin() + first_index, expected.begin() + last_index + 1};
+
+        if (type == subrange_type::equal) {
+            return ranges::equal(actual_subrange, expected_subrange);
+        } else {
+            return ranges::is_permutation(actual_subrange, expected_subrange);
+        }
+    });
 }
 
 template <typename T>
@@ -155,6 +201,10 @@ void test_construction() {
         assert(check_requirements(fmap));
         assert(check_key_content(fmap, {}));
         assert(check_value_content(fmap, {}));
+        flat_multimap<int, int> fmmap;
+        assert(check_requirements(fmmap));
+        assert(check_key_content(fmmap, {}));
+        assert(check_value_content(fmmap, {}));
     }
     {
         vector<int> keys = {0, 1, 2, 3, 4, 2};
@@ -163,6 +213,15 @@ void test_construction() {
         assert(check_requirements(fmap));
         assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
         assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
+        flat_multimap fmmap(keys, vals);
+        assert(check_requirements(fmmap));
+        assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
+        assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5},
+            {
+                {0, 1, subrange_type::equal},
+                {2, 3, subrange_type::permutation},
+                {4, 5, subrange_type::equal},
+            }));
     }
     {
         vector<int, MyAllocator<int>> keys = {0, 1, 2, 3, 4, 2};
@@ -172,6 +231,16 @@ void test_construction() {
         assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
         assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
         assert(MyAllocator<int>::getActiveAllocationCount() > activeAllocations);
+        activeAllocations = MyAllocator<int>::getActiveAllocationCount();
+        flat_multimap fmmap(keys, vals); // FIXME, should use MyAllocator<int>(); deduction guides must be constrained
+        assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
+        assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5},
+            {
+                {0, 1, subrange_type::equal},
+                {2, 3, subrange_type::permutation},
+                {4, 5, subrange_type::equal},
+            }));
+        assert(MyAllocator<int>::getActiveAllocationCount() > activeAllocations);
     }
     {
         vector<int> keys = {0, 1, 2, 3, 38, 242};
@@ -180,13 +249,20 @@ void test_construction() {
         assert(check_requirements(fmap));
         assert(check_key_content(fmap, {0, 1, 2, 3, 38, 242}));
         assert(check_value_content(fmap, {44, 2324, 635462, 433, 5, 7}));
+        static_assert(!is_constructible_v<flat_multimap<int, int>, sorted_unique_t, vector<int>, vector<int>>);
     }
+    // FIXME, test flat_multimap construction from sorted_equivalent_t
+    // FIXME, test more flat_map and flat_multimap constructors
     {
         PackagedCompare<int> comp;
         flat_map<Packaged<int>, int, PackagedCompare<int>> fmap(comp);
         assert(check_requirements(fmap));
         assert(check_key_content(fmap, {}));
         assert(check_value_content(fmap, {}));
+        flat_multimap<Packaged<int>, int, PackagedCompare<int>> fmmap(comp);
+        assert(check_requirements(fmmap));
+        assert(check_key_content(fmmap, {}));
+        assert(check_value_content(fmmap, {}));
     }
     {
         PackagedCompare<int> comp;
@@ -197,6 +273,12 @@ void test_construction() {
         assert(check_requirements(fmap));
         assert(check_key_content(fmap, {}));
         assert(check_value_content(fmap, {}));
+        flat_multimap<Packaged<int>, Packaged<int>, PackagedCompare<int>,
+            vector<Packaged<int>, MyAllocator<Packaged<int>>>, vector<Packaged<int>, MyAllocator<Packaged<int>>>>
+            fmmap(comp, alloc);
+        assert(check_requirements(fmmap));
+        assert(check_key_content(fmmap, {}));
+        assert(check_value_content(fmmap, {}));
     }
     {
         MyAllocator<Packaged<int>> alloc;
@@ -206,6 +288,12 @@ void test_construction() {
         assert(check_requirements(fmap));
         assert(check_key_content(fmap, {}));
         assert(check_value_content(fmap, {}));
+        flat_multimap<Packaged<int>, Packaged<int>, PackagedCompare<int>,
+            vector<Packaged<int>, MyAllocator<Packaged<int>>>, vector<Packaged<int>, MyAllocator<Packaged<int>>>>
+            fmmap(alloc);
+        assert(check_requirements(fmmap));
+        assert(check_key_content(fmmap, {}));
+        assert(check_value_content(fmmap, {}));
     }
     {
         MyAllocator<Packaged<int>> alloc;
@@ -215,6 +303,12 @@ void test_construction() {
         assert(check_requirements(fmap));
         assert(check_key_content(fmap, {}));
         assert(check_value_content(fmap, {}));
+        flat_multimap<Packaged<int>, int, PackagedCompare<int>, vector<Packaged<int>, MyAllocator<Packaged<int>>>,
+            vector<int, MyAllocator<int>>>
+            fmmap(alloc);
+        assert(check_requirements(fmmap));
+        assert(check_key_content(fmmap, {}));
+        assert(check_value_content(fmmap, {}));
     }
     {
         PackagedCompare<int> comp;
@@ -225,6 +319,15 @@ void test_construction() {
         assert(check_requirements(fmap));
         assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
         assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
+        flat_multimap fmmap(keys, vals, comp, alloc);
+        assert(check_requirements(fmmap));
+        assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
+        assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5},
+            {
+                {0, 1, subrange_type::equal},
+                {2, 3, subrange_type::permutation},
+                {4, 5, subrange_type::equal},
+            }));
     }
     {
         TransparentPackagedCompare<int> comp;
@@ -235,6 +338,15 @@ void test_construction() {
         assert(check_requirements(fmap));
         assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
         assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
+        flat_multimap fmmap(keys, vals, comp, alloc);
+        assert(check_requirements(fmmap));
+        assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
+        assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5},
+            {
+                {0, 1, subrange_type::equal},
+                {2, 3, subrange_type::permutation},
+                {4, 5, subrange_type::equal},
+            }));
     }
 }
 

From 0f5adda7a7ca35a1ec1e07aade4a492129a34291 Mon Sep 17 00:00:00 2001
From: Alex Guteniev <gutenev@gmail.com>
Date: Mon, 15 Apr 2024 23:59:49 +0300
Subject: [PATCH 032/134] `<flat_map>`: more `flat_multimap` coverage copied
 from `flat_map` (#4590)

Co-authored-by: Stephan T. Lavavej <stl@nuwen.net>
---
 tests/std/tests/P0429R9_flat_map/test.cpp | 27 ++++++++++++++++++-----
 1 file changed, 22 insertions(+), 5 deletions(-)

diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index 333c77657ff..f589de58c12 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -243,6 +243,7 @@ void test_construction() {
         assert(MyAllocator<int>::getActiveAllocationCount() > activeAllocations);
     }
     {
+        static_assert(is_constructible_v<flat_map<int, int>, sorted_unique_t, vector<int>, vector<int>>);
         vector<int> keys = {0, 1, 2, 3, 38, 242};
         vector<int> vals = {44, 2324, 635462, 433, 5, 7};
         flat_map fmap(sorted_unique, keys, vals);
@@ -251,7 +252,15 @@ void test_construction() {
         assert(check_value_content(fmap, {44, 2324, 635462, 433, 5, 7}));
         static_assert(!is_constructible_v<flat_multimap<int, int>, sorted_unique_t, vector<int>, vector<int>>);
     }
-    // FIXME, test flat_multimap construction from sorted_equivalent_t
+    {
+        static_assert(!is_constructible_v<flat_map<int, int>, sorted_equivalent_t, vector<int>, vector<int>>);
+        static_assert(is_constructible_v<flat_multimap<int, int>, sorted_equivalent_t, vector<int>, vector<int>>);
+        vector<int, MyAllocator<int>> keys = {0, 1, 2, 2, 3, 4};
+        vector<int, MyAllocator<int>> vals = {44, 2324, 635462, 7, 433, 5};
+        flat_multimap fmmap(sorted_equivalent, keys, vals);
+        assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
+        assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5})); // guaranteed by N4971 [flat.multimap.cons]/6
+    }
     // FIXME, test more flat_map and flat_multimap constructors
     {
         PackagedCompare<int> comp;
@@ -352,15 +361,21 @@ void test_construction() {
 
 void test_erase_if() {
     {
-        vector<int> keys = {0, 1, 2, 3, 4, 2};
-        vector<int> vals = {44, 2324, 635462, 433, 5, 7};
+        vector<int> keys      = {0, 1, 2, 3, 4, 2};
+        vector<int> vals      = {44, 2324, 635462, 433, 5, 7};
+        auto even_key_odd_val = [](pair<const int&, const int&> p) { return p.first % 2 == 0 && p.second % 2 != 0; };
         flat_map fmap(keys, vals);
-        const auto erased_num = erase_if(
-            fmap, [](pair<const int&, const int&> refpr) { return refpr.first % 2 == 0 && refpr.second % 2 != 0; });
+        const auto erased_num = erase_if(fmap, even_key_odd_val);
         assert(erased_num == 1);
         assert(fmap.size() == 4);
         assert(check_key_content(fmap, {0, 1, 2, 3}));
         assert(check_value_content(fmap, {44, 2324, 635462, 433}));
+        flat_multimap fmmap(keys, vals);
+        const auto erased_num_m = erase_if(fmmap, even_key_odd_val);
+        assert(erased_num_m == 2);
+        assert(fmmap.size() == 4);
+        assert(check_key_content(fmmap, {0, 1, 2, 3}));
+        assert(check_value_content(fmmap, {44, 2324, 635462, 433}));
     }
 }
 
@@ -376,10 +391,12 @@ struct MyType {
 void test_pointer_to_incomplete_type() {
     struct Test {
         unique_ptr<flat_map<Test, Test>> ptr;
+        unique_ptr<flat_multimap<Test, Test>> ptr_m;
     };
 
     Test t;
     flat_map<MyType<Incomplete>, shared_ptr<MyType<Incomplete>>> fmap;
+    flat_multimap<MyType<Incomplete>, shared_ptr<MyType<Incomplete>>> fmmap;
 }
 
 void test_insert() {

From 5b1053855c1f06d00098452e61b2f64472275971 Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34@live.cn>
Date: Sun, 12 May 2024 06:30:08 +0800
Subject: [PATCH 033/134] `<flat_map>`: Unwrap `flat_(multi)map`'s iterators
 (#4650)

Co-authored-by: Stephan T. Lavavej <stl@nuwen.net>
---
 stl/inc/flat_map                          | 92 ++++++++++++++++++-----
 tests/std/tests/P0429R9_flat_map/test.cpp | 75 ++++++++++++++++++
 2 files changed, 150 insertions(+), 17 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index bc14e268b33..01bd8edfe46 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -86,6 +86,17 @@ struct _NODISCARD _Clear_flat_map_scope_guard {
 template <bool _IsUnique, class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer>
 class _Flat_map_base;
 
+template <class _KeyIter, class _MappedIter, class _MappedConvIter>
+struct _Pairing_iterator_provider;
+
+template <class _KeyIter, class _MappedIter, class _MappedConvIter>
+concept _Can_unwrap_pairing_iterator =
+    !conjunction_v<is_same<_Unwrapped_t<_KeyIter>, _KeyIter>, is_same<_Unwrapped_t<_MappedIter>, _MappedIter>>;
+
+template <class _KeyIter, class _MappedIter, class _MappedConvIter>
+using _Unwrapped_pairing_iterator = _Pairing_iterator_provider<_Unwrapped_t<_KeyIter>, _Unwrapped_t<_MappedIter>,
+    _Unwrapped_t<_MappedConvIter>>::_Iterator;
+
 template <class _KeyIter, class _MappedIter, class _MappedConvIter>
 struct _Pairing_iterator_provider {
     class _Iterator {
@@ -95,7 +106,9 @@ struct _Pairing_iterator_provider {
         friend class _Flat_map_base;
 
         _Iterator() = default;
-        _Iterator(_KeyIter _Key_iter, _MappedIter _Mapped_iter) : _Key_it(_Key_iter), _Mapped_it(_Mapped_iter) {}
+        _Iterator(_KeyIter _Key_iter, _MappedIter _Mapped_iter) noexcept(
+            is_nothrow_move_constructible_v<_KeyIter> && is_nothrow_move_constructible_v<_MappedIter>)
+            : _Key_it(_STD move(_Key_iter)), _Mapped_it(_STD move(_Mapped_iter)) {}
 
         using iterator_category = input_iterator_tag;
         using iterator_concept  = random_access_iterator_tag;
@@ -203,6 +216,57 @@ struct _Pairing_iterator_provider {
             return _Const_iterator{_Key_it, _Mapped_it};
         }
 
+        const _KeyIter& _Key_iterator() const noexcept {
+            return _Key_it;
+        }
+
+        const _MappedIter& _Mapped_iterator() const noexcept {
+            return _Mapped_it;
+        }
+
+        using _Prevent_inheriting_unwrap = _Iterator;
+
+        friend void _Verify_range(const _Iterator& _First, const _Iterator& _Last) noexcept {
+            if constexpr (_Range_verifiable_v<_KeyIter>) {
+                _Verify_range(_First._Key_it, _Last._Key_it); // intentional ADL
+            }
+
+            if constexpr (_Range_verifiable_v<_MappedIter>) {
+                _Verify_range(_First._Mapped_it, _Last._Mapped_it); // intentional ADL
+            }
+
+            _STL_VERIFY(_Last._Key_it - _First._Key_it == _Last._Mapped_it - _First._Mapped_it,
+                "iterators from inconsistent ranges");
+        }
+
+        void _Verify_offset(const difference_type _Off) const noexcept {
+            if constexpr (_Offset_verifiable_v<_KeyIter>) {
+                _Key_it._Verify_offset(_Off);
+            } else {
+                _STL_VERIFY(_Off == 0 || _Key_it != _KeyIter(), "cannot seek value-initialized iterator");
+            }
+
+            if constexpr (_Offset_verifiable_v<_MappedIter>) {
+                _Mapped_it._Verify_offset(_Off);
+            } else {
+                _STL_VERIFY(_Off == 0 || _Mapped_it != _MappedIter(), "cannot seek value-initialized iterator");
+            }
+        }
+
+        _NODISCARD auto _Unwrapped() const
+            requires _Can_unwrap_pairing_iterator<_KeyIter, _MappedIter, _MappedConvIter>
+        {
+            using _Unwrapped_iterator = _Unwrapped_pairing_iterator<_KeyIter, _MappedIter, _MappedConvIter>;
+            return _Unwrapped_iterator{_STD _Get_unwrapped(_Key_it), _STD _Get_unwrapped(_Mapped_it)};
+        }
+
+        void _Seek_to(const _Unwrapped_pairing_iterator<_KeyIter, _MappedIter, _MappedConvIter>& _Dst)
+            requires _Can_unwrap_pairing_iterator<_KeyIter, _MappedIter, _MappedConvIter>
+        {
+            _STD _Seek_wrapped(_Key_it, _Dst._Key_iterator());
+            _STD _Seek_wrapped(_Mapped_it, _Dst._Mapped_iterator());
+        }
+
     private:
         _KeyIter _Key_it;
         _MappedIter _Mapped_it;
@@ -717,8 +781,10 @@ public:
     }
 
     _NODISCARD_FRIEND bool operator==(const _Derived& _Left, const _Derived& _Right) {
-        return _RANGES equal(_Left._Data.keys, _Right._Data.keys)
-            && _RANGES equal(_Left._Data.values, _Right._Data.values);
+        auto& _Left_base  = static_cast<const _Flat_map_base&>(_Left);
+        auto& _Right_base = static_cast<const _Flat_map_base&>(_Right);
+        return _RANGES equal(_Left_base._Data.keys, _Right_base._Data.keys)
+            && _RANGES equal(_Left_base._Data.values, _Right_base._Data.values);
     }
 
     _NODISCARD_FRIEND auto operator<=>(const _Derived& _Left, const _Derived& _Right) {
@@ -863,15 +929,9 @@ private:
     void _Insert_range(_InputIterator _First, _InputIterator _Last) {
         _Clear_flat_map_scope_guard _Guard{this};
 
-        // Insert the new elements at the end
-        const size_type _Old_size = size();
-        if constexpr (_Is_cpp17_fwd_iter_v<_InputIterator>) {
-            const auto _New_size = static_cast<size_type>(_STD distance(_First, _Last));
-
-            _Data.keys.reserve(_Data.keys.size() + _New_size);
-            _Data.values.reserve(_Data.values.size() + _New_size);
-        }
+        const auto _Old_distance = static_cast<difference_type>(size());
 
+        // Insert the new elements at the end
         for (; _First != _Last; ++_First) {
             value_type _Val = *_First;
             _Data.keys.emplace_back(_STD move(_Val.first));
@@ -882,12 +942,12 @@ private:
         auto _Sorted_view = _View_to_mutate();
         if constexpr (_NeedSorting) {
             auto _Sorted_new_elements = _Sorted_view;
-            _Sorted_new_elements.advance(_Old_size);
+            _Sorted_new_elements.advance(_Old_distance);
             _RANGES sort(_Sorted_new_elements, value_compare(_Key_compare));
         }
 
         // Merge the newly inserted elements with the existing elements
-        _RANGES inplace_merge(_Sorted_view, _Sorted_view.begin() + _Old_size, value_compare(_Key_compare));
+        _RANGES inplace_merge(_Sorted_view, _Sorted_view.begin() + _Old_distance, value_compare(_Key_compare));
 
         if constexpr (_NeedDeduping) {
             _Dedup();
@@ -1285,8 +1345,7 @@ flat_map(from_range_t, _Rng&&, _Compare = _Compare(), _Allocator = _Allocator())
 #else // ^^^ defined(__cpp_lib_byte) / !defined(__cpp_lib_byte) vvv
 template <_RANGES input_range _Rng, class _Compare = less<_Range_key_type<_Rng>>>
 flat_map(from_range_t, _Rng&&, _Compare = _Compare()) -> flat_map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>,
-    _Compare, vector<_Range_key_type<_Rng>, allocator<_Range_key_type<_Rng>>>,
-    vector<_Range_mapped_type<_Rng>, allocator<_Range_mapped_type<_Rng>>>>;
+    _Compare, vector<_Range_key_type<_Rng>>, vector<_Range_mapped_type<_Rng>>>;
 
 template <_RANGES input_range _Rng, class _Compare, class _Allocator>
 flat_map(from_range_t, _Rng&&, _Compare, _Allocator) -> flat_map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>,
@@ -1423,8 +1482,7 @@ flat_multimap(from_range_t, _Rng&&, _Compare = _Compare(), _Allocator = _Allocat
 #else // ^^^ defined(__cpp_lib_byte) / !defined(__cpp_lib_byte) vvv
 template <_RANGES input_range _Rng, class _Compare = less<_Range_key_type<_Rng>>>
 flat_multimap(from_range_t, _Rng&&, _Compare = _Compare()) -> flat_multimap<_Range_key_type<_Rng>,
-    _Range_mapped_type<_Rng>, _Compare, vector<_Range_key_type<_Rng>, allocator<_Range_key_type<_Rng>>>,
-    vector<_Range_mapped_type<_Rng>, allocator<_Range_mapped_type<_Rng>>>>;
+    _Range_mapped_type<_Rng>, _Compare, vector<_Range_key_type<_Rng>>, vector<_Range_mapped_type<_Rng>>>;
 
 template <_RANGES input_range _Rng, class _Compare, class _Allocator>
 flat_multimap(from_range_t, _Rng&&, _Compare, _Allocator)
diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index f589de58c12..c2abf2f8932 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -546,6 +546,80 @@ void test_insert_or_assign() {
     assert(check_value_content(direct_fm, {direct_init_only(direct_init_only::src_type{42u})}));
 }
 
+void test_comparison() {
+    {
+        flat_map<int, char> fm1{{1, '1'}, {2, '7'}, {3, '2'}, {4, '9'}};
+
+        assert(fm1 == fm1);
+        assert(!(fm1 != fm1));
+        assert(!(fm1 < fm1));
+        assert(!(fm1 > fm1));
+        assert(fm1 <= fm1);
+        assert(fm1 >= fm1);
+        assert(fm1 <=> fm1 == strong_ordering::equal);
+
+        flat_map<int, char> fm2{{1, '1'}, {7, '2'}, {2, '3'}, {9, '4'}};
+
+        assert(!(fm1 == fm2));
+        assert(fm1 != fm2);
+        assert(!(fm1 < fm2));
+        assert(fm1 > fm2);
+        assert(!(fm1 <= fm2));
+        assert(fm1 >= fm2);
+        assert(fm1 <=> fm2 == strong_ordering::greater);
+    }
+
+    {
+        flat_map<int, char, greater<int>> fm3{{1, '1'}, {2, '7'}, {3, '2'}, {4, '9'}};
+        flat_map<int, char, greater<int>> fm4{{1, '1'}, {7, '2'}, {2, '3'}, {9, '4'}};
+
+        assert(!(fm3 == fm4));
+        assert(fm3 != fm4);
+        assert(fm3 < fm4);
+        assert(!(fm3 > fm4));
+        assert(fm3 <= fm4);
+        assert(!(fm3 >= fm4));
+        assert(fm3 <=> fm4 == strong_ordering::less);
+    }
+    {
+        flat_multimap<int, char> fmm1{
+            {3, '2'}, {1, '7'}, {4, '1'}, {1, '8'}, {5, '2'}, {9, '8'}, {2, '1'}, {6, '8'}, {5, '2'}};
+
+        assert(fmm1 == fmm1);
+        assert(!(fmm1 != fmm1));
+        assert(!(fmm1 < fmm1));
+        assert(!(fmm1 > fmm1));
+        assert(fmm1 <= fmm1);
+        assert(fmm1 >= fmm1);
+        assert(fmm1 <=> fmm1 == strong_ordering::equal);
+
+        flat_multimap<int, char> fmm2{
+            {2, '3'}, {7, '1'}, {1, '4'}, {8, '1'}, {2, '5'}, {8, '9'}, {1, '2'}, {8, '6'}, {2, '5'}};
+
+        assert(!(fmm1 == fmm2));
+        assert(fmm1 != fmm2);
+        assert(!(fmm1 < fmm2));
+        assert(fmm1 > fmm2);
+        assert(!(fmm1 <= fmm2));
+        assert(fmm1 >= fmm2);
+        assert(fmm1 <=> fmm2 == strong_ordering::greater);
+    }
+    {
+        flat_multimap<int, char, greater<int>> fmm3{
+            {3, '2'}, {1, '7'}, {4, '1'}, {1, '8'}, {5, '2'}, {9, '8'}, {2, '1'}, {6, '8'}, {5, '2'}};
+        flat_multimap<int, char, greater<int>> fmm4{
+            {2, '3'}, {7, '1'}, {1, '4'}, {8, '1'}, {2, '5'}, {8, '9'}, {1, '2'}, {8, '6'}, {2, '5'}};
+
+        assert(!(fmm3 == fmm4));
+        assert(fmm3 != fmm4);
+        assert(!(fmm3 < fmm4));
+        assert(fmm3 > fmm4);
+        assert(!(fmm3 <= fmm4));
+        assert(fmm3 >= fmm4);
+        assert(fmm3 <=> fmm4 == strong_ordering::greater);
+    }
+}
+
 // Test MSVC STL-specific SCARY-ness
 
 template <bool>
@@ -628,4 +702,5 @@ int main() {
     test_insert();
     test_gh_4344();
     test_insert_or_assign();
+    test_comparison();
 }

From 1d8e8e25295bb1ac85aa92cdce06504b215fbfdb Mon Sep 17 00:00:00 2001
From: Qingnan Duan <duanqn_own_1@yeah.net>
Date: Wed, 10 Jul 2024 18:43:48 +0800
Subject: [PATCH 034/134] Fix insert for flat_map and flat_multimap (#4778)

Co-authored-by: Stephan T. Lavavej <stl@nuwen.net>
---
 stl/inc/flat_map                          |  2 ++
 tests/std/tests/P0429R9_flat_map/test.cpp | 35 +++++++++++++++++------
 2 files changed, 29 insertions(+), 8 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index 01bd8edfe46..16ca80fd831 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -1085,6 +1085,7 @@ public:
 
     using _MyBase::_MyBase;
     using _MyBase::operator=;
+    using _MyBase::insert;
 
     // [flat.map.access] Access
     _NODISCARD mapped_type& operator[](const key_type& _Key_val) {
@@ -1391,6 +1392,7 @@ public:
 
     using _MyBase::_MyBase;
     using _MyBase::operator=;
+    using _MyBase::insert;
 
     // [flat.multimap.modifiers] Modifiers
     template <class... _ArgTypes>
diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index c2abf2f8932..a2093294c4a 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -418,8 +418,16 @@ void test_insert() {
     assert(res3.first->second == 'w');
     assert(res3.second);
 
-    assert(check_key_content(fm, {10, 90}));
-    assert(check_value_content(fm, {'m', 'w'}));
+    const auto res4 = fm.insert(fm.cbegin(), std::pair<int, char>{30, 'c'});
+    assert(res4->first == 30);
+    assert(res4->second == 'c');
+
+    const auto res5 = fm.insert(fm.cbegin(), std::pair<char, char>{static_cast<char>(40), 'd'});
+    assert(res5->first == 40);
+    assert(res5->second == 'd');
+
+    assert(check_key_content(fm, {10, 30, 40, 90}));
+    assert(check_value_content(fm, {'m', 'c', 'd', 'w'}));
 
     flat_multimap<int, char> fmm;
 
@@ -431,13 +439,24 @@ void test_insert() {
     assert(it2->first == 10);
     assert(it2->second == 'n');
 
-    const flat_multimap<int, char>::value_type val_pair2{90, 'w'};
-    const auto it3 = fmm.insert(val_pair2);
-    assert(it3->first == 90);
-    assert(it3->second == 'w');
+    const auto it3 = fmm.insert(fmm.cend(), {70, 'p'});
+    assert(it3->first == 70);
+    assert(it3->second == 'p');
 
-    assert(check_key_content(fmm, {10, 10, 90}));
-    assert(check_value_content(fmm, {'n', 'm', 'w'}));
+    const flat_multimap<int, char>::value_type val_pair2{90, 'w'};
+    const auto it4 = fmm.insert(val_pair2);
+    assert(it4->first == 90);
+    assert(it4->second == 'w');
+
+    const auto it5 = fmm.insert(fmm.cend(), std::pair<char, char>{static_cast<char>(70), 'q'});
+    assert(it5->first == 70);
+    assert(it5->second == 'q');
+
+    assert(check_key_content(fmm, {10, 10, 70, 70, 90}));
+    // FIXME: The expected order of the last 3 value elements is 'p', 'q', 'w' (no permutation allowed), according to
+    // N4981 [associative.reqmts.general]/72. The current implementation gives 'q', 'p', 'w', which is wrong.
+    assert(check_value_content(fmm, {'n', 'm', 'p', 'q', 'w'},
+        {{0, 1, subrange_type::permutation}, {2, 3, subrange_type::permutation}, {4, 4, subrange_type::equal}}));
 }
 
 // GH-4344 <flat_map> Fix compile errors

From 0d6df8ba87c9390759c9df41f90c0655034dc38c Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34@live.cn>
Date: Fri, 12 Jul 2024 05:48:28 +0800
Subject: [PATCH 035/134] `<flat_map>`: Fix ordering in insertion and access
 control in construction (#4828)

---
 stl/inc/flat_map                          | 51 +++++++++++++++--------
 tests/std/tests/P0429R9_flat_map/test.cpp | 24 +++++++++--
 2 files changed, 53 insertions(+), 22 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index 16ca80fd831..c9dfe198f40 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -459,27 +459,34 @@ public:
         : _Flat_map_base(_Tag, _Ilist, key_compare(), _Alloc) {}
 
     // Copy constructors
-    _Flat_map_base(const _Derived& _Other) : _Key_compare(_Other._Key_compare), _Data(_Other._Data) {}
+    _Flat_map_base(const _Derived& _Other)
+        : _Key_compare(static_cast<const _Flat_map_base&>(_Other)._Key_compare),
+          _Data(static_cast<const _Flat_map_base&>(_Other)._Data) {}
 
     template <_Valid_allocator_for_flat_map<key_container_type, mapped_container_type> _Allocator>
     _Flat_map_base(const _Derived& _Other, const _Allocator& _Alloc)
-        : _Key_compare(_Other._Key_compare),
-          _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Alloc, _Other._Data.keys),
-              .values = _STD make_obj_using_allocator<mapped_container_type>(_Alloc, _Other._Data.values)} {}
+        : _Key_compare(static_cast<const _Flat_map_base&>(_Other)._Key_compare),
+          _Data{.keys = _STD make_obj_using_allocator<key_container_type>(
+                    _Alloc, static_cast<const _Flat_map_base&>(_Other)._Data.keys),
+              .values = _STD make_obj_using_allocator<mapped_container_type>(
+                  _Alloc, static_cast<const _Flat_map_base&>(_Other)._Data.values)} {}
 
     // Move constructors
     _Flat_map_base(_Derived&& _Other) noexcept(is_nothrow_move_constructible_v<key_compare>
                                                && is_nothrow_move_constructible_v<key_container_type>
                                                && is_nothrow_move_constructible_v<mapped_container_type>)
-        : _Key_compare(move(_Other._Key_compare)), _Data(move(_Other).extract()) {}
+        : _Key_compare(_STD move(static_cast<_Flat_map_base&>(_Other)._Key_compare)),
+          _Data(_STD move(static_cast<_Flat_map_base&>(_Other).extract())) {}
 
     template <_Valid_allocator_for_flat_map<key_container_type, mapped_container_type> _Allocator>
     _Flat_map_base(_Derived&& _Other, const _Allocator& _Alloc) noexcept(
         is_nothrow_move_constructible_v<key_compare> && is_nothrow_move_constructible_v<key_container_type>
         && is_nothrow_move_constructible_v<mapped_container_type>)
-        : _Key_compare(move(_Other._Key_compare)),
-          _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Alloc, move(_Other._Data.keys)),
-              .values = _STD make_obj_using_allocator<mapped_container_type>(_Alloc, move(_Other._Data.values))} {}
+        : _Key_compare(_STD move(static_cast<_Flat_map_base&>(_Other)._Key_compare)),
+          _Data{.keys = _STD make_obj_using_allocator<key_container_type>(
+                    _Alloc, _STD move(static_cast<_Flat_map_base&>(_Other)._Data.keys)),
+              .values = _STD make_obj_using_allocator<mapped_container_type>(
+                  _Alloc, _STD move(static_cast<_Flat_map_base&>(_Other)._Data.values))} {}
 
     _Derived& operator=(initializer_list<value_type> _Ilist) {
         clear();
@@ -780,14 +787,14 @@ public:
         return _Equal_range(_Key_val);
     }
 
-    _NODISCARD_FRIEND bool operator==(const _Derived& _Left, const _Derived& _Right) {
+    _NODISCARD friend bool operator==(const _Derived& _Left, const _Derived& _Right) {
         auto& _Left_base  = static_cast<const _Flat_map_base&>(_Left);
         auto& _Right_base = static_cast<const _Flat_map_base&>(_Right);
         return _RANGES equal(_Left_base._Data.keys, _Right_base._Data.keys)
             && _RANGES equal(_Left_base._Data.values, _Right_base._Data.values);
     }
 
-    _NODISCARD_FRIEND auto operator<=>(const _Derived& _Left, const _Derived& _Right) {
+    _NODISCARD friend auto operator<=>(const _Derived& _Left, const _Derived& _Right) {
         return _STD lexicographical_compare_three_way(_STD _Get_unwrapped(_Left.cbegin()),
             _STD _Get_unwrapped(_Left.cend()), _STD _Get_unwrapped(_Right.cbegin()), _STD _Get_unwrapped(_Right.cend()),
             _Synth_three_way{});
@@ -830,20 +837,28 @@ protected:
         const const_iterator _Begin = cbegin();
         const const_iterator _End   = cend();
 
-        const bool _Hint_is_accurate = [&] {
+        const weak_ordering _Hint_order = [&] {
             if constexpr (_IsUnique) {
                 if (_Position == _End || _Key_compare(_Key_val, *_Position._Key_it)) {
-                    return _Position == _Begin || _Key_compare(_Position._Key_it[-1], _Key_val);
+                    if (_Position == _Begin || _Key_compare(_Position._Key_it[-1], _Key_val)) {
+                        return weak_ordering::equivalent;
+                    } else {
+                        return weak_ordering::greater;
+                    }
                 }
             } else {
                 if (_Position == _End || !_Key_compare(*_Position._Key_it, _Key_val)) {
-                    return _Position == _Begin || !_Key_compare(_Key_val, _Position._Key_it[-1]);
+                    if (_Position == _Begin || !_Key_compare(_Key_val, _Position._Key_it[-1])) {
+                        return weak_ordering::equivalent;
+                    } else {
+                        return weak_ordering::greater;
+                    }
                 }
             }
-            return false;
+            return weak_ordering::less;
         }();
 
-        if (_Hint_is_accurate) {
+        if (_Hint_order == weak_ordering::equivalent) {
             const auto _Dist = _Position._Key_it - _Begin._Key_it;
             {
                 key_type _Key_to_insert(_STD forward<_OtherKey>(_Key_val));
@@ -861,7 +876,7 @@ protected:
                 return _It;
             }
 
-            _Position = lower_bound(_Key_val);
+            _Position = _Hint_order == weak_ordering::less ? lower_bound(_Key_val) : upper_bound(_Key_val);
             if (_Position != _End && !_Key_compare(_Key_val, *_Position._Key_it)) {
                 const auto _Dist = _Position._Key_it - _Begin._Key_it;
                 auto _It         = begin() + _Dist;
@@ -869,7 +884,7 @@ protected:
                 return _It;
             }
         } else {
-            _Position = lower_bound(_Key_val);
+            _Position = _Hint_order == weak_ordering::less ? lower_bound(_Key_val) : upper_bound(_Key_val);
         }
 
         const auto _Dist = _Position._Key_it - _Begin._Key_it;
@@ -1428,7 +1443,7 @@ private:
 
     template <class _KeyTy, class _MappedTy>
     iterator _Emplace_key_mapped(_KeyTy&& _Key_val, _MappedTy&& _Mapped_val) {
-        const auto _Key_it = _STD lower_bound(_Data.keys.begin(), _Data.keys.end(), _Key_val, _Key_compare);
+        const auto _Key_it = _STD upper_bound(_Data.keys.begin(), _Data.keys.end(), _Key_val, _Key_compare);
         const auto _Index  = _Key_it - _Data.keys.begin();
 
         {
diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index a2093294c4a..977844600b5 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -357,6 +357,24 @@ void test_construction() {
                 {4, 5, subrange_type::equal},
             }));
     }
+    // Test GH-4779 (access from _Flat_map_base to derived flat_map/flat_multimap)
+    {
+        allocator<int> ator;
+
+        using fm = flat_map<int, int, less<>, vector<int>, vector<int>>;
+        fm m0;
+        fm m1(m0);
+        fm m2(m0, ator);
+        fm m3(move(m0));
+        fm m4(move(m1), ator);
+
+        using fmm = flat_multimap<int, int, less<>, vector<int>, vector<int>>;
+        fmm mm0;
+        fmm mm1(mm0);
+        fmm mm2(mm0, ator);
+        fmm mm3(move(mm0));
+        fmm mm4(move(mm1), ator);
+    }
 }
 
 void test_erase_if() {
@@ -453,10 +471,8 @@ void test_insert() {
     assert(it5->second == 'q');
 
     assert(check_key_content(fmm, {10, 10, 70, 70, 90}));
-    // FIXME: The expected order of the last 3 value elements is 'p', 'q', 'w' (no permutation allowed), according to
-    // N4981 [associative.reqmts.general]/72. The current implementation gives 'q', 'p', 'w', which is wrong.
-    assert(check_value_content(fmm, {'n', 'm', 'p', 'q', 'w'},
-        {{0, 1, subrange_type::permutation}, {2, 3, subrange_type::permutation}, {4, 4, subrange_type::equal}}));
+    // N4981 [associative.reqmts.general]/68 and /72 specify the values of the result to be {'m', 'n', 'p', 'q', 'w'}.
+    assert(check_value_content(fmm, {'m', 'n', 'p', 'q', 'w'}));
 }
 
 // GH-4344 <flat_map> Fix compile errors

From 9618209fdef442e757cbdf1ff9a4e763cf183e86 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Wed, 11 Sep 2024 20:22:48 -0700
Subject: [PATCH 036/134] Regen clang-format, no manual changes.

---
 stl/inc/flat_map | 160 +++++++++++++++++++++++++----------------------
 1 file changed, 85 insertions(+), 75 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index c9dfe198f40..8e66b5037fa 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -106,8 +106,8 @@ struct _Pairing_iterator_provider {
         friend class _Flat_map_base;
 
         _Iterator() = default;
-        _Iterator(_KeyIter _Key_iter, _MappedIter _Mapped_iter) noexcept(
-            is_nothrow_move_constructible_v<_KeyIter> && is_nothrow_move_constructible_v<_MappedIter>)
+        _Iterator(_KeyIter _Key_iter, _MappedIter _Mapped_iter)
+            noexcept(is_nothrow_move_constructible_v<_KeyIter> && is_nothrow_move_constructible_v<_MappedIter>)
             : _Key_it(_STD move(_Key_iter)), _Mapped_it(_STD move(_Mapped_iter)) {}
 
         using iterator_category = input_iterator_tag;
@@ -288,7 +288,7 @@ class _Flat_map_base {
 private:
     using _Sorted_t = conditional_t<_IsUnique, sorted_unique_t, sorted_equivalent_t>;
     using _Derived  = conditional_t<_IsUnique, flat_map<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>,
-        flat_multimap<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>>;
+         flat_multimap<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>>;
 
 public:
     using key_type               = _Key;
@@ -302,9 +302,9 @@ public:
     using key_container_type     = _KeyContainer;
     using mapped_container_type  = _MappedContainer;
     using iterator               = _Pairing_iterator_provider<typename key_container_type::const_iterator,
-        typename mapped_container_type::iterator, typename mapped_container_type::const_iterator>::_Iterator;
+                      typename mapped_container_type::iterator, typename mapped_container_type::const_iterator>::_Iterator;
     using const_iterator         = _Pairing_iterator_provider<typename key_container_type::const_iterator,
-        typename mapped_container_type::const_iterator, typename mapped_container_type::const_iterator>::_Iterator;
+                typename mapped_container_type::const_iterator, typename mapped_container_type::const_iterator>::_Iterator;
     using reverse_iterator       = _STD reverse_iterator<iterator>;
     using const_reverse_iterator = _STD reverse_iterator<const_iterator>;
 
@@ -472,16 +472,16 @@ public:
                   _Alloc, static_cast<const _Flat_map_base&>(_Other)._Data.values)} {}
 
     // Move constructors
-    _Flat_map_base(_Derived&& _Other) noexcept(is_nothrow_move_constructible_v<key_compare>
-                                               && is_nothrow_move_constructible_v<key_container_type>
-                                               && is_nothrow_move_constructible_v<mapped_container_type>)
+    _Flat_map_base(_Derived&& _Other)
+        noexcept(is_nothrow_move_constructible_v<key_compare> && is_nothrow_move_constructible_v<key_container_type>
+                 && is_nothrow_move_constructible_v<mapped_container_type>)
         : _Key_compare(_STD move(static_cast<_Flat_map_base&>(_Other)._Key_compare)),
           _Data(_STD move(static_cast<_Flat_map_base&>(_Other).extract())) {}
 
     template <_Valid_allocator_for_flat_map<key_container_type, mapped_container_type> _Allocator>
-    _Flat_map_base(_Derived&& _Other, const _Allocator& _Alloc) noexcept(
-        is_nothrow_move_constructible_v<key_compare> && is_nothrow_move_constructible_v<key_container_type>
-        && is_nothrow_move_constructible_v<mapped_container_type>)
+    _Flat_map_base(_Derived&& _Other, const _Allocator& _Alloc)
+        noexcept(is_nothrow_move_constructible_v<key_compare> && is_nothrow_move_constructible_v<key_container_type>
+                 && is_nothrow_move_constructible_v<mapped_container_type>)
         : _Key_compare(_STD move(static_cast<_Flat_map_base&>(_Other)._Key_compare)),
           _Data{.keys = _STD make_obj_using_allocator<key_container_type>(
                     _Alloc, _STD move(static_cast<_Flat_map_base&>(_Other)._Data.keys)),
@@ -641,8 +641,8 @@ public:
     }
 
     template <class _OtherKey>
-        requires _Is_transparent_v<key_compare>
-              && (!is_convertible_v<_OtherKey, iterator>) && (!is_convertible_v<_OtherKey, const_iterator>)
+        requires _Is_transparent_v<key_compare> && (!is_convertible_v<_OtherKey, iterator>)
+              && (!is_convertible_v<_OtherKey, const_iterator>)
     size_type erase(_OtherKey&& _Key_val) {
         return _Erase_key(_STD forward<_OtherKey>(_Key_val));
     }
@@ -1177,8 +1177,8 @@ public:
 
     template <class _OtherKey, class... _MappedArgTypes>
         requires _Is_transparent_v<key_compare> && is_constructible_v<key_type, _OtherKey>
-              && is_constructible_v<mapped_type, _MappedArgTypes...>
-              && (!is_convertible_v<_OtherKey, const_iterator>) && (!is_convertible_v<_OtherKey, iterator>)
+              && is_constructible_v<mapped_type, _MappedArgTypes...> && (!is_convertible_v<_OtherKey, const_iterator>)
+              && (!is_convertible_v<_OtherKey, iterator>)
     pair<iterator, bool> try_emplace(_OtherKey&& _Key_val, _MappedArgTypes&&... _Mapped_args) {
         return _Try_emplace(_STD forward<_OtherKey>(_Key_val), _STD forward<_MappedArgTypes>(_Mapped_args)...);
     }
@@ -1314,43 +1314,47 @@ private:
 
 template <class _KeyContainer, class _MappedContainer,
     _Valid_compare_for_container<_KeyContainer> _Compare = less<typename _KeyContainer::value_type>>
-flat_map(_KeyContainer, _MappedContainer, _Compare = _Compare()) -> flat_map<typename _KeyContainer::value_type,
-    typename _MappedContainer::value_type, _Compare, _KeyContainer, _MappedContainer>;
+flat_map(_KeyContainer, _MappedContainer,
+    _Compare = _Compare()) -> flat_map<typename _KeyContainer::value_type, typename _MappedContainer::value_type,
+                               _Compare, _KeyContainer, _MappedContainer>;
 
 template <class _KeyContainer, class _MappedContainer,
     _Valid_allocator_for_flat_map<_KeyContainer, _MappedContainer> _Allocator>
-flat_map(_KeyContainer, _MappedContainer, _Allocator) -> flat_map<typename _KeyContainer::value_type,
-    typename _MappedContainer::value_type, less<typename _KeyContainer::value_type>, _KeyContainer, _MappedContainer>;
+flat_map(_KeyContainer, _MappedContainer,
+    _Allocator) -> flat_map<typename _KeyContainer::value_type, typename _MappedContainer::value_type,
+                    less<typename _KeyContainer::value_type>, _KeyContainer, _MappedContainer>;
 
 template <class _KeyContainer, class _MappedContainer, _Valid_compare_for_container<_KeyContainer> _Compare,
     _Valid_allocator_for_flat_map<_KeyContainer, _MappedContainer> _Allocator>
-flat_map(_KeyContainer, _MappedContainer, _Compare, _Allocator) -> flat_map<typename _KeyContainer::value_type,
-    typename _MappedContainer::value_type, _Compare, _KeyContainer, _MappedContainer>;
+flat_map(_KeyContainer, _MappedContainer, _Compare,
+    _Allocator) -> flat_map<typename _KeyContainer::value_type, typename _MappedContainer::value_type, _Compare,
+                    _KeyContainer, _MappedContainer>;
 
 template <class _KeyContainer, class _MappedContainer,
     _Valid_compare_for_container<_KeyContainer> _Compare = less<typename _KeyContainer::value_type>>
-flat_map(sorted_unique_t, _KeyContainer, _MappedContainer, _Compare = _Compare())
-    -> flat_map<typename _KeyContainer::value_type, typename _MappedContainer::value_type, _Compare, _KeyContainer,
-        _MappedContainer>;
+flat_map(sorted_unique_t, _KeyContainer, _MappedContainer,
+    _Compare = _Compare()) -> flat_map<typename _KeyContainer::value_type, typename _MappedContainer::value_type,
+                               _Compare, _KeyContainer, _MappedContainer>;
 
 template <class _KeyContainer, class _MappedContainer,
     _Valid_allocator_for_flat_map<_KeyContainer, _MappedContainer> _Allocator>
-flat_map(sorted_unique_t, _KeyContainer, _MappedContainer, _Allocator) -> flat_map<typename _KeyContainer::value_type,
-    typename _MappedContainer::value_type, less<typename _KeyContainer::value_type>, _KeyContainer, _MappedContainer>;
+flat_map(sorted_unique_t, _KeyContainer, _MappedContainer,
+    _Allocator) -> flat_map<typename _KeyContainer::value_type, typename _MappedContainer::value_type,
+                    less<typename _KeyContainer::value_type>, _KeyContainer, _MappedContainer>;
 
 template <class _KeyContainer, class _MappedContainer, _Valid_compare_for_container<_KeyContainer> _Compare,
     _Valid_allocator_for_flat_map<_KeyContainer, _MappedContainer> _Allocator>
-flat_map(sorted_unique_t, _KeyContainer, _MappedContainer, _Compare, _Allocator)
-    -> flat_map<typename _KeyContainer::value_type, typename _MappedContainer::value_type, _Compare, _KeyContainer,
-        _MappedContainer>;
+flat_map(sorted_unique_t, _KeyContainer, _MappedContainer, _Compare,
+    _Allocator) -> flat_map<typename _KeyContainer::value_type, typename _MappedContainer::value_type, _Compare,
+                    _KeyContainer, _MappedContainer>;
 
 template <class _InputIterator, class _Compare = less<_Guide_key_t<_InputIterator>>>
-flat_map(_InputIterator, _InputIterator, _Compare = _Compare())
-    -> flat_map<_Guide_key_t<_InputIterator>, _Guide_val_t<_InputIterator>, _Compare>;
+flat_map(_InputIterator, _InputIterator,
+    _Compare = _Compare()) -> flat_map<_Guide_key_t<_InputIterator>, _Guide_val_t<_InputIterator>, _Compare>;
 
 template <class _InputIterator, class _Compare = less<_Guide_key_t<_InputIterator>>>
-flat_map(sorted_unique_t, _InputIterator, _InputIterator, _Compare = _Compare())
-    -> flat_map<_Guide_key_t<_InputIterator>, _Guide_val_t<_InputIterator>, _Compare>;
+flat_map(sorted_unique_t, _InputIterator, _InputIterator,
+    _Compare = _Compare()) -> flat_map<_Guide_key_t<_InputIterator>, _Guide_val_t<_InputIterator>, _Compare>;
 
 #ifdef __cpp_lib_byte
 template <_RANGES input_range _Rng, class _Compare = less<_Range_key_type<_Rng>>, class _Allocator = allocator<byte>>
@@ -1360,26 +1364,29 @@ flat_map(from_range_t, _Rng&&, _Compare = _Compare(), _Allocator = _Allocator())
         vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_mapped_type<_Rng>>>>;
 #else // ^^^ defined(__cpp_lib_byte) / !defined(__cpp_lib_byte) vvv
 template <_RANGES input_range _Rng, class _Compare = less<_Range_key_type<_Rng>>>
-flat_map(from_range_t, _Rng&&, _Compare = _Compare()) -> flat_map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>,
-    _Compare, vector<_Range_key_type<_Rng>>, vector<_Range_mapped_type<_Rng>>>;
+flat_map(
+    from_range_t, _Rng&&, _Compare = _Compare()) -> flat_map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, _Compare,
+                                                     vector<_Range_key_type<_Rng>>, vector<_Range_mapped_type<_Rng>>>;
 
 template <_RANGES input_range _Rng, class _Compare, class _Allocator>
-flat_map(from_range_t, _Rng&&, _Compare, _Allocator) -> flat_map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>,
-    _Compare, vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_key_type<_Rng>>>,
-    vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_mapped_type<_Rng>>>>;
+flat_map(from_range_t, _Rng&&, _Compare,
+    _Allocator) -> flat_map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, _Compare,
+                    vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_key_type<_Rng>>>,
+                    vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_mapped_type<_Rng>>>>;
 #endif // ^^^ !defined(__cpp_lib_byte) ^^^
 
 template <_RANGES input_range _Rng, class _Allocator>
-flat_map(from_range_t, _Rng&&, _Allocator) -> flat_map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>,
-    less<_Range_key_type<_Rng>>, vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_key_type<_Rng>>>,
-    vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_mapped_type<_Rng>>>>;
+flat_map(from_range_t, _Rng&&,
+    _Allocator) -> flat_map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, less<_Range_key_type<_Rng>>,
+                    vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_key_type<_Rng>>>,
+                    vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_mapped_type<_Rng>>>>;
 
 template <class _Key, class _Mapped, class _Compare = less<_Key>>
 flat_map(initializer_list<pair<_Key, _Mapped>>, _Compare = _Compare()) -> flat_map<_Key, _Mapped, _Compare>;
 
 template <class _Key, class _Mapped, class _Compare = less<_Key>>
-flat_map(sorted_unique_t, initializer_list<pair<_Key, _Mapped>>, _Compare = _Compare())
-    -> flat_map<_Key, _Mapped, _Compare>;
+flat_map(
+    sorted_unique_t, initializer_list<pair<_Key, _Mapped>>, _Compare = _Compare()) -> flat_map<_Key, _Mapped, _Compare>;
 
 // Specialization of uses_allocator
 template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer, class _Allocator>
@@ -1456,39 +1463,40 @@ private:
 };
 
 template <class _KeyContainer, class _MappedContainer, class _Compare = less<typename _KeyContainer::value_type>>
-flat_multimap(_KeyContainer, _MappedContainer, _Compare = _Compare())
-    -> flat_multimap<typename _KeyContainer::value_type, typename _MappedContainer::value_type, _Compare, _KeyContainer,
-        _MappedContainer>;
+flat_multimap(_KeyContainer, _MappedContainer,
+    _Compare = _Compare()) -> flat_multimap<typename _KeyContainer::value_type, typename _MappedContainer::value_type,
+                               _Compare, _KeyContainer, _MappedContainer>;
 
 template <class _KeyContainer, class _MappedContainer, class _Allocator>
-flat_multimap(_KeyContainer, _MappedContainer, _Allocator) -> flat_multimap<typename _KeyContainer::value_type,
-    typename _MappedContainer::value_type, less<typename _KeyContainer::value_type>, _KeyContainer, _MappedContainer>;
+flat_multimap(_KeyContainer, _MappedContainer,
+    _Allocator) -> flat_multimap<typename _KeyContainer::value_type, typename _MappedContainer::value_type,
+                    less<typename _KeyContainer::value_type>, _KeyContainer, _MappedContainer>;
 template <class _KeyContainer, class _MappedContainer, class _Compare, class _Allocator>
-flat_multimap(_KeyContainer, _MappedContainer, _Compare, _Allocator)
-    -> flat_multimap<typename _KeyContainer::value_type, typename _MappedContainer::value_type, _Compare, _KeyContainer,
-        _MappedContainer>;
+flat_multimap(_KeyContainer, _MappedContainer, _Compare,
+    _Allocator) -> flat_multimap<typename _KeyContainer::value_type, typename _MappedContainer::value_type, _Compare,
+                    _KeyContainer, _MappedContainer>;
 
 template <class _KeyContainer, class _MappedContainer, class _Compare = less<typename _KeyContainer::value_type>>
-flat_multimap(sorted_equivalent_t, _KeyContainer, _MappedContainer, _Compare = _Compare())
-    -> flat_multimap<typename _KeyContainer::value_type, typename _MappedContainer::value_type, _Compare, _KeyContainer,
-        _MappedContainer>;
+flat_multimap(sorted_equivalent_t, _KeyContainer, _MappedContainer,
+    _Compare = _Compare()) -> flat_multimap<typename _KeyContainer::value_type, typename _MappedContainer::value_type,
+                               _Compare, _KeyContainer, _MappedContainer>;
 
 template <class _KeyContainer, class _MappedContainer, class _Allocator>
-flat_multimap(sorted_equivalent_t, _KeyContainer, _MappedContainer, _Allocator)
-    -> flat_multimap<typename _KeyContainer::value_type, typename _MappedContainer::value_type,
-        less<typename _KeyContainer::value_type>, _KeyContainer, _MappedContainer>;
+flat_multimap(sorted_equivalent_t, _KeyContainer, _MappedContainer,
+    _Allocator) -> flat_multimap<typename _KeyContainer::value_type, typename _MappedContainer::value_type,
+                    less<typename _KeyContainer::value_type>, _KeyContainer, _MappedContainer>;
 template <class _KeyContainer, class _MappedContainer, class _Compare, class _Allocator>
-flat_multimap(sorted_equivalent_t, _KeyContainer, _MappedContainer, _Compare, _Allocator)
-    -> flat_multimap<typename _KeyContainer::value_type, typename _MappedContainer::value_type, _Compare, _KeyContainer,
-        _MappedContainer>;
+flat_multimap(sorted_equivalent_t, _KeyContainer, _MappedContainer, _Compare,
+    _Allocator) -> flat_multimap<typename _KeyContainer::value_type, typename _MappedContainer::value_type, _Compare,
+                    _KeyContainer, _MappedContainer>;
 
 template <class _InputIterator, class _Compare = less<_Guide_key_t<_InputIterator>>>
-flat_multimap(_InputIterator, _InputIterator, _Compare = _Compare())
-    -> flat_multimap<_Guide_key_t<_InputIterator>, _Guide_val_t<_InputIterator>, _Compare>;
+flat_multimap(_InputIterator, _InputIterator,
+    _Compare = _Compare()) -> flat_multimap<_Guide_key_t<_InputIterator>, _Guide_val_t<_InputIterator>, _Compare>;
 
 template <class _InputIterator, class _Compare = less<_Guide_key_t<_InputIterator>>>
-flat_multimap(sorted_equivalent_t, _InputIterator, _InputIterator, _Compare = _Compare())
-    -> flat_multimap<_Guide_key_t<_InputIterator>, _Guide_val_t<_InputIterator>, _Compare>;
+flat_multimap(sorted_equivalent_t, _InputIterator, _InputIterator,
+    _Compare = _Compare()) -> flat_multimap<_Guide_key_t<_InputIterator>, _Guide_val_t<_InputIterator>, _Compare>;
 
 #ifdef __cpp_lib_byte
 template <_RANGES input_range _Rng, class _Compare = less<_Range_key_type<_Rng>>, class _Allocator = allocator<byte>>
@@ -1498,27 +1506,29 @@ flat_multimap(from_range_t, _Rng&&, _Compare = _Compare(), _Allocator = _Allocat
         vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_mapped_type<_Rng>>>>;
 #else // ^^^ defined(__cpp_lib_byte) / !defined(__cpp_lib_byte) vvv
 template <_RANGES input_range _Rng, class _Compare = less<_Range_key_type<_Rng>>>
-flat_multimap(from_range_t, _Rng&&, _Compare = _Compare()) -> flat_multimap<_Range_key_type<_Rng>,
-    _Range_mapped_type<_Rng>, _Compare, vector<_Range_key_type<_Rng>>, vector<_Range_mapped_type<_Rng>>>;
+flat_multimap(from_range_t, _Rng&&,
+    _Compare = _Compare()) -> flat_multimap<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, _Compare,
+                               vector<_Range_key_type<_Rng>>, vector<_Range_mapped_type<_Rng>>>;
 
 template <_RANGES input_range _Rng, class _Compare, class _Allocator>
-flat_multimap(from_range_t, _Rng&&, _Compare, _Allocator)
-    -> flat_multimap<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, _Compare,
-        vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_key_type<_Rng>>>,
-        vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_mapped_type<_Rng>>>>;
+flat_multimap(from_range_t, _Rng&&, _Compare,
+    _Allocator) -> flat_multimap<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, _Compare,
+                    vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_key_type<_Rng>>>,
+                    vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_mapped_type<_Rng>>>>;
 #endif // ^^^ !defined(__cpp_lib_byte) ^^^
 
 template <_RANGES input_range _Rng, class _Allocator>
-flat_multimap(from_range_t, _Rng&&, _Allocator) -> flat_multimap<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>,
-    less<_Range_key_type<_Rng>>, vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_key_type<_Rng>>>,
-    vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_mapped_type<_Rng>>>>;
+flat_multimap(from_range_t, _Rng&&,
+    _Allocator) -> flat_multimap<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, less<_Range_key_type<_Rng>>,
+                    vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_key_type<_Rng>>>,
+                    vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_mapped_type<_Rng>>>>;
 
 template <class _Key, class _Mapped, class _Compare = less<_Key>>
 flat_multimap(initializer_list<pair<_Key, _Mapped>>, _Compare = _Compare()) -> flat_multimap<_Key, _Mapped, _Compare>;
 
 template <class _Key, class _Mapped, class _Compare = less<_Key>>
-flat_multimap(sorted_equivalent_t, initializer_list<pair<_Key, _Mapped>>, _Compare = _Compare())
-    -> flat_multimap<_Key, _Mapped, _Compare>;
+flat_multimap(sorted_equivalent_t, initializer_list<pair<_Key, _Mapped>>,
+    _Compare = _Compare()) -> flat_multimap<_Key, _Mapped, _Compare>;
 
 // Specialization of uses_allocator
 template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer, class _Allocator>

From f8acc4f9009e98b20eccee32b5656e4c94308396 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Wed, 11 Sep 2024 20:24:50 -0700
Subject: [PATCH 037/134] Regen clang-format, no manual changes.

---
 stl/inc/flat_set | 48 +++++++++++++++++++++++++-----------------------
 1 file changed, 25 insertions(+), 23 deletions(-)

diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index 4ec260e41a6..a117d113555 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -752,17 +752,17 @@ struct uses_allocator<flat_multiset<_Kty, _Keylt, _Container>, _Alloc>
 template <class _Container, class _Keylt = less<typename _Container::value_type>>
 flat_set(_Container, _Keylt = _Keylt()) -> flat_set<typename _Container::value_type, _Keylt, _Container>;
 template <class _Container, class _Alloc>
-flat_set(_Container, _Alloc)
-    -> flat_set<typename _Container::value_type, less<typename _Container::value_type>, _Container>;
+flat_set(
+    _Container, _Alloc) -> flat_set<typename _Container::value_type, less<typename _Container::value_type>, _Container>;
 template <class _Container, class _Keylt, class _Alloc>
 flat_set(_Container, _Keylt, _Alloc) -> flat_set<typename _Container::value_type, _Keylt, _Container>;
 
 template <class _Container, class _Keylt = less<typename _Container::value_type>>
-flat_set(sorted_unique_t, _Container, _Keylt = _Keylt())
-    -> flat_set<typename _Container::value_type, _Keylt, _Container>;
+flat_set(
+    sorted_unique_t, _Container, _Keylt = _Keylt()) -> flat_set<typename _Container::value_type, _Keylt, _Container>;
 template <class _Container, class _Alloc>
-flat_set(sorted_unique_t, _Container, _Alloc)
-    -> flat_set<typename _Container::value_type, less<typename _Container::value_type>, _Container>;
+flat_set(sorted_unique_t, _Container,
+    _Alloc) -> flat_set<typename _Container::value_type, less<typename _Container::value_type>, _Container>;
 template <class _Container, class _Keylt, class _Alloc>
 flat_set(sorted_unique_t, _Container, _Keylt, _Alloc) -> flat_set<typename _Container::value_type, _Keylt, _Container>;
 
@@ -772,11 +772,13 @@ template <class _Iter, class _Keylt = less<iter_value_t<_Iter>>>
 flat_set(sorted_unique_t, _Iter, _Iter, _Keylt = _Keylt()) -> flat_set<iter_value_t<_Iter>, _Keylt>;
 template <_RANGES input_range _Range, class _Keylt = less<_RANGES range_value_t<_Range>>,
     class _Alloc = allocator<_RANGES range_value_t<_Range>>>
-flat_set(from_range_t, _Range&&, _Keylt = _Keylt(), _Alloc = _Alloc()) -> flat_set<_RANGES range_value_t<_Range>,
-    _Keylt, vector<_RANGES range_value_t<_Range>, _Rebind_alloc_t<_Alloc, _RANGES range_value_t<_Range>>>>;
+flat_set(from_range_t, _Range&&, _Keylt = _Keylt(), _Alloc = _Alloc())
+    -> flat_set<_RANGES range_value_t<_Range>, _Keylt,
+        vector<_RANGES range_value_t<_Range>, _Rebind_alloc_t<_Alloc, _RANGES range_value_t<_Range>>>>;
 template <_RANGES input_range _Range, class _Alloc>
-flat_set(from_range_t, _Range&&, _Alloc) -> flat_set<_RANGES range_value_t<_Range>, less<_RANGES range_value_t<_Range>>,
-    vector<_RANGES range_value_t<_Range>, _Rebind_alloc_t<_Alloc, _RANGES range_value_t<_Range>>>>;
+flat_set(from_range_t, _Range&&,
+    _Alloc) -> flat_set<_RANGES range_value_t<_Range>, less<_RANGES range_value_t<_Range>>,
+                vector<_RANGES range_value_t<_Range>, _Rebind_alloc_t<_Alloc, _RANGES range_value_t<_Range>>>>;
 template <class _Kty, class _Keylt = less<_Kty>>
 flat_set(initializer_list<_Kty>, _Keylt = _Keylt()) -> flat_set<_Kty, _Keylt>;
 template <class _Kty, class _Keylt = less<_Kty>>
@@ -786,35 +788,35 @@ flat_set(sorted_unique_t, initializer_list<_Kty>, _Keylt = _Keylt()) -> flat_set
 template <class _Container, class _Keylt = less<typename _Container::value_type>>
 flat_multiset(_Container, _Keylt = _Keylt()) -> flat_multiset<typename _Container::value_type, _Keylt, _Container>;
 template <class _Container, class _Alloc>
-flat_multiset(_Container, _Alloc)
-    -> flat_multiset<typename _Container::value_type, less<typename _Container::value_type>, _Container>;
+flat_multiset(_Container,
+    _Alloc) -> flat_multiset<typename _Container::value_type, less<typename _Container::value_type>, _Container>;
 template <class _Container, class _Keylt, class _Alloc>
 flat_multiset(_Container, _Keylt, _Alloc) -> flat_multiset<typename _Container::value_type, _Keylt, _Container>;
 
 template <class _Container, class _Keylt = less<typename _Container::value_type>>
-flat_multiset(sorted_equivalent_t, _Container, _Keylt = _Keylt())
-    -> flat_multiset<typename _Container::value_type, _Keylt, _Container>;
+flat_multiset(sorted_equivalent_t, _Container,
+    _Keylt = _Keylt()) -> flat_multiset<typename _Container::value_type, _Keylt, _Container>;
 template <class _Container, class _Alloc>
-flat_multiset(sorted_equivalent_t, _Container, _Alloc)
-    -> flat_multiset<typename _Container::value_type, less<typename _Container::value_type>, _Container>;
+flat_multiset(sorted_equivalent_t, _Container,
+    _Alloc) -> flat_multiset<typename _Container::value_type, less<typename _Container::value_type>, _Container>;
 template <class _Container, class _Keylt, class _Alloc>
-flat_multiset(sorted_equivalent_t, _Container, _Keylt, _Alloc)
-    -> flat_multiset<typename _Container::value_type, _Keylt, _Container>;
+flat_multiset(sorted_equivalent_t, _Container, _Keylt,
+    _Alloc) -> flat_multiset<typename _Container::value_type, _Keylt, _Container>;
 
 template <class _Iter, class _Keylt = less<iter_value_t<_Iter>>>
 flat_multiset(_Iter, _Iter, _Keylt = _Keylt()) -> flat_multiset<iter_value_t<_Iter>, iter_value_t<_Iter>, _Keylt>;
 template <class _Iter, class _Keylt = less<iter_value_t<_Iter>>>
-flat_multiset(sorted_equivalent_t, _Iter, _Iter, _Keylt = _Keylt())
-    -> flat_multiset<iter_value_t<_Iter>, iter_value_t<_Iter>, _Keylt>;
+flat_multiset(sorted_equivalent_t, _Iter, _Iter,
+    _Keylt = _Keylt()) -> flat_multiset<iter_value_t<_Iter>, iter_value_t<_Iter>, _Keylt>;
 template <_RANGES input_range _Range, class _Keylt = less<_RANGES range_value_t<_Range>>,
     class _Alloc = allocator<_RANGES range_value_t<_Range>>>
 flat_multiset(from_range_t, _Range&&, _Keylt = _Keylt(), _Alloc = _Alloc())
     -> flat_multiset<_RANGES range_value_t<_Range>, _Keylt,
         vector<_RANGES range_value_t<_Range>, _Rebind_alloc_t<_Alloc, _RANGES range_value_t<_Range>>>>;
 template <_RANGES input_range _Range, class _Alloc>
-flat_multiset(from_range_t, _Range&&, _Alloc)
-    -> flat_multiset<_RANGES range_value_t<_Range>, less<_RANGES range_value_t<_Range>>,
-        vector<_RANGES range_value_t<_Range>, _Rebind_alloc_t<_Alloc, _RANGES range_value_t<_Range>>>>;
+flat_multiset(from_range_t, _Range&&,
+    _Alloc) -> flat_multiset<_RANGES range_value_t<_Range>, less<_RANGES range_value_t<_Range>>,
+                vector<_RANGES range_value_t<_Range>, _Rebind_alloc_t<_Alloc, _RANGES range_value_t<_Range>>>>;
 template <class _Kty, class _Keylt = less<_Kty>>
 flat_multiset(initializer_list<_Kty>, _Keylt = _Keylt()) -> flat_multiset<_Kty, _Keylt>;
 template <class _Kty, class _Keylt = less<_Kty>>

From 7bd29ca05049cbc37e65e62b538def5d93091336 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Wed, 11 Sep 2024 20:52:33 -0700
Subject: [PATCH 038/134] Add newlines to avoid long long lines.

---
 stl/inc/flat_map | 31 +++++++++++++++++--------------
 1 file changed, 17 insertions(+), 14 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index 8e66b5037fa..9f3d71b45ab 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -291,20 +291,23 @@ private:
          flat_multimap<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>>;
 
 public:
-    using key_type               = _Key;
-    using mapped_type            = _Mapped;
-    using value_type             = pair<key_type, mapped_type>;
-    using key_compare            = _Compare;
-    using reference              = pair<const key_type&, mapped_type&>;
-    using const_reference        = pair<const key_type&, const mapped_type&>;
-    using size_type              = size_t;
-    using difference_type        = ptrdiff_t;
-    using key_container_type     = _KeyContainer;
-    using mapped_container_type  = _MappedContainer;
-    using iterator               = _Pairing_iterator_provider<typename key_container_type::const_iterator,
-                      typename mapped_container_type::iterator, typename mapped_container_type::const_iterator>::_Iterator;
-    using const_iterator         = _Pairing_iterator_provider<typename key_container_type::const_iterator,
-                typename mapped_container_type::const_iterator, typename mapped_container_type::const_iterator>::_Iterator;
+    using key_type              = _Key;
+    using mapped_type           = _Mapped;
+    using value_type            = pair<key_type, mapped_type>;
+    using key_compare           = _Compare;
+    using reference             = pair<const key_type&, mapped_type&>;
+    using const_reference       = pair<const key_type&, const mapped_type&>;
+    using size_type             = size_t;
+    using difference_type       = ptrdiff_t;
+    using key_container_type    = _KeyContainer;
+    using mapped_container_type = _MappedContainer;
+
+    using iterator = _Pairing_iterator_provider<typename key_container_type::const_iterator,
+        typename mapped_container_type::iterator, typename mapped_container_type::const_iterator>::_Iterator;
+
+    using const_iterator = _Pairing_iterator_provider<typename key_container_type::const_iterator,
+        typename mapped_container_type::const_iterator, typename mapped_container_type::const_iterator>::_Iterator;
+
     using reverse_iterator       = _STD reverse_iterator<iterator>;
     using const_reverse_iterator = _STD reverse_iterator<const_iterator>;
 

From 46cc8e7beb2a256259ba359349b29a489000005a Mon Sep 17 00:00:00 2001
From: Casey Carter <cacarter@microsoft.com>
Date: Thu, 19 Sep 2024 19:18:18 -0700
Subject: [PATCH 039/134] Eliminate duplicate definitions of `sorted_unique` et
 al.

... and push up into `<xmemory>`. Hopefully there's more common machinery that can factored out so we can justify a new `__msvc_flat_meow.hpp` header to hold it all.
---
 stl/inc/flat_map | 10 ----------
 stl/inc/flat_set | 10 ----------
 stl/inc/xmemory  | 12 ++++++++++++
 3 files changed, 12 insertions(+), 20 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index 9f3d71b45ab..34baac062e2 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -28,16 +28,6 @@ _STL_DISABLE_CLANG_WARNINGS
 #undef new
 
 _STD_BEGIN
-_EXPORT_STD struct sorted_unique_t {
-    explicit sorted_unique_t() = default;
-};
-_EXPORT_STD inline constexpr sorted_unique_t sorted_unique{};
-
-_EXPORT_STD struct sorted_equivalent_t {
-    explicit sorted_equivalent_t() = default;
-};
-_EXPORT_STD inline constexpr sorted_equivalent_t sorted_equivalent{};
-
 template <class _Alloc, class _Key_container, class _Mapped_container>
 concept _Valid_allocator_for_flat_map =
     uses_allocator_v<_Key_container, _Alloc> && uses_allocator_v<_Mapped_container, _Alloc>;
diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index a117d113555..12fb4298184 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -679,16 +679,6 @@ private:
     /* [[no_unique_address]] */ key_compare _Mycomp;
 };
 
-_EXPORT_STD struct sorted_unique_t {
-    explicit sorted_unique_t() = default;
-};
-_EXPORT_STD inline constexpr sorted_unique_t sorted_unique{};
-
-_EXPORT_STD struct sorted_equivalent_t {
-    explicit sorted_equivalent_t() = default;
-};
-_EXPORT_STD inline constexpr sorted_equivalent_t sorted_equivalent{};
-
 _EXPORT_STD template <class _Kty, class _Keylt = less<_Kty>, class _Container = vector<_Kty>>
 class flat_set
     : public _Base_flat_set<_Kty, _Keylt, _Container, false, flat_set<_Kty, _Keylt, _Container>, sorted_unique_t> {
diff --git a/stl/inc/xmemory b/stl/inc/xmemory
index 4944352f3a6..06358ef270b 100644
--- a/stl/inc/xmemory
+++ b/stl/inc/xmemory
@@ -2619,6 +2619,18 @@ _NODISCARD _Elem* _UIntegral_to_buff(_Elem* _RNext, _UTy _UVal) { // used by bot
     } while (_UVal_trunc != 0);
     return _RNext;
 }
+
+#if _HAS_CXX23
+_EXPORT_STD struct sorted_unique_t {
+    explicit sorted_unique_t() = default;
+};
+_EXPORT_STD inline constexpr sorted_unique_t sorted_unique{};
+
+_EXPORT_STD struct sorted_equivalent_t {
+    explicit sorted_equivalent_t() = default;
+};
+_EXPORT_STD inline constexpr sorted_equivalent_t sorted_equivalent{};
+#endif // ^^^ _HAS_CXX23 ^^^
 _STD_END
 
 #pragma pop_macro("new")

From 86ca2d320025ec38b4ca7b8466f7aad1d62fc321 Mon Sep 17 00:00:00 2001
From: Casey Carter <cacarter@microsoft.com>
Date: Thu, 19 Sep 2024 21:48:43 -0700
Subject: [PATCH 040/134] Move `sorted_unique` et al. into `<vector>`

... since both `<flat_meow>` headers include it.
---
 stl/inc/vector  | 12 ++++++++++++
 stl/inc/xmemory | 12 ------------
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/stl/inc/vector b/stl/inc/vector
index 52822076c51..294d2ea69fa 100644
--- a/stl/inc/vector
+++ b/stl/inc/vector
@@ -3922,6 +3922,18 @@ _CONSTEXPR20 _OutIt _Copy_vbool(_VbIt _First, _VbIt _Last, _OutIt _Dest) {
 #undef _ASAN_VECTOR_EXTEND_GUARD
 #undef _ASAN_VECTOR_RELEASE_GUARD
 #undef _INSERT_VECTOR_ANNOTATION
+
+#if _HAS_CXX23
+_EXPORT_STD struct sorted_unique_t {
+    explicit sorted_unique_t() = default;
+};
+_EXPORT_STD inline constexpr sorted_unique_t sorted_unique{};
+
+_EXPORT_STD struct sorted_equivalent_t {
+    explicit sorted_equivalent_t() = default;
+};
+_EXPORT_STD inline constexpr sorted_equivalent_t sorted_equivalent{};
+#endif // ^^^ _HAS_CXX23 ^^^
 _STD_END
 
 #pragma pop_macro("new")
diff --git a/stl/inc/xmemory b/stl/inc/xmemory
index 421d5196dac..3aa11f488c8 100644
--- a/stl/inc/xmemory
+++ b/stl/inc/xmemory
@@ -2641,18 +2641,6 @@ _NODISCARD _Elem* _UIntegral_to_buff(_Elem* _RNext, _UTy _UVal) { // used by bot
     } while (_UVal_trunc != 0);
     return _RNext;
 }
-
-#if _HAS_CXX23
-_EXPORT_STD struct sorted_unique_t {
-    explicit sorted_unique_t() = default;
-};
-_EXPORT_STD inline constexpr sorted_unique_t sorted_unique{};
-
-_EXPORT_STD struct sorted_equivalent_t {
-    explicit sorted_equivalent_t() = default;
-};
-_EXPORT_STD inline constexpr sorted_equivalent_t sorted_equivalent{};
-#endif // ^^^ _HAS_CXX23 ^^^
 _STD_END
 
 #if _HAS_CXX17

From dc266edeb23e6237f4dff42d8645d3238466079b Mon Sep 17 00:00:00 2001
From: nerix <nerixdev@outlook.de>
Date: Thu, 24 Oct 2024 20:38:31 +0200
Subject: [PATCH 041/134] Add visualizer for `std::flat_map` (#4887)

---
 stl/debugger/STL.natvis | 118 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 118 insertions(+)

diff --git a/stl/debugger/STL.natvis b/stl/debugger/STL.natvis
index a3d3fb2f1a3..93ab77eebbb 100644
--- a/stl/debugger/STL.natvis
+++ b/stl/debugger/STL.natvis
@@ -2312,4 +2312,122 @@ SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
     </Expand>
   </Type>
 
+  <!-- KeyContainer: vector, MappedContainer: vector -->
+  <Type Name="std::flat_map&lt;*,*,*,std::vector&lt;*&gt;,std::vector&lt;*&gt;&gt;">
+    <Intrinsic Name="size" Expression="(size_t)(_Data.keys._Mypair._Myval2._Mylast - _Data.keys._Mypair._Myval2._Myfirst)"/>
+    <Intrinsic Name="key_at" Expression="&amp;_Data.keys._Mypair._Myval2._Myfirst[index]">
+      <Parameter Name="index" Type="size_t" />
+    </Intrinsic>
+    <Intrinsic Name="value_at" Expression="&amp;_Data.values._Mypair._Myval2._Myfirst[index]">
+      <Parameter Name="index" Type="size_t" />
+    </Intrinsic>
+
+    <DisplayString>{{ size={size()} }}</DisplayString>
+
+    <Expand>
+      <Item Name="[comparator]" ExcludeView="simple">_Key_compare</Item>
+      <Item Name="[size]">size()</Item>
+      <CustomListItems>
+        <Variable Name="i" InitialValue="0" />
+        <Size>size()</Size>
+        <Loop>
+          <Item Name="[{*key_at(i)}]">*value_at(i)</Item>
+          <Exec>++i</Exec>
+        </Loop>
+      </CustomListItems>
+    </Expand>
+  </Type>
+
+  <!-- KeyContainer: std::deque, MappedContainer: std::vector -->
+  <Type Name="std::flat_map&lt;*,*,*,std::deque&lt;*&gt;,std::vector&lt;*&gt;&gt;">
+    <Intrinsic Name="size" Expression="_Data.keys._Mypair._Myval2._Mysize" />
+    <Intrinsic Name="key_at" Expression="&amp;_Data.keys._Mypair._Myval2._Map[((index + _Data.keys._Mypair._Myval2._Myoff) / _Data.keys._EEN_DS) %
+          _Data.keys._Mypair._Myval2._Mapsize][(index + _Data.keys._Mypair._Myval2._Myoff) % _Data.keys._EEN_DS]">
+      <Parameter Name="index" Type="size_t" />
+    </Intrinsic>
+    <Intrinsic Name="value_at" Expression="&amp;_Data.values._Mypair._Myval2._Myfirst[index]">
+      <Parameter Name="index" Type="size_t" />
+    </Intrinsic>
+
+    <DisplayString>{{ size={size()} }}</DisplayString>
+
+    <Expand>
+      <Item Name="[comparator]" ExcludeView="simple">_Key_compare</Item>
+      <Item Name="[size]">size()</Item>
+      <CustomListItems>
+        <Variable Name="i" InitialValue="0" />
+        <Size>size()</Size>
+        <Loop>
+          <Item Name="[{*key_at(i)}]">*value_at(i)</Item>
+          <Exec>++i</Exec>
+        </Loop>
+      </CustomListItems>
+    </Expand>
+  </Type>
+
+  <!-- KeyContainer: std::vector, MappedContainer: std::deque -->
+  <Type Name="std::flat_map&lt;*,*,*,std::vector&lt;*&gt;,std::deque&lt;*&gt;&gt;">
+    <Intrinsic Name="size" Expression="(size_t)(_Data.keys._Mypair._Myval2._Mylast - _Data.keys._Mypair._Myval2._Myfirst)" />
+    <Intrinsic Name="key_at" Expression="&amp;_Data.keys._Mypair._Myval2._Myfirst[index]">
+      <Parameter Name="index" Type="size_t" />
+    </Intrinsic>
+    <Intrinsic Name="value_at" Expression="&amp;_Data.values._Mypair._Myval2._Map[((index + _Data.values._Mypair._Myval2._Myoff) / _Data.values._EEN_DS) %
+          _Data.values._Mypair._Myval2._Mapsize][(index + _Data.values._Mypair._Myval2._Myoff) % _Data.values._EEN_DS]">
+      <Parameter Name="index" Type="size_t" />
+    </Intrinsic>
+
+    <DisplayString>{{ size={size()} }}</DisplayString>
+
+    <Expand>
+      <Item Name="[comparator]" ExcludeView="simple">_Key_compare</Item>
+      <Item Name="[size]">size()</Item>
+      <CustomListItems>
+        <Variable Name="i" InitialValue="0" />
+        <Size>size()</Size>
+        <Loop>
+          <Item Name="[{*key_at(i)}]">*value_at(i)</Item>
+          <Exec>++i</Exec>
+        </Loop>
+      </CustomListItems>
+    </Expand>
+  </Type>
+
+  <!-- KeyContainer: std::deque, MappedContainer: std::deque -->
+  <Type Name="std::flat_map&lt;*,*,*,std::deque&lt;*&gt;,std::deque&lt;*&gt;&gt;">
+    <Intrinsic Name="size" Expression="_Data.keys._Mypair._Myval2._Mysize" />
+    <Intrinsic Name="key_at" Expression="&amp;_Data.keys._Mypair._Myval2._Map[((index + _Data.keys._Mypair._Myval2._Myoff) / _Data.keys._EEN_DS) %
+          _Data.keys._Mypair._Myval2._Mapsize][(index + _Data.keys._Mypair._Myval2._Myoff) % _Data.keys._EEN_DS]">
+      <Parameter Name="index" Type="size_t" />
+    </Intrinsic>
+    <Intrinsic Name="value_at" Expression="&amp;_Data.values._Mypair._Myval2._Map[((index + _Data.values._Mypair._Myval2._Myoff) / _Data.values._EEN_DS) %
+          _Data.values._Mypair._Myval2._Mapsize][(index + _Data.values._Mypair._Myval2._Myoff) % _Data.values._EEN_DS]">
+      <Parameter Name="index" Type="size_t" />
+    </Intrinsic>
+
+    <DisplayString>{{ size={size()} }}</DisplayString>
+
+    <Expand>
+      <Item Name="[comparator]" ExcludeView="simple">_Key_compare</Item>
+      <Item Name="[size]">size()</Item>
+      <CustomListItems>
+        <Variable Name="i" InitialValue="0" />
+        <Size>size()</Size>
+        <Loop>
+          <Item Name="[{*key_at(i)}]">*value_at(i)</Item>
+          <Exec>++i</Exec>
+        </Loop>
+      </CustomListItems>
+    </Expand>
+  </Type>
+
+  <!-- fallback for a custom container -->
+  <Type Name="std::flat_map&lt;*&gt;">
+    <DisplayString>{_Data}</DisplayString>
+    <Expand>
+      <Item Name="[comparator]" ExcludeView="simple">_Key_compare</Item>
+      <Item Name="[keys]">_Data.keys</Item>
+      <Item Name="[values]">_Data.values</Item>
+    </Expand>
+  </Type>
+
 </AutoVisualizer>

From 027f3306706b47640a13a4a837eaab771c4b4cad Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34@live.cn>
Date: Tue, 29 Oct 2024 21:58:58 +0800
Subject: [PATCH 042/134] Reject `vector<bool>` and deduplicate mechanisms for
 `flat_meow` (#5045)

Co-authored-by: Casey Carter <cacarter@microsoft.com>
Co-authored-by: Stephan T. Lavavej <stl@nuwen.net>
---
 stl/inc/flat_map | 106 ++++++++++++++++++++---------------------------
 stl/inc/flat_set |  52 +++++++++--------------
 stl/inc/vector   |  24 +++++++++++
 3 files changed, 90 insertions(+), 92 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index 34baac062e2..9ce2dd5aa20 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -28,10 +28,6 @@ _STL_DISABLE_CLANG_WARNINGS
 #undef new
 
 _STD_BEGIN
-template <class _Alloc, class _Key_container, class _Mapped_container>
-concept _Valid_allocator_for_flat_map =
-    uses_allocator_v<_Key_container, _Alloc> && uses_allocator_v<_Mapped_container, _Alloc>;
-
 template <class _Compare, class _Key_container>
 concept _Valid_compare_for_container = is_invocable_v<const _Compare&, const typename _Key_container::value_type&,
     const typename _Key_container::value_type&>;
@@ -59,18 +55,6 @@ struct _Flat_map_container_provider {
     };
 };
 
-template <class _Ty>
-struct _NODISCARD _Clear_flat_map_scope_guard {
-    _Ty* _Clearable;
-    _Clear_flat_map_scope_guard(_Ty* _Clearable) : _Clearable(_Clearable) {}
-
-    ~_Clear_flat_map_scope_guard() {
-        if (_Clearable) {
-            _Clearable->clear();
-        }
-    }
-};
-
 // Implementation
 
 template <bool _IsUnique, class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer>
@@ -305,6 +289,8 @@ public:
         "key_type should be the element type of key_container_type");
     static_assert(is_same_v<mapped_type, typename mapped_container_type::value_type>,
         "mapped_type should be the element type of mapped_container_type");
+    static_assert(!_Is_vector_bool<key_container_type> && !_Is_vector_bool<mapped_container_type>,
+        "vector<bool, A> cannot be adapted because it is not a sequence container.");
 
     _STL_INTERNAL_STATIC_ASSERT(random_access_iterator<iterator>);
     _STL_INTERNAL_STATIC_ASSERT(convertible_to<iterator, const_iterator>);
@@ -317,10 +303,10 @@ public:
     explicit _Flat_map_base(const key_compare& _Comp) : _Key_compare(_Comp), _Data() {}
     _Flat_map_base() : _Flat_map_base(key_compare()) {}
 
-    template <_Valid_allocator_for_flat_map<key_container_type, mapped_container_type> _Allocator>
+    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
     explicit _Flat_map_base(const _Allocator& _Alloc) : _Flat_map_base(key_compare(), _Alloc) {}
 
-    template <_Valid_allocator_for_flat_map<key_container_type, mapped_container_type> _Allocator>
+    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
     explicit _Flat_map_base(const key_compare& _Comp, const _Allocator& _Alloc)
         : _Key_compare(_Comp), _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Alloc),
                                    .values = _STD make_obj_using_allocator<mapped_container_type>(_Alloc)} {}
@@ -334,7 +320,7 @@ public:
         }
     }
 
-    template <_Valid_allocator_for_flat_map<key_container_type, mapped_container_type> _Allocator>
+    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
     _Flat_map_base(
         const key_container_type& _Key_cont, const mapped_container_type& _Mapped_cont, const _Allocator& _Alloc)
         : _Flat_map_base(_Sorted_t(), _Key_cont, _Mapped_cont, _Alloc) {
@@ -344,7 +330,7 @@ public:
         }
     }
 
-    template <_Valid_allocator_for_flat_map<key_container_type, mapped_container_type> _Allocator>
+    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
     _Flat_map_base(const key_container_type& _Key_cont, const mapped_container_type& _Mapped_cont,
         const key_compare& _Comp, const _Allocator& _Alloc)
         : _Flat_map_base(_Sorted_t(), _Key_cont, _Mapped_cont, _Comp, _Alloc) {
@@ -358,14 +344,14 @@ public:
         const key_compare& _Comp = key_compare())
         : _Key_compare(_Comp), _Data{.keys = _STD move(_Key_cont), .values = _STD move(_Mapped_cont)} {}
 
-    template <_Valid_allocator_for_flat_map<key_container_type, mapped_container_type> _Allocator>
+    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
     _Flat_map_base(_Sorted_t, const key_container_type& _Key_cont, const mapped_container_type& _Mapped_cont,
         const _Allocator& _Alloc)
         : _Key_compare(key_compare()),
           _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Alloc, _Key_cont),
               .values = _STD make_obj_using_allocator<mapped_container_type>(_Alloc, _Mapped_cont)} {}
 
-    template <_Valid_allocator_for_flat_map<key_container_type, mapped_container_type> _Allocator>
+    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
     _Flat_map_base(_Sorted_t, const key_container_type& _Key_cont, const mapped_container_type& _Mapped_cont,
         const key_compare& _Comp, const _Allocator& _Alloc)
         : _Key_compare(_Comp),
@@ -379,7 +365,7 @@ public:
         insert(_First, _Last);
     }
 
-    template <class _InputIterator, _Valid_allocator_for_flat_map<key_container_type, mapped_container_type> _Allocator>
+    template <class _InputIterator, _Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
         requires _Is_iterator_v<_InputIterator>
     _Flat_map_base(_InputIterator _First, _InputIterator _Last, const key_compare& _Comp, const _Allocator& _Alloc)
         : _Flat_map_base(_Comp, _Alloc) {
@@ -391,7 +377,7 @@ public:
         : _Flat_map_base(_From_range, _STD forward<_Rng>(_Range), key_compare()) {}
 
     template <_Container_compatible_range<value_type> _Rng,
-        _Valid_allocator_for_flat_map<key_container_type, mapped_container_type> _Allocator>
+        _Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
     _Flat_map_base(from_range_t _From_range, _Rng&& _Range, const _Allocator& _Alloc)
         : _Flat_map_base(_From_range, _STD forward<_Rng>(_Range), key_compare(), _Alloc) {}
 
@@ -401,7 +387,7 @@ public:
     }
 
     template <_Container_compatible_range<value_type> _Rng,
-        _Valid_allocator_for_flat_map<key_container_type, mapped_container_type> _Allocator>
+        _Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
     _Flat_map_base(from_range_t, _Rng&& _Range, const key_compare& _Comp, const _Allocator& _Alloc)
         : _Flat_map_base(_Comp, _Alloc) {
         insert_range(_STD forward<_Rng>(_Range));
@@ -415,7 +401,7 @@ public:
         insert(_Tag, _First, _Last);
     }
 
-    template <class _InputIterator, _Valid_allocator_for_flat_map<key_container_type, mapped_container_type> _Allocator>
+    template <class _InputIterator, _Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
         requires _Is_iterator_v<_InputIterator>
     _Flat_map_base(
         _Sorted_t _Tag, _InputIterator _First, _InputIterator _Last, const key_compare& _Comp, const _Allocator& _Alloc)
@@ -423,7 +409,7 @@ public:
         insert(_Tag, _First, _Last);
     }
 
-    template <class _InputIterator, _Valid_allocator_for_flat_map<key_container_type, mapped_container_type> _Allocator>
+    template <class _InputIterator, _Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
         requires _Is_iterator_v<_InputIterator>
     _Flat_map_base(_Sorted_t _Tag, _InputIterator _First, _InputIterator _Last, const _Allocator& _Alloc)
         : _Flat_map_base(_Tag, _First, _Last, key_compare(), _Alloc) {}
@@ -431,23 +417,23 @@ public:
     _Flat_map_base(initializer_list<value_type> _Ilist, const key_compare& _Comp = key_compare())
         : _Flat_map_base(_Ilist.begin(), _Ilist.end(), _Comp) {}
 
-    template <_Valid_allocator_for_flat_map<key_container_type, mapped_container_type> _Allocator>
+    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
     _Flat_map_base(initializer_list<value_type> _Ilist, const key_compare& _Comp, const _Allocator& _Alloc)
         : _Flat_map_base(_Ilist.begin(), _Ilist.end(), _Comp, _Alloc) {}
 
-    template <_Valid_allocator_for_flat_map<key_container_type, mapped_container_type> _Allocator>
+    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
     _Flat_map_base(initializer_list<value_type> _Ilist, const _Allocator& _Alloc)
         : _Flat_map_base(_Ilist, key_compare(), _Alloc) {}
 
     _Flat_map_base(_Sorted_t _Tag, initializer_list<value_type> _Ilist, const key_compare& _Comp = key_compare())
         : _Flat_map_base(_Tag, _Ilist.begin(), _Ilist.end(), _Comp) {}
 
-    template <_Valid_allocator_for_flat_map<key_container_type, mapped_container_type> _Allocator>
+    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
     _Flat_map_base(
         _Sorted_t _Tag, initializer_list<value_type> _Ilist, const key_compare& _Comp, const _Allocator& _Alloc)
         : _Flat_map_base(_Tag, _Ilist.begin(), _Ilist.end(), _Comp, _Alloc) {}
 
-    template <_Valid_allocator_for_flat_map<key_container_type, mapped_container_type> _Allocator>
+    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
     _Flat_map_base(_Sorted_t _Tag, initializer_list<value_type> _Ilist, const _Allocator& _Alloc)
         : _Flat_map_base(_Tag, _Ilist, key_compare(), _Alloc) {}
 
@@ -456,7 +442,7 @@ public:
         : _Key_compare(static_cast<const _Flat_map_base&>(_Other)._Key_compare),
           _Data(static_cast<const _Flat_map_base&>(_Other)._Data) {}
 
-    template <_Valid_allocator_for_flat_map<key_container_type, mapped_container_type> _Allocator>
+    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
     _Flat_map_base(const _Derived& _Other, const _Allocator& _Alloc)
         : _Key_compare(static_cast<const _Flat_map_base&>(_Other)._Key_compare),
           _Data{.keys = _STD make_obj_using_allocator<key_container_type>(
@@ -471,7 +457,7 @@ public:
         : _Key_compare(_STD move(static_cast<_Flat_map_base&>(_Other)._Key_compare)),
           _Data(_STD move(static_cast<_Flat_map_base&>(_Other).extract())) {}
 
-    template <_Valid_allocator_for_flat_map<key_container_type, mapped_container_type> _Allocator>
+    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
     _Flat_map_base(_Derived&& _Other, const _Allocator& _Alloc)
         noexcept(is_nothrow_move_constructible_v<key_compare> && is_nothrow_move_constructible_v<key_container_type>
                  && is_nothrow_move_constructible_v<mapped_container_type>)
@@ -614,18 +600,18 @@ public:
     }
 
     iterator erase(const_iterator _Position) {
-        _Clear_flat_map_scope_guard _Guard{this};
-        auto _Key_it      = _Data.keys.erase(_Position._Key_it);
-        auto _Val_it      = _Data.values.erase(_Position._Mapped_it);
-        _Guard._Clearable = nullptr;
+        _Clear_guard _Guard{this};
+        auto _Key_it   = _Data.keys.erase(_Position._Key_it);
+        auto _Val_it   = _Data.values.erase(_Position._Mapped_it);
+        _Guard._Target = nullptr;
         return iterator{_STD move(_Key_it), _STD move(_Val_it)};
     }
 
     iterator erase(const_iterator _First, const_iterator _Last) {
-        _Clear_flat_map_scope_guard _Guard{this};
-        auto _Key_it      = _Data.keys.erase(_First._Key_it, _Last._Key_it);
-        auto _Val_it      = _Data.values.erase(_First._Mapped_it, _Last._Mapped_it);
-        _Guard._Clearable = nullptr;
+        _Clear_guard _Guard{this};
+        auto _Key_it   = _Data.keys.erase(_First._Key_it, _Last._Key_it);
+        auto _Val_it   = _Data.values.erase(_First._Mapped_it, _Last._Mapped_it);
+        _Guard._Target = nullptr;
         return iterator{_STD move(_Key_it), _STD move(_Val_it)};
     }
 
@@ -641,15 +627,15 @@ public:
     }
 
     containers extract() && {
-        _Clear_flat_map_scope_guard _Guard{this};
+        _Clear_guard _Guard{this};
         return _STD move(_Data);
     }
 
     void replace(key_container_type&& _Key_cont, mapped_container_type&& _Mapped_cont) {
-        _Clear_flat_map_scope_guard _Guard{this};
-        _Data.keys        = _STD move(_Key_cont);
-        _Data.values      = _STD move(_Mapped_cont);
-        _Guard._Clearable = nullptr;
+        _Clear_guard _Guard{this};
+        _Data.keys     = _STD move(_Key_cont);
+        _Data.values   = _STD move(_Mapped_cont);
+        _Guard._Target = nullptr;
     }
 
     // observers
@@ -809,13 +795,13 @@ protected:
         auto _Mut_last       = _View.end();
         const auto _Old_size = size();
 
-        _Clear_flat_map_scope_guard<_Flat_map_base> _Guard{this};
+        _Clear_guard<_Flat_map_base> _Guard{this};
 
         _STD _Seek_wrapped(_Mut_first, _RANGES remove_if(_View, _Pred).begin());
         (void) _Data.keys.erase(_Mut_first._Key_it, _Mut_last._Key_it);
         (void) _Data.values.erase(_Mut_first._Mapped_it, _Mut_last._Mapped_it);
 
-        _Guard._Clearable = nullptr;
+        _Guard._Target = nullptr;
         return _Old_size - size();
     }
 
@@ -890,10 +876,10 @@ protected:
     }
 
     void _Insert_exact(const_iterator _Position, key_type&& _Key_val, mapped_type&& _Mapped_val) {
-        _Clear_flat_map_scope_guard _Guard{this};
+        _Clear_guard _Guard{this};
         _Data.keys.insert(_Position._Key_it, _STD move(_Key_val));
         _Data.values.insert(_Position._Mapped_it, _STD move(_Mapped_val));
-        _Guard._Clearable = nullptr;
+        _Guard._Target = nullptr;
     }
 
     template <class _KeyTy1, class _KeyTy2>
@@ -915,13 +901,13 @@ private:
     }
 
     void _Sort() {
-        _Clear_flat_map_scope_guard _Guard{this};
+        _Clear_guard _Guard{this};
         _RANGES sort(_View_to_mutate(), value_compare(_Key_compare));
-        _Guard._Clearable = nullptr;
+        _Guard._Target = nullptr;
     }
 
     void _Dedup() {
-        _Clear_flat_map_scope_guard _Guard{this};
+        _Clear_guard _Guard{this};
         auto _Sorted_view = _View_to_mutate();
         auto _Subrange    = _RANGES unique(_Sorted_view, [this](const_reference _Left, const_reference _Right) {
             return this->_Key_equal(_Left.first, _Right.first);
@@ -929,13 +915,13 @@ private:
         const auto _Remaining_count = _Subrange.begin() - _Sorted_view.begin();
         _Data.keys.erase(_Data.keys.begin() + _Remaining_count, _Data.keys.end());
         _Data.values.erase(_Data.values.begin() + _Remaining_count, _Data.values.end());
-        _Guard._Clearable = nullptr;
+        _Guard._Target = nullptr;
     }
 
     template <bool _NeedSorting, bool _NeedDeduping, class _InputIterator>
         requires _Is_iterator_v<_InputIterator>
     void _Insert_range(_InputIterator _First, _InputIterator _Last) {
-        _Clear_flat_map_scope_guard _Guard{this};
+        _Clear_guard _Guard{this};
 
         const auto _Old_distance = static_cast<difference_type>(size());
 
@@ -961,7 +947,7 @@ private:
             _Dedup();
         }
 
-        _Guard._Clearable = nullptr;
+        _Guard._Target = nullptr;
     }
 
     template <class _KeyTy>
@@ -1312,13 +1298,13 @@ flat_map(_KeyContainer, _MappedContainer,
                                _Compare, _KeyContainer, _MappedContainer>;
 
 template <class _KeyContainer, class _MappedContainer,
-    _Valid_allocator_for_flat_map<_KeyContainer, _MappedContainer> _Allocator>
+    _Usable_allocator_for<_KeyContainer, _MappedContainer> _Allocator>
 flat_map(_KeyContainer, _MappedContainer,
     _Allocator) -> flat_map<typename _KeyContainer::value_type, typename _MappedContainer::value_type,
                     less<typename _KeyContainer::value_type>, _KeyContainer, _MappedContainer>;
 
 template <class _KeyContainer, class _MappedContainer, _Valid_compare_for_container<_KeyContainer> _Compare,
-    _Valid_allocator_for_flat_map<_KeyContainer, _MappedContainer> _Allocator>
+    _Usable_allocator_for<_KeyContainer, _MappedContainer> _Allocator>
 flat_map(_KeyContainer, _MappedContainer, _Compare,
     _Allocator) -> flat_map<typename _KeyContainer::value_type, typename _MappedContainer::value_type, _Compare,
                     _KeyContainer, _MappedContainer>;
@@ -1330,13 +1316,13 @@ flat_map(sorted_unique_t, _KeyContainer, _MappedContainer,
                                _Compare, _KeyContainer, _MappedContainer>;
 
 template <class _KeyContainer, class _MappedContainer,
-    _Valid_allocator_for_flat_map<_KeyContainer, _MappedContainer> _Allocator>
+    _Usable_allocator_for<_KeyContainer, _MappedContainer> _Allocator>
 flat_map(sorted_unique_t, _KeyContainer, _MappedContainer,
     _Allocator) -> flat_map<typename _KeyContainer::value_type, typename _MappedContainer::value_type,
                     less<typename _KeyContainer::value_type>, _KeyContainer, _MappedContainer>;
 
 template <class _KeyContainer, class _MappedContainer, _Valid_compare_for_container<_KeyContainer> _Compare,
-    _Valid_allocator_for_flat_map<_KeyContainer, _MappedContainer> _Allocator>
+    _Usable_allocator_for<_KeyContainer, _MappedContainer> _Allocator>
 flat_map(sorted_unique_t, _KeyContainer, _MappedContainer, _Compare,
     _Allocator) -> flat_map<typename _KeyContainer::value_type, typename _MappedContainer::value_type, _Compare,
                     _KeyContainer, _MappedContainer>;
diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index 12fb4298184..fe3d087c00c 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -24,20 +24,6 @@ _STL_DISABLE_CLANG_WARNINGS
 #undef new
 
 _STD_BEGIN
-
-template <class _Ty>
-struct _NODISCARD _Clear_guard {
-    _Ty* _Target;
-    ~_Clear_guard() {
-        if (_Target) {
-            _Target->clear();
-        }
-    }
-};
-
-template <class _Alloc, class _Container>
-concept _Allocator_for = uses_allocator_v<_Container, _Alloc>;
-
 template <class _Kty, class _Keylt, class _Container, bool _Multi, class _Deriv, class _Tsorted>
 class _Base_flat_set {
 private:
@@ -47,6 +33,8 @@ public:
     static_assert(same_as<_Kty, typename _Container::value_type>,
         "The C++ Standard dictates that the Key type must be the "
         "same as the container's value type [flatset.overview]");
+    static_assert(
+        !_Is_vector_bool<_Container>, "vector<bool, A> cannot be adapted because it is not a sequence container.");
 
     using key_type               = _Kty;
     using value_type             = _Kty;
@@ -67,10 +55,10 @@ public:
 
     _Base_flat_set() : _Mycont(), _Mycomp() {}
 
-    template <_Allocator_for<container_type> _Alloc>
+    template <_Usable_allocator_for<container_type> _Alloc>
     _Base_flat_set(const _Deriv& _Set, const _Alloc& _Al)
         : _Mycont(_STD make_obj_using_allocator<container_type>(_Al, _Set._Mycont)), _Mycomp(_Set._Mycomp) {}
-    template <_Allocator_for<container_type> _Alloc>
+    template <_Usable_allocator_for<container_type> _Alloc>
     _Base_flat_set(_Deriv&& _Set, const _Alloc& _Al)
         : _Mycont(_STD make_obj_using_allocator<container_type>(_Al, _STD move(_Set).extract())),
           _Mycomp(_Set._Mycomp) // intentionally copy comparator, see LWG-2227
@@ -80,10 +68,10 @@ public:
         : _Mycont(_STD move(_Cont)), _Mycomp(_Comp) {
         _Make_invariants_fulfilled();
     }
-    template <_Allocator_for<container_type> _Alloc>
+    template <_Usable_allocator_for<container_type> _Alloc>
     _Base_flat_set(const container_type& _Cont, const _Alloc& _Al)
         : _Base_flat_set(_STD make_obj_using_allocator<container_type>(_Al, _Cont)) {}
-    template <_Allocator_for<container_type> _Alloc>
+    template <_Usable_allocator_for<container_type> _Alloc>
     _Base_flat_set(const container_type& _Cont, const key_compare& _Comp, const _Alloc& _Al)
         : _Base_flat_set(_STD make_obj_using_allocator<container_type>(_Al, _Cont), _Comp) {}
 
@@ -91,31 +79,31 @@ public:
         : _Mycont(_STD move(_Cont)), _Mycomp(_Comp) {
         _STL_ASSERT(_Is_sorted(_Mycont), _Msg_not_sorted);
     }
-    template <_Allocator_for<container_type> _Alloc>
+    template <_Usable_allocator_for<container_type> _Alloc>
     _Base_flat_set(_Tsorted _Tsort, const container_type& _Cont, const _Alloc& _Al)
         : _Base_flat_set(_Tsort, _STD make_obj_using_allocator<container_type>(_Al, _Cont)) {}
-    template <_Allocator_for<container_type> _Alloc>
+    template <_Usable_allocator_for<container_type> _Alloc>
     _Base_flat_set(_Tsorted _Tsort, const container_type& _Cont, const key_compare& _Comp, const _Alloc& _Al)
         : _Base_flat_set(_Tsort, _STD make_obj_using_allocator<container_type>(_Al, _Cont), _Comp) {}
 
     explicit _Base_flat_set(const key_compare& _Comp) : _Mycont(), _Mycomp(_Comp) {}
-    template <_Allocator_for<container_type> _Alloc>
+    template <_Usable_allocator_for<container_type> _Alloc>
     _Base_flat_set(const key_compare& _Comp, const _Alloc& _Al)
         : _Mycont(_STD make_obj_using_allocator<container_type>(_Al)), _Mycomp(_Comp) {}
-    template <_Allocator_for<container_type> _Alloc>
+    template <_Usable_allocator_for<container_type> _Alloc>
     explicit _Base_flat_set(const _Alloc& _Al)
         : _Mycont(_STD make_obj_using_allocator<container_type>(_Al)), _Mycomp() {}
 
     template <input_iterator _Iter>
     _Base_flat_set(_Iter _First, _Iter _Last, const key_compare& _Comp = key_compare())
         : _Base_flat_set(container_type(_First, _Last), _Comp) {}
-    template <input_iterator _Iter, _Allocator_for<container_type> _Alloc>
+    template <input_iterator _Iter, _Usable_allocator_for<container_type> _Alloc>
     _Base_flat_set(_Iter _First, _Iter _Last, const key_compare& _Comp, const _Alloc& _Al)
         : _Mycont(_STD make_obj_using_allocator<container_type>(_Al)), _Mycomp(_Comp) {
         _Mycont.assign(_First, _Last);
         _Make_invariants_fulfilled();
     }
-    template <input_iterator _Iter, _Allocator_for<container_type> _Alloc>
+    template <input_iterator _Iter, _Usable_allocator_for<container_type> _Alloc>
     _Base_flat_set(_Iter _First, _Iter _Last, const _Alloc& _Al)
         : _Mycont(_STD make_obj_using_allocator<container_type>(_Al)), _Mycomp() {
         _Mycont.assign(_First, _Last);
@@ -125,7 +113,7 @@ public:
     template <_Container_compatible_range<_Kty> _Rng>
     _Base_flat_set(from_range_t, _Rng&& _Range)
         : _Base_flat_set(container_type(from_range, _STD forward<_Rng>(_Range))) {}
-    template <_Container_compatible_range<_Kty> _Rng, _Allocator_for<container_type> _Alloc>
+    template <_Container_compatible_range<_Kty> _Rng, _Usable_allocator_for<container_type> _Alloc>
     _Base_flat_set(from_range_t, _Rng&& _Range, const _Alloc& _Al)
         : _Mycont(_STD make_obj_using_allocator<container_type>(_Al)), _Mycomp() {
         _Mycont.assign_range(_STD forward<_Rng>(_Range));
@@ -134,7 +122,7 @@ public:
     template <_Container_compatible_range<_Kty> _Rng>
     _Base_flat_set(from_range_t, _Rng&& _Range, const key_compare& _Comp)
         : _Base_flat_set(container_type(from_range, _STD forward<_Rng>(_Range)), _Comp) {}
-    template <_Container_compatible_range<_Kty> _Rng, _Allocator_for<container_type> _Alloc>
+    template <_Container_compatible_range<_Kty> _Rng, _Usable_allocator_for<container_type> _Alloc>
     _Base_flat_set(from_range_t, _Rng&& _Range, const key_compare& _Comp, const _Alloc& _Al)
         : _Mycont(_STD make_obj_using_allocator<container_type>(_Al)), _Mycomp(_Comp) {
         _Mycont.assign_range(_STD forward<_Rng>(_Range));
@@ -144,28 +132,28 @@ public:
     template <input_iterator _Iter>
     _Base_flat_set(_Tsorted _Tsort, _Iter _First, _Iter _Last, const key_compare& _Comp = key_compare())
         : _Base_flat_set(_Tsort, container_type(_First, _Last), _Comp) {}
-    template <input_iterator _Iter, _Allocator_for<container_type> _Alloc>
+    template <input_iterator _Iter, _Usable_allocator_for<container_type> _Alloc>
     _Base_flat_set(_Tsorted _Tsort, _Iter _First, _Iter _Last, const key_compare& _Comp, const _Alloc& _Al)
         : _Base_flat_set(_Tsort, _STD make_obj_using_allocator<container_type>(_Al, _First, _Last), _Comp) {}
-    template <input_iterator _Iter, _Allocator_for<container_type> _Alloc>
+    template <input_iterator _Iter, _Usable_allocator_for<container_type> _Alloc>
     _Base_flat_set(_Tsorted _Tsort, _Iter _First, _Iter _Last, const _Alloc& _Al)
         : _Base_flat_set(_Tsort, _STD make_obj_using_allocator<container_type>(_Al, _First, _Last)) {}
 
     _Base_flat_set(initializer_list<_Kty> _Ilist, const key_compare& _Comp = key_compare())
         : _Base_flat_set(container_type(_Ilist), _Comp) {}
-    template <_Allocator_for<container_type> _Alloc>
+    template <_Usable_allocator_for<container_type> _Alloc>
     _Base_flat_set(initializer_list<_Kty> _Ilist, const key_compare& _Comp, const _Alloc& _Al)
         : _Base_flat_set(_Ilist.begin(), _Ilist.end(), _Comp, _Al) {}
-    template <_Allocator_for<container_type> _Alloc>
+    template <_Usable_allocator_for<container_type> _Alloc>
     _Base_flat_set(initializer_list<_Kty> _Ilist, const _Alloc& _Al)
         : _Base_flat_set(_Ilist.begin(), _Ilist.end(), _Al) {}
 
     _Base_flat_set(_Tsorted _Tsort, initializer_list<_Kty> _Ilist, const key_compare& _Comp = key_compare())
         : _Base_flat_set(_Tsort, container_type(_Ilist), _Comp) {}
-    template <_Allocator_for<container_type> _Alloc>
+    template <_Usable_allocator_for<container_type> _Alloc>
     _Base_flat_set(_Tsorted _Tsort, initializer_list<_Kty> _Ilist, const key_compare& _Comp, const _Alloc& _Al)
         : _Base_flat_set(_Tsort, _Ilist.begin(), _Ilist.end(), _Comp, _Al) {}
-    template <_Allocator_for<container_type> _Alloc>
+    template <_Usable_allocator_for<container_type> _Alloc>
     _Base_flat_set(_Tsorted _Tsort, initializer_list<_Kty> _Ilist, const _Alloc& _Al)
         : _Base_flat_set(_Tsort, _Ilist.begin(), _Ilist.end(), _Al) {}
 
diff --git a/stl/inc/vector b/stl/inc/vector
index 399f486debb..6c9235864dd 100644
--- a/stl/inc/vector
+++ b/stl/inc/vector
@@ -3950,6 +3950,8 @@ _CONSTEXPR20 _OutIt _Copy_vbool(_VbIt _First, _VbIt _Last, _OutIt _Dest) {
 #undef _INSERT_VECTOR_ANNOTATION
 
 #if _HAS_CXX23
+// This `flat_meow` machinery is here because `vector` is the leaf-most header included by both `flat_meow` headers.
+
 _EXPORT_STD struct sorted_unique_t {
     explicit sorted_unique_t() = default;
 };
@@ -3959,6 +3961,28 @@ _EXPORT_STD struct sorted_equivalent_t {
     explicit sorted_equivalent_t() = default;
 };
 _EXPORT_STD inline constexpr sorted_equivalent_t sorted_equivalent{};
+
+template <class>
+constexpr bool _Is_vector_bool = false;
+template <class _Alloc>
+constexpr bool _Is_vector_bool<vector<bool, _Alloc>> = true;
+
+template <class _Alloc, class... _Containers>
+concept _Usable_allocator_for = (uses_allocator_v<_Containers, _Alloc> && ...);
+
+template <class _Ty>
+struct _NODISCARD _Clear_guard {
+    _Ty* _Target;
+
+    _Clear_guard& operator=(const _Clear_guard&) = delete;
+    _Clear_guard& operator=(_Clear_guard&&)      = delete;
+
+    ~_Clear_guard() {
+        if (_Target) {
+            _Target->clear();
+        }
+    }
+};
 #endif // ^^^ _HAS_CXX23 ^^^
 _STD_END
 

From 9401dbcaafff312704eeec7e524ea89566f6e78a Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Fri, 24 Jan 2025 08:50:49 -0800
Subject: [PATCH 043/134] clang-format, no manual changes: Improve CTAD.

---
 stl/inc/flat_map | 130 ++++++++++++++++++++++-------------------------
 stl/inc/flat_set |  48 +++++++++--------
 2 files changed, 83 insertions(+), 95 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index 9ce2dd5aa20..d19fa701afc 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -1293,47 +1293,43 @@ private:
 
 template <class _KeyContainer, class _MappedContainer,
     _Valid_compare_for_container<_KeyContainer> _Compare = less<typename _KeyContainer::value_type>>
-flat_map(_KeyContainer, _MappedContainer,
-    _Compare = _Compare()) -> flat_map<typename _KeyContainer::value_type, typename _MappedContainer::value_type,
-                               _Compare, _KeyContainer, _MappedContainer>;
+flat_map(_KeyContainer, _MappedContainer, _Compare = _Compare()) -> flat_map<typename _KeyContainer::value_type,
+    typename _MappedContainer::value_type, _Compare, _KeyContainer, _MappedContainer>;
 
 template <class _KeyContainer, class _MappedContainer,
     _Usable_allocator_for<_KeyContainer, _MappedContainer> _Allocator>
-flat_map(_KeyContainer, _MappedContainer,
-    _Allocator) -> flat_map<typename _KeyContainer::value_type, typename _MappedContainer::value_type,
-                    less<typename _KeyContainer::value_type>, _KeyContainer, _MappedContainer>;
+flat_map(_KeyContainer, _MappedContainer, _Allocator) -> flat_map<typename _KeyContainer::value_type,
+    typename _MappedContainer::value_type, less<typename _KeyContainer::value_type>, _KeyContainer, _MappedContainer>;
 
 template <class _KeyContainer, class _MappedContainer, _Valid_compare_for_container<_KeyContainer> _Compare,
     _Usable_allocator_for<_KeyContainer, _MappedContainer> _Allocator>
-flat_map(_KeyContainer, _MappedContainer, _Compare,
-    _Allocator) -> flat_map<typename _KeyContainer::value_type, typename _MappedContainer::value_type, _Compare,
-                    _KeyContainer, _MappedContainer>;
+flat_map(_KeyContainer, _MappedContainer, _Compare, _Allocator) -> flat_map<typename _KeyContainer::value_type,
+    typename _MappedContainer::value_type, _Compare, _KeyContainer, _MappedContainer>;
 
 template <class _KeyContainer, class _MappedContainer,
     _Valid_compare_for_container<_KeyContainer> _Compare = less<typename _KeyContainer::value_type>>
-flat_map(sorted_unique_t, _KeyContainer, _MappedContainer,
-    _Compare = _Compare()) -> flat_map<typename _KeyContainer::value_type, typename _MappedContainer::value_type,
-                               _Compare, _KeyContainer, _MappedContainer>;
+flat_map(sorted_unique_t, _KeyContainer, _MappedContainer, _Compare = _Compare())
+    -> flat_map<typename _KeyContainer::value_type, typename _MappedContainer::value_type, _Compare, _KeyContainer,
+        _MappedContainer>;
 
 template <class _KeyContainer, class _MappedContainer,
     _Usable_allocator_for<_KeyContainer, _MappedContainer> _Allocator>
-flat_map(sorted_unique_t, _KeyContainer, _MappedContainer,
-    _Allocator) -> flat_map<typename _KeyContainer::value_type, typename _MappedContainer::value_type,
-                    less<typename _KeyContainer::value_type>, _KeyContainer, _MappedContainer>;
+flat_map(sorted_unique_t, _KeyContainer, _MappedContainer, _Allocator) -> flat_map<typename _KeyContainer::value_type,
+    typename _MappedContainer::value_type, less<typename _KeyContainer::value_type>, _KeyContainer, _MappedContainer>;
 
 template <class _KeyContainer, class _MappedContainer, _Valid_compare_for_container<_KeyContainer> _Compare,
     _Usable_allocator_for<_KeyContainer, _MappedContainer> _Allocator>
-flat_map(sorted_unique_t, _KeyContainer, _MappedContainer, _Compare,
-    _Allocator) -> flat_map<typename _KeyContainer::value_type, typename _MappedContainer::value_type, _Compare,
-                    _KeyContainer, _MappedContainer>;
+flat_map(sorted_unique_t, _KeyContainer, _MappedContainer, _Compare, _Allocator)
+    -> flat_map<typename _KeyContainer::value_type, typename _MappedContainer::value_type, _Compare, _KeyContainer,
+        _MappedContainer>;
 
 template <class _InputIterator, class _Compare = less<_Guide_key_t<_InputIterator>>>
-flat_map(_InputIterator, _InputIterator,
-    _Compare = _Compare()) -> flat_map<_Guide_key_t<_InputIterator>, _Guide_val_t<_InputIterator>, _Compare>;
+flat_map(_InputIterator, _InputIterator, _Compare = _Compare())
+    -> flat_map<_Guide_key_t<_InputIterator>, _Guide_val_t<_InputIterator>, _Compare>;
 
 template <class _InputIterator, class _Compare = less<_Guide_key_t<_InputIterator>>>
-flat_map(sorted_unique_t, _InputIterator, _InputIterator,
-    _Compare = _Compare()) -> flat_map<_Guide_key_t<_InputIterator>, _Guide_val_t<_InputIterator>, _Compare>;
+flat_map(sorted_unique_t, _InputIterator, _InputIterator, _Compare = _Compare())
+    -> flat_map<_Guide_key_t<_InputIterator>, _Guide_val_t<_InputIterator>, _Compare>;
 
 #ifdef __cpp_lib_byte
 template <_RANGES input_range _Rng, class _Compare = less<_Range_key_type<_Rng>>, class _Allocator = allocator<byte>>
@@ -1343,29 +1339,26 @@ flat_map(from_range_t, _Rng&&, _Compare = _Compare(), _Allocator = _Allocator())
         vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_mapped_type<_Rng>>>>;
 #else // ^^^ defined(__cpp_lib_byte) / !defined(__cpp_lib_byte) vvv
 template <_RANGES input_range _Rng, class _Compare = less<_Range_key_type<_Rng>>>
-flat_map(
-    from_range_t, _Rng&&, _Compare = _Compare()) -> flat_map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, _Compare,
-                                                     vector<_Range_key_type<_Rng>>, vector<_Range_mapped_type<_Rng>>>;
+flat_map(from_range_t, _Rng&&, _Compare = _Compare()) -> flat_map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>,
+    _Compare, vector<_Range_key_type<_Rng>>, vector<_Range_mapped_type<_Rng>>>;
 
 template <_RANGES input_range _Rng, class _Compare, class _Allocator>
-flat_map(from_range_t, _Rng&&, _Compare,
-    _Allocator) -> flat_map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, _Compare,
-                    vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_key_type<_Rng>>>,
-                    vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_mapped_type<_Rng>>>>;
+flat_map(from_range_t, _Rng&&, _Compare, _Allocator) -> flat_map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>,
+    _Compare, vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_key_type<_Rng>>>,
+    vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_mapped_type<_Rng>>>>;
 #endif // ^^^ !defined(__cpp_lib_byte) ^^^
 
 template <_RANGES input_range _Rng, class _Allocator>
-flat_map(from_range_t, _Rng&&,
-    _Allocator) -> flat_map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, less<_Range_key_type<_Rng>>,
-                    vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_key_type<_Rng>>>,
-                    vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_mapped_type<_Rng>>>>;
+flat_map(from_range_t, _Rng&&, _Allocator) -> flat_map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>,
+    less<_Range_key_type<_Rng>>, vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_key_type<_Rng>>>,
+    vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_mapped_type<_Rng>>>>;
 
 template <class _Key, class _Mapped, class _Compare = less<_Key>>
 flat_map(initializer_list<pair<_Key, _Mapped>>, _Compare = _Compare()) -> flat_map<_Key, _Mapped, _Compare>;
 
 template <class _Key, class _Mapped, class _Compare = less<_Key>>
-flat_map(
-    sorted_unique_t, initializer_list<pair<_Key, _Mapped>>, _Compare = _Compare()) -> flat_map<_Key, _Mapped, _Compare>;
+flat_map(sorted_unique_t, initializer_list<pair<_Key, _Mapped>>, _Compare = _Compare())
+    -> flat_map<_Key, _Mapped, _Compare>;
 
 // Specialization of uses_allocator
 template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer, class _Allocator>
@@ -1442,40 +1435,39 @@ private:
 };
 
 template <class _KeyContainer, class _MappedContainer, class _Compare = less<typename _KeyContainer::value_type>>
-flat_multimap(_KeyContainer, _MappedContainer,
-    _Compare = _Compare()) -> flat_multimap<typename _KeyContainer::value_type, typename _MappedContainer::value_type,
-                               _Compare, _KeyContainer, _MappedContainer>;
+flat_multimap(_KeyContainer, _MappedContainer, _Compare = _Compare())
+    -> flat_multimap<typename _KeyContainer::value_type, typename _MappedContainer::value_type, _Compare, _KeyContainer,
+        _MappedContainer>;
 
 template <class _KeyContainer, class _MappedContainer, class _Allocator>
-flat_multimap(_KeyContainer, _MappedContainer,
-    _Allocator) -> flat_multimap<typename _KeyContainer::value_type, typename _MappedContainer::value_type,
-                    less<typename _KeyContainer::value_type>, _KeyContainer, _MappedContainer>;
+flat_multimap(_KeyContainer, _MappedContainer, _Allocator) -> flat_multimap<typename _KeyContainer::value_type,
+    typename _MappedContainer::value_type, less<typename _KeyContainer::value_type>, _KeyContainer, _MappedContainer>;
 template <class _KeyContainer, class _MappedContainer, class _Compare, class _Allocator>
-flat_multimap(_KeyContainer, _MappedContainer, _Compare,
-    _Allocator) -> flat_multimap<typename _KeyContainer::value_type, typename _MappedContainer::value_type, _Compare,
-                    _KeyContainer, _MappedContainer>;
+flat_multimap(_KeyContainer, _MappedContainer, _Compare, _Allocator)
+    -> flat_multimap<typename _KeyContainer::value_type, typename _MappedContainer::value_type, _Compare, _KeyContainer,
+        _MappedContainer>;
 
 template <class _KeyContainer, class _MappedContainer, class _Compare = less<typename _KeyContainer::value_type>>
-flat_multimap(sorted_equivalent_t, _KeyContainer, _MappedContainer,
-    _Compare = _Compare()) -> flat_multimap<typename _KeyContainer::value_type, typename _MappedContainer::value_type,
-                               _Compare, _KeyContainer, _MappedContainer>;
+flat_multimap(sorted_equivalent_t, _KeyContainer, _MappedContainer, _Compare = _Compare())
+    -> flat_multimap<typename _KeyContainer::value_type, typename _MappedContainer::value_type, _Compare, _KeyContainer,
+        _MappedContainer>;
 
 template <class _KeyContainer, class _MappedContainer, class _Allocator>
-flat_multimap(sorted_equivalent_t, _KeyContainer, _MappedContainer,
-    _Allocator) -> flat_multimap<typename _KeyContainer::value_type, typename _MappedContainer::value_type,
-                    less<typename _KeyContainer::value_type>, _KeyContainer, _MappedContainer>;
+flat_multimap(sorted_equivalent_t, _KeyContainer, _MappedContainer, _Allocator)
+    -> flat_multimap<typename _KeyContainer::value_type, typename _MappedContainer::value_type,
+        less<typename _KeyContainer::value_type>, _KeyContainer, _MappedContainer>;
 template <class _KeyContainer, class _MappedContainer, class _Compare, class _Allocator>
-flat_multimap(sorted_equivalent_t, _KeyContainer, _MappedContainer, _Compare,
-    _Allocator) -> flat_multimap<typename _KeyContainer::value_type, typename _MappedContainer::value_type, _Compare,
-                    _KeyContainer, _MappedContainer>;
+flat_multimap(sorted_equivalent_t, _KeyContainer, _MappedContainer, _Compare, _Allocator)
+    -> flat_multimap<typename _KeyContainer::value_type, typename _MappedContainer::value_type, _Compare, _KeyContainer,
+        _MappedContainer>;
 
 template <class _InputIterator, class _Compare = less<_Guide_key_t<_InputIterator>>>
-flat_multimap(_InputIterator, _InputIterator,
-    _Compare = _Compare()) -> flat_multimap<_Guide_key_t<_InputIterator>, _Guide_val_t<_InputIterator>, _Compare>;
+flat_multimap(_InputIterator, _InputIterator, _Compare = _Compare())
+    -> flat_multimap<_Guide_key_t<_InputIterator>, _Guide_val_t<_InputIterator>, _Compare>;
 
 template <class _InputIterator, class _Compare = less<_Guide_key_t<_InputIterator>>>
-flat_multimap(sorted_equivalent_t, _InputIterator, _InputIterator,
-    _Compare = _Compare()) -> flat_multimap<_Guide_key_t<_InputIterator>, _Guide_val_t<_InputIterator>, _Compare>;
+flat_multimap(sorted_equivalent_t, _InputIterator, _InputIterator, _Compare = _Compare())
+    -> flat_multimap<_Guide_key_t<_InputIterator>, _Guide_val_t<_InputIterator>, _Compare>;
 
 #ifdef __cpp_lib_byte
 template <_RANGES input_range _Rng, class _Compare = less<_Range_key_type<_Rng>>, class _Allocator = allocator<byte>>
@@ -1485,29 +1477,27 @@ flat_multimap(from_range_t, _Rng&&, _Compare = _Compare(), _Allocator = _Allocat
         vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_mapped_type<_Rng>>>>;
 #else // ^^^ defined(__cpp_lib_byte) / !defined(__cpp_lib_byte) vvv
 template <_RANGES input_range _Rng, class _Compare = less<_Range_key_type<_Rng>>>
-flat_multimap(from_range_t, _Rng&&,
-    _Compare = _Compare()) -> flat_multimap<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, _Compare,
-                               vector<_Range_key_type<_Rng>>, vector<_Range_mapped_type<_Rng>>>;
+flat_multimap(from_range_t, _Rng&&, _Compare = _Compare()) -> flat_multimap<_Range_key_type<_Rng>,
+    _Range_mapped_type<_Rng>, _Compare, vector<_Range_key_type<_Rng>>, vector<_Range_mapped_type<_Rng>>>;
 
 template <_RANGES input_range _Rng, class _Compare, class _Allocator>
-flat_multimap(from_range_t, _Rng&&, _Compare,
-    _Allocator) -> flat_multimap<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, _Compare,
-                    vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_key_type<_Rng>>>,
-                    vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_mapped_type<_Rng>>>>;
+flat_multimap(from_range_t, _Rng&&, _Compare, _Allocator)
+    -> flat_multimap<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, _Compare,
+        vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_key_type<_Rng>>>,
+        vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_mapped_type<_Rng>>>>;
 #endif // ^^^ !defined(__cpp_lib_byte) ^^^
 
 template <_RANGES input_range _Rng, class _Allocator>
-flat_multimap(from_range_t, _Rng&&,
-    _Allocator) -> flat_multimap<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, less<_Range_key_type<_Rng>>,
-                    vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_key_type<_Rng>>>,
-                    vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_mapped_type<_Rng>>>>;
+flat_multimap(from_range_t, _Rng&&, _Allocator) -> flat_multimap<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>,
+    less<_Range_key_type<_Rng>>, vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_key_type<_Rng>>>,
+    vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_mapped_type<_Rng>>>>;
 
 template <class _Key, class _Mapped, class _Compare = less<_Key>>
 flat_multimap(initializer_list<pair<_Key, _Mapped>>, _Compare = _Compare()) -> flat_multimap<_Key, _Mapped, _Compare>;
 
 template <class _Key, class _Mapped, class _Compare = less<_Key>>
-flat_multimap(sorted_equivalent_t, initializer_list<pair<_Key, _Mapped>>,
-    _Compare = _Compare()) -> flat_multimap<_Key, _Mapped, _Compare>;
+flat_multimap(sorted_equivalent_t, initializer_list<pair<_Key, _Mapped>>, _Compare = _Compare())
+    -> flat_multimap<_Key, _Mapped, _Compare>;
 
 // Specialization of uses_allocator
 template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer, class _Allocator>
diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index fe3d087c00c..8e911ee6227 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -730,17 +730,17 @@ struct uses_allocator<flat_multiset<_Kty, _Keylt, _Container>, _Alloc>
 template <class _Container, class _Keylt = less<typename _Container::value_type>>
 flat_set(_Container, _Keylt = _Keylt()) -> flat_set<typename _Container::value_type, _Keylt, _Container>;
 template <class _Container, class _Alloc>
-flat_set(
-    _Container, _Alloc) -> flat_set<typename _Container::value_type, less<typename _Container::value_type>, _Container>;
+flat_set(_Container, _Alloc)
+    -> flat_set<typename _Container::value_type, less<typename _Container::value_type>, _Container>;
 template <class _Container, class _Keylt, class _Alloc>
 flat_set(_Container, _Keylt, _Alloc) -> flat_set<typename _Container::value_type, _Keylt, _Container>;
 
 template <class _Container, class _Keylt = less<typename _Container::value_type>>
-flat_set(
-    sorted_unique_t, _Container, _Keylt = _Keylt()) -> flat_set<typename _Container::value_type, _Keylt, _Container>;
+flat_set(sorted_unique_t, _Container, _Keylt = _Keylt())
+    -> flat_set<typename _Container::value_type, _Keylt, _Container>;
 template <class _Container, class _Alloc>
-flat_set(sorted_unique_t, _Container,
-    _Alloc) -> flat_set<typename _Container::value_type, less<typename _Container::value_type>, _Container>;
+flat_set(sorted_unique_t, _Container, _Alloc)
+    -> flat_set<typename _Container::value_type, less<typename _Container::value_type>, _Container>;
 template <class _Container, class _Keylt, class _Alloc>
 flat_set(sorted_unique_t, _Container, _Keylt, _Alloc) -> flat_set<typename _Container::value_type, _Keylt, _Container>;
 
@@ -750,13 +750,11 @@ template <class _Iter, class _Keylt = less<iter_value_t<_Iter>>>
 flat_set(sorted_unique_t, _Iter, _Iter, _Keylt = _Keylt()) -> flat_set<iter_value_t<_Iter>, _Keylt>;
 template <_RANGES input_range _Range, class _Keylt = less<_RANGES range_value_t<_Range>>,
     class _Alloc = allocator<_RANGES range_value_t<_Range>>>
-flat_set(from_range_t, _Range&&, _Keylt = _Keylt(), _Alloc = _Alloc())
-    -> flat_set<_RANGES range_value_t<_Range>, _Keylt,
-        vector<_RANGES range_value_t<_Range>, _Rebind_alloc_t<_Alloc, _RANGES range_value_t<_Range>>>>;
+flat_set(from_range_t, _Range&&, _Keylt = _Keylt(), _Alloc = _Alloc()) -> flat_set<_RANGES range_value_t<_Range>,
+    _Keylt, vector<_RANGES range_value_t<_Range>, _Rebind_alloc_t<_Alloc, _RANGES range_value_t<_Range>>>>;
 template <_RANGES input_range _Range, class _Alloc>
-flat_set(from_range_t, _Range&&,
-    _Alloc) -> flat_set<_RANGES range_value_t<_Range>, less<_RANGES range_value_t<_Range>>,
-                vector<_RANGES range_value_t<_Range>, _Rebind_alloc_t<_Alloc, _RANGES range_value_t<_Range>>>>;
+flat_set(from_range_t, _Range&&, _Alloc) -> flat_set<_RANGES range_value_t<_Range>, less<_RANGES range_value_t<_Range>>,
+    vector<_RANGES range_value_t<_Range>, _Rebind_alloc_t<_Alloc, _RANGES range_value_t<_Range>>>>;
 template <class _Kty, class _Keylt = less<_Kty>>
 flat_set(initializer_list<_Kty>, _Keylt = _Keylt()) -> flat_set<_Kty, _Keylt>;
 template <class _Kty, class _Keylt = less<_Kty>>
@@ -766,35 +764,35 @@ flat_set(sorted_unique_t, initializer_list<_Kty>, _Keylt = _Keylt()) -> flat_set
 template <class _Container, class _Keylt = less<typename _Container::value_type>>
 flat_multiset(_Container, _Keylt = _Keylt()) -> flat_multiset<typename _Container::value_type, _Keylt, _Container>;
 template <class _Container, class _Alloc>
-flat_multiset(_Container,
-    _Alloc) -> flat_multiset<typename _Container::value_type, less<typename _Container::value_type>, _Container>;
+flat_multiset(_Container, _Alloc)
+    -> flat_multiset<typename _Container::value_type, less<typename _Container::value_type>, _Container>;
 template <class _Container, class _Keylt, class _Alloc>
 flat_multiset(_Container, _Keylt, _Alloc) -> flat_multiset<typename _Container::value_type, _Keylt, _Container>;
 
 template <class _Container, class _Keylt = less<typename _Container::value_type>>
-flat_multiset(sorted_equivalent_t, _Container,
-    _Keylt = _Keylt()) -> flat_multiset<typename _Container::value_type, _Keylt, _Container>;
+flat_multiset(sorted_equivalent_t, _Container, _Keylt = _Keylt())
+    -> flat_multiset<typename _Container::value_type, _Keylt, _Container>;
 template <class _Container, class _Alloc>
-flat_multiset(sorted_equivalent_t, _Container,
-    _Alloc) -> flat_multiset<typename _Container::value_type, less<typename _Container::value_type>, _Container>;
+flat_multiset(sorted_equivalent_t, _Container, _Alloc)
+    -> flat_multiset<typename _Container::value_type, less<typename _Container::value_type>, _Container>;
 template <class _Container, class _Keylt, class _Alloc>
-flat_multiset(sorted_equivalent_t, _Container, _Keylt,
-    _Alloc) -> flat_multiset<typename _Container::value_type, _Keylt, _Container>;
+flat_multiset(sorted_equivalent_t, _Container, _Keylt, _Alloc)
+    -> flat_multiset<typename _Container::value_type, _Keylt, _Container>;
 
 template <class _Iter, class _Keylt = less<iter_value_t<_Iter>>>
 flat_multiset(_Iter, _Iter, _Keylt = _Keylt()) -> flat_multiset<iter_value_t<_Iter>, iter_value_t<_Iter>, _Keylt>;
 template <class _Iter, class _Keylt = less<iter_value_t<_Iter>>>
-flat_multiset(sorted_equivalent_t, _Iter, _Iter,
-    _Keylt = _Keylt()) -> flat_multiset<iter_value_t<_Iter>, iter_value_t<_Iter>, _Keylt>;
+flat_multiset(sorted_equivalent_t, _Iter, _Iter, _Keylt = _Keylt())
+    -> flat_multiset<iter_value_t<_Iter>, iter_value_t<_Iter>, _Keylt>;
 template <_RANGES input_range _Range, class _Keylt = less<_RANGES range_value_t<_Range>>,
     class _Alloc = allocator<_RANGES range_value_t<_Range>>>
 flat_multiset(from_range_t, _Range&&, _Keylt = _Keylt(), _Alloc = _Alloc())
     -> flat_multiset<_RANGES range_value_t<_Range>, _Keylt,
         vector<_RANGES range_value_t<_Range>, _Rebind_alloc_t<_Alloc, _RANGES range_value_t<_Range>>>>;
 template <_RANGES input_range _Range, class _Alloc>
-flat_multiset(from_range_t, _Range&&,
-    _Alloc) -> flat_multiset<_RANGES range_value_t<_Range>, less<_RANGES range_value_t<_Range>>,
-                vector<_RANGES range_value_t<_Range>, _Rebind_alloc_t<_Alloc, _RANGES range_value_t<_Range>>>>;
+flat_multiset(from_range_t, _Range&&, _Alloc)
+    -> flat_multiset<_RANGES range_value_t<_Range>, less<_RANGES range_value_t<_Range>>,
+        vector<_RANGES range_value_t<_Range>, _Rebind_alloc_t<_Alloc, _RANGES range_value_t<_Range>>>>;
 template <class _Kty, class _Keylt = less<_Kty>>
 flat_multiset(initializer_list<_Kty>, _Keylt = _Keylt()) -> flat_multiset<_Kty, _Keylt>;
 template <class _Kty, class _Keylt = less<_Kty>>

From 85bd0d9bfe4cd2f332c5568c15a18faeeb6b962b Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Fri, 24 Jan 2025 09:27:15 -0800
Subject: [PATCH 044/134] Update libcxx/expected_results.txt for flat_map.

---
 tests/libcxx/expected_results.txt | 39 +++++++++++++++----------------
 1 file changed, 19 insertions(+), 20 deletions(-)

diff --git a/tests/libcxx/expected_results.txt b/tests/libcxx/expected_results.txt
index 52c4877f626..c09243532a5 100644
--- a/tests/libcxx/expected_results.txt
+++ b/tests/libcxx/expected_results.txt
@@ -226,49 +226,50 @@ std/depr/depr.c.headers/uchar_h.compile.pass.cpp FAIL
 std/strings/c.strings/cuchar.compile.pass.cpp FAIL
 
 # P0429R9 <flat_map>
-std/containers/container.adaptors/flat.map.syn/sorted_unique.pass.cpp FAIL
+# FIXME! Investigate these failures before merging!
 std/containers/container.adaptors/flat.map/flat.map.access/at_transparent.pass.cpp FAIL
 std/containers/container.adaptors/flat.map/flat.map.access/at.pass.cpp FAIL
 std/containers/container.adaptors/flat.map/flat.map.access/index_key.pass.cpp FAIL
 std/containers/container.adaptors/flat.map/flat.map.access/index_rv_key.pass.cpp FAIL
 std/containers/container.adaptors/flat.map/flat.map.access/index_transparent.pass.cpp FAIL
 std/containers/container.adaptors/flat.map/flat.map.capacity/empty.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.capacity/max_size.pass.cpp FAIL
 std/containers/container.adaptors/flat.map/flat.map.capacity/size.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.cons/alloc.pass.cpp FAIL
 std/containers/container.adaptors/flat.map/flat.map.cons/assign_initializer_list.pass.cpp FAIL
 std/containers/container.adaptors/flat.map/flat.map.cons/compare.pass.cpp FAIL
 std/containers/container.adaptors/flat.map/flat.map.cons/containers.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.cons/copy_alloc.pass.cpp FAIL
+std/containers/container.adaptors/flat.map/flat.map.cons/copy_alloc.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.map/flat.map.cons/copy_alloc.pass.cpp:1 FAIL
 std/containers/container.adaptors/flat.map/flat.map.cons/copy_assign.addressof.compile.pass.cpp FAIL
 std/containers/container.adaptors/flat.map/flat.map.cons/copy_assign.pass.cpp FAIL
 std/containers/container.adaptors/flat.map/flat.map.cons/copy.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.cons/deduct_pmr.pass.cpp FAIL
+std/containers/container.adaptors/flat.map/flat.map.cons/deduct_pmr.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.map/flat.map.cons/deduct_pmr.pass.cpp:1 FAIL
 std/containers/container.adaptors/flat.map/flat.map.cons/deduct.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.cons/default_noexcept.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.cons/default.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.cons/dtor_noexcept.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.cons/initializer_list.pass.cpp FAIL
+std/containers/container.adaptors/flat.map/flat.map.cons/initializer_list.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.map/flat.map.cons/initializer_list.pass.cpp:1 FAIL
 std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter.pass.cpp FAIL
 std/containers/container.adaptors/flat.map/flat.map.cons/move_alloc.pass.cpp FAIL
 std/containers/container.adaptors/flat.map/flat.map.cons/move_assign_clears.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.cons/move_assign_noexcept.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.cons/move_assign.pass.cpp FAIL
+std/containers/container.adaptors/flat.map/flat.map.cons/move_assign_noexcept.pass.cpp:2 FAIL
+std/containers/container.adaptors/flat.map/flat.map.cons/move_assign.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.map/flat.map.cons/move_assign.pass.cpp:1 FAIL
 std/containers/container.adaptors/flat.map/flat.map.cons/move_exceptions.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.cons/move_noexcept.pass.cpp FAIL
 std/containers/container.adaptors/flat.map/flat.map.cons/move.pass.cpp FAIL
 std/containers/container.adaptors/flat.map/flat.map.cons/pmr.pass.cpp FAIL
 std/containers/container.adaptors/flat.map/flat.map.cons/range.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.cons/sorted_container.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.cons/sorted_initializer_list.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.cons/sorted_iter_iter.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.erasure/erase_if_exceptions.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.erasure/erase_if.pass.cpp FAIL
+std/containers/container.adaptors/flat.map/flat.map.cons/sorted_container.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.map/flat.map.cons/sorted_container.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.map/flat.map.cons/sorted_initializer_list.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.map/flat.map.cons/sorted_initializer_list.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.map/flat.map.cons/sorted_iter_iter.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.map/flat.map.cons/sorted_iter_iter.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.map/flat.map.erasure/erase_if_exceptions.pass.cpp:2 FAIL
+std/containers/container.adaptors/flat.map/flat.map.erasure/erase_if.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.map/flat.map.erasure/erase_if.pass.cpp:1 FAIL
 std/containers/container.adaptors/flat.map/flat.map.iterators/iterator_comparison.pass.cpp FAIL
 std/containers/container.adaptors/flat.map/flat.map.iterators/iterator_concept_conformance.compile.pass.cpp FAIL
 std/containers/container.adaptors/flat.map/flat.map.iterators/iterator.pass.cpp FAIL
 std/containers/container.adaptors/flat.map/flat.map.iterators/range_concept_conformance.compile.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.iterators/reverse_iterator.pass.cpp FAIL
 std/containers/container.adaptors/flat.map/flat.map.modifiers/clear.pass.cpp FAIL
 std/containers/container.adaptors/flat.map/flat.map.modifiers/emplace_hint.pass.cpp FAIL
 std/containers/container.adaptors/flat.map/flat.map.modifiers/emplace.pass.cpp FAIL
@@ -294,7 +295,6 @@ std/containers/container.adaptors/flat.map/flat.map.modifiers/swap_free.pass.cpp
 std/containers/container.adaptors/flat.map/flat.map.modifiers/swap_member.pass.cpp FAIL
 std/containers/container.adaptors/flat.map/flat.map.modifiers/try_emplace_transparent.pass.cpp FAIL
 std/containers/container.adaptors/flat.map/flat.map.modifiers/try_emplace.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.observers/comp.pass.cpp FAIL
 std/containers/container.adaptors/flat.map/flat.map.observers/keys_values.pass.cpp FAIL
 std/containers/container.adaptors/flat.map/flat.map.operations/contains_transparent.pass.cpp FAIL
 std/containers/container.adaptors/flat.map/flat.map.operations/contains.pass.cpp FAIL
@@ -310,7 +310,6 @@ std/containers/container.adaptors/flat.map/flat.map.operations/upper_bound_trans
 std/containers/container.adaptors/flat.map/flat.map.operations/upper_bound.pass.cpp FAIL
 std/containers/container.adaptors/flat.map/incomplete_type.pass.cpp FAIL
 std/containers/container.adaptors/flat.map/op_compare.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/types.compile.pass.cpp FAIL
 
 # P0533R9 constexpr For <cmath> And <cstdlib>
 std/language.support/support.limits/support.limits.general/cmath.version.compile.pass.cpp FAIL

From 9297219ef9350c476f327462026edd5be58d599a Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Fri, 24 Jan 2025 10:01:03 -0800
Subject: [PATCH 045/134] Mark x64-specific failures as SKIPPED.

---
 tests/libcxx/expected_results.txt | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/tests/libcxx/expected_results.txt b/tests/libcxx/expected_results.txt
index c09243532a5..8f987d07f5e 100644
--- a/tests/libcxx/expected_results.txt
+++ b/tests/libcxx/expected_results.txt
@@ -237,8 +237,8 @@ std/containers/container.adaptors/flat.map/flat.map.capacity/size.pass.cpp FAIL
 std/containers/container.adaptors/flat.map/flat.map.cons/assign_initializer_list.pass.cpp FAIL
 std/containers/container.adaptors/flat.map/flat.map.cons/compare.pass.cpp FAIL
 std/containers/container.adaptors/flat.map/flat.map.cons/containers.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.cons/copy_alloc.pass.cpp:0 FAIL
-std/containers/container.adaptors/flat.map/flat.map.cons/copy_alloc.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.map/flat.map.cons/copy_alloc.pass.cpp:0 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.cons/copy_alloc.pass.cpp:1 SKIPPED
 std/containers/container.adaptors/flat.map/flat.map.cons/copy_assign.addressof.compile.pass.cpp FAIL
 std/containers/container.adaptors/flat.map/flat.map.cons/copy_assign.pass.cpp FAIL
 std/containers/container.adaptors/flat.map/flat.map.cons/copy.pass.cpp FAIL
@@ -264,8 +264,8 @@ std/containers/container.adaptors/flat.map/flat.map.cons/sorted_initializer_list
 std/containers/container.adaptors/flat.map/flat.map.cons/sorted_iter_iter.pass.cpp:0 FAIL
 std/containers/container.adaptors/flat.map/flat.map.cons/sorted_iter_iter.pass.cpp:1 FAIL
 std/containers/container.adaptors/flat.map/flat.map.erasure/erase_if_exceptions.pass.cpp:2 FAIL
-std/containers/container.adaptors/flat.map/flat.map.erasure/erase_if.pass.cpp:0 FAIL
-std/containers/container.adaptors/flat.map/flat.map.erasure/erase_if.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.map/flat.map.erasure/erase_if.pass.cpp:0 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.erasure/erase_if.pass.cpp:1 SKIPPED
 std/containers/container.adaptors/flat.map/flat.map.iterators/iterator_comparison.pass.cpp FAIL
 std/containers/container.adaptors/flat.map/flat.map.iterators/iterator_concept_conformance.compile.pass.cpp FAIL
 std/containers/container.adaptors/flat.map/flat.map.iterators/iterator.pass.cpp FAIL

From 41b1826d7bf824821e7d69e6941044eba810379f Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34@live.cn>
Date: Fri, 14 Mar 2025 05:45:02 +0800
Subject: [PATCH 046/134] `<flat_map>`: Fix several bugs found by libcxx tests
 (#5306)

Co-authored-by: Stephan T. Lavavej <stl@microsoft.com>
---
 stl/inc/flat_map                         | 319 ++++++++++++++---------
 stl/inc/vector                           |  11 +-
 stl/inc/xutility                         |  19 +-
 tests/libcxx/expected_results.txt        | 146 +++++++----
 tests/std/tests/P0429R9_flat_map/env.lst |   2 +-
 5 files changed, 306 insertions(+), 191 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index d19fa701afc..558880e9d5c 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -112,6 +112,11 @@ struct _Pairing_iterator_provider {
             return reference{*_Key_it, *_Mapped_it};
         }
 
+        friend pair<iter_rvalue_reference_t<_KeyIter>, iter_rvalue_reference_t<_MappedIter>> iter_move(
+            const _Iterator& _It) {
+            return {_RANGES iter_move(_It._Key_it), _RANGES iter_move(_It._Mapped_it)};
+        }
+
         pointer operator->() const {
             return pointer{**this};
         }
@@ -133,7 +138,7 @@ struct _Pairing_iterator_provider {
         }
 
         auto operator<=>(const _Iterator& _Right) const {
-            return _Key_it <=> _Right._Key_it;
+            return _Synth_three_way{}(_Key_it, _Right._Key_it);
         }
 
         _Iterator& operator--() {
@@ -149,14 +154,14 @@ struct _Pairing_iterator_provider {
         }
 
         _Iterator& operator+=(const difference_type _Off) {
-            _Key_it += _Off;
-            _Mapped_it += _Off;
+            _Key_it += static_cast<iter_difference_t<_KeyIter>>(_Off);
+            _Mapped_it += static_cast<iter_difference_t<_MappedIter>>(_Off);
             return *this;
         }
 
         _Iterator& operator-=(const difference_type _Off) {
-            _Key_it -= _Off;
-            _Mapped_it -= _Off;
+            _Key_it -= static_cast<iter_difference_t<_KeyIter>>(_Off);
+            _Mapped_it -= static_cast<iter_difference_t<_MappedIter>>(_Off);
             return *this;
         }
 
@@ -245,8 +250,6 @@ struct _Pairing_iterator_provider {
         _KeyIter _Key_it;
         _MappedIter _Mapped_it;
     };
-
-    _STL_INTERNAL_STATIC_ASSERT(swappable<_Iterator>);
 };
 
 _EXPORT_STD template <class _Key, class _Mapped, class _Compare = less<_Key>, class _KeyContainer = vector<_Key>,
@@ -292,9 +295,6 @@ public:
     static_assert(!_Is_vector_bool<key_container_type> && !_Is_vector_bool<mapped_container_type>,
         "vector<bool, A> cannot be adapted because it is not a sequence container.");
 
-    _STL_INTERNAL_STATIC_ASSERT(random_access_iterator<iterator>);
-    _STL_INTERNAL_STATIC_ASSERT(convertible_to<iterator, const_iterator>);
-
     using value_compare = _Flat_map_value_compare_provider<key_type, mapped_type, key_compare>::value_compare;
     using containers    = _Flat_map_container_provider<key_container_type, mapped_container_type>::containers;
 
@@ -307,13 +307,13 @@ public:
     explicit _Flat_map_base(const _Allocator& _Alloc) : _Flat_map_base(key_compare(), _Alloc) {}
 
     template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
-    explicit _Flat_map_base(const key_compare& _Comp, const _Allocator& _Alloc)
+    _Flat_map_base(const key_compare& _Comp, const _Allocator& _Alloc)
         : _Key_compare(_Comp), _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Alloc),
                                    .values = _STD make_obj_using_allocator<mapped_container_type>(_Alloc)} {}
 
     _Flat_map_base(
         key_container_type _Key_cont, mapped_container_type _Mapped_cont, const key_compare& _Comp = key_compare())
-        : _Flat_map_base(_Sorted_t(), _Key_cont, _Mapped_cont, _Comp) {
+        : _Key_compare(_Comp), _Data{.keys = _STD move(_Key_cont), .values = _STD move(_Mapped_cont)} {
         _Sort();
         if constexpr (_IsUnique) {
             _Dedup();
@@ -358,15 +358,20 @@ public:
           _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Alloc, _Key_cont),
               .values = _STD make_obj_using_allocator<mapped_container_type>(_Alloc, _Mapped_cont)} {}
 
-    template <class _InputIterator>
-        requires _Is_iterator_v<_InputIterator>
+    template <_Iterator_for_container _InputIterator>
     _Flat_map_base(_InputIterator _First, _InputIterator _Last, const key_compare& _Comp = key_compare())
         : _Flat_map_base(_Comp) {
         insert(_First, _Last);
     }
 
-    template <class _InputIterator, _Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
-        requires _Is_iterator_v<_InputIterator>
+    template <_Iterator_for_container _InputIterator,
+        _Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
+    _Flat_map_base(_InputIterator _First, _InputIterator _Last, const _Allocator& _Alloc) : _Flat_map_base(_Alloc) {
+        insert(_First, _Last);
+    }
+
+    template <_Iterator_for_container _InputIterator,
+        _Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
     _Flat_map_base(_InputIterator _First, _InputIterator _Last, const key_compare& _Comp, const _Allocator& _Alloc)
         : _Flat_map_base(_Comp, _Alloc) {
         insert(_First, _Last);
@@ -393,24 +398,23 @@ public:
         insert_range(_STD forward<_Rng>(_Range));
     }
 
-    template <class _InputIterator>
-        requires _Is_iterator_v<_InputIterator>
+    template <_Iterator_for_container _InputIterator>
     _Flat_map_base(
         _Sorted_t _Tag, _InputIterator _First, _InputIterator _Last, const key_compare& _Comp = key_compare())
         : _Flat_map_base(_Comp) {
         insert(_Tag, _First, _Last);
     }
 
-    template <class _InputIterator, _Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
-        requires _Is_iterator_v<_InputIterator>
+    template <_Iterator_for_container _InputIterator,
+        _Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
     _Flat_map_base(
         _Sorted_t _Tag, _InputIterator _First, _InputIterator _Last, const key_compare& _Comp, const _Allocator& _Alloc)
         : _Flat_map_base(_Comp, _Alloc) {
         insert(_Tag, _First, _Last);
     }
 
-    template <class _InputIterator, _Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
-        requires _Is_iterator_v<_InputIterator>
+    template <_Iterator_for_container _InputIterator,
+        _Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
     _Flat_map_base(_Sorted_t _Tag, _InputIterator _First, _InputIterator _Last, const _Allocator& _Alloc)
         : _Flat_map_base(_Tag, _First, _Last, key_compare(), _Alloc) {}
 
@@ -467,27 +471,24 @@ public:
               .values = _STD make_obj_using_allocator<mapped_container_type>(
                   _Alloc, _STD move(static_cast<_Flat_map_base&>(_Other)._Data.values))} {}
 
-    _Derived& operator=(initializer_list<value_type> _Ilist) {
-        clear();
-        insert(_Ilist.begin(), _Ilist.end());
-        return static_cast<_Derived&>(*this); // TRANSITION, P0847R7, should use explicit object parameter
-    }
-
     // [container.reqmts] iterators
     _NODISCARD iterator begin() noexcept {
-        return iterator{_Data.keys.cbegin(), _Data.values.begin()};
+        _STL_INTERNAL_STATIC_ASSERT(random_access_iterator<iterator>);
+        return iterator{_STD cbegin(_Data.keys), _Data.values.begin()};
     }
 
     _NODISCARD const_iterator begin() const noexcept {
-        return const_iterator{_Data.keys.cbegin(), _Data.values.begin()};
+        _STL_INTERNAL_STATIC_ASSERT(random_access_iterator<const_iterator>);
+        _STL_INTERNAL_STATIC_ASSERT(convertible_to<iterator, const_iterator>);
+        return const_iterator{_STD cbegin(_Data.keys), _Data.values.begin()};
     }
 
     _NODISCARD iterator end() noexcept {
-        return iterator{_Data.keys.cend(), _Data.values.end()};
+        return iterator{_STD cend(_Data.keys), _Data.values.end()};
     }
 
     _NODISCARD const_iterator end() const noexcept {
-        return const_iterator{_Data.keys.cend(), _Data.values.end()};
+        return const_iterator{_STD cend(_Data.keys), _Data.values.end()};
     }
 
     _NODISCARD reverse_iterator rbegin() noexcept {
@@ -507,11 +508,11 @@ public:
     }
 
     _NODISCARD const_iterator cbegin() const noexcept {
-        return const_iterator{_Data.keys.cbegin(), _Data.values.cbegin()};
+        return const_iterator{_STD cbegin(_Data.keys), _STD cbegin(_Data.values)};
     }
 
     _NODISCARD const_iterator cend() const noexcept {
-        return const_iterator{_Data.keys.cend(), _Data.values.cend()};
+        return const_iterator{_STD cend(_Data.keys), _STD cend(_Data.values)};
     }
 
     _NODISCARD const_reverse_iterator crbegin() const noexcept {
@@ -523,9 +524,10 @@ public:
     }
 
     void swap(_Derived& _Other) noexcept {
-        _RANGES swap(_Key_compare, _Other._Key_compare);
-        _RANGES swap(_Data.keys, _Other._Data.keys);
-        _RANGES swap(_Data.values, _Other._Data.values);
+        auto& _Other_base = static_cast<_Flat_map_base&>(_Other);
+        _RANGES swap(_Key_compare, _Other_base._Key_compare);
+        _RANGES swap(_Data.keys, _Other_base._Data.keys);
+        _RANGES swap(_Data.values, _Other_base._Data.values);
     }
 
     // [container.reqmts] clear
@@ -570,21 +572,19 @@ public:
         return emplace_hint(_Position, _STD forward<_PairValTy>(_Pair_val));
     }
 
-    template <class _InputIterator>
-        requires _Is_iterator_v<_InputIterator>
+    template <_Iterator_for_container _InputIterator>
     void insert(_InputIterator _First, _InputIterator _Last) {
         _Insert_range<true, _IsUnique>(_First, _Last);
     }
 
-    template <class _InputIterator>
-        requires _Is_iterator_v<_InputIterator>
+    template <_Iterator_for_container _InputIterator>
     void insert(_Sorted_t, _InputIterator _First, _InputIterator _Last) {
         _Insert_range<false, _IsUnique>(_First, _Last);
     }
 
     template <_Container_compatible_range<value_type> _Rng>
     void insert_range(_Rng&& _Range) {
-        insert(_RANGES begin(_Range), _RANGES end(_Range));
+        _Insert_range<true, _IsUnique>(_RANGES begin(_Range), _RANGES end(_Range));
     }
 
     void insert(initializer_list<value_type> _Ilist) {
@@ -774,9 +774,9 @@ public:
     }
 
     _NODISCARD friend auto operator<=>(const _Derived& _Left, const _Derived& _Right) {
-        return _STD lexicographical_compare_three_way(_STD _Get_unwrapped(_Left.cbegin()),
-            _STD _Get_unwrapped(_Left.cend()), _STD _Get_unwrapped(_Right.cbegin()), _STD _Get_unwrapped(_Right.cend()),
-            _Synth_three_way{});
+        return _STD lexicographical_compare_three_way(_STD _Get_unwrapped(_STD cbegin(_Left)),
+            _STD _Get_unwrapped(_STD cend(_Left)), _STD _Get_unwrapped(_STD cbegin(_Right)),
+            _STD _Get_unwrapped(_STD cend(_Right)), _Synth_three_way{});
     }
 
     friend void swap(_Derived& _Left, _Derived& _Right) noexcept {
@@ -806,7 +806,7 @@ protected:
     }
 
     template <bool _OverwriteIfExists, class _OtherKey, class... _MappedArgTypes>
-    iterator _Emplace_hint(const_iterator _Position, _OtherKey&& _Key_val, _MappedArgTypes&&... _Args) {
+    iterator _Emplace_hint(const const_iterator _Position, _OtherKey&& _Key_val, _MappedArgTypes&&... _Args) {
         _STL_INTERNAL_STATIC_ASSERT(
             is_constructible_v<mapped_type, _MappedArgTypes...>
             && (is_same_v<remove_cvref_t<_OtherKey>, key_type>
@@ -819,7 +819,7 @@ protected:
         const weak_ordering _Hint_order = [&] {
             if constexpr (_IsUnique) {
                 if (_Position == _End || _Key_compare(_Key_val, *_Position._Key_it)) {
-                    if (_Position == _Begin || _Key_compare(_Position._Key_it[-1], _Key_val)) {
+                    if (_Position == _Begin || _Key_compare(*_STD prev(_Position._Key_it), _Key_val)) {
                         return weak_ordering::equivalent;
                     } else {
                         return weak_ordering::greater;
@@ -827,7 +827,7 @@ protected:
                 }
             } else {
                 if (_Position == _End || !_Key_compare(*_Position._Key_it, _Key_val)) {
-                    if (_Position == _Begin || !_Key_compare(_Key_val, _Position._Key_it[-1])) {
+                    if (_Position == _Begin || !_Key_compare(_Key_val, *_STD prev(_Position._Key_it))) {
                         return weak_ordering::equivalent;
                     } else {
                         return weak_ordering::greater;
@@ -839,6 +839,11 @@ protected:
 
         if (_Hint_order == weak_ordering::equivalent) {
             const auto _Dist = _Position._Key_it - _Begin._Key_it;
+            if constexpr (_IsUnique) {
+                if (_Position != _Begin && !_Key_compare(*_STD prev(_Position._Key_it), _Key_val)) {
+                    return begin() + _Dist;
+                }
+            }
             {
                 key_type _Key_to_insert(_STD forward<_OtherKey>(_Key_val));
                 mapped_type _Mapped_to_insert(_STD forward<_MappedArgTypes>(_Args)...);
@@ -847,30 +852,35 @@ protected:
             return begin() + _Dist;
         }
 
-        if constexpr (_OverwriteIfExists) {
-            if (_Key_equal(_Key_val, *_Position._Key_it)) {
-                const auto _Dist = _Position._Key_it - _Begin._Key_it;
-                const auto _It   = begin() + _Dist;
-                *_It._Mapped_it  = mapped_type(_STD forward<_MappedArgTypes>(_Args)...);
-                return _It;
-            }
-
-            _Position = _Hint_order == weak_ordering::less ? lower_bound(_Key_val) : upper_bound(_Key_val);
-            if (_Position != _End && !_Key_compare(_Key_val, *_Position._Key_it)) {
-                const auto _Dist = _Position._Key_it - _Begin._Key_it;
-                auto _It         = begin() + _Dist;
-                *_It._Mapped_it  = mapped_type(_STD forward<_MappedArgTypes>(_Args)...);
-                return _It;
+        const auto _New_position = _Hint_order == weak_ordering::less ? _STD as_const(*this).lower_bound(_Key_val)
+                                                                      : _STD as_const(*this).upper_bound(_Key_val);
+        if constexpr (_IsUnique) {
+            if (_Hint_order == weak_ordering::less) {
+                if (_New_position != _End && !_Key_compare(_Key_val, *_New_position._Key_it)) {
+                    const auto _Dist = _New_position._Key_it - _Begin._Key_it;
+                    auto _It         = begin() + _Dist;
+                    if constexpr (_OverwriteIfExists) {
+                        *_It._Mapped_it = mapped_type(_STD forward<_MappedArgTypes>(_Args)...);
+                    }
+                    return _It;
+                }
+            } else {
+                if (_New_position != _Begin && !_Key_compare(*_STD prev(_New_position._Key_it), _Key_val)) {
+                    const auto _Dist = _STD prev(_New_position._Key_it) - _Begin._Key_it;
+                    auto _It         = begin() + _Dist;
+                    if constexpr (_OverwriteIfExists) {
+                        *_It._Mapped_it = mapped_type(_STD forward<_MappedArgTypes>(_Args)...);
+                    }
+                    return _It;
+                }
             }
-        } else {
-            _Position = _Hint_order == weak_ordering::less ? lower_bound(_Key_val) : upper_bound(_Key_val);
         }
 
-        const auto _Dist = _Position._Key_it - _Begin._Key_it;
+        const auto _Dist = _New_position - _Begin;
         {
             key_type _Key_to_insert(_STD forward<_OtherKey>(_Key_val));
             mapped_type _Mapped_to_insert(_STD forward<_MappedArgTypes>(_Args)...);
-            _Insert_exact(_Position, _STD move(_Key_to_insert), _STD move(_Mapped_to_insert));
+            _Insert_exact(_New_position, _STD move(_Key_to_insert), _STD move(_Mapped_to_insert));
         }
         return begin() + _Dist;
     }
@@ -913,14 +923,16 @@ private:
             return this->_Key_equal(_Left.first, _Right.first);
         });
         const auto _Remaining_count = _Subrange.begin() - _Sorted_view.begin();
-        _Data.keys.erase(_Data.keys.begin() + _Remaining_count, _Data.keys.end());
-        _Data.values.erase(_Data.values.begin() + _Remaining_count, _Data.values.end());
+        _Data.keys.erase(_Data.keys.begin() + static_cast<_RANGES range_difference_t<_KeyContainer>>(_Remaining_count),
+            _Data.keys.end());
+        _Data.values.erase(
+            _Data.values.begin() + static_cast<_RANGES range_difference_t<_MappedContainer>>(_Remaining_count),
+            _Data.values.end());
         _Guard._Target = nullptr;
     }
 
-    template <bool _NeedSorting, bool _NeedDeduping, class _InputIterator>
-        requires _Is_iterator_v<_InputIterator>
-    void _Insert_range(_InputIterator _First, _InputIterator _Last) {
+    template <bool _NeedSorting, bool _NeedDeduping, class _InputIterator, class _Sentinel>
+    void _Insert_range(_InputIterator _First, _Sentinel _Last) {
         _Clear_guard _Guard{this};
 
         const auto _Old_distance = static_cast<difference_type>(size());
@@ -928,8 +940,17 @@ private:
         // Insert the new elements at the end
         for (; _First != _Last; ++_First) {
             value_type _Val = *_First;
-            _Data.keys.emplace_back(_STD move(_Val.first));
-            _Data.values.emplace_back(_STD move(_Val.second));
+            if constexpr (requires { _Data.keys.push_back(_STD move(_Val.first)); }) {
+                _Data.keys.push_back(_STD move(_Val.first));
+            } else {
+                _Data.keys.insert(_Data.keys.end(), _STD move(_Val.first));
+            }
+
+            if constexpr (requires { _Data.values.push_back(_STD move(_Val.second)); }) {
+                _Data.values.push_back(_STD move(_Val.second));
+            } else {
+                _Data.values.insert(_Data.values.end(), _STD move(_Val.second));
+            }
         }
 
         // Sort the newly inserted elements
@@ -954,7 +975,7 @@ private:
     size_type _Erase_key(_KeyTy&& _Key_val) {
         const auto _Equal_pos = equal_range(_STD forward<_KeyTy>(_Key_val));
         const auto _Count     = static_cast<size_type>(_Equal_pos.second - _Equal_pos.first);
-        erase(_Equal_pos.second, _Equal_pos.first);
+        erase(_Equal_pos.first, _Equal_pos.second);
         return _Count;
     }
 
@@ -995,56 +1016,58 @@ private:
     template <class _KeyTy>
     _NODISCARD iterator _Lower_bound(const _KeyTy& _Key_val) {
         _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Is_transparent_v<key_compare>);
-        const auto _Key_unchecked_begin = _STD _Get_unwrapped(_Data.keys.cbegin());
+        const auto _Key_unchecked_begin = _STD _Get_unwrapped(_STD cbegin(_Data.keys));
         const auto _Key_unchecked_it =
-            _STD lower_bound(_Key_unchecked_begin, _STD _Get_unwrapped(_Data.keys.cend()), _Key_val, _Key_compare);
+            _STD lower_bound(_Key_unchecked_begin, _STD _Get_unwrapped(_STD cend(_Data.keys)), _Key_val, _Key_compare);
         const auto _Dist = _Key_unchecked_it - _Key_unchecked_begin;
 
-        auto _Key_it = _Data.keys.cbegin();
+        auto _Key_it = _STD cbegin(_Data.keys);
         _STD _Seek_wrapped(_Key_it, _Key_unchecked_it);
-        auto _Val_it = _Data.values.begin() + _Dist;
+        auto _Val_it = _Data.values.begin() + static_cast<_RANGES range_difference_t<_MappedContainer>>(_Dist);
         return iterator{_STD move(_Key_it), _STD move(_Val_it)};
     }
 
     template <class _KeyTy>
     _NODISCARD const_iterator _Lower_bound(const _KeyTy& _Key_val) const {
         _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Is_transparent_v<key_compare>);
-        const auto _Key_unchecked_begin = _STD _Get_unwrapped(_Data.keys.cbegin());
+        const auto _Key_unchecked_begin = _STD _Get_unwrapped(_STD cbegin(_Data.keys));
         const auto _Key_unchecked_it =
-            _STD lower_bound(_Key_unchecked_begin, _STD _Get_unwrapped(_Data.keys.cend()), _Key_val, _Key_compare);
+            _STD lower_bound(_Key_unchecked_begin, _STD _Get_unwrapped(_STD cend(_Data.keys)), _Key_val, _Key_compare);
         const auto _Dist = _Key_unchecked_it - _Key_unchecked_begin;
 
-        auto _Key_it = _Data.keys.cbegin();
+        auto _Key_it = _STD cbegin(_Data.keys);
         _STD _Seek_wrapped(_Key_it, _Key_unchecked_it);
-        auto _Val_it = _Data.values.cbegin() + _Dist;
+        auto _Val_it =
+            _STD cbegin(_Data.values) + static_cast<_RANGES range_difference_t<const _MappedContainer>>(_Dist);
         return const_iterator{_STD move(_Key_it), _STD move(_Val_it)};
     }
 
     template <class _KeyTy>
     _NODISCARD iterator _Upper_bound(const _KeyTy& _Key_val) {
         _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Is_transparent_v<key_compare>);
-        const auto _Key_unchecked_begin = _STD _Get_unwrapped(_Data.keys.cbegin());
+        const auto _Key_unchecked_begin = _STD _Get_unwrapped(_STD cbegin(_Data.keys));
         const auto _Key_unchecked_it =
-            _STD upper_bound(_Key_unchecked_begin, _STD _Get_unwrapped(_Data.keys.cend()), _Key_val, _Key_compare);
+            _STD upper_bound(_Key_unchecked_begin, _STD _Get_unwrapped(_STD cend(_Data.keys)), _Key_val, _Key_compare);
         const auto _Dist = _Key_unchecked_it - _Key_unchecked_begin;
 
-        auto _Key_it = _Data.keys.cbegin();
+        auto _Key_it = _STD cbegin(_Data.keys);
         _STD _Seek_wrapped(_Key_it, _Key_unchecked_it);
-        auto _Val_it = _Data.values.begin() + _Dist;
+        auto _Val_it = _Data.values.begin() + static_cast<_RANGES range_difference_t<_MappedContainer>>(_Dist);
         return iterator{_STD move(_Key_it), _STD move(_Val_it)};
     }
 
     template <class _KeyTy>
     _NODISCARD const_iterator _Upper_bound(const _KeyTy& _Key_val) const {
         _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Is_transparent_v<key_compare>);
-        const auto _Key_unchecked_begin = _STD _Get_unwrapped(_Data.keys.cbegin());
+        const auto _Key_unchecked_begin = _STD _Get_unwrapped(_STD cbegin(_Data.keys));
         const auto _Key_unchecked_it =
-            _STD upper_bound(_Key_unchecked_begin, _STD _Get_unwrapped(_Data.keys.cend()), _Key_val, _Key_compare);
+            _STD upper_bound(_Key_unchecked_begin, _STD _Get_unwrapped(_STD cend(_Data.keys)), _Key_val, _Key_compare);
         const auto _Dist = _Key_unchecked_it - _Key_unchecked_begin;
 
-        auto _Key_it = _Data.keys.cbegin();
+        auto _Key_it = _STD cbegin(_Data.keys);
         _STD _Seek_wrapped(_Key_it, _Key_unchecked_it);
-        auto _Val_it = _Data.values.cbegin() + _Dist;
+        auto _Val_it =
+            _STD cbegin(_Data.values) + static_cast<_RANGES range_difference_t<const _MappedContainer>>(_Dist);
         return const_iterator{_STD move(_Key_it), _STD move(_Val_it)};
     }
 
@@ -1078,14 +1101,32 @@ public:
     using typename _MyBase::value_type;
 
     using _MyBase::_MyBase;
-    using _MyBase::operator=;
+    using _MyBase::clear;
     using _MyBase::insert;
 
+#if 1 // TRANSITION, P2582R1 (MSVC, Clang, EDG)
+    template <_Usable_allocator_for<_KeyContainer, _MappedContainer> _Allocator>
+    flat_map(const flat_map& _Other, const _Allocator& _Al) : _MyBase(_Other, _Al) {}
+
+    template <_Usable_allocator_for<_KeyContainer, _MappedContainer> _Allocator>
+    flat_map(flat_map&& _Other, const _Allocator& _Al) : _MyBase(_STD move(_Other), _Al) {}
+#endif // ^^^ workaround ^^^
+
+    flat_map& operator=(initializer_list<value_type> _Ilist) {
+        clear();
+        insert(_Ilist.begin(), _Ilist.end());
+        return *this;
+    }
+
     // [flat.map.access] Access
-    _NODISCARD mapped_type& operator[](const key_type& _Key_val) {
+    _NODISCARD mapped_type& operator[](const key_type& _Key_val)
+        requires is_default_constructible_v<mapped_type>
+    {
         return this->try_emplace(_Key_val).first->second;
     }
-    _NODISCARD mapped_type& operator[](key_type&& _Key_val) {
+    _NODISCARD mapped_type& operator[](key_type&& _Key_val)
+        requires is_default_constructible_v<mapped_type>
+    {
         return this->try_emplace(_STD move(_Key_val)).first->second;
     }
 
@@ -1276,7 +1317,7 @@ private:
         {
             key_type _Key_to_insert(_STD forward<_KeyTy>(_Key_val));
             mapped_type _Mapped_to_insert(_STD forward<_MappedArgTypes>(_Mapped_args)...);
-            this->_Insert_exact(this->cbegin() + _Index, _STD move(_Key_to_insert), _STD move(_Mapped_to_insert));
+            this->_Insert_exact(_STD cbegin(*this) + _Index, _STD move(_Key_to_insert), _STD move(_Mapped_to_insert));
         }
         return {this->begin() + _Index, true};
     }
@@ -1291,72 +1332,77 @@ private:
     }
 };
 
-template <class _KeyContainer, class _MappedContainer,
+template <_Not_allocator_for_container _KeyContainer, _Not_allocator_for_container _MappedContainer,
     _Valid_compare_for_container<_KeyContainer> _Compare = less<typename _KeyContainer::value_type>>
 flat_map(_KeyContainer, _MappedContainer, _Compare = _Compare()) -> flat_map<typename _KeyContainer::value_type,
     typename _MappedContainer::value_type, _Compare, _KeyContainer, _MappedContainer>;
 
-template <class _KeyContainer, class _MappedContainer,
+template <_Not_allocator_for_container _KeyContainer, _Not_allocator_for_container _MappedContainer,
     _Usable_allocator_for<_KeyContainer, _MappedContainer> _Allocator>
 flat_map(_KeyContainer, _MappedContainer, _Allocator) -> flat_map<typename _KeyContainer::value_type,
     typename _MappedContainer::value_type, less<typename _KeyContainer::value_type>, _KeyContainer, _MappedContainer>;
 
-template <class _KeyContainer, class _MappedContainer, _Valid_compare_for_container<_KeyContainer> _Compare,
+template <_Not_allocator_for_container _KeyContainer, _Not_allocator_for_container _MappedContainer,
+    _Valid_compare_for_container<_KeyContainer> _Compare,
     _Usable_allocator_for<_KeyContainer, _MappedContainer> _Allocator>
 flat_map(_KeyContainer, _MappedContainer, _Compare, _Allocator) -> flat_map<typename _KeyContainer::value_type,
     typename _MappedContainer::value_type, _Compare, _KeyContainer, _MappedContainer>;
 
-template <class _KeyContainer, class _MappedContainer,
+template <_Not_allocator_for_container _KeyContainer, _Not_allocator_for_container _MappedContainer,
     _Valid_compare_for_container<_KeyContainer> _Compare = less<typename _KeyContainer::value_type>>
 flat_map(sorted_unique_t, _KeyContainer, _MappedContainer, _Compare = _Compare())
     -> flat_map<typename _KeyContainer::value_type, typename _MappedContainer::value_type, _Compare, _KeyContainer,
         _MappedContainer>;
 
-template <class _KeyContainer, class _MappedContainer,
+template <_Not_allocator_for_container _KeyContainer, _Not_allocator_for_container _MappedContainer,
     _Usable_allocator_for<_KeyContainer, _MappedContainer> _Allocator>
 flat_map(sorted_unique_t, _KeyContainer, _MappedContainer, _Allocator) -> flat_map<typename _KeyContainer::value_type,
     typename _MappedContainer::value_type, less<typename _KeyContainer::value_type>, _KeyContainer, _MappedContainer>;
 
-template <class _KeyContainer, class _MappedContainer, _Valid_compare_for_container<_KeyContainer> _Compare,
+template <_Not_allocator_for_container _KeyContainer, _Not_allocator_for_container _MappedContainer,
+    _Valid_compare_for_container<_KeyContainer> _Compare,
     _Usable_allocator_for<_KeyContainer, _MappedContainer> _Allocator>
 flat_map(sorted_unique_t, _KeyContainer, _MappedContainer, _Compare, _Allocator)
     -> flat_map<typename _KeyContainer::value_type, typename _MappedContainer::value_type, _Compare, _KeyContainer,
         _MappedContainer>;
 
-template <class _InputIterator, class _Compare = less<_Guide_key_t<_InputIterator>>>
+template <_Iterator_for_container _InputIterator,
+    _Not_allocator_for_container _Compare = less<_Guide_key_t<_InputIterator>>>
 flat_map(_InputIterator, _InputIterator, _Compare = _Compare())
     -> flat_map<_Guide_key_t<_InputIterator>, _Guide_val_t<_InputIterator>, _Compare>;
 
-template <class _InputIterator, class _Compare = less<_Guide_key_t<_InputIterator>>>
+template <_Iterator_for_container _InputIterator,
+    _Not_allocator_for_container _Compare = less<_Guide_key_t<_InputIterator>>>
 flat_map(sorted_unique_t, _InputIterator, _InputIterator, _Compare = _Compare())
     -> flat_map<_Guide_key_t<_InputIterator>, _Guide_val_t<_InputIterator>, _Compare>;
 
 #ifdef __cpp_lib_byte
-template <_RANGES input_range _Rng, class _Compare = less<_Range_key_type<_Rng>>, class _Allocator = allocator<byte>>
+template <_RANGES input_range _Rng, _Not_allocator_for_container _Compare = less<_Range_key_type<_Rng>>,
+    _Allocator_for_container _Allocator = allocator<byte>>
 flat_map(from_range_t, _Rng&&, _Compare = _Compare(), _Allocator = _Allocator())
     -> flat_map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, _Compare,
         vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_key_type<_Rng>>>,
         vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_mapped_type<_Rng>>>>;
 #else // ^^^ defined(__cpp_lib_byte) / !defined(__cpp_lib_byte) vvv
-template <_RANGES input_range _Rng, class _Compare = less<_Range_key_type<_Rng>>>
+template <_RANGES input_range _Rng, _Not_allocator_for_container _Compare = less<_Range_key_type<_Rng>>>
 flat_map(from_range_t, _Rng&&, _Compare = _Compare()) -> flat_map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>,
     _Compare, vector<_Range_key_type<_Rng>>, vector<_Range_mapped_type<_Rng>>>;
 
-template <_RANGES input_range _Rng, class _Compare, class _Allocator>
+template <_RANGES input_range _Rng, _Not_allocator_for_container _Compare, _Allocator_for_container _Allocator>
 flat_map(from_range_t, _Rng&&, _Compare, _Allocator) -> flat_map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>,
     _Compare, vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_key_type<_Rng>>>,
     vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_mapped_type<_Rng>>>>;
 #endif // ^^^ !defined(__cpp_lib_byte) ^^^
 
-template <_RANGES input_range _Rng, class _Allocator>
+template <_RANGES input_range _Rng, _Allocator_for_container _Allocator>
 flat_map(from_range_t, _Rng&&, _Allocator) -> flat_map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>,
     less<_Range_key_type<_Rng>>, vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_key_type<_Rng>>>,
     vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_mapped_type<_Rng>>>>;
 
-template <class _Key, class _Mapped, class _Compare = less<_Key>>
+template <class _Key, class _Mapped, _Not_allocator_for_container _Compare = less<_Key>>
 flat_map(initializer_list<pair<_Key, _Mapped>>, _Compare = _Compare()) -> flat_map<_Key, _Mapped, _Compare>;
 
-template <class _Key, class _Mapped, class _Compare = less<_Key>>
+template <class _Key, class _Mapped, _Not_allocator_for_container _Compare = less<_Key>>
 flat_map(sorted_unique_t, initializer_list<pair<_Key, _Mapped>>, _Compare = _Compare())
     -> flat_map<_Key, _Mapped, _Compare>;
 
@@ -1385,9 +1431,23 @@ public:
     using typename _MyBase::value_type;
 
     using _MyBase::_MyBase;
-    using _MyBase::operator=;
+    using _MyBase::clear;
     using _MyBase::insert;
 
+#if 1 // TRANSITION, P2582R1 (MSVC, Clang, EDG)
+    template <_Usable_allocator_for<_KeyContainer, _MappedContainer> _Allocator>
+    flat_multimap(const flat_multimap& _Other, const _Allocator& _Al) : _MyBase(_Other, _Al) {}
+
+    template <_Usable_allocator_for<_KeyContainer, _MappedContainer> _Allocator>
+    flat_multimap(flat_multimap&& _Other, const _Allocator& _Al) : _MyBase(_STD move(_Other), _Al) {}
+#endif // ^^^ workaround ^^^
+
+    flat_multimap& operator=(initializer_list<value_type> _Ilist) {
+        clear();
+        insert(_Ilist.begin(), _Ilist.end());
+        return *this;
+    }
+
     // [flat.multimap.modifiers] Modifiers
     template <class... _ArgTypes>
     iterator emplace(_ArgTypes&&... _Args) {
@@ -1428,74 +1488,85 @@ private:
         {
             _Key _Key_to_insert(_STD forward<_KeyTy>(_Key_val));
             _Mapped _Mapped_to_insert(_STD forward<_MappedTy>(_Mapped_val));
-            this->_Insert_exact(this->cbegin() + _Index, _STD move(_Key_to_insert), _STD move(_Mapped_to_insert));
+            this->_Insert_exact(_STD cbegin(*this) + _Index, _STD move(_Key_to_insert), _STD move(_Mapped_to_insert));
         }
         return this->begin() + _Index;
     }
 };
 
-template <class _KeyContainer, class _MappedContainer, class _Compare = less<typename _KeyContainer::value_type>>
+template <_Not_allocator_for_container _KeyContainer, _Not_allocator_for_container _MappedContainer,
+    _Valid_compare_for_container<_KeyContainer> _Compare = less<typename _KeyContainer::value_type>>
 flat_multimap(_KeyContainer, _MappedContainer, _Compare = _Compare())
     -> flat_multimap<typename _KeyContainer::value_type, typename _MappedContainer::value_type, _Compare, _KeyContainer,
         _MappedContainer>;
 
-template <class _KeyContainer, class _MappedContainer, class _Allocator>
+template <_Not_allocator_for_container _KeyContainer, _Not_allocator_for_container _MappedContainer,
+    _Usable_allocator_for<_KeyContainer, _MappedContainer> _Allocator>
 flat_multimap(_KeyContainer, _MappedContainer, _Allocator) -> flat_multimap<typename _KeyContainer::value_type,
     typename _MappedContainer::value_type, less<typename _KeyContainer::value_type>, _KeyContainer, _MappedContainer>;
-template <class _KeyContainer, class _MappedContainer, class _Compare, class _Allocator>
+template <_Not_allocator_for_container _KeyContainer, _Not_allocator_for_container _MappedContainer,
+    _Valid_compare_for_container<_KeyContainer> _Compare,
+    _Usable_allocator_for<_KeyContainer, _MappedContainer> _Allocator>
 flat_multimap(_KeyContainer, _MappedContainer, _Compare, _Allocator)
     -> flat_multimap<typename _KeyContainer::value_type, typename _MappedContainer::value_type, _Compare, _KeyContainer,
         _MappedContainer>;
 
-template <class _KeyContainer, class _MappedContainer, class _Compare = less<typename _KeyContainer::value_type>>
+template <_Not_allocator_for_container _KeyContainer, _Not_allocator_for_container _MappedContainer,
+    _Valid_compare_for_container<_KeyContainer> _Compare = less<typename _KeyContainer::value_type>>
 flat_multimap(sorted_equivalent_t, _KeyContainer, _MappedContainer, _Compare = _Compare())
     -> flat_multimap<typename _KeyContainer::value_type, typename _MappedContainer::value_type, _Compare, _KeyContainer,
         _MappedContainer>;
 
-template <class _KeyContainer, class _MappedContainer, class _Allocator>
+template <_Not_allocator_for_container _KeyContainer, _Not_allocator_for_container _MappedContainer,
+    _Usable_allocator_for<_KeyContainer, _MappedContainer> _Allocator>
 flat_multimap(sorted_equivalent_t, _KeyContainer, _MappedContainer, _Allocator)
     -> flat_multimap<typename _KeyContainer::value_type, typename _MappedContainer::value_type,
         less<typename _KeyContainer::value_type>, _KeyContainer, _MappedContainer>;
-template <class _KeyContainer, class _MappedContainer, class _Compare, class _Allocator>
+template <_Not_allocator_for_container _KeyContainer, _Not_allocator_for_container _MappedContainer,
+    _Valid_compare_for_container<_KeyContainer> _Compare,
+    _Usable_allocator_for<_KeyContainer, _MappedContainer> _Allocator>
 flat_multimap(sorted_equivalent_t, _KeyContainer, _MappedContainer, _Compare, _Allocator)
     -> flat_multimap<typename _KeyContainer::value_type, typename _MappedContainer::value_type, _Compare, _KeyContainer,
         _MappedContainer>;
 
-template <class _InputIterator, class _Compare = less<_Guide_key_t<_InputIterator>>>
+template <_Iterator_for_container _InputIterator,
+    _Not_allocator_for_container _Compare = less<_Guide_key_t<_InputIterator>>>
 flat_multimap(_InputIterator, _InputIterator, _Compare = _Compare())
     -> flat_multimap<_Guide_key_t<_InputIterator>, _Guide_val_t<_InputIterator>, _Compare>;
 
-template <class _InputIterator, class _Compare = less<_Guide_key_t<_InputIterator>>>
+template <_Iterator_for_container _InputIterator,
+    _Not_allocator_for_container _Compare = less<_Guide_key_t<_InputIterator>>>
 flat_multimap(sorted_equivalent_t, _InputIterator, _InputIterator, _Compare = _Compare())
     -> flat_multimap<_Guide_key_t<_InputIterator>, _Guide_val_t<_InputIterator>, _Compare>;
 
 #ifdef __cpp_lib_byte
-template <_RANGES input_range _Rng, class _Compare = less<_Range_key_type<_Rng>>, class _Allocator = allocator<byte>>
+template <_RANGES input_range _Rng, _Not_allocator_for_container _Compare = less<_Range_key_type<_Rng>>,
+    _Allocator_for_container _Allocator = allocator<byte>>
 flat_multimap(from_range_t, _Rng&&, _Compare = _Compare(), _Allocator = _Allocator())
     -> flat_multimap<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, _Compare,
         vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_key_type<_Rng>>>,
         vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_mapped_type<_Rng>>>>;
 #else // ^^^ defined(__cpp_lib_byte) / !defined(__cpp_lib_byte) vvv
-template <_RANGES input_range _Rng, class _Compare = less<_Range_key_type<_Rng>>>
+template <_RANGES input_range _Rng, _Not_allocator_for_container _Compare = less<_Range_key_type<_Rng>>>
 flat_multimap(from_range_t, _Rng&&, _Compare = _Compare()) -> flat_multimap<_Range_key_type<_Rng>,
     _Range_mapped_type<_Rng>, _Compare, vector<_Range_key_type<_Rng>>, vector<_Range_mapped_type<_Rng>>>;
 
-template <_RANGES input_range _Rng, class _Compare, class _Allocator>
+template <_RANGES input_range _Rng, _Not_allocator_for_container _Compare, _Allocator_for_container _Allocator>
 flat_multimap(from_range_t, _Rng&&, _Compare, _Allocator)
     -> flat_multimap<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, _Compare,
         vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_key_type<_Rng>>>,
         vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_mapped_type<_Rng>>>>;
 #endif // ^^^ !defined(__cpp_lib_byte) ^^^
 
-template <_RANGES input_range _Rng, class _Allocator>
+template <_RANGES input_range _Rng, _Allocator_for_container _Allocator>
 flat_multimap(from_range_t, _Rng&&, _Allocator) -> flat_multimap<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>,
     less<_Range_key_type<_Rng>>, vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_key_type<_Rng>>>,
     vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_mapped_type<_Rng>>>>;
 
-template <class _Key, class _Mapped, class _Compare = less<_Key>>
+template <class _Key, class _Mapped, _Not_allocator_for_container _Compare = less<_Key>>
 flat_multimap(initializer_list<pair<_Key, _Mapped>>, _Compare = _Compare()) -> flat_multimap<_Key, _Mapped, _Compare>;
 
-template <class _Key, class _Mapped, class _Compare = less<_Key>>
+template <class _Key, class _Mapped, _Not_allocator_for_container _Compare = less<_Key>>
 flat_multimap(sorted_equivalent_t, initializer_list<pair<_Key, _Mapped>>, _Compare = _Compare())
     -> flat_multimap<_Key, _Mapped, _Compare>;
 
diff --git a/stl/inc/vector b/stl/inc/vector
index e1dce0933c0..f39373d2e14 100644
--- a/stl/inc/vector
+++ b/stl/inc/vector
@@ -868,7 +868,7 @@ private:
 
         _STL_INTERNAL_CHECK(_Mylast == _My_data._Myend); // check that we have no unused capacity
 
-        const auto _Whereoff = static_cast<size_type>(_Whereptr - _Myfirst);
+        const auto _Whereoff = _Whereptr - _Myfirst;
         const auto _Oldsize  = static_cast<size_type>(_Mylast - _Myfirst);
 
         if (_Oldsize == max_size()) {
@@ -879,7 +879,7 @@ private:
         size_type _Newcapacity   = _Calculate_growth(_Newsize);
 
         const pointer _Newvec           = _STD _Allocate_at_least_helper(_Al, _Newcapacity);
-        const pointer _Constructed_last = _Newvec + _Whereoff + 1;
+        const pointer _Constructed_last = _Newvec + static_cast<_Iter_diff_t<pointer>>(_Whereoff + 1);
 
         _Reallocation_guard _Guard{_Al, _Newvec, _Newcapacity, _Constructed_last, _Constructed_last};
         auto& _Constructed_first = _Guard._Constructed_first;
@@ -896,7 +896,8 @@ private:
         } else { // provide basic guarantee
             _STD _Uninitialized_move(_Myfirst, _Whereptr, _Newvec, _Al);
             _Constructed_first = _Newvec;
-            _STD _Uninitialized_move(_Whereptr, _Mylast, _Newvec + _Whereoff + 1, _Al);
+            _STD _Uninitialized_move(
+                _Whereptr, _Mylast, _Newvec + static_cast<_Iter_diff_t<pointer>>(_Whereoff + 1), _Al);
         }
 
         _Guard._New_begin = nullptr;
@@ -2060,8 +2061,8 @@ private:
         }
 
         _Myfirst = _Newvec;
-        _Mylast  = _Newvec + _Newsize;
-        _Myend   = _Newvec + _Newcapacity;
+        _Mylast  = _Newvec + static_cast<_Iter_diff_t<pointer>>(_Newsize);
+        _Myend   = _Newvec + static_cast<_Iter_diff_t<pointer>>(_Newcapacity);
         _ASAN_VECTOR_CREATE;
     }
 
diff --git a/stl/inc/xutility b/stl/inc/xutility
index 0d5b9872e48..0e8ef534d81 100644
--- a/stl/inc/xutility
+++ b/stl/inc/xutility
@@ -1491,6 +1491,9 @@ concept _Allocator_for_container = requires(_Ty& _Alloc) {
     _Alloc.deallocate(_Alloc.allocate(size_t{1}), size_t{1});
 };
 
+template <class _Ty>
+concept _Not_allocator_for_container = !_Allocator_for_container<_Ty>;
+
 template <class _Ty>
 struct _Is_allocator : bool_constant<_Allocator_for_container<_Ty>> {};
 #else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
@@ -7419,12 +7422,12 @@ _EXPORT_STD template <class _FwdIt, class _Ty, class _Pr>
 _NODISCARD _CONSTEXPR20 _FwdIt lower_bound(_FwdIt _First, const _FwdIt _Last, const _Ty& _Val, _Pr _Pred) {
     // find first element not before _Val
     _STD _Adl_verify_range(_First, _Last);
-    auto _UFirst                = _STD _Get_unwrapped(_First);
-    _Iter_diff_t<_FwdIt> _Count = _STD distance(_UFirst, _STD _Get_unwrapped(_Last));
+    auto _UFirst = _STD _Get_unwrapped(_First);
+    auto _Count  = _STD distance(_UFirst, _STD _Get_unwrapped(_Last));
 
     while (0 < _Count) { // divide and conquer, find half that contains answer
-        const _Iter_diff_t<_FwdIt> _Count2 = _Count / 2;
-        const auto _UMid                   = _STD next(_UFirst, _Count2);
+        const auto _Count2 = static_cast<decltype(_Count)>(_Count / 2);
+        const auto _UMid   = _STD next(_UFirst, _Count2);
         if (_Pred(*_UMid, _Val)) { // try top half
             _UFirst = _STD _Next_iter(_UMid);
             _Count -= _Count2 + 1;
@@ -7447,12 +7450,12 @@ _EXPORT_STD template <class _FwdIt, class _Ty, class _Pr>
 _NODISCARD _CONSTEXPR20 _FwdIt upper_bound(_FwdIt _First, _FwdIt _Last, const _Ty& _Val, _Pr _Pred) {
     // find first element that _Val is before
     _STD _Adl_verify_range(_First, _Last);
-    auto _UFirst                = _STD _Get_unwrapped(_First);
-    _Iter_diff_t<_FwdIt> _Count = _STD distance(_UFirst, _STD _Get_unwrapped(_Last));
+    auto _UFirst = _STD _Get_unwrapped(_First);
+    auto _Count  = _STD distance(_UFirst, _STD _Get_unwrapped(_Last));
 
     while (0 < _Count) { // divide and conquer, find half that contains answer
-        _Iter_diff_t<_FwdIt> _Count2 = _Count / 2;
-        const auto _UMid             = _STD next(_UFirst, _Count2);
+        const auto _Count2 = static_cast<decltype(_Count)>(_Count / 2);
+        const auto _UMid   = _STD next(_UFirst, _Count2);
         if (_Pred(_Val, *_UMid)) {
             _Count = _Count2;
         } else { // try top half
diff --git a/tests/libcxx/expected_results.txt b/tests/libcxx/expected_results.txt
index fa55b8db6ca..2bf1c7ea323 100644
--- a/tests/libcxx/expected_results.txt
+++ b/tests/libcxx/expected_results.txt
@@ -228,26 +228,18 @@ std/strings/c.strings/cuchar.compile.pass.cpp FAIL
 # P0429R9 <flat_map>
 # FIXME! Investigate these failures before merging!
 std/containers/container.adaptors/flat.map/flat.map.access/at_transparent.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.access/at.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.access/index_key.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.access/index_rv_key.pass.cpp FAIL
 std/containers/container.adaptors/flat.map/flat.map.access/index_transparent.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.capacity/empty.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.capacity/size.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.cons/assign_initializer_list.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.cons/compare.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.cons/containers.pass.cpp FAIL
 std/containers/container.adaptors/flat.map/flat.map.cons/copy_alloc.pass.cpp:0 SKIPPED
 std/containers/container.adaptors/flat.map/flat.map.cons/copy_alloc.pass.cpp:1 SKIPPED
-std/containers/container.adaptors/flat.map/flat.map.cons/copy_assign.addressof.compile.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.cons/copy_assign.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.cons/copy.pass.cpp FAIL
+std/containers/container.adaptors/flat.map/flat.map.cons/copy_assign.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.map/flat.map.cons/copy_assign.pass.cpp:1 FAIL
 std/containers/container.adaptors/flat.map/flat.map.cons/deduct_pmr.pass.cpp:0 FAIL
 std/containers/container.adaptors/flat.map/flat.map.cons/deduct_pmr.pass.cpp:1 FAIL
 std/containers/container.adaptors/flat.map/flat.map.cons/deduct.pass.cpp FAIL
 std/containers/container.adaptors/flat.map/flat.map.cons/initializer_list.pass.cpp:0 FAIL
 std/containers/container.adaptors/flat.map/flat.map.cons/initializer_list.pass.cpp:1 FAIL
-std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter.pass.cpp FAIL
+std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter.pass.cpp:1 FAIL
 std/containers/container.adaptors/flat.map/flat.map.cons/move_alloc.pass.cpp FAIL
 std/containers/container.adaptors/flat.map/flat.map.cons/move_assign_clears.pass.cpp FAIL
 std/containers/container.adaptors/flat.map/flat.map.cons/move_assign_noexcept.pass.cpp:2 FAIL
@@ -255,8 +247,10 @@ std/containers/container.adaptors/flat.map/flat.map.cons/move_assign.pass.cpp:0
 std/containers/container.adaptors/flat.map/flat.map.cons/move_assign.pass.cpp:1 FAIL
 std/containers/container.adaptors/flat.map/flat.map.cons/move_exceptions.pass.cpp FAIL
 std/containers/container.adaptors/flat.map/flat.map.cons/move.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.cons/pmr.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.cons/range.pass.cpp FAIL
+std/containers/container.adaptors/flat.map/flat.map.cons/pmr.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.map/flat.map.cons/pmr.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.map/flat.map.cons/range.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.map/flat.map.cons/range.pass.cpp:1 FAIL
 std/containers/container.adaptors/flat.map/flat.map.cons/sorted_container.pass.cpp:0 FAIL
 std/containers/container.adaptors/flat.map/flat.map.cons/sorted_container.pass.cpp:1 FAIL
 std/containers/container.adaptors/flat.map/flat.map.cons/sorted_initializer_list.pass.cpp:0 FAIL
@@ -266,50 +260,96 @@ std/containers/container.adaptors/flat.map/flat.map.cons/sorted_iter_iter.pass.c
 std/containers/container.adaptors/flat.map/flat.map.erasure/erase_if_exceptions.pass.cpp:2 FAIL
 std/containers/container.adaptors/flat.map/flat.map.erasure/erase_if.pass.cpp:0 SKIPPED
 std/containers/container.adaptors/flat.map/flat.map.erasure/erase_if.pass.cpp:1 SKIPPED
-std/containers/container.adaptors/flat.map/flat.map.iterators/iterator_comparison.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.iterators/iterator_concept_conformance.compile.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.iterators/iterator.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.iterators/range_concept_conformance.compile.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.modifiers/clear.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.modifiers/emplace_hint.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.modifiers/emplace.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_iter_iter.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_iter.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_key_transparent.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_key.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.modifiers/extract.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_cv.pass.cpp FAIL
+std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_key.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_key.pass.cpp:1 FAIL
 std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_initializer_list.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_iter_cv.pass.cpp FAIL
 std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_iter_iter.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_iter_rv.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_or_assign_transparent.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_or_assign.pass.cpp FAIL
 std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_range.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_rv.pass.cpp FAIL
 std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_sorted_initializer_list.pass.cpp FAIL
 std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_sorted_iter_iter.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_transparent.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.modifiers/replace.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.modifiers/swap_free.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.modifiers/swap_member.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.modifiers/try_emplace_transparent.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.modifiers/try_emplace.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.observers/keys_values.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.operations/contains_transparent.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.operations/contains.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.operations/count_transparent.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.operations/count.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.operations/equal_range_transparent.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.operations/equal_range.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.operations/find_transparent.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.operations/find.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.operations/lower_bound_transparent.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.operations/lower_bound.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.operations/upper_bound_transparent.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.operations/upper_bound.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/incomplete_type.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/op_compare.pass.cpp FAIL
+# FIXME! These tests perform narrowing conversions on x64 but not on x86.
+std/containers/container.adaptors/flat.map/flat.map.access/at.pass.cpp:0 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.access/at.pass.cpp:1 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.access/index_key.pass.cpp:0 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.access/index_key.pass.cpp:1 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.access/index_rv_key.pass.cpp:0 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.access/index_rv_key.pass.cpp:1 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.capacity/empty.pass.cpp:0 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.capacity/empty.pass.cpp:1 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.capacity/size.pass.cpp:0 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.capacity/size.pass.cpp:1 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.cons/assign_initializer_list.pass.cpp:0 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.cons/assign_initializer_list.pass.cpp:1 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.iterators/iterator.pass.cpp:0 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.iterators/iterator.pass.cpp:1 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.iterators/iterator_comparison.pass.cpp:0 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.iterators/iterator_comparison.pass.cpp:1 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.iterators/range_concept_conformance.compile.pass.cpp:0 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.iterators/range_concept_conformance.compile.pass.cpp:1 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.modifiers/clear.pass.cpp:0 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.modifiers/clear.pass.cpp:1 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.modifiers/emplace.pass.cpp:0 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.modifiers/emplace.pass.cpp:1 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.modifiers/emplace_hint.pass.cpp:0 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.modifiers/emplace_hint.pass.cpp:1 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_iter.pass.cpp:0 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_iter.pass.cpp:1 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_iter_iter.pass.cpp:0 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_iter_iter.pass.cpp:1 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_key_transparent.pass.cpp:0 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_key_transparent.pass.cpp:1 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.modifiers/extract.pass.cpp:0 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.modifiers/extract.pass.cpp:1 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_cv.pass.cpp:0 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_cv.pass.cpp:1 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_rv.pass.cpp:0 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_rv.pass.cpp:1 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_iter_cv.pass.cpp:0 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_iter_cv.pass.cpp:1 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_iter_rv.pass.cpp:0 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_iter_rv.pass.cpp:1 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_or_assign.pass.cpp:0 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_or_assign.pass.cpp:1 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_or_assign_transparent.pass.cpp:0 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_or_assign_transparent.pass.cpp:1 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_transparent.pass.cpp:0 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_transparent.pass.cpp:1 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.modifiers/replace.pass.cpp:0 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.modifiers/replace.pass.cpp:1 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.modifiers/swap_free.pass.cpp:0 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.modifiers/swap_free.pass.cpp:1 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.modifiers/swap_member.pass.cpp:0 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.modifiers/swap_member.pass.cpp:1 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.modifiers/try_emplace.pass.cpp:0 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.modifiers/try_emplace.pass.cpp:1 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.modifiers/try_emplace_transparent.pass.cpp:0 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.modifiers/try_emplace_transparent.pass.cpp:1 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.observers/keys_values.pass.cpp:0 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.observers/keys_values.pass.cpp:1 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.operations/contains.pass.cpp:0 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.operations/contains.pass.cpp:1 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.operations/contains_transparent.pass.cpp:0 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.operations/contains_transparent.pass.cpp:1 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.operations/count.pass.cpp:0 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.operations/count.pass.cpp:1 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.operations/count_transparent.pass.cpp:0 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.operations/count_transparent.pass.cpp:1 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.operations/equal_range.pass.cpp:0 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.operations/equal_range.pass.cpp:1 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.operations/equal_range_transparent.pass.cpp:0 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.operations/equal_range_transparent.pass.cpp:1 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.operations/find.pass.cpp:0 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.operations/find.pass.cpp:1 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.operations/find_transparent.pass.cpp:0 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.operations/find_transparent.pass.cpp:1 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.operations/lower_bound.pass.cpp:0 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.operations/lower_bound.pass.cpp:1 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.operations/lower_bound_transparent.pass.cpp:0 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.operations/lower_bound_transparent.pass.cpp:1 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.operations/upper_bound.pass.cpp:0 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.operations/upper_bound.pass.cpp:1 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.operations/upper_bound_transparent.pass.cpp:0 SKIPPED
+std/containers/container.adaptors/flat.map/flat.map.operations/upper_bound_transparent.pass.cpp:1 SKIPPED
 
 # P0533R9 constexpr For <cmath> And <cstdlib>
 std/language.support/support.limits/support.limits.general/cmath.version.compile.pass.cpp FAIL
diff --git a/tests/std/tests/P0429R9_flat_map/env.lst b/tests/std/tests/P0429R9_flat_map/env.lst
index 642f530ffad..b2dc2c0f570 100644
--- a/tests/std/tests/P0429R9_flat_map/env.lst
+++ b/tests/std/tests/P0429R9_flat_map/env.lst
@@ -1,4 +1,4 @@
 # Copyright (c) Microsoft Corporation.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-RUNALL_INCLUDE ..\usual_latest_matrix.lst
+RUNALL_INCLUDE ..\strict_latest_matrix.lst

From 956149eb667cf49040abb50dc0295e287d53ef3d Mon Sep 17 00:00:00 2001
From: nerix <nerixdev@outlook.de>
Date: Mon, 24 Mar 2025 21:34:55 +0100
Subject: [PATCH 047/134] Add visualizer for `std::flat_set` and flat-map
 iterators (#5353)

---
 stl/debugger/STL.natvis | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/stl/debugger/STL.natvis b/stl/debugger/STL.natvis
index 496762184ed..96949090536 100644
--- a/stl/debugger/STL.natvis
+++ b/stl/debugger/STL.natvis
@@ -2410,4 +2410,20 @@ SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
     </Expand>
   </Type>
 
+  <Type Name="std::_Pairing_iterator_provider&lt;*&gt;::_Iterator">
+    <DisplayString>({_Key_it}, {_Mapped_it})</DisplayString>
+    <Expand>
+      <Item Name="[key]">_Key_it</Item>
+      <Item Name="[value]">_Mapped_it</Item>
+    </Expand>
+  </Type>
+
+  <Type Name="std::flat_set&lt;*&gt;">
+    <DisplayString>{_Mycont}</DisplayString>
+    <Expand>
+      <Item Name="[comparator]" ExcludeView="simple">_Mycomp</Item>
+      <ExpandedItem>_Mycont</ExpandedItem>
+    </Expand>
+  </Type>
+
 </AutoVisualizer>

From e54056fdd31dcb8db717c354ce82b71299e5a35e Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Mon, 24 Mar 2025 21:08:26 -0700
Subject: [PATCH 048/134] Recategorize libcxx failures from scratch.

---
 tests/libcxx/expected_results.txt | 93 ++++++++++++++++++++++++++++++-
 1 file changed, 91 insertions(+), 2 deletions(-)

diff --git a/tests/libcxx/expected_results.txt b/tests/libcxx/expected_results.txt
index 2c36f3bc889..f4e1ef53e3b 100644
--- a/tests/libcxx/expected_results.txt
+++ b/tests/libcxx/expected_results.txt
@@ -231,9 +231,98 @@ std/depr/depr.c.headers/uchar_h.compile.pass.cpp FAIL
 std/strings/c.strings/cuchar.compile.pass.cpp FAIL
 
 # P0429R9 <flat_map>
-# FIXME! Investigate these failures before merging!
 
-# FIXME! These tests perform narrowing conversions on x64 but not on x86.
+# FIXME! static_assert(!CanIndex<TransparentMap, NonConvertibleTransparent<int>>);
+std/containers/container.adaptors/flat.map/flat.map.access/index_transparent.pass.cpp FAIL
+
+# FIXME! static_assert(!CanEmplace<Map, Emplaceable>);
+std/containers/container.adaptors/flat.multimap/flat.multimap.modifiers/emplace.pass.cpp FAIL
+
+# FIXME! error: no type named 'value_type' in 'std::greater<int>'
+std/containers/container.adaptors/flat.map/flat.map.cons/deduct.pass.cpp FAIL
+std/containers/container.adaptors/flat.multimap/flat.multimap.cons/deduct.pass.cpp FAIL
+
+# FIXME! Assertion failed: mo.empty()
+std/containers/container.adaptors/flat.map/flat.map.cons/move_alloc.pass.cpp FAIL
+std/containers/container.adaptors/flat.multimap/flat.multimap.cons/move_alloc.pass.cpp FAIL
+
+# FIXME! Assertion failed: m.keys().size() == m.values().size()
+std/containers/container.adaptors/flat.map/flat.map.cons/move_assign_clears.pass.cpp FAIL
+std/containers/container.adaptors/flat.map/flat.map.cons/move_exceptions.pass.cpp FAIL
+std/containers/container.adaptors/flat.multimap/flat.multimap.cons/move_assign_clears.pass.cpp FAIL
+std/containers/container.adaptors/flat.multimap/flat.multimap.cons/move_exceptions.pass.cpp FAIL
+
+# FIXME! abort() has been called
+std/containers/container.adaptors/flat.map/flat.map.cons/move.pass.cpp FAIL
+std/containers/container.adaptors/flat.multimap/flat.multimap.cons/move.pass.cpp FAIL
+
+# FIXME! Assertion failed: false
+std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_initializer_list.pass.cpp FAIL
+std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_iter_iter.pass.cpp FAIL
+std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_range.pass.cpp FAIL
+std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_sorted_initializer_list.pass.cpp FAIL
+std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_sorted_iter_iter.pass.cpp FAIL
+std/containers/container.adaptors/flat.multimap/flat.multimap.modifiers/insert_initializer_list.pass.cpp FAIL
+std/containers/container.adaptors/flat.multimap/flat.multimap.modifiers/insert_iter_iter.pass.cpp FAIL
+std/containers/container.adaptors/flat.multimap/flat.multimap.modifiers/insert_range.pass.cpp FAIL
+std/containers/container.adaptors/flat.multimap/flat.multimap.modifiers/insert_sorted_initializer_list.pass.cpp FAIL
+std/containers/container.adaptors/flat.multimap/flat.multimap.modifiers/insert_sorted_iter_iter.pass.cpp FAIL
+
+# FIXME! warning C4242: 'initializing': conversion from '_Ty' to '_Ty2', possible loss of data
+std/containers/container.adaptors/flat.map/flat.map.cons/copy_assign.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.map/flat.map.cons/copy_assign.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.map/flat.map.cons/deduct_pmr.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.map/flat.map.cons/deduct_pmr.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.map/flat.map.cons/initializer_list.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.map/flat.map.cons/initializer_list.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.map/flat.map.cons/move_assign.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.map/flat.map.cons/move_assign.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.map/flat.map.cons/pmr.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.map/flat.map.cons/pmr.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.map/flat.map.cons/range.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.map/flat.map.cons/range.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.map/flat.map.cons/sorted_container.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.map/flat.map.cons/sorted_container.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.map/flat.map.cons/sorted_initializer_list.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.map/flat.map.cons/sorted_initializer_list.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.map/flat.map.cons/sorted_iter_iter.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.map/flat.map.cons/sorted_iter_iter.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_key.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_key.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.multimap/flat.multimap.cons/containers.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.multimap/flat.multimap.cons/containers.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.multimap/flat.multimap.cons/copy_assign.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.multimap/flat.multimap.cons/copy_assign.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.multimap/flat.multimap.cons/deduct_pmr.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.multimap/flat.multimap.cons/deduct_pmr.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.multimap/flat.multimap.cons/initializer_list.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.multimap/flat.multimap.cons/initializer_list.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.multimap/flat.multimap.cons/iter_iter.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.multimap/flat.multimap.cons/iter_iter.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.multimap/flat.multimap.cons/move_assign.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.multimap/flat.multimap.cons/move_assign.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.multimap/flat.multimap.cons/pmr.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.multimap/flat.multimap.cons/pmr.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.multimap/flat.multimap.cons/range.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.multimap/flat.multimap.cons/range.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.multimap/flat.multimap.cons/sorted_container.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.multimap/flat.multimap.cons/sorted_container.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.multimap/flat.multimap.cons/sorted_initializer_list.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.multimap/flat.multimap.cons/sorted_initializer_list.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.multimap/flat.multimap.cons/sorted_iter_iter.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.multimap/flat.multimap.cons/sorted_iter_iter.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.multimap/flat.multimap.modifiers/erase_key.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.multimap/flat.multimap.modifiers/erase_key.pass.cpp:1 FAIL
+
+# FIXME! error: unused type alias 'C' [-Werror,-Wunused-local-typedef]
+std/containers/container.adaptors/flat.map/flat.map.cons/move_assign_noexcept.pass.cpp:2 FAIL
+std/containers/container.adaptors/flat.multimap/flat.multimap.cons/move_assign_noexcept.pass.cpp:2 FAIL
+
+# FIXME! error: unused variable 'expected' [-Werror,-Wunused-variable]
+std/containers/container.adaptors/flat.map/flat.map.erasure/erase_if_exceptions.pass.cpp:2 FAIL
+std/containers/container.adaptors/flat.multimap/flat.multimap.erasure/erase_if_exceptions.pass.cpp:2 FAIL
 
 # P0533R9 constexpr For <cmath> And <cstdlib>
 std/language.support/support.limits/support.limits.general/cmath.version.compile.pass.cpp FAIL

From 8f584f47448c3e50a1db89d601c3c602e3f0e414 Mon Sep 17 00:00:00 2001
From: Nikolai Vavilov <vvnicholas@gmail.com>
Date: Fri, 18 Apr 2025 01:07:58 +0300
Subject: [PATCH 049/134] Fix [flat.map.access] bugs found by libcxx tests
 (#5414)

---
 stl/inc/flat_map                  | 9 +++++----
 tests/libcxx/expected_results.txt | 3 ---
 2 files changed, 5 insertions(+), 7 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index 558880e9d5c..c649e463eae 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -1119,20 +1119,21 @@ public:
     }
 
     // [flat.map.access] Access
-    _NODISCARD mapped_type& operator[](const key_type& _Key_val)
+    mapped_type& operator[](const key_type& _Key_val)
         requires is_default_constructible_v<mapped_type>
     {
         return this->try_emplace(_Key_val).first->second;
     }
-    _NODISCARD mapped_type& operator[](key_type&& _Key_val)
+    mapped_type& operator[](key_type&& _Key_val)
         requires is_default_constructible_v<mapped_type>
     {
         return this->try_emplace(_STD move(_Key_val)).first->second;
     }
 
     template <class _OtherKey>
-    _NODISCARD mapped_type& operator[](_OtherKey&& _Key_val)
-        requires _Is_transparent_v<key_compare>
+    mapped_type& operator[](_OtherKey&& _Key_val)
+        requires _Is_transparent_v<key_compare> && is_constructible_v<key_type, _OtherKey>
+              && is_default_constructible_v<mapped_type>
     {
         return this->try_emplace(_STD forward<_OtherKey>(_Key_val)).first->second;
     }
diff --git a/tests/libcxx/expected_results.txt b/tests/libcxx/expected_results.txt
index f4e1ef53e3b..67878076fc2 100644
--- a/tests/libcxx/expected_results.txt
+++ b/tests/libcxx/expected_results.txt
@@ -232,9 +232,6 @@ std/strings/c.strings/cuchar.compile.pass.cpp FAIL
 
 # P0429R9 <flat_map>
 
-# FIXME! static_assert(!CanIndex<TransparentMap, NonConvertibleTransparent<int>>);
-std/containers/container.adaptors/flat.map/flat.map.access/index_transparent.pass.cpp FAIL
-
 # FIXME! static_assert(!CanEmplace<Map, Emplaceable>);
 std/containers/container.adaptors/flat.multimap/flat.multimap.modifiers/emplace.pass.cpp FAIL
 

From 058de5c6db949e97f8485b04a25a9481ba4df017 Mon Sep 17 00:00:00 2001
From: Nikolai Vavilov <vvnicholas@gmail.com>
Date: Sat, 19 Apr 2025 18:01:10 +0300
Subject: [PATCH 050/134] Fix [flat.map.modifiers] bugs found by libcxx tests
 (#5419)

---
 stl/inc/flat_map                  | 17 +++++------------
 tests/libcxx/expected_results.txt | 15 ---------------
 2 files changed, 5 insertions(+), 27 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index c649e463eae..3baef2c8cfe 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -940,17 +940,8 @@ private:
         // Insert the new elements at the end
         for (; _First != _Last; ++_First) {
             value_type _Val = *_First;
-            if constexpr (requires { _Data.keys.push_back(_STD move(_Val.first)); }) {
-                _Data.keys.push_back(_STD move(_Val.first));
-            } else {
-                _Data.keys.insert(_Data.keys.end(), _STD move(_Val.first));
-            }
-
-            if constexpr (requires { _Data.values.push_back(_STD move(_Val.second)); }) {
-                _Data.values.push_back(_STD move(_Val.second));
-            } else {
-                _Data.values.insert(_Data.values.end(), _STD move(_Val.second));
-            }
+            _Data.keys.insert(_Data.keys.end(), _STD move(_Val.first));
+            _Data.values.insert(_Data.values.end(), _STD move(_Val.second));
         }
 
         // Sort the newly inserted elements
@@ -1451,7 +1442,9 @@ public:
 
     // [flat.multimap.modifiers] Modifiers
     template <class... _ArgTypes>
-    iterator emplace(_ArgTypes&&... _Args) {
+    iterator emplace(_ArgTypes&&... _Args)
+        requires is_constructible_v<value_type, _ArgTypes...>
+    {
         value_type _Val(_STD forward<_ArgTypes>(_Args)...);
         return _Emplace_key_mapped(_STD move(_Val.first), _STD move(_Val.second));
     }
diff --git a/tests/libcxx/expected_results.txt b/tests/libcxx/expected_results.txt
index 67878076fc2..5a26fed73fc 100644
--- a/tests/libcxx/expected_results.txt
+++ b/tests/libcxx/expected_results.txt
@@ -232,9 +232,6 @@ std/strings/c.strings/cuchar.compile.pass.cpp FAIL
 
 # P0429R9 <flat_map>
 
-# FIXME! static_assert(!CanEmplace<Map, Emplaceable>);
-std/containers/container.adaptors/flat.multimap/flat.multimap.modifiers/emplace.pass.cpp FAIL
-
 # FIXME! error: no type named 'value_type' in 'std::greater<int>'
 std/containers/container.adaptors/flat.map/flat.map.cons/deduct.pass.cpp FAIL
 std/containers/container.adaptors/flat.multimap/flat.multimap.cons/deduct.pass.cpp FAIL
@@ -253,18 +250,6 @@ std/containers/container.adaptors/flat.multimap/flat.multimap.cons/move_exceptio
 std/containers/container.adaptors/flat.map/flat.map.cons/move.pass.cpp FAIL
 std/containers/container.adaptors/flat.multimap/flat.multimap.cons/move.pass.cpp FAIL
 
-# FIXME! Assertion failed: false
-std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_initializer_list.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_iter_iter.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_range.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_sorted_initializer_list.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_sorted_iter_iter.pass.cpp FAIL
-std/containers/container.adaptors/flat.multimap/flat.multimap.modifiers/insert_initializer_list.pass.cpp FAIL
-std/containers/container.adaptors/flat.multimap/flat.multimap.modifiers/insert_iter_iter.pass.cpp FAIL
-std/containers/container.adaptors/flat.multimap/flat.multimap.modifiers/insert_range.pass.cpp FAIL
-std/containers/container.adaptors/flat.multimap/flat.multimap.modifiers/insert_sorted_initializer_list.pass.cpp FAIL
-std/containers/container.adaptors/flat.multimap/flat.multimap.modifiers/insert_sorted_iter_iter.pass.cpp FAIL
-
 # FIXME! warning C4242: 'initializing': conversion from '_Ty' to '_Ty2', possible loss of data
 std/containers/container.adaptors/flat.map/flat.map.cons/copy_assign.pass.cpp:0 FAIL
 std/containers/container.adaptors/flat.map/flat.map.cons/copy_assign.pass.cpp:1 FAIL

From 2fabe62177bf0c6e84397b54d16415ba7c406a2e Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34@live.cn>
Date: Tue, 22 Apr 2025 06:22:17 +0800
Subject: [PATCH 051/134] `<flat_map>`: Restore use of `push_back` in
 `flat_(multi)map::insert` (#5422)

---
 stl/inc/deque    |  5 +++++
 stl/inc/flat_map | 13 +++++++++++--
 stl/inc/vector   |  3 +++
 stl/inc/xmemory  |  3 +++
 stl/inc/xstring  |  5 +++++
 5 files changed, 27 insertions(+), 2 deletions(-)

diff --git a/stl/inc/deque b/stl/inc/deque
index 05793b8ac41..2e587fec0f1 100644
--- a/stl/inc/deque
+++ b/stl/inc/deque
@@ -1847,6 +1847,11 @@ namespace pmr {
     using deque = _STD deque<_Ty, polymorphic_allocator<_Ty>>;
 } // namespace pmr
 #endif // _HAS_CXX17
+
+#if _HAS_CXX23
+template <class _Ty, class _Alloc>
+constexpr bool _Has_guaranteed_push_back<deque<_Ty, _Alloc>> = true;
+#endif // _HAS_CXX23
 _STD_END
 
 #pragma pop_macro("new")
diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index 3baef2c8cfe..4f417832f4d 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -940,8 +940,17 @@ private:
         // Insert the new elements at the end
         for (; _First != _Last; ++_First) {
             value_type _Val = *_First;
-            _Data.keys.insert(_Data.keys.end(), _STD move(_Val.first));
-            _Data.values.insert(_Data.values.end(), _STD move(_Val.second));
+            if constexpr (_Has_guaranteed_push_back<_KeyContainer>) {
+                _Data.keys.push_back(_STD move(_Val.first));
+            } else {
+                _Data.keys.insert(_Data.keys.end(), _STD move(_Val.first));
+            }
+
+            if constexpr (_Has_guaranteed_push_back<_MappedContainer>) {
+                _Data.values.push_back(_STD move(_Val.second));
+            } else {
+                _Data.values.insert(_Data.values.end(), _STD move(_Val.second));
+            }
         }
 
         // Sort the newly inserted elements
diff --git a/stl/inc/vector b/stl/inc/vector
index 476f80e4629..4c102e45043 100644
--- a/stl/inc/vector
+++ b/stl/inc/vector
@@ -3998,6 +3998,9 @@ constexpr bool _Is_vector_bool = false;
 template <class _Alloc>
 constexpr bool _Is_vector_bool<vector<bool, _Alloc>> = true;
 
+template <class _Ty, class _Alloc>
+constexpr bool _Has_guaranteed_push_back<vector<_Ty, _Alloc>> = !is_same_v<_Ty, bool>;
+
 template <class _Alloc, class... _Containers>
 concept _Usable_allocator_for = (uses_allocator_v<_Containers, _Alloc> && ...);
 
diff --git a/stl/inc/xmemory b/stl/inc/xmemory
index 80041fc71bc..b224836c133 100644
--- a/stl/inc/xmemory
+++ b/stl/inc/xmemory
@@ -2752,6 +2752,9 @@ namespace ranges {
     elements_of(_Rng&&, _Alloc) -> elements_of<_Rng&&, _Alloc>;
 #endif // ^^^ !defined(__cpp_lib_byte) ^^^
 } // namespace ranges
+
+template <class>
+constexpr bool _Has_guaranteed_push_back = false; // N5008 [sequence.reqmts]/104, /108; used by flat_(multi)map::insert.
 #endif // _HAS_CXX23
 
 template <class _Elem, class _UTy>
diff --git a/stl/inc/xstring b/stl/inc/xstring
index 85f7f8a89fe..89b81ddddc5 100644
--- a/stl/inc/xstring
+++ b/stl/inc/xstring
@@ -3500,6 +3500,11 @@ namespace pmr {
     _EXPORT_STD using wstring   = basic_string<wchar_t>;
 } // namespace pmr
 #endif // _HAS_CXX17
+
+#if _HAS_CXX23
+template <class _Elem, class _Traits, class _Alloc>
+constexpr bool _Has_guaranteed_push_back<basic_string<_Elem, _Traits, _Alloc>> = true;
+#endif // _HAS_CXX23
 _STD_END
 
 #undef _ASAN_STRING_REMOVE

From 0e9009265cf4b1e06d3f2dc70787ad7224a563a2 Mon Sep 17 00:00:00 2001
From: Alex Guteniev <gutenev@gmail.com>
Date: Thu, 1 May 2025 01:02:25 -0700
Subject: [PATCH 052/134] `<flat_map>`: explain test failures caused by being
 moved-out (#5451)

Co-authored-by: seishun <vvnicholas@gmail.com>
---
 tests/libcxx/expected_results.txt | 18 ++++++++++++++----
 1 file changed, 14 insertions(+), 4 deletions(-)

diff --git a/tests/libcxx/expected_results.txt b/tests/libcxx/expected_results.txt
index 3625b6763d3..53cbe6b72d7 100644
--- a/tests/libcxx/expected_results.txt
+++ b/tests/libcxx/expected_results.txt
@@ -236,17 +236,23 @@ std/strings/c.strings/cuchar.compile.pass.cpp FAIL
 std/containers/container.adaptors/flat.map/flat.map.cons/deduct.pass.cpp FAIL
 std/containers/container.adaptors/flat.multimap/flat.multimap.cons/deduct.pass.cpp FAIL
 
-# FIXME! Assertion failed: mo.empty()
-std/containers/container.adaptors/flat.map/flat.map.cons/move_alloc.pass.cpp FAIL
-std/containers/container.adaptors/flat.multimap/flat.multimap.cons/move_alloc.pass.cpp FAIL
-
 # FIXME! Assertion failed: m.keys().size() == m.values().size()
+# [flat.map.defn] doesn't declare a move constructor, which seems to imply that moving from a flat_map should behave
+# as if the move constructor were implicitly defined, i.e. it can't restore the invariants
+# P2767R2 does not specify move constructor, which is broken
+# P3567R0 adds a move constructor that asks to restore invariants
+# P3567R0 constructor also moves comparator, which we should veto if it makes into the Standard
 std/containers/container.adaptors/flat.map/flat.map.cons/move_assign_clears.pass.cpp FAIL
 std/containers/container.adaptors/flat.map/flat.map.cons/move_exceptions.pass.cpp FAIL
 std/containers/container.adaptors/flat.multimap/flat.multimap.cons/move_assign_clears.pass.cpp FAIL
 std/containers/container.adaptors/flat.multimap/flat.multimap.cons/move_exceptions.pass.cpp FAIL
 
 # FIXME! abort() has been called
+# caused by insert failing when called on a moved-from flat_map due to its comparator being moved from,
+# but this seems to be in line with the specification: flat_map::insert transitively requires that the comparator
+# "induce a strict weak ordering on the values"
+# P2767R2 does not specify move constructor, which is broken
+# P3567R0 constructor is still asked to move comparator, which is also broken
 std/containers/container.adaptors/flat.map/flat.map.cons/move.pass.cpp FAIL
 std/containers/container.adaptors/flat.multimap/flat.multimap.cons/move.pass.cpp FAIL
 
@@ -591,6 +597,10 @@ std/depr/depr.c.headers/stddef_h.compile.pass.cpp:1 FAIL
 
 # *** LIKELY BOGUS TESTS ***
 
+# A moved-from flat_map is not empty, which doesn't seem to be required
+std/containers/container.adaptors/flat.map/flat.map.cons/move_alloc.pass.cpp FAIL
+std/containers/container.adaptors/flat.multimap/flat.multimap.cons/move_alloc.pass.cpp FAIL
+
 # Test bug after LWG-2899 "is_(nothrow_)move_constructible and tuple, optional and unique_ptr" was accepted.
 std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.pass.cpp FAIL
 std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.runtime.pass.cpp FAIL

From 9299901f28e74bdca6b71f96f721843e1e1596f9 Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34@live.cn>
Date: Fri, 2 May 2025 07:44:39 +0800
Subject: [PATCH 053/134] `<flat_map>`: Workaround for CWG-2369 in deduction
 guides (#5455)

---
 stl/inc/flat_map                  | 25 +++++++++++++++++--------
 tests/libcxx/expected_results.txt |  8 ++++----
 2 files changed, 21 insertions(+), 12 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index 4f417832f4d..ec993207511 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -29,8 +29,9 @@ _STL_DISABLE_CLANG_WARNINGS
 
 _STD_BEGIN
 template <class _Compare, class _Key_container>
-concept _Valid_compare_for_container = is_invocable_v<const _Compare&, const typename _Key_container::value_type&,
-    const typename _Key_container::value_type&>;
+concept _Valid_compare_for_container = _Not_allocator_for_container<_Compare>
+                                    && is_invocable_v<const _Compare&, const typename _Key_container::value_type&,
+                                        const typename _Key_container::value_type&>;
 
 template <class _Key, class _Mapped, class _KeyCompare>
 struct _Flat_map_value_compare_provider {
@@ -1378,8 +1379,9 @@ flat_map(sorted_unique_t, _InputIterator, _InputIterator, _Compare = _Compare())
     -> flat_map<_Guide_key_t<_InputIterator>, _Guide_val_t<_InputIterator>, _Compare>;
 
 #ifdef __cpp_lib_byte
+// TRANSITION, CWG-2369, should just use constrained template parameters.
 template <_RANGES input_range _Rng, _Not_allocator_for_container _Compare = less<_Range_key_type<_Rng>>,
-    _Allocator_for_container _Allocator = allocator<byte>>
+    class _Allocator = allocator<byte>, enable_if_t<_Allocator_for_container<_Allocator>, int> = 0>
 flat_map(from_range_t, _Rng&&, _Compare = _Compare(), _Allocator = _Allocator())
     -> flat_map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, _Compare,
         vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_key_type<_Rng>>>,
@@ -1389,13 +1391,16 @@ template <_RANGES input_range _Rng, _Not_allocator_for_container _Compare = less
 flat_map(from_range_t, _Rng&&, _Compare = _Compare()) -> flat_map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>,
     _Compare, vector<_Range_key_type<_Rng>>, vector<_Range_mapped_type<_Rng>>>;
 
-template <_RANGES input_range _Rng, _Not_allocator_for_container _Compare, _Allocator_for_container _Allocator>
+// TRANSITION, CWG-2369, should just use constrained template parameters.
+template <_RANGES input_range _Rng, _Not_allocator_for_container _Compare, class _Allocator,
+    enable_if_t<_Allocator_for_container<_Allocator>, int> = 0>
 flat_map(from_range_t, _Rng&&, _Compare, _Allocator) -> flat_map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>,
     _Compare, vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_key_type<_Rng>>>,
     vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_mapped_type<_Rng>>>>;
 #endif // ^^^ !defined(__cpp_lib_byte) ^^^
 
-template <_RANGES input_range _Rng, _Allocator_for_container _Allocator>
+// TRANSITION, CWG-2369, should just use constrained template parameters.
+template <_RANGES input_range _Rng, class _Allocator, enable_if_t<_Allocator_for_container<_Allocator>, int> = 0>
 flat_map(from_range_t, _Rng&&, _Allocator) -> flat_map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>,
     less<_Range_key_type<_Rng>>, vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_key_type<_Rng>>>,
     vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_mapped_type<_Rng>>>>;
@@ -1543,8 +1548,9 @@ flat_multimap(sorted_equivalent_t, _InputIterator, _InputIterator, _Compare = _C
     -> flat_multimap<_Guide_key_t<_InputIterator>, _Guide_val_t<_InputIterator>, _Compare>;
 
 #ifdef __cpp_lib_byte
+// TRANSITION, CWG-2369, should just use constrained template parameters.
 template <_RANGES input_range _Rng, _Not_allocator_for_container _Compare = less<_Range_key_type<_Rng>>,
-    _Allocator_for_container _Allocator = allocator<byte>>
+    class _Allocator = allocator<byte>, enable_if_t<_Allocator_for_container<_Allocator>, int> = 0>
 flat_multimap(from_range_t, _Rng&&, _Compare = _Compare(), _Allocator = _Allocator())
     -> flat_multimap<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, _Compare,
         vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_key_type<_Rng>>>,
@@ -1554,14 +1560,17 @@ template <_RANGES input_range _Rng, _Not_allocator_for_container _Compare = less
 flat_multimap(from_range_t, _Rng&&, _Compare = _Compare()) -> flat_multimap<_Range_key_type<_Rng>,
     _Range_mapped_type<_Rng>, _Compare, vector<_Range_key_type<_Rng>>, vector<_Range_mapped_type<_Rng>>>;
 
-template <_RANGES input_range _Rng, _Not_allocator_for_container _Compare, _Allocator_for_container _Allocator>
+// TRANSITION, CWG-2369, should just use constrained template parameters.
+template <_RANGES input_range _Rng, _Not_allocator_for_container _Compare, class _Allocator,
+    enable_if_t<_Allocator_for_container<_Allocator>, int> = 0>
 flat_multimap(from_range_t, _Rng&&, _Compare, _Allocator)
     -> flat_multimap<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, _Compare,
         vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_key_type<_Rng>>>,
         vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_mapped_type<_Rng>>>>;
 #endif // ^^^ !defined(__cpp_lib_byte) ^^^
 
-template <_RANGES input_range _Rng, _Allocator_for_container _Allocator>
+// TRANSITION, CWG-2369, should just use constrained template parameters.
+template <_RANGES input_range _Rng, class _Allocator, enable_if_t<_Allocator_for_container<_Allocator>, int> = 0>
 flat_multimap(from_range_t, _Rng&&, _Allocator) -> flat_multimap<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>,
     less<_Range_key_type<_Rng>>, vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_key_type<_Rng>>>,
     vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_mapped_type<_Rng>>>>;
diff --git a/tests/libcxx/expected_results.txt b/tests/libcxx/expected_results.txt
index 53cbe6b72d7..c8647ca92b3 100644
--- a/tests/libcxx/expected_results.txt
+++ b/tests/libcxx/expected_results.txt
@@ -232,10 +232,6 @@ std/strings/c.strings/cuchar.compile.pass.cpp FAIL
 
 # P0429R9 <flat_map>
 
-# FIXME! error: no type named 'value_type' in 'std::greater<int>'
-std/containers/container.adaptors/flat.map/flat.map.cons/deduct.pass.cpp FAIL
-std/containers/container.adaptors/flat.multimap/flat.multimap.cons/deduct.pass.cpp FAIL
-
 # FIXME! Assertion failed: m.keys().size() == m.values().size()
 # [flat.map.defn] doesn't declare a move constructor, which seems to imply that moving from a flat_map should behave
 # as if the move constructor were implicitly defined, i.e. it can't restore the invariants
@@ -259,6 +255,8 @@ std/containers/container.adaptors/flat.multimap/flat.multimap.cons/move.pass.cpp
 # FIXME! warning C4242: 'initializing': conversion from '_Ty' to '_Ty2', possible loss of data
 std/containers/container.adaptors/flat.map/flat.map.cons/copy_assign.pass.cpp:0 FAIL
 std/containers/container.adaptors/flat.map/flat.map.cons/copy_assign.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.map/flat.map.cons/deduct.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.map/flat.map.cons/deduct.pass.cpp:1 FAIL
 std/containers/container.adaptors/flat.map/flat.map.cons/deduct_pmr.pass.cpp:0 FAIL
 std/containers/container.adaptors/flat.map/flat.map.cons/deduct_pmr.pass.cpp:1 FAIL
 std/containers/container.adaptors/flat.map/flat.map.cons/initializer_list.pass.cpp:0 FAIL
@@ -283,6 +281,8 @@ std/containers/container.adaptors/flat.multimap/flat.multimap.cons/containers.pa
 std/containers/container.adaptors/flat.multimap/flat.multimap.cons/containers.pass.cpp:1 FAIL
 std/containers/container.adaptors/flat.multimap/flat.multimap.cons/copy_assign.pass.cpp:0 FAIL
 std/containers/container.adaptors/flat.multimap/flat.multimap.cons/copy_assign.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.multimap/flat.multimap.cons/deduct.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.multimap/flat.multimap.cons/deduct.pass.cpp:1 FAIL
 std/containers/container.adaptors/flat.multimap/flat.multimap.cons/deduct_pmr.pass.cpp:0 FAIL
 std/containers/container.adaptors/flat.multimap/flat.multimap.cons/deduct_pmr.pass.cpp:1 FAIL
 std/containers/container.adaptors/flat.multimap/flat.multimap.cons/initializer_list.pass.cpp:0 FAIL

From 5a1bf15210bf89f21abcf83163504d79682f174d Mon Sep 17 00:00:00 2001
From: Alex Guteniev <gutenev@gmail.com>
Date: Thu, 1 May 2025 21:43:41 -0700
Subject: [PATCH 054/134] `<flat_map>`: move invariants preserving (#5454)

Co-authored-by: Stephan T. Lavavej <stl@microsoft.com>
---
 stl/inc/flat_map                  | 62 +++++++++++++++++++++----------
 tests/libcxx/expected_results.txt | 24 ------------
 2 files changed, 42 insertions(+), 44 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index ec993207511..33f9e6f1567 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -443,34 +443,48 @@ public:
         : _Flat_map_base(_Tag, _Ilist, key_compare(), _Alloc) {}
 
     // Copy constructors
-    _Flat_map_base(const _Derived& _Other)
-        : _Key_compare(static_cast<const _Flat_map_base&>(_Other)._Key_compare),
-          _Data(static_cast<const _Flat_map_base&>(_Other)._Data) {}
+    _Flat_map_base(const _Flat_map_base& _Other) : _Key_compare(_Other._Key_compare), _Data(_Other._Data) {}
 
     template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
-    _Flat_map_base(const _Derived& _Other, const _Allocator& _Alloc)
-        : _Key_compare(static_cast<const _Flat_map_base&>(_Other)._Key_compare),
-          _Data{.keys = _STD make_obj_using_allocator<key_container_type>(
-                    _Alloc, static_cast<const _Flat_map_base&>(_Other)._Data.keys),
-              .values = _STD make_obj_using_allocator<mapped_container_type>(
-                  _Alloc, static_cast<const _Flat_map_base&>(_Other)._Data.values)} {}
+    _Flat_map_base(const _Flat_map_base& _Other, const _Allocator& _Alloc)
+        : _Key_compare(_Other._Key_compare),
+          _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Alloc, _Other._Data.keys),
+              .values = _STD make_obj_using_allocator<mapped_container_type>(_Alloc, _Other._Data.values)} {}
 
     // Move constructors
-    _Flat_map_base(_Derived&& _Other)
-        noexcept(is_nothrow_move_constructible_v<key_compare> && is_nothrow_move_constructible_v<key_container_type>
+    _Flat_map_base(_Flat_map_base&& _Other)
+        noexcept(is_nothrow_copy_constructible_v<key_compare> && is_nothrow_move_constructible_v<key_compare>
+                 && is_nothrow_move_constructible_v<key_container_type>
                  && is_nothrow_move_constructible_v<mapped_container_type>)
-        : _Key_compare(_STD move(static_cast<_Flat_map_base&>(_Other)._Key_compare)),
-          _Data(_STD move(static_cast<_Flat_map_base&>(_Other).extract())) {}
+        : _Key_compare(_Other._Key_compare), _Data(_STD move(_Other).extract()) {}
 
     template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
-    _Flat_map_base(_Derived&& _Other, const _Allocator& _Alloc)
-        noexcept(is_nothrow_move_constructible_v<key_compare> && is_nothrow_move_constructible_v<key_container_type>
+    _Flat_map_base(_Flat_map_base&& _Other, const _Allocator& _Alloc)
+        noexcept(is_nothrow_copy_constructible_v<key_compare> && is_nothrow_move_constructible_v<key_compare>
+                 && is_nothrow_move_constructible_v<key_container_type>
                  && is_nothrow_move_constructible_v<mapped_container_type>)
-        : _Key_compare(_STD move(static_cast<_Flat_map_base&>(_Other)._Key_compare)),
-          _Data{.keys = _STD make_obj_using_allocator<key_container_type>(
-                    _Alloc, _STD move(static_cast<_Flat_map_base&>(_Other)._Data.keys)),
-              .values = _STD make_obj_using_allocator<mapped_container_type>(
-                  _Alloc, _STD move(static_cast<_Flat_map_base&>(_Other)._Data.values))} {}
+        : _Key_compare(_Other._Key_compare), _Data{_Other._Extract_using_allocator(_Alloc)} {}
+
+    // Assignment
+    _Flat_map_base& operator=(const _Flat_map_base& _Other)
+        noexcept(is_nothrow_copy_assignable_v<key_compare> && is_nothrow_copy_assignable_v<key_container_type>
+                 && is_nothrow_copy_assignable_v<mapped_container_type>) {
+        _Clear_guard _Guard{this};
+        _Key_compare   = _Other._Key_compare;
+        _Data          = _Other._Data;
+        _Guard._Target = nullptr;
+        return *this;
+    }
+
+    _Flat_map_base& operator=(_Flat_map_base&& _Other) noexcept(
+        is_nothrow_copy_assignable_v<key_compare> && is_nothrow_move_assignable_v<key_compare>
+        && is_nothrow_move_assignable_v<key_container_type> && is_nothrow_move_assignable_v<mapped_container_type>) {
+        _Clear_guard _Guard{this};
+        _Key_compare   = _Other._Key_compare;
+        _Data          = _STD move(_Other).extract();
+        _Guard._Target = nullptr;
+        return *this;
+    }
 
     // [container.reqmts] iterators
     _NODISCARD iterator begin() noexcept {
@@ -632,6 +646,14 @@ public:
         return _STD move(_Data);
     }
 
+    template <class _Allocator>
+    containers _Extract_using_allocator(const _Allocator& _Alloc) noexcept(
+        is_nothrow_move_constructible_v<key_container_type> && is_nothrow_move_constructible_v<mapped_container_type>) {
+        _Clear_guard _Guard{this};
+        return containers{.keys = _STD make_obj_using_allocator<key_container_type>(_Alloc, _STD move(_Data.keys)),
+            .values = _STD make_obj_using_allocator<mapped_container_type>(_Alloc, _STD move(_Data.values))};
+    }
+
     void replace(key_container_type&& _Key_cont, mapped_container_type&& _Mapped_cont) {
         _Clear_guard _Guard{this};
         _Data.keys     = _STD move(_Key_cont);
diff --git a/tests/libcxx/expected_results.txt b/tests/libcxx/expected_results.txt
index c8647ca92b3..30ffd067ad3 100644
--- a/tests/libcxx/expected_results.txt
+++ b/tests/libcxx/expected_results.txt
@@ -232,26 +232,6 @@ std/strings/c.strings/cuchar.compile.pass.cpp FAIL
 
 # P0429R9 <flat_map>
 
-# FIXME! Assertion failed: m.keys().size() == m.values().size()
-# [flat.map.defn] doesn't declare a move constructor, which seems to imply that moving from a flat_map should behave
-# as if the move constructor were implicitly defined, i.e. it can't restore the invariants
-# P2767R2 does not specify move constructor, which is broken
-# P3567R0 adds a move constructor that asks to restore invariants
-# P3567R0 constructor also moves comparator, which we should veto if it makes into the Standard
-std/containers/container.adaptors/flat.map/flat.map.cons/move_assign_clears.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.cons/move_exceptions.pass.cpp FAIL
-std/containers/container.adaptors/flat.multimap/flat.multimap.cons/move_assign_clears.pass.cpp FAIL
-std/containers/container.adaptors/flat.multimap/flat.multimap.cons/move_exceptions.pass.cpp FAIL
-
-# FIXME! abort() has been called
-# caused by insert failing when called on a moved-from flat_map due to its comparator being moved from,
-# but this seems to be in line with the specification: flat_map::insert transitively requires that the comparator
-# "induce a strict weak ordering on the values"
-# P2767R2 does not specify move constructor, which is broken
-# P3567R0 constructor is still asked to move comparator, which is also broken
-std/containers/container.adaptors/flat.map/flat.map.cons/move.pass.cpp FAIL
-std/containers/container.adaptors/flat.multimap/flat.multimap.cons/move.pass.cpp FAIL
-
 # FIXME! warning C4242: 'initializing': conversion from '_Ty' to '_Ty2', possible loss of data
 std/containers/container.adaptors/flat.map/flat.map.cons/copy_assign.pass.cpp:0 FAIL
 std/containers/container.adaptors/flat.map/flat.map.cons/copy_assign.pass.cpp:1 FAIL
@@ -597,10 +577,6 @@ std/depr/depr.c.headers/stddef_h.compile.pass.cpp:1 FAIL
 
 # *** LIKELY BOGUS TESTS ***
 
-# A moved-from flat_map is not empty, which doesn't seem to be required
-std/containers/container.adaptors/flat.map/flat.map.cons/move_alloc.pass.cpp FAIL
-std/containers/container.adaptors/flat.multimap/flat.multimap.cons/move_alloc.pass.cpp FAIL
-
 # Test bug after LWG-2899 "is_(nothrow_)move_constructible and tuple, optional and unique_ptr" was accepted.
 std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.pass.cpp FAIL
 std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.runtime.pass.cpp FAIL

From 3252573a0bf289b360b4071a9c6ec3714c3b180c Mon Sep 17 00:00:00 2001
From: Alex Guteniev <gutenev@gmail.com>
Date: Fri, 2 May 2025 03:45:21 -0700
Subject: [PATCH 055/134] `<flat_map>`: drop bogus exception specifications
 (#5460)

---
 stl/inc/flat_map | 10 ++--------
 1 file changed, 2 insertions(+), 8 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index 33f9e6f1567..03a3033bcea 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -460,15 +460,10 @@ public:
 
     template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
     _Flat_map_base(_Flat_map_base&& _Other, const _Allocator& _Alloc)
-        noexcept(is_nothrow_copy_constructible_v<key_compare> && is_nothrow_move_constructible_v<key_compare>
-                 && is_nothrow_move_constructible_v<key_container_type>
-                 && is_nothrow_move_constructible_v<mapped_container_type>)
         : _Key_compare(_Other._Key_compare), _Data{_Other._Extract_using_allocator(_Alloc)} {}
 
     // Assignment
-    _Flat_map_base& operator=(const _Flat_map_base& _Other)
-        noexcept(is_nothrow_copy_assignable_v<key_compare> && is_nothrow_copy_assignable_v<key_container_type>
-                 && is_nothrow_copy_assignable_v<mapped_container_type>) {
+    _Flat_map_base& operator=(const _Flat_map_base& _Other) {
         _Clear_guard _Guard{this};
         _Key_compare   = _Other._Key_compare;
         _Data          = _Other._Data;
@@ -647,8 +642,7 @@ public:
     }
 
     template <class _Allocator>
-    containers _Extract_using_allocator(const _Allocator& _Alloc) noexcept(
-        is_nothrow_move_constructible_v<key_container_type> && is_nothrow_move_constructible_v<mapped_container_type>) {
+    containers _Extract_using_allocator(const _Allocator& _Alloc) {
         _Clear_guard _Guard{this};
         return containers{.keys = _STD make_obj_using_allocator<key_container_type>(_Alloc, _STD move(_Data.keys)),
             .values = _STD make_obj_using_allocator<mapped_container_type>(_Alloc, _STD move(_Data.values))};

From d2e3e14a19661cd77d3da10363ca35f6d9f8cefa Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34@live.cn>
Date: Sat, 3 May 2025 01:15:10 +0800
Subject: [PATCH 056/134] `<flat_set>`: Fix some significant bugs caught by
 latest libcxx tests (#5465)

---
 stl/inc/algorithm |   5 +-
 stl/inc/flat_map  |   5 --
 stl/inc/flat_set  | 159 +++++++++++++++++++++++++++-------------------
 stl/inc/vector    |   5 ++
 4 files changed, 101 insertions(+), 73 deletions(-)

diff --git a/stl/inc/algorithm b/stl/inc/algorithm
index 5da863e79a1..d96ecabc8c9 100644
--- a/stl/inc/algorithm
+++ b/stl/inc/algorithm
@@ -8238,14 +8238,13 @@ void inplace_merge(_BidIt _First, _BidIt _Mid, _BidIt _Last, _Pr _Pred) {
 
     ++_ULast;
 
-    using _Diff         = _Iter_diff_t<_BidIt>;
-    const _Diff _Count1 = _STD distance(_UFirst, _UMid);
+    const auto _Count1 = _STD distance(_UFirst, _UMid);
     if (_Count1 == 1) { // rotate only element remaining in left partition to the end, without allocating
         _STD _Rotate_one_left(_UFirst, _UMid, _ULast);
         return;
     }
 
-    const _Diff _Count2 = _STD distance(_UMid, _ULast);
+    const auto _Count2 = _STD distance(_UMid, _ULast);
     _Optimistic_temporary_buffer<_Iter_value_t<_BidIt>> _Temp_buf{(_STD min)(_Count1, _Count2)};
     _STD _Buffered_inplace_merge_unchecked_impl(
         _UFirst, _UMid, _ULast, _Count1, _Count2, _Temp_buf._Data, _Temp_buf._Capacity, _STD _Pass_fn(_Pred));
diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index 03a3033bcea..dfc2acc2512 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -28,11 +28,6 @@ _STL_DISABLE_CLANG_WARNINGS
 #undef new
 
 _STD_BEGIN
-template <class _Compare, class _Key_container>
-concept _Valid_compare_for_container = _Not_allocator_for_container<_Compare>
-                                    && is_invocable_v<const _Compare&, const typename _Key_container::value_type&,
-                                        const typename _Key_container::value_type&>;
-
 template <class _Key, class _Mapped, class _KeyCompare>
 struct _Flat_map_value_compare_provider {
     struct value_compare {
diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index 8e911ee6227..33b914d4479 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -94,16 +94,16 @@ public:
     explicit _Base_flat_set(const _Alloc& _Al)
         : _Mycont(_STD make_obj_using_allocator<container_type>(_Al)), _Mycomp() {}
 
-    template <input_iterator _Iter>
+    template <_Iterator_for_container _Iter>
     _Base_flat_set(_Iter _First, _Iter _Last, const key_compare& _Comp = key_compare())
         : _Base_flat_set(container_type(_First, _Last), _Comp) {}
-    template <input_iterator _Iter, _Usable_allocator_for<container_type> _Alloc>
+    template <_Iterator_for_container _Iter, _Usable_allocator_for<container_type> _Alloc>
     _Base_flat_set(_Iter _First, _Iter _Last, const key_compare& _Comp, const _Alloc& _Al)
         : _Mycont(_STD make_obj_using_allocator<container_type>(_Al)), _Mycomp(_Comp) {
         _Mycont.assign(_First, _Last);
         _Make_invariants_fulfilled();
     }
-    template <input_iterator _Iter, _Usable_allocator_for<container_type> _Alloc>
+    template <_Iterator_for_container _Iter, _Usable_allocator_for<container_type> _Alloc>
     _Base_flat_set(_Iter _First, _Iter _Last, const _Alloc& _Al)
         : _Mycont(_STD make_obj_using_allocator<container_type>(_Al)), _Mycomp() {
         _Mycont.assign(_First, _Last);
@@ -129,13 +129,13 @@ public:
         _Make_invariants_fulfilled();
     }
 
-    template <input_iterator _Iter>
+    template <_Iterator_for_container _Iter>
     _Base_flat_set(_Tsorted _Tsort, _Iter _First, _Iter _Last, const key_compare& _Comp = key_compare())
         : _Base_flat_set(_Tsort, container_type(_First, _Last), _Comp) {}
-    template <input_iterator _Iter, _Usable_allocator_for<container_type> _Alloc>
+    template <_Iterator_for_container _Iter, _Usable_allocator_for<container_type> _Alloc>
     _Base_flat_set(_Tsorted _Tsort, _Iter _First, _Iter _Last, const key_compare& _Comp, const _Alloc& _Al)
         : _Base_flat_set(_Tsort, _STD make_obj_using_allocator<container_type>(_Al, _First, _Last), _Comp) {}
-    template <input_iterator _Iter, _Usable_allocator_for<container_type> _Alloc>
+    template <_Iterator_for_container _Iter, _Usable_allocator_for<container_type> _Alloc>
     _Base_flat_set(_Tsorted _Tsort, _Iter _First, _Iter _Last, const _Alloc& _Al)
         : _Base_flat_set(_Tsort, _STD make_obj_using_allocator<container_type>(_Al, _First, _Last)) {}
 
@@ -208,10 +208,10 @@ public:
     }
 
     _NODISCARD const_iterator cbegin() const noexcept {
-        return _Mycont.cbegin();
+        return _Mycont.begin();
     }
     _NODISCARD const_iterator cend() const noexcept {
-        return _Mycont.cend();
+        return _Mycont.end();
     }
     _NODISCARD const_reverse_iterator crbegin() const noexcept {
         return rbegin();
@@ -277,11 +277,11 @@ public:
         return _Emplace_hint(_Hint, _STD forward<_Other>(_Val));
     }
 
-    template <input_iterator _Iter>
+    template <_Iterator_for_container _Iter>
     void insert(_Iter _First, _Iter _Last) {
         _Insert_range<false>(_First, _Last);
     }
-    template <input_iterator _Iter>
+    template <_Iterator_for_container _Iter>
     void insert(_Tsorted, _Iter _First, _Iter _Last) {
         _Insert_range<true>(_First, _Last);
     }
@@ -447,7 +447,7 @@ private:
     }
 
     _NODISCARD bool _Is_sorted(const container_type& _Cont) const {
-        return _Is_sorted(_Cont.cbegin(), _Cont.cend());
+        return _Is_sorted(_Cont.begin(), _Cont.end());
     }
 
     static constexpr const char* _Msg_not_sorted = _Multi ? "Input was not sorted!" : "Input was not sorted-unique!";
@@ -678,6 +678,14 @@ public:
     flat_set(const flat_set&) = default;
     flat_set(flat_set&&)      = default;
 
+#if 1 // TRANSITION, P2582R1 (MSVC, Clang, EDG)
+    template <_Usable_allocator_for<_Container> _Allocator>
+    flat_set(const flat_set& _Other, const _Allocator& _Al) : _Mybase(_Other, _Al) {}
+
+    template <_Usable_allocator_for<_Container> _Allocator>
+    flat_set(flat_set&& _Other, const _Allocator& _Al) : _Mybase(_STD move(_Other), _Al) {}
+#endif // ^^^ workaround ^^^
+
     using _Mybase::operator=;
     flat_set& operator=(const flat_set&) = default;
     flat_set& operator=(flat_set&&)      = default;
@@ -694,6 +702,14 @@ public:
     flat_multiset(const flat_multiset&) = default;
     flat_multiset(flat_multiset&&)      = default;
 
+#if 1 // TRANSITION, P2582R1 (MSVC, Clang, EDG)
+    template <_Usable_allocator_for<_Container> _Allocator>
+    flat_multiset(const flat_multiset& _Other, const _Allocator& _Al) : _Mybase(_Other, _Al) {}
+
+    template <_Usable_allocator_for<_Container> _Allocator>
+    flat_multiset(flat_multiset&& _Other, const _Allocator& _Al) : _Mybase(_STD move(_Other), _Al) {}
+#endif // ^^^ workaround ^^^
+
     using _Mybase::operator=;
     flat_multiset& operator=(const flat_multiset&) = default;
     flat_multiset& operator=(flat_multiset&&)      = default;
@@ -727,76 +743,89 @@ template <class _Kty, class _Keylt, class _Container, class _Alloc>
 struct uses_allocator<flat_multiset<_Kty, _Keylt, _Container>, _Alloc>
     : bool_constant<uses_allocator_v<_Container, _Alloc>> {};
 
-template <class _Container, class _Keylt = less<typename _Container::value_type>>
-flat_set(_Container, _Keylt = _Keylt()) -> flat_set<typename _Container::value_type, _Keylt, _Container>;
-template <class _Container, class _Alloc>
+template <_Not_allocator_for_container _Container,
+    _Valid_compare_for_container<_Container> _Compare = less<typename _Container::value_type>>
+flat_set(_Container, _Compare = _Compare()) -> flat_set<typename _Container::value_type, _Compare, _Container>;
+template <_Not_allocator_for_container _Container, _Usable_allocator_for<_Container> _Alloc>
 flat_set(_Container, _Alloc)
     -> flat_set<typename _Container::value_type, less<typename _Container::value_type>, _Container>;
-template <class _Container, class _Keylt, class _Alloc>
-flat_set(_Container, _Keylt, _Alloc) -> flat_set<typename _Container::value_type, _Keylt, _Container>;
-
-template <class _Container, class _Keylt = less<typename _Container::value_type>>
-flat_set(sorted_unique_t, _Container, _Keylt = _Keylt())
-    -> flat_set<typename _Container::value_type, _Keylt, _Container>;
-template <class _Container, class _Alloc>
+template <_Not_allocator_for_container _Container, _Valid_compare_for_container<_Container> _Compare,
+    _Usable_allocator_for<_Container> _Alloc>
+flat_set(_Container, _Compare, _Alloc) -> flat_set<typename _Container::value_type, _Compare, _Container>;
+
+template <_Not_allocator_for_container _Container,
+    _Valid_compare_for_container<_Container> _Compare = less<typename _Container::value_type>>
+flat_set(sorted_unique_t, _Container, _Compare = _Compare())
+    -> flat_set<typename _Container::value_type, _Compare, _Container>;
+template <_Not_allocator_for_container _Container, _Usable_allocator_for<_Container> _Alloc>
 flat_set(sorted_unique_t, _Container, _Alloc)
     -> flat_set<typename _Container::value_type, less<typename _Container::value_type>, _Container>;
-template <class _Container, class _Keylt, class _Alloc>
-flat_set(sorted_unique_t, _Container, _Keylt, _Alloc) -> flat_set<typename _Container::value_type, _Keylt, _Container>;
-
-template <class _Iter, class _Keylt = less<iter_value_t<_Iter>>>
-flat_set(_Iter, _Iter, _Keylt = _Keylt()) -> flat_set<iter_value_t<_Iter>, _Keylt>;
-template <class _Iter, class _Keylt = less<iter_value_t<_Iter>>>
-flat_set(sorted_unique_t, _Iter, _Iter, _Keylt = _Keylt()) -> flat_set<iter_value_t<_Iter>, _Keylt>;
-template <_RANGES input_range _Range, class _Keylt = less<_RANGES range_value_t<_Range>>,
-    class _Alloc = allocator<_RANGES range_value_t<_Range>>>
-flat_set(from_range_t, _Range&&, _Keylt = _Keylt(), _Alloc = _Alloc()) -> flat_set<_RANGES range_value_t<_Range>,
-    _Keylt, vector<_RANGES range_value_t<_Range>, _Rebind_alloc_t<_Alloc, _RANGES range_value_t<_Range>>>>;
-template <_RANGES input_range _Range, class _Alloc>
+template <_Not_allocator_for_container _Container, _Valid_compare_for_container<_Container> _Compare,
+    _Usable_allocator_for<_Container> _Alloc>
+flat_set(sorted_unique_t, _Container, _Compare, _Alloc)
+    -> flat_set<typename _Container::value_type, _Compare, _Container>;
+
+template <_Iterator_for_container _Iter, _Not_allocator_for_container _Compare = less<iter_value_t<_Iter>>>
+flat_set(_Iter, _Iter, _Compare = _Compare()) -> flat_set<iter_value_t<_Iter>, _Compare>;
+template <_Iterator_for_container _Iter, _Not_allocator_for_container _Compare = less<iter_value_t<_Iter>>>
+flat_set(sorted_unique_t, _Iter, _Iter, _Compare = _Compare()) -> flat_set<iter_value_t<_Iter>, _Compare>;
+// TRANSITION, CWG-2369, should just use constrained template parameters.
+template <_RANGES input_range _Range, _Not_allocator_for_container _Compare = less<_RANGES range_value_t<_Range>>,
+    class _Alloc = allocator<_RANGES range_value_t<_Range>>, enable_if_t<_Allocator_for_container<_Alloc>, int> = 0>
+flat_set(from_range_t, _Range&&, _Compare = _Compare(), _Alloc = _Alloc()) -> flat_set<_RANGES range_value_t<_Range>,
+    _Compare, vector<_RANGES range_value_t<_Range>, _Rebind_alloc_t<_Alloc, _RANGES range_value_t<_Range>>>>;
+// TRANSITION, CWG-2369, should just use constrained template parameters.
+template <_RANGES input_range _Range, class _Alloc, enable_if_t<_Allocator_for_container<_Alloc>, int> = 0>
 flat_set(from_range_t, _Range&&, _Alloc) -> flat_set<_RANGES range_value_t<_Range>, less<_RANGES range_value_t<_Range>>,
     vector<_RANGES range_value_t<_Range>, _Rebind_alloc_t<_Alloc, _RANGES range_value_t<_Range>>>>;
-template <class _Kty, class _Keylt = less<_Kty>>
-flat_set(initializer_list<_Kty>, _Keylt = _Keylt()) -> flat_set<_Kty, _Keylt>;
-template <class _Kty, class _Keylt = less<_Kty>>
-flat_set(sorted_unique_t, initializer_list<_Kty>, _Keylt = _Keylt()) -> flat_set<_Kty, _Keylt>;
+template <class _Kty, _Not_allocator_for_container _Compare = less<_Kty>>
+flat_set(initializer_list<_Kty>, _Compare = _Compare()) -> flat_set<_Kty, _Compare>;
+template <class _Kty, _Not_allocator_for_container _Compare = less<_Kty>>
+flat_set(sorted_unique_t, initializer_list<_Kty>, _Compare = _Compare()) -> flat_set<_Kty, _Compare>;
 
 
-template <class _Container, class _Keylt = less<typename _Container::value_type>>
-flat_multiset(_Container, _Keylt = _Keylt()) -> flat_multiset<typename _Container::value_type, _Keylt, _Container>;
-template <class _Container, class _Alloc>
+template <_Not_allocator_for_container _Container,
+    _Valid_compare_for_container<_Container> _Compare = less<typename _Container::value_type>>
+flat_multiset(_Container, _Compare = _Compare())
+    -> flat_multiset<typename _Container::value_type, _Compare, _Container>;
+template <_Not_allocator_for_container _Container, _Usable_allocator_for<_Container> _Alloc>
 flat_multiset(_Container, _Alloc)
     -> flat_multiset<typename _Container::value_type, less<typename _Container::value_type>, _Container>;
-template <class _Container, class _Keylt, class _Alloc>
-flat_multiset(_Container, _Keylt, _Alloc) -> flat_multiset<typename _Container::value_type, _Keylt, _Container>;
-
-template <class _Container, class _Keylt = less<typename _Container::value_type>>
-flat_multiset(sorted_equivalent_t, _Container, _Keylt = _Keylt())
-    -> flat_multiset<typename _Container::value_type, _Keylt, _Container>;
-template <class _Container, class _Alloc>
+template <_Not_allocator_for_container _Container, _Valid_compare_for_container<_Container> _Compare,
+    _Usable_allocator_for<_Container> _Alloc>
+flat_multiset(_Container, _Compare, _Alloc) -> flat_multiset<typename _Container::value_type, _Compare, _Container>;
+
+template <_Not_allocator_for_container _Container,
+    _Valid_compare_for_container<_Container> _Compare = less<typename _Container::value_type>>
+flat_multiset(sorted_equivalent_t, _Container, _Compare = _Compare())
+    -> flat_multiset<typename _Container::value_type, _Compare, _Container>;
+template <_Not_allocator_for_container _Container, _Usable_allocator_for<_Container> _Alloc>
 flat_multiset(sorted_equivalent_t, _Container, _Alloc)
     -> flat_multiset<typename _Container::value_type, less<typename _Container::value_type>, _Container>;
-template <class _Container, class _Keylt, class _Alloc>
-flat_multiset(sorted_equivalent_t, _Container, _Keylt, _Alloc)
-    -> flat_multiset<typename _Container::value_type, _Keylt, _Container>;
-
-template <class _Iter, class _Keylt = less<iter_value_t<_Iter>>>
-flat_multiset(_Iter, _Iter, _Keylt = _Keylt()) -> flat_multiset<iter_value_t<_Iter>, iter_value_t<_Iter>, _Keylt>;
-template <class _Iter, class _Keylt = less<iter_value_t<_Iter>>>
-flat_multiset(sorted_equivalent_t, _Iter, _Iter, _Keylt = _Keylt())
-    -> flat_multiset<iter_value_t<_Iter>, iter_value_t<_Iter>, _Keylt>;
-template <_RANGES input_range _Range, class _Keylt = less<_RANGES range_value_t<_Range>>,
-    class _Alloc = allocator<_RANGES range_value_t<_Range>>>
-flat_multiset(from_range_t, _Range&&, _Keylt = _Keylt(), _Alloc = _Alloc())
-    -> flat_multiset<_RANGES range_value_t<_Range>, _Keylt,
+template <_Not_allocator_for_container _Container, _Valid_compare_for_container<_Container> _Compare,
+    _Usable_allocator_for<_Container> _Alloc>
+flat_multiset(sorted_equivalent_t, _Container, _Compare, _Alloc)
+    -> flat_multiset<typename _Container::value_type, _Compare, _Container>;
+
+template <_Iterator_for_container _Iter, _Not_allocator_for_container _Compare = less<iter_value_t<_Iter>>>
+flat_multiset(_Iter, _Iter, _Compare = _Compare()) -> flat_multiset<iter_value_t<_Iter>, _Compare>;
+template <_Iterator_for_container _Iter, _Not_allocator_for_container _Compare = less<iter_value_t<_Iter>>>
+flat_multiset(sorted_equivalent_t, _Iter, _Iter, _Compare = _Compare()) -> flat_multiset<iter_value_t<_Iter>, _Compare>;
+// TRANSITION, CWG-2369, should just use constrained template parameters.
+template <_RANGES input_range _Range, _Not_allocator_for_container _Compare = less<_RANGES range_value_t<_Range>>,
+    class _Alloc = allocator<_RANGES range_value_t<_Range>>, enable_if_t<_Allocator_for_container<_Alloc>, int> = 0>
+flat_multiset(from_range_t, _Range&&, _Compare = _Compare(), _Alloc = _Alloc())
+    -> flat_multiset<_RANGES range_value_t<_Range>, _Compare,
         vector<_RANGES range_value_t<_Range>, _Rebind_alloc_t<_Alloc, _RANGES range_value_t<_Range>>>>;
-template <_RANGES input_range _Range, class _Alloc>
+// TRANSITION, CWG-2369, should just use constrained template parameters.
+template <_RANGES input_range _Range, class _Alloc, enable_if_t<_Allocator_for_container<_Alloc>, int> = 0>
 flat_multiset(from_range_t, _Range&&, _Alloc)
     -> flat_multiset<_RANGES range_value_t<_Range>, less<_RANGES range_value_t<_Range>>,
         vector<_RANGES range_value_t<_Range>, _Rebind_alloc_t<_Alloc, _RANGES range_value_t<_Range>>>>;
-template <class _Kty, class _Keylt = less<_Kty>>
-flat_multiset(initializer_list<_Kty>, _Keylt = _Keylt()) -> flat_multiset<_Kty, _Keylt>;
-template <class _Kty, class _Keylt = less<_Kty>>
-flat_multiset(sorted_equivalent_t, initializer_list<_Kty>, _Keylt = _Keylt()) -> flat_multiset<_Kty, _Keylt>;
+template <class _Kty, _Not_allocator_for_container _Compare = less<_Kty>>
+flat_multiset(initializer_list<_Kty>, _Compare = _Compare()) -> flat_multiset<_Kty, _Compare>;
+template <class _Kty, _Not_allocator_for_container _Compare = less<_Kty>>
+flat_multiset(sorted_equivalent_t, initializer_list<_Kty>, _Compare = _Compare()) -> flat_multiset<_Kty, _Compare>;
 
 _STD_END
 
diff --git a/stl/inc/vector b/stl/inc/vector
index 6baa169fcde..56d420f2b4c 100644
--- a/stl/inc/vector
+++ b/stl/inc/vector
@@ -4022,6 +4022,11 @@ constexpr bool _Has_guaranteed_push_back<vector<_Ty, _Alloc>> = !is_same_v<_Ty,
 template <class _Alloc, class... _Containers>
 concept _Usable_allocator_for = (uses_allocator_v<_Containers, _Alloc> && ...);
 
+template <class _Compare, class _KeyContainer>
+concept _Valid_compare_for_container = _Not_allocator_for_container<_Compare>
+                                    && is_invocable_v<const _Compare&, const typename _KeyContainer::value_type&,
+                                        const typename _KeyContainer::value_type&>;
+
 template <class _Ty>
 struct _NODISCARD _Clear_guard {
     _Ty* _Target;

From 3280d7e3334f1b03f3e293a3355bf187397547a3 Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34@live.cn>
Date: Sat, 10 May 2025 01:17:54 +0800
Subject: [PATCH 057/134] Make implementation details of `flat_meow` more
 similar (#5474)

---
 stl/inc/flat_map |  29 ++---
 stl/inc/flat_set | 330 +++++++++++++++++++++++------------------------
 2 files changed, 179 insertions(+), 180 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index dfc2acc2512..de1f84945ee 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -319,7 +319,7 @@ public:
     template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
     _Flat_map_base(
         const key_container_type& _Key_cont, const mapped_container_type& _Mapped_cont, const _Allocator& _Alloc)
-        : _Flat_map_base(_Sorted_t(), _Key_cont, _Mapped_cont, _Alloc) {
+        : _Flat_map_base(_Sorted_t{}, _Key_cont, _Mapped_cont, _Alloc) {
         _Sort();
         if constexpr (_IsUnique) {
             _Dedup();
@@ -329,7 +329,7 @@ public:
     template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
     _Flat_map_base(const key_container_type& _Key_cont, const mapped_container_type& _Mapped_cont,
         const key_compare& _Comp, const _Allocator& _Alloc)
-        : _Flat_map_base(_Sorted_t(), _Key_cont, _Mapped_cont, _Comp, _Alloc) {
+        : _Flat_map_base(_Sorted_t{}, _Key_cont, _Mapped_cont, _Comp, _Alloc) {
         _Sort();
         if constexpr (_IsUnique) {
             _Dedup();
@@ -395,18 +395,17 @@ public:
     }
 
     template <_Iterator_for_container _InputIterator>
-    _Flat_map_base(
-        _Sorted_t _Tag, _InputIterator _First, _InputIterator _Last, const key_compare& _Comp = key_compare())
+    _Flat_map_base(_Sorted_t, _InputIterator _First, _InputIterator _Last, const key_compare& _Comp = key_compare())
         : _Flat_map_base(_Comp) {
-        insert(_Tag, _First, _Last);
+        _Insert_range<false>(_First, _Last);
     }
 
     template <_Iterator_for_container _InputIterator,
         _Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
     _Flat_map_base(
-        _Sorted_t _Tag, _InputIterator _First, _InputIterator _Last, const key_compare& _Comp, const _Allocator& _Alloc)
+        _Sorted_t, _InputIterator _First, _InputIterator _Last, const key_compare& _Comp, const _Allocator& _Alloc)
         : _Flat_map_base(_Comp, _Alloc) {
-        insert(_Tag, _First, _Last);
+        _Insert_range<false>(_First, _Last);
     }
 
     template <_Iterator_for_container _InputIterator,
@@ -579,25 +578,25 @@ public:
 
     template <_Iterator_for_container _InputIterator>
     void insert(_InputIterator _First, _InputIterator _Last) {
-        _Insert_range<true, _IsUnique>(_First, _Last);
+        _Insert_range<true>(_First, _Last);
     }
 
     template <_Iterator_for_container _InputIterator>
     void insert(_Sorted_t, _InputIterator _First, _InputIterator _Last) {
-        _Insert_range<false, _IsUnique>(_First, _Last);
+        _Insert_range<false>(_First, _Last);
     }
 
     template <_Container_compatible_range<value_type> _Rng>
     void insert_range(_Rng&& _Range) {
-        _Insert_range<true, _IsUnique>(_RANGES begin(_Range), _RANGES end(_Range));
+        _Insert_range<true>(_RANGES begin(_Range), _RANGES end(_Range));
     }
 
     void insert(initializer_list<value_type> _Ilist) {
-        insert(_Ilist.begin(), _Ilist.end());
+        _Insert_range<true>(_Ilist.begin(), _Ilist.end());
     }
 
-    void insert(_Sorted_t _Tag, initializer_list<value_type> _Ilist) {
-        insert(_Tag, _Ilist.begin(), _Ilist.end());
+    void insert(_Sorted_t, initializer_list<value_type> _Ilist) {
+        _Insert_range<false>(_Ilist.begin(), _Ilist.end());
     }
 
     iterator erase(iterator _Position) {
@@ -943,7 +942,7 @@ private:
         _Guard._Target = nullptr;
     }
 
-    template <bool _NeedSorting, bool _NeedDeduping, class _InputIterator, class _Sentinel>
+    template <bool _NeedSorting, class _InputIterator, class _Sentinel>
     void _Insert_range(_InputIterator _First, _Sentinel _Last) {
         _Clear_guard _Guard{this};
 
@@ -976,7 +975,7 @@ private:
         // Merge the newly inserted elements with the existing elements
         _RANGES inplace_merge(_Sorted_view, _Sorted_view.begin() + _Old_distance, value_compare(_Key_compare));
 
-        if constexpr (_NeedDeduping) {
+        if constexpr (_IsUnique) {
             _Dedup();
         }
 
diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index 33b914d4479..ea04da753e7 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -24,10 +24,21 @@ _STL_DISABLE_CLANG_WARNINGS
 #undef new
 
 _STD_BEGIN
-template <class _Kty, class _Keylt, class _Container, bool _Multi, class _Deriv, class _Tsorted>
-class _Base_flat_set {
+_EXPORT_STD template <class _Kty, class _Keylt = less<_Kty>, class _Container = vector<_Kty>>
+class flat_set;
+
+_EXPORT_STD template <class _Kty, class _Keylt = less<_Kty>, class _Container = vector<_Kty>>
+class flat_multiset;
+
+template <bool _IsUnique, class _Kty, class _Keylt, class _Container>
+class _Flat_set_base {
 private:
-    static constexpr bool _Keylt_transparent = _Is_transparent_v<_Keylt>;
+    using _Sorted_t = conditional_t<_IsUnique, sorted_unique_t, sorted_equivalent_t>;
+    using _Derived =
+        conditional_t<_IsUnique, flat_set<_Kty, _Keylt, _Container>, flat_multiset<_Kty, _Keylt, _Container>>;
+
+    static constexpr bool _Keylt_transparent     = _Is_transparent_v<_Keylt>;
+    static constexpr const char* _Msg_not_sorted = _IsUnique ? "Input was not sorted-unique!" : "Input was not sorted!";
 
 public:
     static_assert(same_as<_Kty, typename _Container::value_type>,
@@ -53,124 +64,124 @@ public:
     static_assert(random_access_iterator<iterator>, "The C++ Standard forbids containers without random "
                                                     "access iterators from being adapted. See [flatset.overview].");
 
-    _Base_flat_set() : _Mycont(), _Mycomp() {}
+    _Flat_set_base() : _Mycont(), _Mycomp() {}
 
     template <_Usable_allocator_for<container_type> _Alloc>
-    _Base_flat_set(const _Deriv& _Set, const _Alloc& _Al)
+    _Flat_set_base(const _Derived& _Set, const _Alloc& _Al)
         : _Mycont(_STD make_obj_using_allocator<container_type>(_Al, _Set._Mycont)), _Mycomp(_Set._Mycomp) {}
     template <_Usable_allocator_for<container_type> _Alloc>
-    _Base_flat_set(_Deriv&& _Set, const _Alloc& _Al)
+    _Flat_set_base(_Derived&& _Set, const _Alloc& _Al)
         : _Mycont(_STD make_obj_using_allocator<container_type>(_Al, _STD move(_Set).extract())),
           _Mycomp(_Set._Mycomp) // intentionally copy comparator, see LWG-2227
     {}
 
-    explicit _Base_flat_set(container_type _Cont, const key_compare& _Comp = key_compare())
+    explicit _Flat_set_base(container_type _Cont, const key_compare& _Comp = key_compare())
         : _Mycont(_STD move(_Cont)), _Mycomp(_Comp) {
         _Make_invariants_fulfilled();
     }
     template <_Usable_allocator_for<container_type> _Alloc>
-    _Base_flat_set(const container_type& _Cont, const _Alloc& _Al)
-        : _Base_flat_set(_STD make_obj_using_allocator<container_type>(_Al, _Cont)) {}
+    _Flat_set_base(const container_type& _Cont, const _Alloc& _Al)
+        : _Flat_set_base(_STD make_obj_using_allocator<container_type>(_Al, _Cont)) {}
     template <_Usable_allocator_for<container_type> _Alloc>
-    _Base_flat_set(const container_type& _Cont, const key_compare& _Comp, const _Alloc& _Al)
-        : _Base_flat_set(_STD make_obj_using_allocator<container_type>(_Al, _Cont), _Comp) {}
+    _Flat_set_base(const container_type& _Cont, const key_compare& _Comp, const _Alloc& _Al)
+        : _Flat_set_base(_STD make_obj_using_allocator<container_type>(_Al, _Cont), _Comp) {}
 
-    _Base_flat_set(_Tsorted, container_type _Cont, const key_compare& _Comp = key_compare())
+    _Flat_set_base(_Sorted_t, container_type _Cont, const key_compare& _Comp = key_compare())
         : _Mycont(_STD move(_Cont)), _Mycomp(_Comp) {
         _STL_ASSERT(_Is_sorted(_Mycont), _Msg_not_sorted);
     }
     template <_Usable_allocator_for<container_type> _Alloc>
-    _Base_flat_set(_Tsorted _Tsort, const container_type& _Cont, const _Alloc& _Al)
-        : _Base_flat_set(_Tsort, _STD make_obj_using_allocator<container_type>(_Al, _Cont)) {}
+    _Flat_set_base(_Sorted_t _Tag, const container_type& _Cont, const _Alloc& _Al)
+        : _Flat_set_base(_Tag, _STD make_obj_using_allocator<container_type>(_Al, _Cont)) {}
     template <_Usable_allocator_for<container_type> _Alloc>
-    _Base_flat_set(_Tsorted _Tsort, const container_type& _Cont, const key_compare& _Comp, const _Alloc& _Al)
-        : _Base_flat_set(_Tsort, _STD make_obj_using_allocator<container_type>(_Al, _Cont), _Comp) {}
+    _Flat_set_base(_Sorted_t _Tag, const container_type& _Cont, const key_compare& _Comp, const _Alloc& _Al)
+        : _Flat_set_base(_Tag, _STD make_obj_using_allocator<container_type>(_Al, _Cont), _Comp) {}
 
-    explicit _Base_flat_set(const key_compare& _Comp) : _Mycont(), _Mycomp(_Comp) {}
+    explicit _Flat_set_base(const key_compare& _Comp) : _Mycont(), _Mycomp(_Comp) {}
     template <_Usable_allocator_for<container_type> _Alloc>
-    _Base_flat_set(const key_compare& _Comp, const _Alloc& _Al)
+    _Flat_set_base(const key_compare& _Comp, const _Alloc& _Al)
         : _Mycont(_STD make_obj_using_allocator<container_type>(_Al)), _Mycomp(_Comp) {}
     template <_Usable_allocator_for<container_type> _Alloc>
-    explicit _Base_flat_set(const _Alloc& _Al)
+    explicit _Flat_set_base(const _Alloc& _Al)
         : _Mycont(_STD make_obj_using_allocator<container_type>(_Al)), _Mycomp() {}
 
     template <_Iterator_for_container _Iter>
-    _Base_flat_set(_Iter _First, _Iter _Last, const key_compare& _Comp = key_compare())
-        : _Base_flat_set(container_type(_First, _Last), _Comp) {}
+    _Flat_set_base(_Iter _First, _Iter _Last, const key_compare& _Comp = key_compare())
+        : _Flat_set_base(container_type(_First, _Last), _Comp) {}
     template <_Iterator_for_container _Iter, _Usable_allocator_for<container_type> _Alloc>
-    _Base_flat_set(_Iter _First, _Iter _Last, const key_compare& _Comp, const _Alloc& _Al)
+    _Flat_set_base(_Iter _First, _Iter _Last, const key_compare& _Comp, const _Alloc& _Al)
         : _Mycont(_STD make_obj_using_allocator<container_type>(_Al)), _Mycomp(_Comp) {
         _Mycont.assign(_First, _Last);
         _Make_invariants_fulfilled();
     }
     template <_Iterator_for_container _Iter, _Usable_allocator_for<container_type> _Alloc>
-    _Base_flat_set(_Iter _First, _Iter _Last, const _Alloc& _Al)
+    _Flat_set_base(_Iter _First, _Iter _Last, const _Alloc& _Al)
         : _Mycont(_STD make_obj_using_allocator<container_type>(_Al)), _Mycomp() {
         _Mycont.assign(_First, _Last);
         _Make_invariants_fulfilled();
     }
 
     template <_Container_compatible_range<_Kty> _Rng>
-    _Base_flat_set(from_range_t, _Rng&& _Range)
-        : _Base_flat_set(container_type(from_range, _STD forward<_Rng>(_Range))) {}
+    _Flat_set_base(from_range_t, _Rng&& _Range)
+        : _Flat_set_base(container_type(from_range, _STD forward<_Rng>(_Range))) {}
     template <_Container_compatible_range<_Kty> _Rng, _Usable_allocator_for<container_type> _Alloc>
-    _Base_flat_set(from_range_t, _Rng&& _Range, const _Alloc& _Al)
+    _Flat_set_base(from_range_t, _Rng&& _Range, const _Alloc& _Al)
         : _Mycont(_STD make_obj_using_allocator<container_type>(_Al)), _Mycomp() {
         _Mycont.assign_range(_STD forward<_Rng>(_Range));
         _Make_invariants_fulfilled();
     }
     template <_Container_compatible_range<_Kty> _Rng>
-    _Base_flat_set(from_range_t, _Rng&& _Range, const key_compare& _Comp)
-        : _Base_flat_set(container_type(from_range, _STD forward<_Rng>(_Range)), _Comp) {}
+    _Flat_set_base(from_range_t, _Rng&& _Range, const key_compare& _Comp)
+        : _Flat_set_base(container_type(from_range, _STD forward<_Rng>(_Range)), _Comp) {}
     template <_Container_compatible_range<_Kty> _Rng, _Usable_allocator_for<container_type> _Alloc>
-    _Base_flat_set(from_range_t, _Rng&& _Range, const key_compare& _Comp, const _Alloc& _Al)
+    _Flat_set_base(from_range_t, _Rng&& _Range, const key_compare& _Comp, const _Alloc& _Al)
         : _Mycont(_STD make_obj_using_allocator<container_type>(_Al)), _Mycomp(_Comp) {
         _Mycont.assign_range(_STD forward<_Rng>(_Range));
         _Make_invariants_fulfilled();
     }
 
     template <_Iterator_for_container _Iter>
-    _Base_flat_set(_Tsorted _Tsort, _Iter _First, _Iter _Last, const key_compare& _Comp = key_compare())
-        : _Base_flat_set(_Tsort, container_type(_First, _Last), _Comp) {}
+    _Flat_set_base(_Sorted_t _Tag, _Iter _First, _Iter _Last, const key_compare& _Comp = key_compare())
+        : _Flat_set_base(_Tag, container_type(_First, _Last), _Comp) {}
     template <_Iterator_for_container _Iter, _Usable_allocator_for<container_type> _Alloc>
-    _Base_flat_set(_Tsorted _Tsort, _Iter _First, _Iter _Last, const key_compare& _Comp, const _Alloc& _Al)
-        : _Base_flat_set(_Tsort, _STD make_obj_using_allocator<container_type>(_Al, _First, _Last), _Comp) {}
+    _Flat_set_base(_Sorted_t _Tag, _Iter _First, _Iter _Last, const key_compare& _Comp, const _Alloc& _Al)
+        : _Flat_set_base(_Tag, _STD make_obj_using_allocator<container_type>(_Al, _First, _Last), _Comp) {}
     template <_Iterator_for_container _Iter, _Usable_allocator_for<container_type> _Alloc>
-    _Base_flat_set(_Tsorted _Tsort, _Iter _First, _Iter _Last, const _Alloc& _Al)
-        : _Base_flat_set(_Tsort, _STD make_obj_using_allocator<container_type>(_Al, _First, _Last)) {}
+    _Flat_set_base(_Sorted_t _Tag, _Iter _First, _Iter _Last, const _Alloc& _Al)
+        : _Flat_set_base(_Tag, _STD make_obj_using_allocator<container_type>(_Al, _First, _Last)) {}
 
-    _Base_flat_set(initializer_list<_Kty> _Ilist, const key_compare& _Comp = key_compare())
-        : _Base_flat_set(container_type(_Ilist), _Comp) {}
+    _Flat_set_base(initializer_list<_Kty> _Ilist, const key_compare& _Comp = key_compare())
+        : _Flat_set_base(container_type(_Ilist), _Comp) {}
     template <_Usable_allocator_for<container_type> _Alloc>
-    _Base_flat_set(initializer_list<_Kty> _Ilist, const key_compare& _Comp, const _Alloc& _Al)
-        : _Base_flat_set(_Ilist.begin(), _Ilist.end(), _Comp, _Al) {}
+    _Flat_set_base(initializer_list<_Kty> _Ilist, const key_compare& _Comp, const _Alloc& _Al)
+        : _Flat_set_base(_Ilist.begin(), _Ilist.end(), _Comp, _Al) {}
     template <_Usable_allocator_for<container_type> _Alloc>
-    _Base_flat_set(initializer_list<_Kty> _Ilist, const _Alloc& _Al)
-        : _Base_flat_set(_Ilist.begin(), _Ilist.end(), _Al) {}
+    _Flat_set_base(initializer_list<_Kty> _Ilist, const _Alloc& _Al)
+        : _Flat_set_base(_Ilist.begin(), _Ilist.end(), _Al) {}
 
-    _Base_flat_set(_Tsorted _Tsort, initializer_list<_Kty> _Ilist, const key_compare& _Comp = key_compare())
-        : _Base_flat_set(_Tsort, container_type(_Ilist), _Comp) {}
+    _Flat_set_base(_Sorted_t _Tag, initializer_list<_Kty> _Ilist, const key_compare& _Comp = key_compare())
+        : _Flat_set_base(_Tag, container_type(_Ilist), _Comp) {}
     template <_Usable_allocator_for<container_type> _Alloc>
-    _Base_flat_set(_Tsorted _Tsort, initializer_list<_Kty> _Ilist, const key_compare& _Comp, const _Alloc& _Al)
-        : _Base_flat_set(_Tsort, _Ilist.begin(), _Ilist.end(), _Comp, _Al) {}
+    _Flat_set_base(_Sorted_t _Tag, initializer_list<_Kty> _Ilist, const key_compare& _Comp, const _Alloc& _Al)
+        : _Flat_set_base(_Tag, _Ilist.begin(), _Ilist.end(), _Comp, _Al) {}
     template <_Usable_allocator_for<container_type> _Alloc>
-    _Base_flat_set(_Tsorted _Tsort, initializer_list<_Kty> _Ilist, const _Alloc& _Al)
-        : _Base_flat_set(_Tsort, _Ilist.begin(), _Ilist.end(), _Al) {}
+    _Flat_set_base(_Sorted_t _Tag, initializer_list<_Kty> _Ilist, const _Alloc& _Al)
+        : _Flat_set_base(_Tag, _Ilist.begin(), _Ilist.end(), _Al) {}
 
-    _Base_flat_set(const _Base_flat_set&) = default;
-    _Base_flat_set(_Base_flat_set&& _Other) noexcept(
+    _Flat_set_base(const _Flat_set_base&) = default;
+    _Flat_set_base(_Flat_set_base&& _Other) noexcept(
         is_nothrow_move_constructible_v<container_type> && is_nothrow_copy_constructible_v<key_compare>) // strengthened
         : _Mycont(_STD move(_Other).extract()), _Mycomp(_Other._Mycomp) // intentionally copy comparator, see LWG-2227
     {}
 
-    _Base_flat_set& operator=(const _Base_flat_set& _Other) {
+    _Flat_set_base& operator=(const _Flat_set_base& _Other) {
         _Clear_guard<container_type> _Guard{_STD addressof(_Mycont)};
         _Mycont        = _Other._Mycont;
         _Mycomp        = _Other._Mycomp;
         _Guard._Target = nullptr;
         return *this;
     }
-    _Base_flat_set& operator=(_Base_flat_set&& _Other) noexcept(
+    _Flat_set_base& operator=(_Flat_set_base&& _Other) noexcept(
         is_nothrow_move_assignable_v<container_type> && is_nothrow_copy_assignable_v<key_compare>) // strengthened
     {
         if (this != _STD addressof(_Other)) {
@@ -183,12 +194,12 @@ public:
         return *this;
     }
 
-    _Deriv& operator=(initializer_list<_Kty> _Ilist) {
+    _Derived& operator=(initializer_list<_Kty> _Ilist) {
         _Clear_guard<container_type> _Guard{_STD addressof(_Mycont)};
         _Mycont.assign(_Ilist);
         _Make_invariants_fulfilled();
         _Guard._Target = nullptr;
-        return static_cast<_Deriv&>(*this);
+        return static_cast<_Derived&>(*this);
     }
 
     // iterators
@@ -260,7 +271,7 @@ public:
         return _Emplace(_STD move(_Val));
     }
     template <_Different_from<_Kty> _Other>
-        requires (!_Multi && _Keylt_transparent && is_constructible_v<_Kty, _Other>)
+        requires _IsUnique && _Keylt_transparent && is_constructible_v<_Kty, _Other>
     auto insert(_Other&& _Val) {
         return _Emplace(_STD forward<_Other>(_Val));
     }
@@ -272,18 +283,18 @@ public:
         return _Emplace_hint(_Hint, _STD move(_Val));
     }
     template <_Different_from<_Kty> _Other>
-        requires (!_Multi && _Keylt_transparent && is_constructible_v<_Kty, _Other>)
+        requires _IsUnique && _Keylt_transparent && is_constructible_v<_Kty, _Other>
     iterator insert(const_iterator _Hint, _Other&& _Val) {
         return _Emplace_hint(_Hint, _STD forward<_Other>(_Val));
     }
 
     template <_Iterator_for_container _Iter>
     void insert(_Iter _First, _Iter _Last) {
-        _Insert_range<false>(_First, _Last);
+        _Insert_range<true>(_First, _Last);
     }
     template <_Iterator_for_container _Iter>
-    void insert(_Tsorted, _Iter _First, _Iter _Last) {
-        _Insert_range<true>(_First, _Last);
+    void insert(_Sorted_t, _Iter _First, _Iter _Last) {
+        _Insert_range<false>(_First, _Last);
     }
     template <_Container_compatible_range<_Kty> _Rng>
     void insert_range(_Rng&& _Range) {
@@ -294,15 +305,15 @@ public:
         } else {
             _Mycont.insert_range(_Mycont.end(), _STD forward<_Rng>(_Range));
         }
-        _Restore_invariants_after_insert<false>(_Old_size);
+        _Restore_invariants_after_insert<true>(_Old_size);
     }
 
     void insert(initializer_list<_Kty> _Ilist) {
-        _Insert_range<false>(_Ilist.begin(), _Ilist.end());
-    }
-    void insert(_Tsorted, initializer_list<_Kty> _Ilist) {
         _Insert_range<true>(_Ilist.begin(), _Ilist.end());
     }
+    void insert(_Sorted_t, initializer_list<_Kty> _Ilist) {
+        _Insert_range<false>(_Ilist.begin(), _Ilist.end());
+    }
 
     _NODISCARD container_type extract() && noexcept(
         is_nothrow_move_constructible_v<container_type>) /* strengthened */ {
@@ -333,7 +344,7 @@ public:
         return _Mycont.erase(_First, _Last);
     }
 
-    void swap(_Deriv& _Other) noexcept {
+    void swap(_Derived& _Other) noexcept {
         _RANGES swap(_Mycomp, _Other._Mycomp);
         _RANGES swap(_Mycont, _Other._Mycont);
     }
@@ -365,11 +376,11 @@ public:
     }
 
     _NODISCARD size_type count(const _Kty& _Val) const {
-        if constexpr (_Multi) {
+        if constexpr (_IsUnique) {
+            return contains(_Val);
+        } else {
             const auto [_First, _Last] = equal_range(_Val);
             return static_cast<size_type>(_Last - _First);
-        } else {
-            return contains(_Val);
         }
     }
     template <class _Other>
@@ -415,24 +426,22 @@ public:
         return _STD equal_range(cbegin(), cend(), _Val, _Pass_comp());
     }
 
-    _NODISCARD friend bool operator==(const _Deriv& _Lhs, const _Deriv& _Rhs) {
+    _NODISCARD friend bool operator==(const _Derived& _Lhs, const _Derived& _Rhs) {
         return _RANGES equal(_Lhs._Mycont, _Rhs._Mycont);
     }
 
-    _NODISCARD friend auto operator<=>(const _Deriv& _Lhs, const _Deriv& _Rhs) {
+    _NODISCARD friend auto operator<=>(const _Derived& _Lhs, const _Derived& _Rhs) {
         return _STD lexicographical_compare_three_way(
             _Lhs.cbegin(), _Lhs.cend(), _Rhs.cbegin(), _Rhs.cend(), _Synth_three_way{});
     }
 
-    friend void swap(_Deriv& _Lhs, _Deriv& _Rhs) noexcept {
+    friend void swap(_Derived& _Lhs, _Derived& _Rhs) noexcept {
         _Lhs.swap(_Rhs);
     }
 
 private:
     _NODISCARD bool _Is_sorted(const_iterator _It, const const_iterator _End) const {
-        if constexpr (_Multi) {
-            return _STD is_sorted(_It, _End, _Pass_comp());
-        } else {
+        if constexpr (_IsUnique) {
             // sorted-unique
             if (_It == _End) {
                 return true;
@@ -443,6 +452,8 @@ private:
                 }
             }
             return true;
+        } else {
+            return _STD is_sorted(_It, _End, _Pass_comp());
         }
     }
 
@@ -450,133 +461,124 @@ private:
         return _Is_sorted(_Cont.begin(), _Cont.end());
     }
 
-    static constexpr const char* _Msg_not_sorted = _Multi ? "Input was not sorted!" : "Input was not sorted-unique!";
-
     template <class _Ty>
     _NODISCARD bool _Can_insert(const const_iterator _Where, const _Ty& _Val) const {
         _STL_INTERNAL_STATIC_ASSERT(is_same_v<_Ty, _Kty>); // only accepts _Kty
 
         // check that _Val can be inserted before _Where
-        if constexpr (_Multi) {
-            // check that _Where is the upper_bound for _Val
-            // equivalent to checking *(_Where-1) <= _Val < *_Where
-            return (_Where == cend() || _Compare(_Val, *_Where))
-                && (_Where == cbegin() || !_Compare(_Val, *(_Where - 1)));
-        } else {
+        if constexpr (_IsUnique) {
             // check that _Where is the lower_bound for _Val, and *_Where is not equivalent to _Val
             // equivalent to checking *(_Where-1) < _Val < *_Where
             return (_Where == cend() || _Compare(_Val, *_Where))
                 && (_Where == cbegin() || _Compare(*(_Where - 1), _Val));
+        } else {
+            // check that _Where is the upper_bound for _Val
+            // equivalent to checking *(_Where-1) <= _Val < *_Where
+            return (_Where == cend() || _Compare(_Val, *_Where))
+                && (_Where == cbegin() || !_Compare(_Val, *(_Where - 1)));
         }
     }
 
     template <class _Ty>
-        requires _Multi // flat_multiset
-    _NODISCARD iterator _Emplace(_Ty&& _Val) {
-        _STL_INTERNAL_STATIC_ASSERT(is_same_v<remove_cvref_t<_Ty>, _Kty>);
-        return _Mycont.emplace(upper_bound(_Val), _STD forward<_Ty>(_Val));
-    }
-
-    template <class _Ty>
-        requires (!_Multi) // flat_set
-    _NODISCARD pair<iterator, bool> _Emplace(_Ty&& _Val) {
-        const const_iterator _Where = lower_bound(_Val);
-        if (_Where != cend() && !_Compare(_Val, *_Where)) {
-            return pair{_Where, false};
-        }
+    _NODISCARD conditional_t<_IsUnique, pair<iterator, bool>, iterator> _Emplace(_Ty&& _Val) {
+        if constexpr (_IsUnique) {
+            const const_iterator _Where = lower_bound(_Val);
+            if (_Where != cend() && !_Compare(_Val, *_Where)) {
+                return pair{_Where, false};
+            }
 
-        if constexpr (is_same_v<remove_cvref_t<_Ty>, _Kty>) {
-            _STL_INTERNAL_CHECK(_Can_insert(_Where, _Val));
-            return pair{_Mycont.emplace(_Where, _STD forward<_Ty>(_Val)), true};
+            if constexpr (is_same_v<remove_cvref_t<_Ty>, _Kty>) {
+                _STL_INTERNAL_CHECK(_Can_insert(_Where, _Val));
+                return pair{_Mycont.emplace(_Where, _STD forward<_Ty>(_Val)), true};
+            } else {
+                // heterogeneous insertion
+                // FIXME: The standard only requires `find(_Val) == find(_Keyval)` (per N4958 [flat.set.modifiers]/2),
+                // which cannot guarantee `_Can_insert(_Where, _Keyval)`.
+                _STL_INTERNAL_STATIC_ASSERT(_Keylt_transparent && is_constructible_v<_Kty, _Ty>);
+                _Kty _Keyval(_STD forward<_Ty>(_Val));
+                _STL_ASSERT(_Can_insert(_Where, _Keyval),
+                    "The conversion from the heterogeneous key to key_type should "
+                    "be consistent with the heterogeneous lookup!");
+                return pair{_Mycont.emplace(_Where, _STD move(_Keyval)), true};
+            }
         } else {
-            // heterogeneous insertion
-            // FIXME: The standard only requires `find(_Val) == find(_Keyval)` (per N4958 [flat.set.modifiers]/2),
-            // which cannot guarantee `_Can_insert(_Where, _Keyval)`.
-            _STL_INTERNAL_STATIC_ASSERT(_Keylt_transparent && is_constructible_v<_Kty, _Ty>);
-            _Kty _Keyval(_STD forward<_Ty>(_Val));
-            _STL_ASSERT(_Can_insert(_Where, _Keyval), "The conversion from the heterogeneous key to key_type should "
-                                                      "be consistent with the heterogeneous lookup!");
-            return pair{_Mycont.emplace(_Where, _STD move(_Keyval)), true};
+            _STL_INTERNAL_STATIC_ASSERT(is_same_v<remove_cvref_t<_Ty>, _Kty>);
+            return _Mycont.emplace(upper_bound(_Val), _STD forward<_Ty>(_Val));
         }
     }
 
     template <class _Ty>
-        requires _Multi // flat_multiset
     _NODISCARD iterator _Emplace_hint(const_iterator _Where, _Ty&& _Val) {
-        _STL_INTERNAL_STATIC_ASSERT(is_same_v<remove_cvref_t<_Ty>, _Kty>);
-
         const const_iterator _Begin = cbegin();
         const const_iterator _End   = cend();
 
-        // look for upper_bound(_Val)
-        if (_Where == _End || _Compare(_Val, *_Where)) {
-            // _Val < *_Where
-            if (_Where == _Begin || !_Compare(_Val, *(_Where - 1))) {
-                // _Val >= *(_Where-1) ~ upper_bound is _Where
+        if constexpr (_IsUnique) {
+            // look for lower_bound(_Val)
+            if (_Where == _End || !_Compare(*_Where, _Val)) {
+                // _Val <= *_Where
+                if (_Where == _Begin || _Compare(*(_Where - 1), _Val)) {
+                    // _Val > *(_Where-1) ~ lower_bound is _Where
+                } else {
+                    // _Val <= *(_Where-1) ~ lower_bound is in [_Begin,_Where-1]
+                    _Where = _STD lower_bound(_Begin, _Where - 1, _Val, _Pass_comp());
+                }
             } else {
-                // _Val < *(_Where-1) ~ upper_bound is in [_Begin,_Where-1]
-                _Where = _STD upper_bound(_Begin, _Where - 1, _Val, _Pass_comp());
+                // _Val > *_Where ~ lower_bound is in [_Where+1,_End]
+                _Where = _STD lower_bound(_Where + 1, _End, _Val, _Pass_comp());
             }
-        } else {
-            // _Val >= *_Where ~ upper_bound is in [_Where+1,_End]
-            _Where = _STD upper_bound(_Where + 1, _End, _Val, _Pass_comp());
-        }
-
-        _STL_INTERNAL_CHECK(_Can_insert(_Where, _Val));
-        return _Mycont.emplace(_Where, _STD forward<_Ty>(_Val));
-    }
 
-    template <class _Ty>
-        requires (!_Multi) // flat_set
-    _NODISCARD iterator _Emplace_hint(const_iterator _Where, _Ty&& _Val) {
-        const const_iterator _Begin = cbegin();
-        const const_iterator _End   = cend();
+            if (_Where != _End && !_Compare(_Val, *_Where)) {
+                return _Where;
+            }
 
-        // look for lower_bound(_Val)
-        if (_Where == _End || !_Compare(*_Where, _Val)) {
-            // _Val <= *_Where
-            if (_Where == _Begin || _Compare(*(_Where - 1), _Val)) {
-                // _Val > *(_Where-1) ~ lower_bound is _Where
+            if constexpr (is_same_v<remove_cvref_t<_Ty>, _Kty>) {
+                _STL_INTERNAL_CHECK(_Can_insert(_Where, _Val));
+                return _Mycont.emplace(_Where, _STD forward<_Ty>(_Val));
             } else {
-                // _Val <= *(_Where-1) ~ lower_bound is in [_Begin,_Where-1]
-                _Where = _STD lower_bound(_Begin, _Where - 1, _Val, _Pass_comp());
+                // heterogeneous insertion
+                // FIXME: The standard only requires `find(_Val) == find(_Keyval)` (per N4958 [flat.set.modifiers]/2),
+                // which cannot guarantee `_Can_insert(_Where, _Keyval)`.
+                _STL_INTERNAL_STATIC_ASSERT(_Keylt_transparent && is_constructible_v<_Kty, _Ty>);
+                _Kty _Keyval(_STD forward<_Ty>(_Val));
+                _STL_ASSERT(_Can_insert(_Where, _Keyval),
+                    "The conversion from the heterogeneous key to key_type should "
+                    "be consistent with the heterogeneous lookup!");
+                return _Mycont.emplace(_Where, _STD move(_Keyval));
             }
         } else {
-            // _Val > *_Where ~ lower_bound is in [_Where+1,_End]
-            _Where = _STD lower_bound(_Where + 1, _End, _Val, _Pass_comp());
-        }
-
-        if (_Where != _End && !_Compare(_Val, *_Where)) {
-            return _Where;
-        }
+            _STL_INTERNAL_STATIC_ASSERT(is_same_v<remove_cvref_t<_Ty>, _Kty>);
+
+            // look for upper_bound(_Val)
+            if (_Where == _End || _Compare(_Val, *_Where)) {
+                // _Val < *_Where
+                if (_Where == _Begin || !_Compare(_Val, *(_Where - 1))) {
+                    // _Val >= *(_Where-1) ~ upper_bound is _Where
+                } else {
+                    // _Val < *(_Where-1) ~ upper_bound is in [_Begin,_Where-1]
+                    _Where = _STD upper_bound(_Begin, _Where - 1, _Val, _Pass_comp());
+                }
+            } else {
+                // _Val >= *_Where ~ upper_bound is in [_Where+1,_End]
+                _Where = _STD upper_bound(_Where + 1, _End, _Val, _Pass_comp());
+            }
 
-        if constexpr (is_same_v<remove_cvref_t<_Ty>, _Kty>) {
             _STL_INTERNAL_CHECK(_Can_insert(_Where, _Val));
             return _Mycont.emplace(_Where, _STD forward<_Ty>(_Val));
-        } else {
-            // heterogeneous insertion
-            // FIXME: The standard only requires `find(_Val) == find(_Keyval)` (per N4958 [flat.set.modifiers]/2),
-            // which cannot guarantee `_Can_insert(_Where, _Keyval)`.
-            _STL_INTERNAL_STATIC_ASSERT(_Keylt_transparent && is_constructible_v<_Kty, _Ty>);
-            _Kty _Keyval(_STD forward<_Ty>(_Val));
-            _STL_ASSERT(_Can_insert(_Where, _Keyval), "The conversion from the heterogeneous key to key_type should "
-                                                      "be consistent with the heterogeneous lookup!");
-            return _Mycont.emplace(_Where, _STD move(_Keyval));
         }
     }
 
-    template <bool _Presorted, class _Iter>
+    template <bool _NeedSorting, class _Iter>
     void _Insert_range(const _Iter _First, const _Iter _Last) {
         const size_type _Old_size = size();
         _Mycont.insert(_Mycont.end(), _First, _Last);
-        _Restore_invariants_after_insert<_Presorted>(_Old_size);
+        _Restore_invariants_after_insert<_NeedSorting>(_Old_size);
     }
 
     template <class _Ty>
     _NODISCARD size_type _Erase(const _Ty& _Val) {
         _STL_INTERNAL_STATIC_ASSERT(_Keylt_transparent || is_same_v<_Ty, _Kty>);
 
-        if constexpr (!_Multi && is_same_v<_Ty, _Kty>) {
+        if constexpr (_IsUnique && is_same_v<_Ty, _Kty>) {
             const const_iterator _Where = lower_bound(_Val);
             if (_Where != cend() && !_Compare(_Val, *_Where)) {
                 _Mycont.erase(_Where);
@@ -606,7 +608,7 @@ private:
     }
 
     void _Erase_dupes_if_not_multi() {
-        if constexpr (!_Multi) {
+        if constexpr (_IsUnique) {
             const auto _Equivalent = [this](const _Kty& _Lhs, const _Kty& _Rhs) {
                 return !_Compare(_Lhs, _Rhs) && !_Compare(_Rhs, _Lhs);
             };
@@ -615,13 +617,13 @@ private:
         }
     }
 
-    template <bool _Presorted>
+    template <bool _NeedSorting>
     void _Restore_invariants_after_insert(const size_type _Old_size) {
         const auto _Begin   = _Mycont.begin();
         const auto _Old_end = _Begin + static_cast<difference_type>(_Old_size);
         const auto _End     = _Mycont.end();
 
-        if constexpr (!_Presorted) {
+        if constexpr (_NeedSorting) {
             _STD sort(_Old_end, _End, _Pass_comp());
         } else {
             _STL_ASSERT(_Is_sorted(_Old_end, _End), _Msg_not_sorted);
@@ -667,11 +669,10 @@ private:
     /* [[no_unique_address]] */ key_compare _Mycomp;
 };
 
-_EXPORT_STD template <class _Kty, class _Keylt = less<_Kty>, class _Container = vector<_Kty>>
-class flat_set
-    : public _Base_flat_set<_Kty, _Keylt, _Container, false, flat_set<_Kty, _Keylt, _Container>, sorted_unique_t> {
+_EXPORT_STD template <class _Kty, class _Keylt, class _Container>
+class flat_set : public _Flat_set_base<true, _Kty, _Keylt, _Container> {
 private:
-    using _Mybase = _Base_flat_set<_Kty, _Keylt, _Container, false, flat_set, sorted_unique_t>;
+    using _Mybase = _Flat_set_base<true, _Kty, _Keylt, _Container>;
 
 public:
     using _Mybase::_Mybase;
@@ -691,11 +692,10 @@ public:
     flat_set& operator=(flat_set&&)      = default;
 };
 
-_EXPORT_STD template <class _Kty, class _Keylt = less<_Kty>, class _Container = vector<_Kty>>
-class flat_multiset : public _Base_flat_set<_Kty, _Keylt, _Container, true, flat_multiset<_Kty, _Keylt, _Container>,
-                          sorted_equivalent_t> {
+_EXPORT_STD template <class _Kty, class _Keylt, class _Container>
+class flat_multiset : public _Flat_set_base<false, _Kty, _Keylt, _Container> {
 private:
-    using _Mybase = _Base_flat_set<_Kty, _Keylt, _Container, true, flat_multiset, sorted_equivalent_t>;
+    using _Mybase = _Flat_set_base<false, _Kty, _Keylt, _Container>;
 
 public:
     using _Mybase::_Mybase;

From d05e29c05fd4007f2ece6a6f45ee7653a6d11502 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Sat, 10 May 2025 05:59:54 -0700
Subject: [PATCH 058/134] Categorize flat_set failures.

---
 tests/libcxx/expected_results.txt | 152 +++++++-----------------------
 1 file changed, 32 insertions(+), 120 deletions(-)

diff --git a/tests/libcxx/expected_results.txt b/tests/libcxx/expected_results.txt
index 6989abece23..0622a48722c 100644
--- a/tests/libcxx/expected_results.txt
+++ b/tests/libcxx/expected_results.txt
@@ -314,144 +314,56 @@ std/numerics/numeric.ops/numeric.ops.sat/sub_sat.compile.pass.cpp FAIL
 std/numerics/numeric.ops/numeric.ops.sat/sub_sat.pass.cpp FAIL
 
 # P1222R4 <flat_set>
+
+# FIXME! error: no member named 'assign' in 'MinSequenceContainer<int>'
 std/containers/container.adaptors/flat.multiset/flat.multiset.capacity/empty.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.capacity/max_size.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.capacity/size.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.cons/alloc.pass.cpp FAIL
 std/containers/container.adaptors/flat.multiset/flat.multiset.cons/assign_initializer_list.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.cons/compare.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.cons/containers.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.cons/copy_alloc.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.cons/copy_assign.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.cons/copy.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.cons/deduct_pmr.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.cons/deduct.compile.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.cons/deduct.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.cons/default.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.cons/dtor_noexcept.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.cons/initializer_list.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.cons/iter_iter.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.cons/move_alloc.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.cons/move_assign.pass.cpp FAIL
+std/containers/container.adaptors/flat.set/flat.set.capacity/empty.pass.cpp FAIL
+std/containers/container.adaptors/flat.set/flat.set.cons/assign_initializer_list.pass.cpp FAIL
+
+# FIXME! error: no member named 'insert_range' in 'MinSequenceContainer<int>'
+std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_range.pass.cpp FAIL
+std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_range.pass.cpp FAIL
+
+# FIXME! error: static assertion failed due to requirement '!std::is_nothrow_move_constructible_v<std::flat_MEOW<int, ThrowingMoveComp, std::vector<int, std::allocator<int>>>>'
 std/containers/container.adaptors/flat.multiset/flat.multiset.cons/move.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.cons/pmr.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.cons/range.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.cons/sorted_container.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.cons/sorted_initializer_list.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.cons/sorted_iter_iter.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.erasure/erase_if_exceptions.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.erasure/erase_if.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.iterators/iterator_comparison.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.iterators/iterator_concept_conformance.compile.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.iterators/iterator.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.iterators/range_concept_conformance.compile.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.iterators/reverse_iterator.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/clear.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/emplace_hint.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/emplace.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/erase_iter_iter.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/erase_iter.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/erase_key_transparent.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/erase_key.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/extract.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_cv.pass.cpp FAIL
+std/containers/container.adaptors/flat.set/flat.set.cons/move.pass.cpp FAIL
+
+# FIXME! error: call to implicitly-deleted copy constructor of 'container_type' (aka 'MoveAssignThrows')
+std/containers/container.adaptors/flat.multiset/flat.multiset.cons/move_assign.pass.cpp FAIL
+std/containers/container.adaptors/flat.set/flat.set.cons/move_assign.pass.cpp FAIL
+
+# FIXME! Assertion failed: std::is_sorted(m.begin(), m.end(), m.key_comp())
 std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_initializer_list.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_iter_cv.pass.cpp FAIL
 std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_iter_iter.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_iter_rv.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_range.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_rv.pass.cpp FAIL
 std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_sorted_initializer_list.pass.cpp FAIL
 std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_sorted_iter_iter.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/replace.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/swap_free.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/swap_member.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.observers/comp.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.operations/contains_transparent.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.operations/contains.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.operations/count_transparent.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.operations/count.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.operations/equal_range_transparent.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.operations/equal_range.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.operations/find_transparent.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.operations/find.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.operations/lower_bound_transparent.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.operations/lower_bound.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.operations/upper_bound_transparent.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.operations/upper_bound.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/incomplete_type.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/op_compare.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/types.compile.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.capacity/empty.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.capacity/max_size.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.capacity/size.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.cons/alloc.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.cons/assign_initializer_list.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.cons/compare.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.cons/containers.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.cons/copy_alloc.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.cons/copy_assign.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.cons/copy.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.cons/deduct_pmr.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.cons/deduct.compile.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.cons/deduct.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.cons/default.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.cons/dtor_noexcept.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.cons/initializer_list.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.cons/iter_iter.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.cons/move_alloc.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.cons/move_assign.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.cons/move.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.cons/pmr.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.cons/range.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.cons/sorted_container.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.cons/sorted_initializer_list.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.cons/sorted_iter_iter.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.erasure/erase_if_exceptions.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.erasure/erase_if.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.iterators/iterator_comparison.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.iterators/iterator_concept_conformance.compile.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.iterators/iterator.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.iterators/range_concept_conformance.compile.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.iterators/reverse_iterator.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.modifiers/clear.pass.cpp FAIL
 std/containers/container.adaptors/flat.set/flat.set.modifiers/emplace_hint.pass.cpp FAIL
 std/containers/container.adaptors/flat.set/flat.set.modifiers/emplace.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.modifiers/erase_iter_iter.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.modifiers/erase_iter.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.modifiers/erase_key_transparent.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.modifiers/erase_key.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.modifiers/extract.pass.cpp FAIL
 std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_cv.pass.cpp FAIL
 std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_initializer_list.pass.cpp FAIL
 std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_iter_cv.pass.cpp FAIL
 std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_iter_iter.pass.cpp FAIL
 std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_iter_rv.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_range.pass.cpp FAIL
 std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_rv.pass.cpp FAIL
 std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_sorted_initializer_list.pass.cpp FAIL
 std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_sorted_iter_iter.pass.cpp FAIL
 std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_transparent.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.modifiers/replace.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.modifiers/swap_free.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.modifiers/swap_member.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.observers/comp.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.operations/contains_transparent.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.operations/contains.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.operations/count_transparent.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.operations/count.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.operations/equal_range_transparent.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.operations/equal_range.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.operations/find_transparent.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.operations/find.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.operations/lower_bound_transparent.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.operations/lower_bound.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.operations/upper_bound_transparent.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.operations/upper_bound.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/incomplete_type.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/op_compare.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/types.compile.pass.cpp FAIL
-std/language.support/support.limits/support.limits.general/flat_set.version.compile.pass.cpp FAIL
+
+# FIXME! Assertion failed: r == m.begin() + 2
+std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/emplace_hint.pass.cpp FAIL
+
+# FIXME! Assertion failed: r == m.begin() + 1
+std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_iter_rv.pass.cpp FAIL
+
+# FIXME! warning C4242: 'initializing': conversion from 'int' to '_Ty', possible loss of data
+std/containers/container.adaptors/flat.multiset/flat.multiset.cons/sorted_iter_iter.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.multiset/flat.multiset.cons/sorted_iter_iter.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.set/flat.set.cons/sorted_iter_iter.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.set/flat.set.cons/sorted_iter_iter.pass.cpp:1 FAIL
+
+# FIXME! error: unused variable 'expected' [-Werror,-Wunused-variable]
+std/containers/container.adaptors/flat.set/flat.set.erasure/erase_if_exceptions.pass.cpp:2 FAIL
 
 # P2255R2 "Type Traits To Detect References Binding To Temporaries"
 std/language.support/support.limits/support.limits.general/type_traits.version.compile.pass.cpp FAIL

From 208001b64ab29c2b90ad4026fae6d6dc7b1a7198 Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34@live.cn>
Date: Tue, 13 May 2025 04:29:16 +0800
Subject: [PATCH 059/134] Use the `_Transparent` concept for `flat_meow`
 (#5499)

---
 stl/inc/flat_map | 69 ++++++++++++++++++++++++------------------------
 stl/inc/flat_set | 29 ++++++++++----------
 2 files changed, 48 insertions(+), 50 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index de1f84945ee..8f8d632a950 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -624,7 +624,7 @@ public:
     }
 
     template <class _OtherKey>
-        requires _Is_transparent_v<key_compare> && (!is_convertible_v<_OtherKey, iterator>)
+        requires _Transparent<key_compare> && (!is_convertible_v<_OtherKey, iterator>)
               && (!is_convertible_v<_OtherKey, const_iterator>)
     size_type erase(_OtherKey&& _Key_val) {
         return _Erase_key(_STD forward<_OtherKey>(_Key_val));
@@ -673,7 +673,7 @@ public:
 
     template <class _OtherKey>
     _NODISCARD iterator find(const _OtherKey& _Key_val)
-        requires _Is_transparent_v<key_compare>
+        requires _Transparent<key_compare>
     {
         return _Find(_Key_val);
     }
@@ -684,7 +684,7 @@ public:
 
     template <class _OtherKey>
     _NODISCARD const_iterator find(const _OtherKey& _Key_val) const
-        requires _Is_transparent_v<key_compare>
+        requires _Transparent<key_compare>
     {
         return _Find(_Key_val);
     }
@@ -695,7 +695,7 @@ public:
 
     template <class _OtherKey>
     _NODISCARD size_type count(const _OtherKey& _Key_val) const
-        requires _Is_transparent_v<key_compare>
+        requires _Transparent<key_compare>
     {
         return _Count(_Key_val);
     }
@@ -706,7 +706,7 @@ public:
 
     template <class _OtherKey>
     _NODISCARD bool contains(const _OtherKey& _Key_val) const
-        requires _Is_transparent_v<key_compare>
+        requires _Transparent<key_compare>
     {
         return _Contains(_Key_val);
     }
@@ -717,7 +717,7 @@ public:
 
     template <class _OtherKey>
     _NODISCARD iterator lower_bound(const _OtherKey& _Key_val)
-        requires _Is_transparent_v<key_compare>
+        requires _Transparent<key_compare>
     {
         return _Lower_bound(_Key_val);
     }
@@ -728,7 +728,7 @@ public:
 
     template <class _OtherKey>
     _NODISCARD const_iterator lower_bound(const _OtherKey& _Key_val) const
-        requires _Is_transparent_v<key_compare>
+        requires _Transparent<key_compare>
     {
         return _Lower_bound(_Key_val);
     }
@@ -739,7 +739,7 @@ public:
 
     template <class _OtherKey>
     _NODISCARD iterator upper_bound(const _OtherKey& _Key_val)
-        requires _Is_transparent_v<key_compare>
+        requires _Transparent<key_compare>
     {
         return _Upper_bound(_Key_val);
     }
@@ -750,7 +750,7 @@ public:
 
     template <class _OtherKey>
     _NODISCARD const_iterator upper_bound(const _OtherKey& _Key_val) const
-        requires _Is_transparent_v<key_compare>
+        requires _Transparent<key_compare>
     {
         return _Upper_bound(_Key_val);
     }
@@ -761,7 +761,7 @@ public:
 
     template <class _OtherKey>
     _NODISCARD pair<iterator, iterator> equal_range(const _OtherKey& _Key_val)
-        requires _Is_transparent_v<key_compare>
+        requires _Transparent<key_compare>
     {
         return _Equal_range(_Key_val);
     }
@@ -772,7 +772,7 @@ public:
 
     template <class _OtherKey>
     _NODISCARD pair<const_iterator, const_iterator> equal_range(const _OtherKey& _Key_val) const
-        requires _Is_transparent_v<key_compare>
+        requires _Transparent<key_compare>
     {
         return _Equal_range(_Key_val);
     }
@@ -818,10 +818,9 @@ protected:
 
     template <bool _OverwriteIfExists, class _OtherKey, class... _MappedArgTypes>
     iterator _Emplace_hint(const const_iterator _Position, _OtherKey&& _Key_val, _MappedArgTypes&&... _Args) {
-        _STL_INTERNAL_STATIC_ASSERT(
-            is_constructible_v<mapped_type, _MappedArgTypes...>
-            && (is_same_v<remove_cvref_t<_OtherKey>, key_type>
-                || (is_constructible_v<key_type, _OtherKey> && _Is_transparent_v<key_compare>) ));
+        _STL_INTERNAL_STATIC_ASSERT(is_constructible_v<mapped_type, _MappedArgTypes...>
+                                    && (is_same_v<remove_cvref_t<_OtherKey>, key_type>
+                                        || (is_constructible_v<key_type, _OtherKey> && _Transparent<key_compare>) ));
         static_assert(_IsUnique || !_OverwriteIfExists,
             "Overwriting is not supported when the container allows multiple copies of a key.");
         const const_iterator _Begin = cbegin();
@@ -908,7 +907,7 @@ protected:
         _STL_INTERNAL_STATIC_ASSERT(
             (is_same_v<remove_cvref_t<_KeyTy1>, key_type> && is_same_v<remove_cvref_t<_KeyTy2>, key_type>)
             || (is_constructible_v<key_type, _KeyTy1> && is_constructible_v<key_type, _KeyTy2>
-                && _Is_transparent_v<key_compare>) );
+                && _Transparent<key_compare>) );
         return !_Key_compare(_STD forward<_KeyTy1>(_Left), _STD forward<_KeyTy2>(_Right))
             && !_Key_compare(_STD forward<_KeyTy2>(_Right), _STD forward<_KeyTy1>(_Left));
     }
@@ -992,7 +991,7 @@ private:
 
     template <class _KeyTy>
     _NODISCARD iterator _Find(const _KeyTy& _Key_val) {
-        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Is_transparent_v<key_compare>);
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
         iterator _Position = lower_bound(_Key_val);
         if (_Position != end() && !_Key_compare(_Key_val, _Position->first)) {
             return _Position;
@@ -1003,7 +1002,7 @@ private:
 
     template <class _KeyTy>
     _NODISCARD const_iterator _Find(const _KeyTy& _Key_val) const {
-        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Is_transparent_v<key_compare>);
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
         const_iterator _Position = lower_bound(_Key_val);
         if (_Position != cend() && !_Key_compare(_Key_val, _Position->first)) {
             return _Position;
@@ -1014,19 +1013,19 @@ private:
 
     template <class _KeyTy>
     _NODISCARD size_type _Count(const _KeyTy& _Key_val) const {
-        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Is_transparent_v<key_compare>);
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
         return upper_bound(_Key_val) - lower_bound(_Key_val);
     }
 
     template <class _KeyTy>
     _NODISCARD bool _Contains(const _KeyTy& _Key_val) const {
-        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Is_transparent_v<key_compare>);
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
         return find(_Key_val) != cend();
     }
 
     template <class _KeyTy>
     _NODISCARD iterator _Lower_bound(const _KeyTy& _Key_val) {
-        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Is_transparent_v<key_compare>);
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
         const auto _Key_unchecked_begin = _STD _Get_unwrapped(_STD cbegin(_Data.keys));
         const auto _Key_unchecked_it =
             _STD lower_bound(_Key_unchecked_begin, _STD _Get_unwrapped(_STD cend(_Data.keys)), _Key_val, _Key_compare);
@@ -1040,7 +1039,7 @@ private:
 
     template <class _KeyTy>
     _NODISCARD const_iterator _Lower_bound(const _KeyTy& _Key_val) const {
-        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Is_transparent_v<key_compare>);
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
         const auto _Key_unchecked_begin = _STD _Get_unwrapped(_STD cbegin(_Data.keys));
         const auto _Key_unchecked_it =
             _STD lower_bound(_Key_unchecked_begin, _STD _Get_unwrapped(_STD cend(_Data.keys)), _Key_val, _Key_compare);
@@ -1055,7 +1054,7 @@ private:
 
     template <class _KeyTy>
     _NODISCARD iterator _Upper_bound(const _KeyTy& _Key_val) {
-        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Is_transparent_v<key_compare>);
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
         const auto _Key_unchecked_begin = _STD _Get_unwrapped(_STD cbegin(_Data.keys));
         const auto _Key_unchecked_it =
             _STD upper_bound(_Key_unchecked_begin, _STD _Get_unwrapped(_STD cend(_Data.keys)), _Key_val, _Key_compare);
@@ -1069,7 +1068,7 @@ private:
 
     template <class _KeyTy>
     _NODISCARD const_iterator _Upper_bound(const _KeyTy& _Key_val) const {
-        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Is_transparent_v<key_compare>);
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
         const auto _Key_unchecked_begin = _STD _Get_unwrapped(_STD cbegin(_Data.keys));
         const auto _Key_unchecked_it =
             _STD upper_bound(_Key_unchecked_begin, _STD _Get_unwrapped(_STD cend(_Data.keys)), _Key_val, _Key_compare);
@@ -1084,13 +1083,13 @@ private:
 
     template <class _KeyTy>
     _NODISCARD pair<iterator, iterator> _Equal_range(const _KeyTy& _Key_val) {
-        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Is_transparent_v<key_compare>);
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
         return {lower_bound(_Key_val), upper_bound(_Key_val)};
     }
 
     template <class _KeyTy>
     _NODISCARD pair<const_iterator, const_iterator> _Equal_range(const _KeyTy& _Key_val) const {
-        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Is_transparent_v<key_compare>);
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
         return {lower_bound(_Key_val), upper_bound(_Key_val)};
     }
 };
@@ -1143,7 +1142,7 @@ public:
 
     template <class _OtherKey>
     mapped_type& operator[](_OtherKey&& _Key_val)
-        requires _Is_transparent_v<key_compare> && is_constructible_v<key_type, _OtherKey>
+        requires _Transparent<key_compare> && is_constructible_v<key_type, _OtherKey>
               && is_default_constructible_v<mapped_type>
     {
         return this->try_emplace(_STD forward<_OtherKey>(_Key_val)).first->second;
@@ -1159,14 +1158,14 @@ public:
 
     template <class _OtherKey>
     _NODISCARD mapped_type& at(const _OtherKey& _Key_val)
-        requires _Is_transparent_v<key_compare>
+        requires _Transparent<key_compare>
     {
         return _At(_Key_val);
     }
 
     template <class _OtherKey>
     _NODISCARD const mapped_type& at(const _OtherKey& _Key_val) const
-        requires _Is_transparent_v<key_compare>
+        requires _Transparent<key_compare>
     {
         return _At(_Key_val);
     }
@@ -1208,7 +1207,7 @@ public:
     }
 
     template <class _OtherKey, class... _MappedArgTypes>
-        requires _Is_transparent_v<key_compare> && is_constructible_v<key_type, _OtherKey>
+        requires _Transparent<key_compare> && is_constructible_v<key_type, _OtherKey>
               && is_constructible_v<mapped_type, _MappedArgTypes...> && (!is_convertible_v<_OtherKey, const_iterator>)
               && (!is_convertible_v<_OtherKey, iterator>)
     pair<iterator, bool> try_emplace(_OtherKey&& _Key_val, _MappedArgTypes&&... _Mapped_args) {
@@ -1232,7 +1231,7 @@ public:
 
     template <class _OtherKey, class... _MappedArgTypes>
     iterator try_emplace(const_iterator _Position, _OtherKey&& _Key_val, _MappedArgTypes&&... _Mapped_args)
-        requires _Is_transparent_v<key_compare> && is_constructible_v<key_type, _OtherKey>
+        requires _Transparent<key_compare> && is_constructible_v<key_type, _OtherKey>
               && is_constructible_v<mapped_type, _MappedArgTypes&&...>
     {
         return this->template _Emplace_hint<false>(
@@ -1255,7 +1254,7 @@ public:
 
     template <class _OtherKey, class _MappedTy>
     pair<iterator, bool> insert_or_assign(_OtherKey&& _Key_val, _MappedTy&& _Mapped_val)
-        requires _Is_transparent_v<key_compare> && is_constructible_v<key_type, _OtherKey>
+        requires _Transparent<key_compare> && is_constructible_v<key_type, _OtherKey>
               && is_assignable_v<mapped_type&, _MappedTy> && is_constructible_v<mapped_type, _MappedTy>
     {
         return _Insert_or_assign(_STD forward<_OtherKey>(_Key_val), _STD forward<_MappedTy>(_Mapped_val));
@@ -1277,7 +1276,7 @@ public:
 
     template <class _OtherKey, class _MappedTy>
     iterator insert_or_assign(const_iterator _Position, _OtherKey&& _Key_val, _MappedTy&& _Mapped_val)
-        requires _Is_transparent_v<key_compare> && is_constructible_v<key_type, _OtherKey>
+        requires _Transparent<key_compare> && is_constructible_v<key_type, _OtherKey>
               && is_assignable_v<mapped_type&, _MappedTy> && is_constructible_v<mapped_type, _MappedTy>
     {
         return this->template _Emplace_hint<true>(
@@ -1296,7 +1295,7 @@ private:
 
     template <class _KeyTy>
     _NODISCARD mapped_type& _At(const _KeyTy& _Key_val) {
-        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Is_transparent_v<key_compare>);
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
         const auto _Position = this->find(_Key_val);
         if (_Position == this->end()) {
             _Xout_of_range("std::flat_map::at: the specified key does not exist.");
@@ -1307,7 +1306,7 @@ private:
 
     template <class _KeyTy>
     _NODISCARD const mapped_type& _At(const _KeyTy& _Key_val) const {
-        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Is_transparent_v<key_compare>);
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
         const auto _Position = this->find(_Key_val);
         if (_Position == this->end()) {
             _Xout_of_range("std::flat_map::at: the specified key does not exist.");
diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index ea04da753e7..4124d2b91c9 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -37,7 +37,6 @@ private:
     using _Derived =
         conditional_t<_IsUnique, flat_set<_Kty, _Keylt, _Container>, flat_multiset<_Kty, _Keylt, _Container>>;
 
-    static constexpr bool _Keylt_transparent     = _Is_transparent_v<_Keylt>;
     static constexpr const char* _Msg_not_sorted = _IsUnique ? "Input was not sorted-unique!" : "Input was not sorted!";
 
 public:
@@ -271,7 +270,7 @@ public:
         return _Emplace(_STD move(_Val));
     }
     template <_Different_from<_Kty> _Other>
-        requires _IsUnique && _Keylt_transparent && is_constructible_v<_Kty, _Other>
+        requires _IsUnique && _Transparent<key_compare> && is_constructible_v<_Kty, _Other>
     auto insert(_Other&& _Val) {
         return _Emplace(_STD forward<_Other>(_Val));
     }
@@ -283,7 +282,7 @@ public:
         return _Emplace_hint(_Hint, _STD move(_Val));
     }
     template <_Different_from<_Kty> _Other>
-        requires _IsUnique && _Keylt_transparent && is_constructible_v<_Kty, _Other>
+        requires _IsUnique && _Transparent<key_compare> && is_constructible_v<_Kty, _Other>
     iterator insert(const_iterator _Hint, _Other&& _Val) {
         return _Emplace_hint(_Hint, _STD forward<_Other>(_Val));
     }
@@ -336,7 +335,7 @@ public:
         return _Erase(_Val);
     }
     template <_Different_from<_Kty> _Other>
-        requires (_Keylt_transparent && !is_convertible_v<_Other, const_iterator>)
+        requires _Transparent<key_compare> && (!is_convertible_v<_Other, const_iterator>)
     size_type erase(_Other&& _Val) {
         return _Erase(_Val);
     }
@@ -370,7 +369,7 @@ public:
         return _Find(_Val);
     }
     template <class _Other>
-        requires _Keylt_transparent
+        requires _Transparent<key_compare>
     _NODISCARD const_iterator find(const _Other& _Val) const {
         return _Find(_Val);
     }
@@ -384,7 +383,7 @@ public:
         }
     }
     template <class _Other>
-        requires _Keylt_transparent
+        requires _Transparent<key_compare>
     _NODISCARD size_type count(const _Other& _Val) const {
         const auto [_First, _Last] = equal_range(_Val);
         return static_cast<size_type>(_Last - _First);
@@ -394,7 +393,7 @@ public:
         return _STD binary_search(cbegin(), cend(), _Val, _Pass_comp());
     }
     template <class _Other>
-        requires _Keylt_transparent
+        requires _Transparent<key_compare>
     _NODISCARD bool contains(const _Other& _Val) const {
         return _STD binary_search(cbegin(), cend(), _Val, _Pass_comp());
     }
@@ -403,7 +402,7 @@ public:
         return _STD lower_bound(cbegin(), cend(), _Val, _Pass_comp());
     }
     template <class _Other>
-        requires _Keylt_transparent
+        requires _Transparent<key_compare>
     _NODISCARD const_iterator lower_bound(const _Other& _Val) const {
         return _STD lower_bound(cbegin(), cend(), _Val, _Pass_comp());
     }
@@ -412,7 +411,7 @@ public:
         return _STD upper_bound(cbegin(), cend(), _Val, _Pass_comp());
     }
     template <class _Other>
-        requires _Keylt_transparent
+        requires _Transparent<key_compare>
     _NODISCARD const_iterator upper_bound(const _Other& _Val) const {
         return _STD upper_bound(cbegin(), cend(), _Val, _Pass_comp());
     }
@@ -421,7 +420,7 @@ public:
         return _STD equal_range(cbegin(), cend(), _Val, _Pass_comp());
     }
     template <class _Other>
-        requires _Keylt_transparent
+        requires _Transparent<key_compare>
     _NODISCARD pair<const_iterator, const_iterator> equal_range(const _Other& _Val) const {
         return _STD equal_range(cbegin(), cend(), _Val, _Pass_comp());
     }
@@ -494,7 +493,7 @@ private:
                 // heterogeneous insertion
                 // FIXME: The standard only requires `find(_Val) == find(_Keyval)` (per N4958 [flat.set.modifiers]/2),
                 // which cannot guarantee `_Can_insert(_Where, _Keyval)`.
-                _STL_INTERNAL_STATIC_ASSERT(_Keylt_transparent && is_constructible_v<_Kty, _Ty>);
+                _STL_INTERNAL_STATIC_ASSERT(_Transparent<key_compare> && is_constructible_v<_Kty, _Ty>);
                 _Kty _Keyval(_STD forward<_Ty>(_Val));
                 _STL_ASSERT(_Can_insert(_Where, _Keyval),
                     "The conversion from the heterogeneous key to key_type should "
@@ -538,7 +537,7 @@ private:
                 // heterogeneous insertion
                 // FIXME: The standard only requires `find(_Val) == find(_Keyval)` (per N4958 [flat.set.modifiers]/2),
                 // which cannot guarantee `_Can_insert(_Where, _Keyval)`.
-                _STL_INTERNAL_STATIC_ASSERT(_Keylt_transparent && is_constructible_v<_Kty, _Ty>);
+                _STL_INTERNAL_STATIC_ASSERT(_Transparent<key_compare> && is_constructible_v<_Kty, _Ty>);
                 _Kty _Keyval(_STD forward<_Ty>(_Val));
                 _STL_ASSERT(_Can_insert(_Where, _Keyval),
                     "The conversion from the heterogeneous key to key_type should "
@@ -576,7 +575,7 @@ private:
 
     template <class _Ty>
     _NODISCARD size_type _Erase(const _Ty& _Val) {
-        _STL_INTERNAL_STATIC_ASSERT(_Keylt_transparent || is_same_v<_Ty, _Kty>);
+        _STL_INTERNAL_STATIC_ASSERT(_Transparent<key_compare> || is_same_v<_Ty, _Kty>);
 
         if constexpr (_IsUnique && is_same_v<_Ty, _Kty>) {
             const const_iterator _Where = lower_bound(_Val);
@@ -596,7 +595,7 @@ private:
 
     template <class _Ty>
     _NODISCARD const_iterator _Find(const _Ty& _Val) const {
-        _STL_INTERNAL_STATIC_ASSERT(_Keylt_transparent || is_same_v<_Ty, _Kty>);
+        _STL_INTERNAL_STATIC_ASSERT(_Transparent<key_compare> || is_same_v<_Ty, _Kty>);
 
         const const_iterator _End   = cend();
         const const_iterator _Where = lower_bound(_Val);
@@ -656,7 +655,7 @@ private:
     template <class _Lty, class _Rty>
     _NODISCARD bool _Compare(const _Lty& _Lhs, const _Rty& _Rhs) const
         noexcept(noexcept(_DEBUG_LT_PRED(_Mycomp, _Lhs, _Rhs))) {
-        _STL_INTERNAL_STATIC_ASSERT(_Keylt_transparent || (is_same_v<_Kty, _Lty> && is_same_v<_Kty, _Rty>) );
+        _STL_INTERNAL_STATIC_ASSERT(_Transparent<key_compare> || (is_same_v<_Kty, _Lty> && is_same_v<_Kty, _Rty>) );
 
         return _DEBUG_LT_PRED(_Mycomp, _Lhs, _Rhs);
     }

From 8d7368c796e8c6853b18be14f6d0759f3b270c60 Mon Sep 17 00:00:00 2001
From: Alex Guteniev <gutenev@gmail.com>
Date: Thu, 15 May 2025 23:13:50 +0300
Subject: [PATCH 060/134] `<flat_set>`: some libc++ tests look bogus (#5508)

---
 tests/libcxx/expected_results.txt | 24 ++++++++++++++----------
 1 file changed, 14 insertions(+), 10 deletions(-)

diff --git a/tests/libcxx/expected_results.txt b/tests/libcxx/expected_results.txt
index 0622a48722c..b5428277793 100644
--- a/tests/libcxx/expected_results.txt
+++ b/tests/libcxx/expected_results.txt
@@ -315,16 +315,6 @@ std/numerics/numeric.ops/numeric.ops.sat/sub_sat.pass.cpp FAIL
 
 # P1222R4 <flat_set>
 
-# FIXME! error: no member named 'assign' in 'MinSequenceContainer<int>'
-std/containers/container.adaptors/flat.multiset/flat.multiset.capacity/empty.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.cons/assign_initializer_list.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.capacity/empty.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.cons/assign_initializer_list.pass.cpp FAIL
-
-# FIXME! error: no member named 'insert_range' in 'MinSequenceContainer<int>'
-std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_range.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_range.pass.cpp FAIL
-
 # FIXME! error: static assertion failed due to requirement '!std::is_nothrow_move_constructible_v<std::flat_MEOW<int, ThrowingMoveComp, std::vector<int, std::allocator<int>>>>'
 std/containers/container.adaptors/flat.multiset/flat.multiset.cons/move.pass.cpp FAIL
 std/containers/container.adaptors/flat.set/flat.set.cons/move.pass.cpp FAIL
@@ -636,6 +626,20 @@ std/depr/depr.c.headers/stddef_h.compile.pass.cpp:1 FAIL
 
 # *** LIKELY BOGUS TESTS ***
 
+# P1222R4 <flat_set>;
+# error: no member named 'assign' in 'MinSequenceContainer<int>';
+# it is mandatory according to [sequence.reqmts]/104
+std/containers/container.adaptors/flat.multiset/flat.multiset.capacity/empty.pass.cpp FAIL
+std/containers/container.adaptors/flat.multiset/flat.multiset.cons/assign_initializer_list.pass.cpp FAIL
+std/containers/container.adaptors/flat.set/flat.set.capacity/empty.pass.cpp FAIL
+std/containers/container.adaptors/flat.set/flat.set.cons/assign_initializer_list.pass.cpp FAIL
+
+# P1222R4 <flat_set>;
+# error: no member named 'insert_range' in 'MinSequenceContainer<int>';
+# it is mandatory according to [sequence.reqmts]/40
+std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_range.pass.cpp FAIL
+std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_range.pass.cpp FAIL
+
 # Test bug after LWG-2899 "is_(nothrow_)move_constructible and tuple, optional and unique_ptr" was accepted.
 std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.pass.cpp FAIL
 std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.runtime.pass.cpp FAIL

From bfa5444cef298cb91d75697323ae0ab3e856a3da Mon Sep 17 00:00:00 2001
From: Alex Guteniev <gutenev@gmail.com>
Date: Sat, 17 May 2025 05:36:24 +0300
Subject: [PATCH 061/134] `<flat_set>`: insert range invariant fix (#5514)

---
 stl/inc/flat_set                  | 2 ++
 tests/libcxx/expected_results.txt | 8 --------
 2 files changed, 2 insertions(+), 8 deletions(-)

diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index 4124d2b91c9..1ec4c6ce049 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -569,8 +569,10 @@ private:
     template <bool _NeedSorting, class _Iter>
     void _Insert_range(const _Iter _First, const _Iter _Last) {
         const size_type _Old_size = size();
+        _Clear_guard _Guard{this};
         _Mycont.insert(_Mycont.end(), _First, _Last);
         _Restore_invariants_after_insert<_NeedSorting>(_Old_size);
+        _Guard._Target = nullptr;
     }
 
     template <class _Ty>
diff --git a/tests/libcxx/expected_results.txt b/tests/libcxx/expected_results.txt
index b5428277793..2c47e4078e9 100644
--- a/tests/libcxx/expected_results.txt
+++ b/tests/libcxx/expected_results.txt
@@ -324,20 +324,12 @@ std/containers/container.adaptors/flat.multiset/flat.multiset.cons/move_assign.p
 std/containers/container.adaptors/flat.set/flat.set.cons/move_assign.pass.cpp FAIL
 
 # FIXME! Assertion failed: std::is_sorted(m.begin(), m.end(), m.key_comp())
-std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_initializer_list.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_iter_iter.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_sorted_initializer_list.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_sorted_iter_iter.pass.cpp FAIL
 std/containers/container.adaptors/flat.set/flat.set.modifiers/emplace_hint.pass.cpp FAIL
 std/containers/container.adaptors/flat.set/flat.set.modifiers/emplace.pass.cpp FAIL
 std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_cv.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_initializer_list.pass.cpp FAIL
 std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_iter_cv.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_iter_iter.pass.cpp FAIL
 std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_iter_rv.pass.cpp FAIL
 std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_rv.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_sorted_initializer_list.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_sorted_iter_iter.pass.cpp FAIL
 std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_transparent.pass.cpp FAIL
 
 # FIXME! Assertion failed: r == m.begin() + 2

From bbef8e8bfc5bd02646b2217a8c24c3d0ff26099e Mon Sep 17 00:00:00 2001
From: Alex Guteniev <gutenev@gmail.com>
Date: Sun, 18 May 2025 08:25:21 +0300
Subject: [PATCH 062/134] `<flat_set>`: more invariants fixes (#5516)

---
 stl/inc/flat_set                  | 28 ++++++++++++++++++++++------
 tests/libcxx/expected_results.txt |  9 ---------
 2 files changed, 22 insertions(+), 15 deletions(-)

diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index 1ec4c6ce049..8000018ed8c 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -486,9 +486,12 @@ private:
                 return pair{_Where, false};
             }
 
+            _Clear_guard _Guard{this};
             if constexpr (is_same_v<remove_cvref_t<_Ty>, _Kty>) {
                 _STL_INTERNAL_CHECK(_Can_insert(_Where, _Val));
-                return pair{_Mycont.emplace(_Where, _STD forward<_Ty>(_Val)), true};
+                iterator _Result = _Mycont.emplace(_Where, _STD forward<_Ty>(_Val));
+                _Guard._Target   = nullptr;
+                return pair{_STD move(_Result), true};
             } else {
                 // heterogeneous insertion
                 // FIXME: The standard only requires `find(_Val) == find(_Keyval)` (per N4958 [flat.set.modifiers]/2),
@@ -498,11 +501,16 @@ private:
                 _STL_ASSERT(_Can_insert(_Where, _Keyval),
                     "The conversion from the heterogeneous key to key_type should "
                     "be consistent with the heterogeneous lookup!");
-                return pair{_Mycont.emplace(_Where, _STD move(_Keyval)), true};
+                iterator _Result = _Mycont.emplace(_Where, _STD move(_Keyval));
+                _Guard._Target   = nullptr;
+                return pair{_STD move(_Result), true};
             }
         } else {
             _STL_INTERNAL_STATIC_ASSERT(is_same_v<remove_cvref_t<_Ty>, _Kty>);
-            return _Mycont.emplace(upper_bound(_Val), _STD forward<_Ty>(_Val));
+            _Clear_guard _Guard{this};
+            iterator _Result = _Mycont.emplace(upper_bound(_Val), _STD forward<_Ty>(_Val));
+            _Guard._Target   = nullptr;
+            return _Result;
         }
     }
 
@@ -530,9 +538,12 @@ private:
                 return _Where;
             }
 
+            _Clear_guard _Guard{this};
             if constexpr (is_same_v<remove_cvref_t<_Ty>, _Kty>) {
                 _STL_INTERNAL_CHECK(_Can_insert(_Where, _Val));
-                return _Mycont.emplace(_Where, _STD forward<_Ty>(_Val));
+                iterator _Result = _Mycont.emplace(_Where, _STD forward<_Ty>(_Val));
+                _Guard._Target   = nullptr;
+                return _Result;
             } else {
                 // heterogeneous insertion
                 // FIXME: The standard only requires `find(_Val) == find(_Keyval)` (per N4958 [flat.set.modifiers]/2),
@@ -542,7 +553,9 @@ private:
                 _STL_ASSERT(_Can_insert(_Where, _Keyval),
                     "The conversion from the heterogeneous key to key_type should "
                     "be consistent with the heterogeneous lookup!");
-                return _Mycont.emplace(_Where, _STD move(_Keyval));
+                iterator _Result = _Mycont.emplace(_Where, _STD move(_Keyval));
+                _Guard._Target   = nullptr;
+                return _Result;
             }
         } else {
             _STL_INTERNAL_STATIC_ASSERT(is_same_v<remove_cvref_t<_Ty>, _Kty>);
@@ -562,7 +575,10 @@ private:
             }
 
             _STL_INTERNAL_CHECK(_Can_insert(_Where, _Val));
-            return _Mycont.emplace(_Where, _STD forward<_Ty>(_Val));
+            _Clear_guard _Guard{this};
+            iterator _Result = _Mycont.emplace(_Where, _STD forward<_Ty>(_Val));
+            _Guard._Target   = nullptr;
+            return _Result;
         }
     }
 
diff --git a/tests/libcxx/expected_results.txt b/tests/libcxx/expected_results.txt
index 2c47e4078e9..7cd1b5cc8ab 100644
--- a/tests/libcxx/expected_results.txt
+++ b/tests/libcxx/expected_results.txt
@@ -323,15 +323,6 @@ std/containers/container.adaptors/flat.set/flat.set.cons/move.pass.cpp FAIL
 std/containers/container.adaptors/flat.multiset/flat.multiset.cons/move_assign.pass.cpp FAIL
 std/containers/container.adaptors/flat.set/flat.set.cons/move_assign.pass.cpp FAIL
 
-# FIXME! Assertion failed: std::is_sorted(m.begin(), m.end(), m.key_comp())
-std/containers/container.adaptors/flat.set/flat.set.modifiers/emplace_hint.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.modifiers/emplace.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_cv.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_iter_cv.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_iter_rv.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_rv.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_transparent.pass.cpp FAIL
-
 # FIXME! Assertion failed: r == m.begin() + 2
 std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/emplace_hint.pass.cpp FAIL
 

From e20fc34b51f2e388b9dfde6ee782762b482f17c8 Mon Sep 17 00:00:00 2001
From: Nikolai Vavilov <vvnicholas@gmail.com>
Date: Sun, 18 May 2025 08:30:03 +0300
Subject: [PATCH 063/134] `<flat_map>`: Remove unreachable code (#5520)

---
 stl/inc/flat_map | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index 8f8d632a950..1575edc71c8 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -849,11 +849,6 @@ protected:
 
         if (_Hint_order == weak_ordering::equivalent) {
             const auto _Dist = _Position._Key_it - _Begin._Key_it;
-            if constexpr (_IsUnique) {
-                if (_Position != _Begin && !_Key_compare(*_STD prev(_Position._Key_it), _Key_val)) {
-                    return begin() + _Dist;
-                }
-            }
             {
                 key_type _Key_to_insert(_STD forward<_OtherKey>(_Key_val));
                 mapped_type _Mapped_to_insert(_STD forward<_MappedArgTypes>(_Args)...);

From 2c570f3a29906576e6b6b57b2318474da3e78434 Mon Sep 17 00:00:00 2001
From: Alex Guteniev <gutenev@gmail.com>
Date: Sun, 18 May 2025 20:00:05 +0300
Subject: [PATCH 064/134] Revert incorrect `<flat_set>` change, and update test
 failure reason (#5522)

---
 stl/inc/flat_set                  | 28 ++++++----------------------
 tests/libcxx/expected_results.txt | 31 +++++++++++++++++--------------
 2 files changed, 23 insertions(+), 36 deletions(-)

diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index 8000018ed8c..1ec4c6ce049 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -486,12 +486,9 @@ private:
                 return pair{_Where, false};
             }
 
-            _Clear_guard _Guard{this};
             if constexpr (is_same_v<remove_cvref_t<_Ty>, _Kty>) {
                 _STL_INTERNAL_CHECK(_Can_insert(_Where, _Val));
-                iterator _Result = _Mycont.emplace(_Where, _STD forward<_Ty>(_Val));
-                _Guard._Target   = nullptr;
-                return pair{_STD move(_Result), true};
+                return pair{_Mycont.emplace(_Where, _STD forward<_Ty>(_Val)), true};
             } else {
                 // heterogeneous insertion
                 // FIXME: The standard only requires `find(_Val) == find(_Keyval)` (per N4958 [flat.set.modifiers]/2),
@@ -501,16 +498,11 @@ private:
                 _STL_ASSERT(_Can_insert(_Where, _Keyval),
                     "The conversion from the heterogeneous key to key_type should "
                     "be consistent with the heterogeneous lookup!");
-                iterator _Result = _Mycont.emplace(_Where, _STD move(_Keyval));
-                _Guard._Target   = nullptr;
-                return pair{_STD move(_Result), true};
+                return pair{_Mycont.emplace(_Where, _STD move(_Keyval)), true};
             }
         } else {
             _STL_INTERNAL_STATIC_ASSERT(is_same_v<remove_cvref_t<_Ty>, _Kty>);
-            _Clear_guard _Guard{this};
-            iterator _Result = _Mycont.emplace(upper_bound(_Val), _STD forward<_Ty>(_Val));
-            _Guard._Target   = nullptr;
-            return _Result;
+            return _Mycont.emplace(upper_bound(_Val), _STD forward<_Ty>(_Val));
         }
     }
 
@@ -538,12 +530,9 @@ private:
                 return _Where;
             }
 
-            _Clear_guard _Guard{this};
             if constexpr (is_same_v<remove_cvref_t<_Ty>, _Kty>) {
                 _STL_INTERNAL_CHECK(_Can_insert(_Where, _Val));
-                iterator _Result = _Mycont.emplace(_Where, _STD forward<_Ty>(_Val));
-                _Guard._Target   = nullptr;
-                return _Result;
+                return _Mycont.emplace(_Where, _STD forward<_Ty>(_Val));
             } else {
                 // heterogeneous insertion
                 // FIXME: The standard only requires `find(_Val) == find(_Keyval)` (per N4958 [flat.set.modifiers]/2),
@@ -553,9 +542,7 @@ private:
                 _STL_ASSERT(_Can_insert(_Where, _Keyval),
                     "The conversion from the heterogeneous key to key_type should "
                     "be consistent with the heterogeneous lookup!");
-                iterator _Result = _Mycont.emplace(_Where, _STD move(_Keyval));
-                _Guard._Target   = nullptr;
-                return _Result;
+                return _Mycont.emplace(_Where, _STD move(_Keyval));
             }
         } else {
             _STL_INTERNAL_STATIC_ASSERT(is_same_v<remove_cvref_t<_Ty>, _Kty>);
@@ -575,10 +562,7 @@ private:
             }
 
             _STL_INTERNAL_CHECK(_Can_insert(_Where, _Val));
-            _Clear_guard _Guard{this};
-            iterator _Result = _Mycont.emplace(_Where, _STD forward<_Ty>(_Val));
-            _Guard._Target   = nullptr;
-            return _Result;
+            return _Mycont.emplace(_Where, _STD forward<_Ty>(_Val));
         }
     }
 
diff --git a/tests/libcxx/expected_results.txt b/tests/libcxx/expected_results.txt
index 7cd1b5cc8ab..3cbfcfa4544 100644
--- a/tests/libcxx/expected_results.txt
+++ b/tests/libcxx/expected_results.txt
@@ -51,6 +51,23 @@ std/strings/basic.string/string.modifiers/string_append/initializer_list.pass.cp
 std/strings/basic.string/string.modifiers/string_assign/string.pass.cpp:0 FAIL
 std/strings/basic.string/string.modifiers/string_assign/string.pass.cpp:1 FAIL
 
+# LLVM-140287: libc++ test: update MinSequenceContainer.h to make some tests pass on MSVC STL #140287
+std/containers/container.adaptors/flat.multiset/flat.multiset.capacity/empty.pass.cpp FAIL
+std/containers/container.adaptors/flat.multiset/flat.multiset.cons/assign_initializer_list.pass.cpp FAIL
+std/containers/container.adaptors/flat.set/flat.set.capacity/empty.pass.cpp FAIL
+std/containers/container.adaptors/flat.set/flat.set.cons/assign_initializer_list.pass.cpp FAIL
+std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_range.pass.cpp FAIL
+std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_range.pass.cpp FAIL
+
+# LLVM-140448: [libc++][test] flat_set std test uses EmplaceUnsafeContainer which is non-standard
+std/containers/container.adaptors/flat.set/flat.set.modifiers/emplace_hint.pass.cpp FAIL
+std/containers/container.adaptors/flat.set/flat.set.modifiers/emplace.pass.cpp FAIL
+std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_cv.pass.cpp FAIL
+std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_iter_cv.pass.cpp FAIL
+std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_iter_rv.pass.cpp FAIL
+std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_rv.pass.cpp FAIL
+std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_transparent.pass.cpp FAIL
+
 # Non-Standard regex behavior.
 # "It seems likely that the test is still non-conforming due to how libc++ handles the 'w' character class."
 std/re/re.traits/lookup_classname.pass.cpp FAIL
@@ -609,20 +626,6 @@ std/depr/depr.c.headers/stddef_h.compile.pass.cpp:1 FAIL
 
 # *** LIKELY BOGUS TESTS ***
 
-# P1222R4 <flat_set>;
-# error: no member named 'assign' in 'MinSequenceContainer<int>';
-# it is mandatory according to [sequence.reqmts]/104
-std/containers/container.adaptors/flat.multiset/flat.multiset.capacity/empty.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.cons/assign_initializer_list.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.capacity/empty.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.cons/assign_initializer_list.pass.cpp FAIL
-
-# P1222R4 <flat_set>;
-# error: no member named 'insert_range' in 'MinSequenceContainer<int>';
-# it is mandatory according to [sequence.reqmts]/40
-std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_range.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_range.pass.cpp FAIL
-
 # Test bug after LWG-2899 "is_(nothrow_)move_constructible and tuple, optional and unique_ptr" was accepted.
 std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.pass.cpp FAIL
 std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.asgn/move_convert.runtime.pass.cpp FAIL

From 67c4a9fe6463f550ffe5ecbb9e4083d7215bb1f0 Mon Sep 17 00:00:00 2001
From: Alex Guteniev <gutenev@gmail.com>
Date: Thu, 28 Aug 2025 19:06:00 +0300
Subject: [PATCH 065/134] `<flat_map>`, `<flat_set>`: mark unused variables and
 typedef libc++ test failures as known upstream (#5702)

---
 tests/libcxx/expected_results.txt | 18 +++++++-----------
 1 file changed, 7 insertions(+), 11 deletions(-)

diff --git a/tests/libcxx/expected_results.txt b/tests/libcxx/expected_results.txt
index 81f4ae8014f..9f85c2c3b9c 100644
--- a/tests/libcxx/expected_results.txt
+++ b/tests/libcxx/expected_results.txt
@@ -60,6 +60,13 @@ std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_iter_rv.pas
 std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_rv.pass.cpp FAIL
 std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_transparent.pass.cpp FAIL
 
+# LLVM-155679: [libcxx][test] Avoid warnings about unused variables and typedefs if _LIBCPP_VERSION is not defined
+std/containers/container.adaptors/flat.map/flat.map.cons/move_assign_noexcept.compile.pass.cpp:2 FAIL
+std/containers/container.adaptors/flat.multimap/flat.multimap.cons/move_assign_noexcept.compile.pass.cpp:2 FAIL
+std/containers/container.adaptors/flat.map/flat.map.erasure/erase_if_exceptions.pass.cpp:2 FAIL
+std/containers/container.adaptors/flat.multimap/flat.multimap.erasure/erase_if_exceptions.pass.cpp:2 FAIL
+std/containers/container.adaptors/flat.set/flat.set.erasure/erase_if_exceptions.pass.cpp:2 FAIL
+
 # Non-Standard regex behavior.
 # "It seems likely that the test is still non-conforming due to how libc++ handles the 'w' character class."
 std/re/re.traits/lookup_classname.pass.cpp FAIL
@@ -288,14 +295,6 @@ std/containers/container.adaptors/flat.multimap/flat.multimap.cons/sorted_iter_i
 std/containers/container.adaptors/flat.multimap/flat.multimap.modifiers/erase_key.pass.cpp:0 FAIL
 std/containers/container.adaptors/flat.multimap/flat.multimap.modifiers/erase_key.pass.cpp:1 FAIL
 
-# FIXME! error: unused type alias 'C' [-Werror,-Wunused-local-typedef]
-std/containers/container.adaptors/flat.map/flat.map.cons/move_assign_noexcept.compile.pass.cpp:2 FAIL
-std/containers/container.adaptors/flat.multimap/flat.multimap.cons/move_assign_noexcept.compile.pass.cpp:2 FAIL
-
-# FIXME! error: unused variable 'expected' [-Werror,-Wunused-variable]
-std/containers/container.adaptors/flat.map/flat.map.erasure/erase_if_exceptions.pass.cpp:2 FAIL
-std/containers/container.adaptors/flat.multimap/flat.multimap.erasure/erase_if_exceptions.pass.cpp:2 FAIL
-
 # FIXME! C++26 "P3372R3 constexpr Containers And Adaptors" isn't completely guarded with `TEST_STD_VER >= 26`.
 std/containers/container.adaptors/flat.map/flat.map.access/at_transparent.pass.cpp:0 FAIL
 std/containers/container.adaptors/flat.map/flat.map.access/at_transparent.pass.cpp:1 FAIL
@@ -407,9 +406,6 @@ std/containers/container.adaptors/flat.multiset/flat.multiset.cons/sorted_iter_i
 std/containers/container.adaptors/flat.set/flat.set.cons/sorted_iter_iter.pass.cpp:0 FAIL
 std/containers/container.adaptors/flat.set/flat.set.cons/sorted_iter_iter.pass.cpp:1 FAIL
 
-# FIXME! error: unused variable 'expected' [-Werror,-Wunused-variable]
-std/containers/container.adaptors/flat.set/flat.set.erasure/erase_if_exceptions.pass.cpp:2 FAIL
-
 # FIXME! Asserts while testing insert_range's exception guarantee.
 std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_range.pass.cpp FAIL
 std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_range.pass.cpp FAIL

From 71977b121f8795de369d35ac186774f70c5aaef3 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Fri, 17 Oct 2025 15:29:39 -0700
Subject: [PATCH 066/134] Mark flat.map.observers and flat.multimap.observers
 tests as FAIL for Clang.

---
 tests/libcxx/expected_results.txt | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/tests/libcxx/expected_results.txt b/tests/libcxx/expected_results.txt
index e31369cd205..354da4121ea 100644
--- a/tests/libcxx/expected_results.txt
+++ b/tests/libcxx/expected_results.txt
@@ -379,6 +379,10 @@ std/containers/container.adaptors/flat.multimap/flat.multimap.operations/lower_b
 std/containers/container.adaptors/flat.multimap/flat.multimap.operations/upper_bound_transparent.pass.cpp:0 FAIL
 std/containers/container.adaptors/flat.multimap/flat.multimap.operations/upper_bound_transparent.pass.cpp:1 FAIL
 
+# FIXME! error: conversion function from 'pair<_Unrefwrap_t<int>, _Unrefwrap_t<int>>' to 'pair<const int &, const char &>' invokes a deleted function
+std/containers/container.adaptors/flat.map/flat.map.observers/comp.pass.cpp:2 FAIL
+std/containers/container.adaptors/flat.multimap/flat.multimap.observers/comp.pass.cpp:2 FAIL
+
 # P0533R9 constexpr For <cmath> And <cstdlib>
 std/language.support/support.limits/support.limits.general/cmath.version.compile.pass.cpp FAIL
 std/language.support/support.limits/support.limits.general/cstdlib.version.compile.pass.cpp FAIL

From 42cd3da27f7648eccc5a6e77fced10ff5224a82a Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Thu, 27 Nov 2025 16:28:22 -0800
Subject: [PATCH 067/134] Some tests are now passing.

---
 tests/libcxx/expected_results.txt | 12 ------------
 1 file changed, 12 deletions(-)

diff --git a/tests/libcxx/expected_results.txt b/tests/libcxx/expected_results.txt
index 80df565bb60..43e524e9ba4 100644
--- a/tests/libcxx/expected_results.txt
+++ b/tests/libcxx/expected_results.txt
@@ -60,13 +60,6 @@ std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_iter_rv.pas
 std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_rv.pass.cpp FAIL
 std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_transparent.pass.cpp FAIL
 
-# LLVM-155679: [libcxx][test] Avoid warnings about unused variables and typedefs if _LIBCPP_VERSION is not defined
-std/containers/container.adaptors/flat.map/flat.map.cons/move_assign_noexcept.compile.pass.cpp:2 FAIL
-std/containers/container.adaptors/flat.multimap/flat.multimap.cons/move_assign_noexcept.compile.pass.cpp:2 FAIL
-std/containers/container.adaptors/flat.map/flat.map.erasure/erase_if_exceptions.pass.cpp:2 FAIL
-std/containers/container.adaptors/flat.multimap/flat.multimap.erasure/erase_if_exceptions.pass.cpp:2 FAIL
-std/containers/container.adaptors/flat.set/flat.set.erasure/erase_if_exceptions.pass.cpp:2 FAIL
-
 # LLVM-158302: Clang 20 i686-pc-windows-msvc regression, silent bad codegen for std::current_exception()
 # SKIPPED because this is x86-specific.
 std/language.support/support.exception/except.nested/assign.pass.cpp:2 SKIPPED
@@ -429,11 +422,6 @@ std/containers/container.adaptors/flat.set/flat.set.cons/sorted_iter_iter.pass.c
 std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_range.pass.cpp FAIL
 std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_range.pass.cpp FAIL
 
-# FIXME! Possibly related to LLVM-140287.
-# MSVC error C2440: '<function-style-cast>': cannot convert from 'initializer list' to 'MinSequenceContainer<int,three_way_random_access_iterator<T *>,three_way_random_access_iterator<const T *>>'
-# Clang error: no matching constructor for initialization of 'container_type' (aka 'MinSequenceContainer<int>')
-std/containers/container.adaptors/flat.set/flat.set.cons/range.pass.cpp FAIL
-
 # FIXME! C++26 "P3372R3 constexpr Containers And Adaptors" isn't completely guarded with `TEST_STD_VER >= 26`.
 std/containers/container.adaptors/flat.set/flat.set.capacity/max_size.pass.cpp:0 FAIL
 std/containers/container.adaptors/flat.set/flat.set.capacity/max_size.pass.cpp:1 FAIL

From 042eb7b1b37d6ca7b80e8ee6a8730fe7d1cfabd9 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Thu, 27 Nov 2025 16:38:19 -0800
Subject: [PATCH 068/134] Categorize new failures.

---
 tests/libcxx/expected_results.txt | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/tests/libcxx/expected_results.txt b/tests/libcxx/expected_results.txt
index 43e524e9ba4..5d354f031d8 100644
--- a/tests/libcxx/expected_results.txt
+++ b/tests/libcxx/expected_results.txt
@@ -423,6 +423,30 @@ std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_r
 std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_range.pass.cpp FAIL
 
 # FIXME! C++26 "P3372R3 constexpr Containers And Adaptors" isn't completely guarded with `TEST_STD_VER >= 26`.
+std/containers/container.adaptors/flat.multiset/flat.multiset.capacity/max_size.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.multiset/flat.multiset.capacity/max_size.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/erase_key_transparent.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/erase_key_transparent.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/extract.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/extract.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_iter_iter.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_iter_iter.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.multiset/flat.multiset.observers/comp.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.multiset/flat.multiset.observers/comp.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.multiset/flat.multiset.operations/contains_transparent.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.multiset/flat.multiset.operations/contains_transparent.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.multiset/flat.multiset.operations/count_transparent.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.multiset/flat.multiset.operations/count_transparent.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.multiset/flat.multiset.operations/equal_range_transparent.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.multiset/flat.multiset.operations/equal_range_transparent.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.multiset/flat.multiset.operations/find_transparent.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.multiset/flat.multiset.operations/find_transparent.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.multiset/flat.multiset.operations/lower_bound_transparent.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.multiset/flat.multiset.operations/lower_bound_transparent.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.multiset/flat.multiset.operations/upper_bound_transparent.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.multiset/flat.multiset.operations/upper_bound_transparent.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.multiset/op_compare.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.multiset/op_compare.pass.cpp:1 FAIL
 std/containers/container.adaptors/flat.set/flat.set.capacity/max_size.pass.cpp:0 FAIL
 std/containers/container.adaptors/flat.set/flat.set.capacity/max_size.pass.cpp:1 FAIL
 std/containers/container.adaptors/flat.set/flat.set.modifiers/erase_key_transparent.pass.cpp:0 FAIL
@@ -448,6 +472,10 @@ std/containers/container.adaptors/flat.set/flat.set.operations/upper_bound_trans
 std/containers/container.adaptors/flat.set/op_compare.pass.cpp:0 FAIL
 std/containers/container.adaptors/flat.set/op_compare.pass.cpp:1 FAIL
 
+# FIXME! Looks like test code isn't defending itself against evil overloaded comma operators.
+std/containers/container.adaptors/flat.multiset/flat.multiset.iterators/iterator.pass.cpp FAIL
+std/containers/container.adaptors/flat.set/flat.set.iterators/iterator.pass.cpp FAIL
+
 # P2255R2 "Type Traits To Detect References Binding To Temporaries"
 # (type_traits.version.compile.pass.cpp still fails for Clang due to LLVM-48860)
 std/language.support/support.limits/support.limits.general/type_traits.version.compile.pass.cpp FAIL

From f09869f6b6e49e8ed45129de0c92a8aa39ec58db Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34@live.cn>
Date: Mon, 1 Dec 2025 22:31:48 +0800
Subject: [PATCH 069/134] Implement P3567R2 `flat_meow` Fixes (#5882)

Co-authored-by: Stephan T. Lavavej <stl@microsoft.com>
---
 stl/inc/deque                                 |   3 +
 stl/inc/flat_map                              |  47 +++-
 stl/inc/flat_set                              |  62 +++++-
 stl/inc/vector                                |   3 +
 stl/inc/xmemory                               |   5 +-
 stl/inc/yvals_core.h                          |   5 +-
 tests/libcxx/expected_results.txt             | 208 +++++++++---------
 tests/std/test.lst                            |   1 +
 tests/std/tests/P0429R9_flat_map/env.lst      |   2 +-
 tests/std/tests/P0429R9_flat_map/test.cpp     | 174 +++++++++------
 .../P0429R9_flat_map_ms_specific/env.lst      |   4 +
 .../test.compile.pass.cpp                     | 109 +++++++++
 tests/std/tests/P1222R4_flat_set/test.cpp     |  98 ++++++++-
 .../test.compile.pass.cpp                     |   4 +-
 14 files changed, 534 insertions(+), 191 deletions(-)
 create mode 100644 tests/std/tests/P0429R9_flat_map_ms_specific/env.lst
 create mode 100644 tests/std/tests/P0429R9_flat_map_ms_specific/test.compile.pass.cpp

diff --git a/stl/inc/deque b/stl/inc/deque
index 4f886126f16..82551c1b627 100644
--- a/stl/inc/deque
+++ b/stl/inc/deque
@@ -1852,6 +1852,9 @@ namespace pmr {
 #if _HAS_CXX23
 template <class _Ty, class _Alloc>
 constexpr bool _Has_guaranteed_push_back<deque<_Ty, _Alloc>> = true;
+
+template <class _Ty, class _Alloc>
+constexpr bool _Has_guaranteed_append_range<deque<_Ty, _Alloc>> = true;
 #endif // _HAS_CXX23
 _STD_END
 
diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index 1575edc71c8..441aaa02af5 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -248,6 +248,37 @@ struct _Pairing_iterator_provider {
     };
 };
 
+template <bool _IsNoexcept, class _Containers>
+struct _NODISCARD _Flat_map_swap_clear_guard {
+    // Invariant: (_Target1 == nullptr) == (_Target2 == nullptr)
+    _Containers* _Target1;
+    _Containers* _Target2;
+
+    _Flat_map_swap_clear_guard& operator=(const _Flat_map_swap_clear_guard&) = delete;
+
+    void _Dismiss() noexcept {
+        _Target1 = nullptr;
+        _Target2 = nullptr;
+    }
+
+    ~_Flat_map_swap_clear_guard() {
+        if (_Target1) {
+            _Target1->keys.clear();
+            _Target1->values.clear();
+            _Target2->keys.clear();
+            _Target2->values.clear();
+        }
+    }
+};
+template <class _Containers>
+struct _NODISCARD _Flat_map_swap_clear_guard<true, _Containers> {
+    constexpr explicit _Flat_map_swap_clear_guard(_Containers*, _Containers*) noexcept {}
+
+    _Flat_map_swap_clear_guard& operator=(const _Flat_map_swap_clear_guard&) = delete;
+
+    void _Dismiss() noexcept {}
+};
+
 _EXPORT_STD template <class _Key, class _Mapped, class _Compare = less<_Key>, class _KeyContainer = vector<_Key>,
     class _MappedContainer = vector<_Mapped>>
 class flat_map;
@@ -527,11 +558,18 @@ public:
         return _STD make_reverse_iterator(cbegin());
     }
 
-    void swap(_Derived& _Other) noexcept {
+    void swap(_Derived& _Other)
+        noexcept(is_nothrow_swappable_v<_KeyContainer> && is_nothrow_swappable_v<_MappedContainer>
+                 && is_nothrow_swappable_v<_Compare>) {
+        constexpr bool _Is_noexcept = is_nothrow_swappable_v<_KeyContainer> && is_nothrow_swappable_v<_MappedContainer>
+                                   && is_nothrow_swappable_v<_Compare>;
         auto& _Other_base = static_cast<_Flat_map_base&>(_Other);
+        _Flat_map_swap_clear_guard<_Is_noexcept, containers> _Guard{
+            _STD addressof(_Data), _STD addressof(_Other_base._Data)};
         _RANGES swap(_Key_compare, _Other_base._Key_compare);
         _RANGES swap(_Data.keys, _Other_base._Data.keys);
         _RANGES swap(_Data.values, _Other_base._Data.values);
+        _Guard._Dismiss();
     }
 
     // [container.reqmts] clear
@@ -591,6 +629,11 @@ public:
         _Insert_range<true>(_RANGES begin(_Range), _RANGES end(_Range));
     }
 
+    template <_Container_compatible_range<value_type> _Rng>
+    void insert_range(_Sorted_t, _Rng&& _Range) {
+        _Insert_range<false>(_RANGES begin(_Range), _RANGES end(_Range));
+    }
+
     void insert(initializer_list<value_type> _Ilist) {
         _Insert_range<true>(_Ilist.begin(), _Ilist.end());
     }
@@ -790,7 +833,7 @@ public:
             _STD _Get_unwrapped(_STD cend(_Right)), _Synth_three_way{});
     }
 
-    friend void swap(_Derived& _Left, _Derived& _Right) noexcept {
+    friend void swap(_Derived& _Left, _Derived& _Right) noexcept(noexcept(_Left.swap(_Right))) {
         _Left.swap(_Right);
     }
 
diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index 1ec4c6ce049..fe26264da45 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -24,6 +24,35 @@ _STL_DISABLE_CLANG_WARNINGS
 #undef new
 
 _STD_BEGIN
+template <bool _IsNoexcept, class _Container>
+struct _NODISCARD _Flat_set_swap_clear_guard {
+    // Invariant: (_Target1 == nullptr) == (_Target2 == nullptr)
+    _Container* _Target1;
+    _Container* _Target2;
+
+    _Flat_set_swap_clear_guard& operator=(const _Flat_set_swap_clear_guard&) = delete;
+
+    void _Dismiss() noexcept {
+        _Target1 = nullptr;
+        _Target2 = nullptr;
+    }
+
+    ~_Flat_set_swap_clear_guard() {
+        if (_Target1) {
+            _Target1->clear();
+            _Target2->clear();
+        }
+    }
+};
+template <class _Container>
+struct _NODISCARD _Flat_set_swap_clear_guard<true, _Container> {
+    constexpr explicit _Flat_set_swap_clear_guard(_Container*, _Container*) noexcept {}
+
+    _Flat_set_swap_clear_guard& operator=(const _Flat_set_swap_clear_guard&) = delete;
+
+    void _Dismiss() noexcept {}
+};
+
 _EXPORT_STD template <class _Kty, class _Keylt = less<_Kty>, class _Container = vector<_Kty>>
 class flat_set;
 
@@ -297,14 +326,11 @@ public:
     }
     template <_Container_compatible_range<_Kty> _Rng>
     void insert_range(_Rng&& _Range) {
-        const size_type _Old_size = size();
-
-        if constexpr (requires { _Mycont.append_range(_STD forward<_Rng>(_Range)); }) {
-            _Mycont.append_range(_STD forward<_Rng>(_Range));
-        } else {
-            _Mycont.insert_range(_Mycont.end(), _STD forward<_Rng>(_Range));
-        }
-        _Restore_invariants_after_insert<true>(_Old_size);
+        _Insert_range<true>(_STD forward<_Rng>(_Range));
+    }
+    template <_Container_compatible_range<_Kty> _Rng>
+    void insert_range(_Sorted_t, _Rng&& _Range) {
+        _Insert_range<false>(_STD forward<_Rng>(_Range));
     }
 
     void insert(initializer_list<_Kty> _Ilist) {
@@ -343,9 +369,13 @@ public:
         return _Mycont.erase(_First, _Last);
     }
 
-    void swap(_Derived& _Other) noexcept {
+    void swap(_Derived& _Other) noexcept(is_nothrow_swappable_v<_Container> && is_nothrow_swappable_v<_Keylt>) {
+        constexpr bool _Is_noexcept = is_nothrow_swappable_v<_Container> && is_nothrow_swappable_v<_Keylt>;
+        _Flat_set_swap_clear_guard<_Is_noexcept, _Container> _Guard{
+            _STD addressof(_Mycont), _STD addressof(_Other._Mycont)};
         _RANGES swap(_Mycomp, _Other._Mycomp);
         _RANGES swap(_Mycont, _Other._Mycont);
+        _Guard._Dismiss();
     }
     void clear() noexcept {
         _Mycont.clear();
@@ -434,7 +464,7 @@ public:
             _Lhs.cbegin(), _Lhs.cend(), _Rhs.cbegin(), _Rhs.cend(), _Synth_three_way{});
     }
 
-    friend void swap(_Derived& _Lhs, _Derived& _Rhs) noexcept {
+    friend void swap(_Derived& _Lhs, _Derived& _Rhs) noexcept(noexcept(_Lhs.swap(_Rhs))) {
         _Lhs.swap(_Rhs);
     }
 
@@ -574,6 +604,18 @@ private:
         _Restore_invariants_after_insert<_NeedSorting>(_Old_size);
         _Guard._Target = nullptr;
     }
+    template <bool _NeedSorting, _Container_compatible_range<_Kty> _Rng>
+    void _Insert_range(_Rng&& _Range) {
+        const size_type _Old_size = size();
+        _Clear_guard _Guard{this};
+        if constexpr (_Has_guaranteed_append_range<_Container>) {
+            _Mycont.append_range(_STD forward<_Rng>(_Range));
+        } else {
+            _Mycont.insert_range(_Mycont.end(), _STD forward<_Rng>(_Range));
+        }
+        _Restore_invariants_after_insert<_NeedSorting>(_Old_size);
+        _Guard._Target = nullptr;
+    }
 
     template <class _Ty>
     _NODISCARD size_type _Erase(const _Ty& _Val) {
diff --git a/stl/inc/vector b/stl/inc/vector
index 190fd936248..816bf4d6b9c 100644
--- a/stl/inc/vector
+++ b/stl/inc/vector
@@ -4077,6 +4077,9 @@ constexpr bool _Is_vector_bool<vector<bool, _Alloc>> = true;
 template <class _Ty, class _Alloc>
 constexpr bool _Has_guaranteed_push_back<vector<_Ty, _Alloc>> = !is_same_v<_Ty, bool>;
 
+template <class _Ty, class _Alloc>
+constexpr bool _Has_guaranteed_append_range<vector<_Ty, _Alloc>> = !is_same_v<_Ty, bool>;
+
 template <class _Alloc, class... _Containers>
 concept _Usable_allocator_for = (uses_allocator_v<_Containers, _Alloc> && ...);
 
diff --git a/stl/inc/xmemory b/stl/inc/xmemory
index b46376761e3..d2d00fb01fc 100644
--- a/stl/inc/xmemory
+++ b/stl/inc/xmemory
@@ -2762,7 +2762,10 @@ namespace ranges {
 } // namespace ranges
 
 template <class>
-constexpr bool _Has_guaranteed_push_back = false; // N5008 [sequence.reqmts]/104, /108; used by flat_(multi)map::insert.
+constexpr bool _Has_guaranteed_push_back = false; // N5014 [sequence.reqmts]/104, /108; used by flat_(multi)map::insert.
+
+template <class>
+constexpr bool _Has_guaranteed_append_range = false; // N5014 [sequence.reqmts]/112; used by flat_(multi)set::insert.
 #endif // _HAS_CXX23
 
 template <class _Elem, class _UTy>
diff --git a/stl/inc/yvals_core.h b/stl/inc/yvals_core.h
index f401088c454..37f97b69c90 100644
--- a/stl/inc/yvals_core.h
+++ b/stl/inc/yvals_core.h
@@ -411,6 +411,7 @@
 // P3142R0 Printing Blank Lines With println()
 // P3235R3 std::print More Types Faster With Less Memory
 //     (partial implementation; see GH-4924)
+// P3567R2 flat_meow Fixes
 
 // _HAS_CXX23 and _SILENCE_ALL_CXX23_DEPRECATION_WARNINGS control:
 // P1413R3 Deprecate aligned_storage And aligned_union
@@ -1767,8 +1768,8 @@ _EMIT_STL_ERROR(STL1004, "C++98 unexpected() is incompatible with C++23 unexpect
 #define __cpp_lib_constexpr_typeinfo                202106L
 #define __cpp_lib_containers_ranges                 202202L
 #define __cpp_lib_expected                          202211L
-#define __cpp_lib_flat_map                          202207L
-#define __cpp_lib_flat_set                          202207L
+#define __cpp_lib_flat_map                          202511L
+#define __cpp_lib_flat_set                          202511L
 #define __cpp_lib_format_ranges                     202207L
 #define __cpp_lib_formatters                        202302L
 #define __cpp_lib_forward_like                      202207L
diff --git a/tests/libcxx/expected_results.txt b/tests/libcxx/expected_results.txt
index 5d354f031d8..adfd72a9139 100644
--- a/tests/libcxx/expected_results.txt
+++ b/tests/libcxx/expected_results.txt
@@ -152,6 +152,18 @@ std/atomics/atomics.ref/member_types.compile.pass.cpp FAIL
 std/thread/futures/futures.promise/uses_allocator.pass.cpp FAIL
 std/thread/futures/futures.task/futures.task.members/ctor2.compile.pass.cpp FAIL
 
+# libc++ has not implemented P3567R2: "flat_meow Fixes"
+std/containers/container.adaptors/flat.map/flat.map.modifiers/swap_free.pass.cpp FAIL
+std/containers/container.adaptors/flat.map/flat.map.modifiers/swap_member.pass.cpp FAIL
+std/containers/container.adaptors/flat.multimap/flat.multimap.modifiers/swap_free.pass.cpp FAIL
+std/containers/container.adaptors/flat.multimap/flat.multimap.modifiers/swap_member.pass.cpp FAIL
+std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/swap_free.pass.cpp FAIL
+std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/swap_member.pass.cpp FAIL
+std/containers/container.adaptors/flat.set/flat.set.modifiers/swap_free.pass.cpp FAIL
+std/containers/container.adaptors/flat.set/flat.set.modifiers/swap_member.pass.cpp FAIL
+std/language.support/support.limits/support.limits.general/flat_map.version.compile.pass.cpp FAIL
+std/language.support/support.limits/support.limits.general/flat_set.version.compile.pass.cpp FAIL
+
 # Various bogosity (LLVM-D141004)
 std/utilities/utility/mem.res/mem.res.pool/mem.res.pool.ctor/ctor_does_not_allocate.pass.cpp FAIL
 std/utilities/utility/mem.res/mem.res.pool/mem.res.pool.ctor/sync_with_default_resource.pass.cpp FAIL
@@ -303,7 +315,99 @@ std/containers/container.adaptors/flat.multimap/flat.multimap.cons/sorted_iter_i
 std/containers/container.adaptors/flat.multimap/flat.multimap.modifiers/erase_key.pass.cpp:0 FAIL
 std/containers/container.adaptors/flat.multimap/flat.multimap.modifiers/erase_key.pass.cpp:1 FAIL
 
-# FIXME! C++26 "P3372R3 constexpr Containers And Adaptors" isn't completely guarded with `TEST_STD_VER >= 26`.
+# FIXME! error: conversion function from 'pair<_Unrefwrap_t<int>, _Unrefwrap_t<int>>' to 'pair<const int &, const char &>' invokes a deleted function
+std/containers/container.adaptors/flat.map/flat.map.observers/comp.pass.cpp:2 FAIL
+std/containers/container.adaptors/flat.multimap/flat.multimap.observers/comp.pass.cpp:2 FAIL
+
+# P0533R9 constexpr For <cmath> And <cstdlib>
+std/language.support/support.limits/support.limits.general/cmath.version.compile.pass.cpp FAIL
+std/language.support/support.limits/support.limits.general/cstdlib.version.compile.pass.cpp FAIL
+
+# P0543R3 Saturation Arithmetic
+# Add 'std-at-least-c++26' to tests/utils/stl/test/tests.py when beginning work on C++26.
+std/numerics/numeric.ops/numeric.ops.sat/add_sat.compile.pass.cpp FAIL
+std/numerics/numeric.ops/numeric.ops.sat/add_sat.pass.cpp FAIL
+std/numerics/numeric.ops/numeric.ops.sat/div_sat.compile.pass.cpp FAIL
+std/numerics/numeric.ops/numeric.ops.sat/div_sat.pass.cpp FAIL
+std/numerics/numeric.ops/numeric.ops.sat/mul_sat.compile.pass.cpp FAIL
+std/numerics/numeric.ops/numeric.ops.sat/mul_sat.pass.cpp FAIL
+std/numerics/numeric.ops/numeric.ops.sat/saturate_cast.compile.pass.cpp FAIL
+std/numerics/numeric.ops/numeric.ops.sat/saturate_cast.pass.cpp FAIL
+std/numerics/numeric.ops/numeric.ops.sat/sub_sat.compile.pass.cpp FAIL
+std/numerics/numeric.ops/numeric.ops.sat/sub_sat.pass.cpp FAIL
+
+# P1222R4 <flat_set>
+
+# FIXME! error: static assertion failed due to requirement '!std::is_nothrow_move_constructible_v<std::flat_MEOW<int, ThrowingMoveComp, std::vector<int, std::allocator<int>>>>'
+std/containers/container.adaptors/flat.multiset/flat.multiset.cons/move.pass.cpp FAIL
+std/containers/container.adaptors/flat.set/flat.set.cons/move.pass.cpp FAIL
+
+# FIXME! error: call to implicitly-deleted copy constructor of 'container_type' (aka 'MoveAssignThrows')
+std/containers/container.adaptors/flat.multiset/flat.multiset.cons/move_assign.pass.cpp FAIL
+std/containers/container.adaptors/flat.set/flat.set.cons/move_assign.pass.cpp FAIL
+
+# FIXME! Assertion failed: r == m.begin() + 2
+std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/emplace_hint.pass.cpp FAIL
+
+# FIXME! Assertion failed: r == m.begin() + 1
+std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_iter_rv.pass.cpp FAIL
+
+# FIXME! warning C4242: 'initializing': conversion from 'int' to '_Ty', possible loss of data
+std/containers/container.adaptors/flat.multiset/flat.multiset.cons/sorted_iter_iter.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.multiset/flat.multiset.cons/sorted_iter_iter.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.set/flat.set.cons/sorted_iter_iter.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.set/flat.set.cons/sorted_iter_iter.pass.cpp:1 FAIL
+
+# FIXME! Looks like test code isn't defending itself against evil overloaded comma operators.
+std/containers/container.adaptors/flat.multiset/flat.multiset.iterators/iterator.pass.cpp FAIL
+std/containers/container.adaptors/flat.set/flat.set.iterators/iterator.pass.cpp FAIL
+
+# P2255R2 "Type Traits To Detect References Binding To Temporaries"
+# (type_traits.version.compile.pass.cpp still fails for Clang due to LLVM-48860)
+std/language.support/support.limits/support.limits.general/type_traits.version.compile.pass.cpp FAIL
+std/utilities/meta/meta.unary/meta.unary.prop/reference_constructs_from_temporary.pass.cpp:0 FAIL
+std/utilities/meta/meta.unary/meta.unary.prop/reference_constructs_from_temporary.pass.cpp:1 FAIL
+std/utilities/meta/meta.unary/meta.unary.prop/reference_converts_from_temporary.pass.cpp:0 FAIL
+std/utilities/meta/meta.unary/meta.unary.prop/reference_converts_from_temporary.pass.cpp:1 FAIL
+
+# P2835R7 atomic_ref::address()
+# Add 'std-at-least-c++26' to tests/utils/stl/test/tests.py when beginning work on C++26.
+std/atomics/atomics.ref/address.pass.cpp FAIL
+
+# P2944R3 Comparisons For reference_wrapper
+# Add 'std-at-least-c++26' to tests/utils/stl/test/tests.py when beginning work on C++26.
+std/utilities/function.objects/refwrap/refwrap.comparisons/compare.three_way.refwrap.const_ref.pass.cpp FAIL
+std/utilities/function.objects/refwrap/refwrap.comparisons/compare.three_way.refwrap.refwrap_const.pass.cpp FAIL
+std/utilities/function.objects/refwrap/refwrap.comparisons/compare.three_way.refwrap.refwrap.pass.cpp FAIL
+
+# P2988R12 optional<T&>
+# Add 'std-at-least-c++26' to tests/utils/stl/test/tests.py when beginning work on C++26.
+std/utilities/optional/optional.object/optional.object.ctor/ref_t.pass.cpp FAIL
+
+# P3044R2 basic_string::subview()
+# Add 'std-at-least-c++26' to tests/utils/stl/test/tests.py when beginning work on C++26.
+std/strings/basic.string/string.ops/string_substr/subview.pass.cpp FAIL
+std/strings/string.view/string.view.ops/subview.pass.cpp FAIL
+
+# P3060R3 views::indices
+# Add 'std-at-least-c++26' to tests/utils/stl/test/tests.py when beginning work on C++26.
+std/ranges/range.factories/range.iota.view/indices.pass.cpp FAIL
+
+# P3168R2 std::optional Range Support
+# Add 'std-at-least-c++26' to tests/utils/stl/test/tests.py when beginning work on C++26.
+std/utilities/optional/optional.iterator/begin.pass.cpp FAIL
+std/utilities/optional/optional.iterator/borrowed_range.compile.pass.cpp FAIL
+std/utilities/optional/optional.iterator/end.pass.cpp FAIL
+std/utilities/optional/optional.iterator/iterator.pass.cpp FAIL
+
+
+# *** MISSING COMPILER FEATURES ***
+
+# VSO-2581622 C1XX should implement `__builtin_is_implicit_lifetime`
+std/utilities/meta/meta.unary/meta.unary.prop/is_implicit_lifetime.pass.cpp:0 FAIL
+std/utilities/meta/meta.unary/meta.unary.prop/is_implicit_lifetime.pass.cpp:1 FAIL
+
+# MSVC has not implemented P2448R2 "Relaxing some constexpr restrictions"
 std/containers/container.adaptors/flat.map/flat.map.access/at_transparent.pass.cpp:0 FAIL
 std/containers/container.adaptors/flat.map/flat.map.access/at_transparent.pass.cpp:1 FAIL
 std/containers/container.adaptors/flat.map/flat.map.access/index_transparent.pass.cpp:0 FAIL
@@ -374,55 +478,6 @@ std/containers/container.adaptors/flat.multimap/flat.multimap.operations/lower_b
 std/containers/container.adaptors/flat.multimap/flat.multimap.operations/lower_bound_transparent.pass.cpp:1 FAIL
 std/containers/container.adaptors/flat.multimap/flat.multimap.operations/upper_bound_transparent.pass.cpp:0 FAIL
 std/containers/container.adaptors/flat.multimap/flat.multimap.operations/upper_bound_transparent.pass.cpp:1 FAIL
-
-# FIXME! error: conversion function from 'pair<_Unrefwrap_t<int>, _Unrefwrap_t<int>>' to 'pair<const int &, const char &>' invokes a deleted function
-std/containers/container.adaptors/flat.map/flat.map.observers/comp.pass.cpp:2 FAIL
-std/containers/container.adaptors/flat.multimap/flat.multimap.observers/comp.pass.cpp:2 FAIL
-
-# P0533R9 constexpr For <cmath> And <cstdlib>
-std/language.support/support.limits/support.limits.general/cmath.version.compile.pass.cpp FAIL
-std/language.support/support.limits/support.limits.general/cstdlib.version.compile.pass.cpp FAIL
-
-# P0543R3 Saturation Arithmetic
-# Add 'std-at-least-c++26' to tests/utils/stl/test/tests.py when beginning work on C++26.
-std/numerics/numeric.ops/numeric.ops.sat/add_sat.compile.pass.cpp FAIL
-std/numerics/numeric.ops/numeric.ops.sat/add_sat.pass.cpp FAIL
-std/numerics/numeric.ops/numeric.ops.sat/div_sat.compile.pass.cpp FAIL
-std/numerics/numeric.ops/numeric.ops.sat/div_sat.pass.cpp FAIL
-std/numerics/numeric.ops/numeric.ops.sat/mul_sat.compile.pass.cpp FAIL
-std/numerics/numeric.ops/numeric.ops.sat/mul_sat.pass.cpp FAIL
-std/numerics/numeric.ops/numeric.ops.sat/saturate_cast.compile.pass.cpp FAIL
-std/numerics/numeric.ops/numeric.ops.sat/saturate_cast.pass.cpp FAIL
-std/numerics/numeric.ops/numeric.ops.sat/sub_sat.compile.pass.cpp FAIL
-std/numerics/numeric.ops/numeric.ops.sat/sub_sat.pass.cpp FAIL
-
-# P1222R4 <flat_set>
-
-# FIXME! error: static assertion failed due to requirement '!std::is_nothrow_move_constructible_v<std::flat_MEOW<int, ThrowingMoveComp, std::vector<int, std::allocator<int>>>>'
-std/containers/container.adaptors/flat.multiset/flat.multiset.cons/move.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.cons/move.pass.cpp FAIL
-
-# FIXME! error: call to implicitly-deleted copy constructor of 'container_type' (aka 'MoveAssignThrows')
-std/containers/container.adaptors/flat.multiset/flat.multiset.cons/move_assign.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.cons/move_assign.pass.cpp FAIL
-
-# FIXME! Assertion failed: r == m.begin() + 2
-std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/emplace_hint.pass.cpp FAIL
-
-# FIXME! Assertion failed: r == m.begin() + 1
-std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_iter_rv.pass.cpp FAIL
-
-# FIXME! warning C4242: 'initializing': conversion from 'int' to '_Ty', possible loss of data
-std/containers/container.adaptors/flat.multiset/flat.multiset.cons/sorted_iter_iter.pass.cpp:0 FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.cons/sorted_iter_iter.pass.cpp:1 FAIL
-std/containers/container.adaptors/flat.set/flat.set.cons/sorted_iter_iter.pass.cpp:0 FAIL
-std/containers/container.adaptors/flat.set/flat.set.cons/sorted_iter_iter.pass.cpp:1 FAIL
-
-# FIXME! Asserts while testing insert_range's exception guarantee.
-std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_range.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_range.pass.cpp FAIL
-
-# FIXME! C++26 "P3372R3 constexpr Containers And Adaptors" isn't completely guarded with `TEST_STD_VER >= 26`.
 std/containers/container.adaptors/flat.multiset/flat.multiset.capacity/max_size.pass.cpp:0 FAIL
 std/containers/container.adaptors/flat.multiset/flat.multiset.capacity/max_size.pass.cpp:1 FAIL
 std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/erase_key_transparent.pass.cpp:0 FAIL
@@ -431,6 +486,8 @@ std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/extract.
 std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/extract.pass.cpp:1 FAIL
 std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_iter_iter.pass.cpp:0 FAIL
 std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_iter_iter.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_range.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_range.pass.cpp:1 FAIL
 std/containers/container.adaptors/flat.multiset/flat.multiset.observers/comp.pass.cpp:0 FAIL
 std/containers/container.adaptors/flat.multiset/flat.multiset.observers/comp.pass.cpp:1 FAIL
 std/containers/container.adaptors/flat.multiset/flat.multiset.operations/contains_transparent.pass.cpp:0 FAIL
@@ -455,6 +512,8 @@ std/containers/container.adaptors/flat.set/flat.set.modifiers/extract.pass.cpp:0
 std/containers/container.adaptors/flat.set/flat.set.modifiers/extract.pass.cpp:1 FAIL
 std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_iter_iter.pass.cpp:0 FAIL
 std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_iter_iter.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_range.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_range.pass.cpp:1 FAIL
 std/containers/container.adaptors/flat.set/flat.set.observers/comp.pass.cpp:0 FAIL
 std/containers/container.adaptors/flat.set/flat.set.observers/comp.pass.cpp:1 FAIL
 std/containers/container.adaptors/flat.set/flat.set.operations/contains_transparent.pass.cpp:0 FAIL
@@ -472,55 +531,6 @@ std/containers/container.adaptors/flat.set/flat.set.operations/upper_bound_trans
 std/containers/container.adaptors/flat.set/op_compare.pass.cpp:0 FAIL
 std/containers/container.adaptors/flat.set/op_compare.pass.cpp:1 FAIL
 
-# FIXME! Looks like test code isn't defending itself against evil overloaded comma operators.
-std/containers/container.adaptors/flat.multiset/flat.multiset.iterators/iterator.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.iterators/iterator.pass.cpp FAIL
-
-# P2255R2 "Type Traits To Detect References Binding To Temporaries"
-# (type_traits.version.compile.pass.cpp still fails for Clang due to LLVM-48860)
-std/language.support/support.limits/support.limits.general/type_traits.version.compile.pass.cpp FAIL
-std/utilities/meta/meta.unary/meta.unary.prop/reference_constructs_from_temporary.pass.cpp:0 FAIL
-std/utilities/meta/meta.unary/meta.unary.prop/reference_constructs_from_temporary.pass.cpp:1 FAIL
-std/utilities/meta/meta.unary/meta.unary.prop/reference_converts_from_temporary.pass.cpp:0 FAIL
-std/utilities/meta/meta.unary/meta.unary.prop/reference_converts_from_temporary.pass.cpp:1 FAIL
-
-# P2835R7 atomic_ref::address()
-# Add 'std-at-least-c++26' to tests/utils/stl/test/tests.py when beginning work on C++26.
-std/atomics/atomics.ref/address.pass.cpp FAIL
-
-# P2944R3 Comparisons For reference_wrapper
-# Add 'std-at-least-c++26' to tests/utils/stl/test/tests.py when beginning work on C++26.
-std/utilities/function.objects/refwrap/refwrap.comparisons/compare.three_way.refwrap.const_ref.pass.cpp FAIL
-std/utilities/function.objects/refwrap/refwrap.comparisons/compare.three_way.refwrap.refwrap_const.pass.cpp FAIL
-std/utilities/function.objects/refwrap/refwrap.comparisons/compare.three_way.refwrap.refwrap.pass.cpp FAIL
-
-# P2988R12 optional<T&>
-# Add 'std-at-least-c++26' to tests/utils/stl/test/tests.py when beginning work on C++26.
-std/utilities/optional/optional.object/optional.object.ctor/ref_t.pass.cpp FAIL
-
-# P3044R2 basic_string::subview()
-# Add 'std-at-least-c++26' to tests/utils/stl/test/tests.py when beginning work on C++26.
-std/strings/basic.string/string.ops/string_substr/subview.pass.cpp FAIL
-std/strings/string.view/string.view.ops/subview.pass.cpp FAIL
-
-# P3060R3 views::indices
-# Add 'std-at-least-c++26' to tests/utils/stl/test/tests.py when beginning work on C++26.
-std/ranges/range.factories/range.iota.view/indices.pass.cpp FAIL
-
-# P3168R2 std::optional Range Support
-# Add 'std-at-least-c++26' to tests/utils/stl/test/tests.py when beginning work on C++26.
-std/utilities/optional/optional.iterator/begin.pass.cpp FAIL
-std/utilities/optional/optional.iterator/borrowed_range.compile.pass.cpp FAIL
-std/utilities/optional/optional.iterator/end.pass.cpp FAIL
-std/utilities/optional/optional.iterator/iterator.pass.cpp FAIL
-
-
-# *** MISSING COMPILER FEATURES ***
-
-# VSO-2581622 C1XX should implement `__builtin_is_implicit_lifetime`
-std/utilities/meta/meta.unary/meta.unary.prop/is_implicit_lifetime.pass.cpp:0 FAIL
-std/utilities/meta/meta.unary/meta.unary.prop/is_implicit_lifetime.pass.cpp:1 FAIL
-
 
 # *** MISSING LWG ISSUE RESOLUTIONS ***
 # LWG-2532 "Satisfying a promise at thread exit" (Open)
diff --git a/tests/std/test.lst b/tests/std/test.lst
index 764f052399d..03b92e9a84a 100644
--- a/tests/std/test.lst
+++ b/tests/std/test.lst
@@ -380,6 +380,7 @@ tests\P0414R2_shared_ptr_for_arrays
 tests\P0415R1_constexpr_complex
 tests\P0426R1_constexpr_char_traits
 tests\P0429R9_flat_map
+tests\P0429R9_flat_map_ms_specific
 tests\P0433R2_deduction_guides
 tests\P0448R4_iosfwd
 tests\P0448R4_spanstream
diff --git a/tests/std/tests/P0429R9_flat_map/env.lst b/tests/std/tests/P0429R9_flat_map/env.lst
index b2dc2c0f570..642f530ffad 100644
--- a/tests/std/tests/P0429R9_flat_map/env.lst
+++ b/tests/std/tests/P0429R9_flat_map/env.lst
@@ -1,4 +1,4 @@
 # Copyright (c) Microsoft Corporation.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-RUNALL_INCLUDE ..\strict_latest_matrix.lst
+RUNALL_INCLUDE ..\usual_latest_matrix.lst
diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index 977844600b5..74e88ddc81d 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -475,6 +475,33 @@ void test_insert() {
     assert(check_value_content(fmm, {'m', 'n', 'p', 'q', 'w'}));
 }
 
+void test_insert_range() {
+    {
+        flat_map<int, char> fm{{1, 'p'}, {4, 'q'}, {9, 'r'}};
+        using char_type_array = flat_map<int, char>::value_type[];
+
+        fm.insert_range(char_type_array{{16, 'x'}, {9, 'y'}, {4, 'z'}});
+        assert(check_key_content(fm, {1, 4, 9, 16}));
+        assert(check_value_content(fm, {'p', 'q', 'r', 'x'}));
+
+        fm.insert_range(sorted_unique, char_type_array{{9, 'a'}, {16, 'b'}, {25, 'c'}});
+        assert(check_key_content(fm, {1, 4, 9, 16, 25}));
+        assert(check_value_content(fm, {'p', 'q', 'r', 'x', 'c'}));
+    }
+    {
+        flat_multimap<int, char> fmm{{1, 'p'}, {4, 'q'}, {9, 'r'}};
+        using char_type_array = flat_multimap<int, char>::value_type[];
+
+        fmm.insert_range(char_type_array{{16, 'x'}, {9, 'y'}, {4, 'z'}});
+        assert(check_key_content(fmm, {1, 4, 4, 9, 9, 16}));
+        assert(check_value_content(fmm, {'p', 'q', 'z', 'r', 'y', 'x'}));
+
+        fmm.insert_range(sorted_equivalent, char_type_array{{9, 'a'}, {16, 'b'}, {25, 'c'}});
+        assert(check_key_content(fmm, {1, 4, 4, 9, 9, 9, 16, 16, 25}));
+        assert(check_value_content(fmm, {'p', 'q', 'z', 'r', 'y', 'a', 'x', 'b', 'c'}));
+    }
+}
+
 // GH-4344 <flat_map> Fix compile errors
 void test_gh_4344() {
     flat_map<int, char> fm;
@@ -655,79 +682,88 @@ void test_comparison() {
     }
 }
 
-// Test MSVC STL-specific SCARY-ness
-
-template <bool>
-struct flat_map_unique_if_impl;
-template <>
-struct flat_map_unique_if_impl<true> {
-    template <class Key, class Mapped, class Comp, class KeyCont, class MappedCont>
-    using type = flat_map<Key, Mapped, Comp, KeyCont, MappedCont>;
-};
-template <>
-struct flat_map_unique_if_impl<false> {
-    template <class Key, class Mapped, class Comp, class KeyCont, class MappedCont>
-    using type = flat_multimap<Key, Mapped, Comp, KeyCont, MappedCont>;
-};
-
-template <bool IsUnique, class Key, class Mapped, class Comp, class KeyCont, class MappedCont>
-using flat_map_unique_if = flat_map_unique_if_impl<IsUnique>::template type<Key, Mapped, Comp, KeyCont, MappedCont>;
-
-template <bool IsUnique, class Comparator, class Alloc1, class Alloc2>
-void test_scary_ness_one() { // COMPILE-ONLY
-    using Iter = flat_map<int, int>::iterator;
-    using OtherIter =
-        flat_map_unique_if<IsUnique, int, int, Comparator, vector<int, Alloc1>, vector<int, Alloc2>>::iterator;
-    static_assert(is_same_v<Iter, OtherIter>);
-
-    using ConstIter = flat_map<int, int>::const_iterator;
-    using OtherConstIter =
-        flat_map_unique_if<IsUnique, int, int, Comparator, vector<int, Alloc1>, vector<int, Alloc2>>::const_iterator;
-    static_assert(is_same_v<ConstIter, OtherConstIter>);
-
-    using Cont = flat_map<int, int, less<int>, vector<int, Alloc1>, vector<int, Alloc2>>::containers;
-    using OtherCont =
-        flat_map_unique_if<IsUnique, int, int, Comparator, vector<int, Alloc1>, vector<int, Alloc2>>::containers;
-    static_assert(is_same_v<Cont, OtherCont>);
-
-    using ValueComp = flat_map<int, int, Comparator, vector<int, Alloc1>, vector<int, Alloc2>>::value_compare;
-    using OtherValueComp1 =
-        flat_map_unique_if<IsUnique, int, int, Comparator, vector<int, Alloc1>, vector<int, Alloc2>>::value_compare;
-    using OtherValueComp2 = flat_map_unique_if<IsUnique, int, int, Comparator, vector<int>, vector<int>>::value_compare;
-    using OtherValueComp3 =
-        flat_map_unique_if<IsUnique, int, int, Comparator, vector<int, Alloc1>, deque<int, Alloc2>>::value_compare;
-    using OtherValueComp4 =
-        flat_map_unique_if<IsUnique, int, int, Comparator, deque<int, Alloc1>, vector<int, Alloc2>>::value_compare;
-    static_assert(is_same_v<ValueComp, OtherValueComp1>);
-    static_assert(is_same_v<ValueComp, OtherValueComp2>);
-    static_assert(is_same_v<ValueComp, OtherValueComp3>);
-    static_assert(is_same_v<ValueComp, OtherValueComp4>);
-}
-
-void test_scary_ness() { // COMPILE-ONLY
-    test_scary_ness_one<true, greater<int>, allocator<int>, allocator<int>>();
-    test_scary_ness_one<true, greater<int>, allocator<int>, MyAllocator<int>>();
-    test_scary_ness_one<true, greater<int>, MyAllocator<int>, allocator<int>>();
+namespace test_throwing_swap {
+    struct unique_exception {};
 
-    test_scary_ness_one<true, less<>, allocator<int>, allocator<int>>();
-    test_scary_ness_one<true, less<>, allocator<int>, MyAllocator<int>>();
-    test_scary_ness_one<true, less<>, MyAllocator<int>, allocator<int>>();
+    template <class T>
+    struct throwing_less {
+        static bool operator()(const T& left, const T& right) {
+            return left < right;
+        }
 
-    test_scary_ness_one<true, greater<>, allocator<int>, allocator<int>>();
-    test_scary_ness_one<true, greater<>, allocator<int>, MyAllocator<int>>();
-    test_scary_ness_one<true, greater<>, MyAllocator<int>, allocator<int>>();
+        bool throws_;
+    };
 
-    test_scary_ness_one<false, greater<int>, allocator<int>, allocator<int>>();
-    test_scary_ness_one<false, greater<int>, allocator<int>, MyAllocator<int>>();
-    test_scary_ness_one<false, greater<int>, MyAllocator<int>, allocator<int>>();
+    template <class T>
+    void swap(throwing_less<T>& lhs, throwing_less<T>& rhs) {
+        if (lhs.throws_ || rhs.throws_) {
+            throw unique_exception{};
+        }
+    }
+} // namespace test_throwing_swap
+
+template <template <class...> class FlatMapCont, template <class...> class KeyCont,
+    template <class...> class MappedCont>
+void test_throwing_compare_swap_single() {
+    using test_throwing_swap::unique_exception;
+    using comparator = test_throwing_swap::throwing_less<int>;
+
+    using map_type =
+        FlatMapCont<int, char, comparator, KeyCont<int, allocator<int>>, MappedCont<char, allocator<char>>>;
+    using value_type = map_type::value_type;
+    static_assert(!is_nothrow_swappable_v<map_type>);
+    {
+        map_type m1{{{1, 'x'}, {2, 'y'}, {3, 'z'}}, comparator{false}};
+        map_type m2{{{4, 'A'}, {5, 'B'}, {6, 'C'}}, comparator{false}};
+        m1.swap(m2);
+        assert(ranges::equal(m1, initializer_list<value_type>{{4, 'A'}, {5, 'B'}, {6, 'C'}}));
+        assert(ranges::equal(m2, initializer_list<value_type>{{1, 'x'}, {2, 'y'}, {3, 'z'}}));
+    }
+    {
+        map_type m1{{{1, 'x'}, {2, 'y'}, {3, 'z'}}, comparator{false}};
+        map_type m2{{{4, 'A'}, {5, 'B'}, {6, 'C'}}, comparator{false}};
+        ranges::swap(m1, m2);
+        assert(ranges::equal(m1, initializer_list<value_type>{{4, 'A'}, {5, 'B'}, {6, 'C'}}));
+        assert(ranges::equal(m2, initializer_list<value_type>{{1, 'x'}, {2, 'y'}, {3, 'z'}}));
+    }
+    {
+        map_type m1{{{1, 'x'}, {2, 'y'}, {3, 'z'}}, comparator{false}};
+        map_type m2{{{4, 'A'}, {5, 'B'}, {6, 'C'}}, comparator{true}};
+        try {
+            m1.swap(m2);
+            assert(false);
+        } catch (const unique_exception&) {
+            assert(m1.empty());
+            assert(m2.empty());
+        } catch (...) {
+            assert(false);
+        }
+    }
+    {
+        map_type m1{{{1, 'x'}, {2, 'y'}, {3, 'z'}}, comparator{false}};
+        map_type m2{{{4, 'A'}, {5, 'B'}, {6, 'C'}}, comparator{true}};
+        try {
+            ranges::swap(m1, m2);
+            assert(false);
+        } catch (const unique_exception&) {
+            assert(m1.empty());
+            assert(m2.empty());
+        } catch (...) {
+            assert(false);
+        }
+    }
+}
 
-    test_scary_ness_one<false, less<>, allocator<int>, allocator<int>>();
-    test_scary_ness_one<false, less<>, allocator<int>, MyAllocator<int>>();
-    test_scary_ness_one<false, less<>, MyAllocator<int>, allocator<int>>();
+void test_throwing_compare_swap() {
+    test_throwing_compare_swap_single<flat_map, vector, vector>();
+    test_throwing_compare_swap_single<flat_map, vector, deque>();
+    test_throwing_compare_swap_single<flat_map, deque, vector>();
+    test_throwing_compare_swap_single<flat_map, deque, deque>();
 
-    test_scary_ness_one<false, greater<>, allocator<int>, allocator<int>>();
-    test_scary_ness_one<false, greater<>, allocator<int>, MyAllocator<int>>();
-    test_scary_ness_one<false, greater<>, MyAllocator<int>, allocator<int>>();
+    test_throwing_compare_swap_single<flat_multimap, vector, vector>();
+    test_throwing_compare_swap_single<flat_multimap, vector, deque>();
+    test_throwing_compare_swap_single<flat_multimap, deque, vector>();
+    test_throwing_compare_swap_single<flat_multimap, deque, deque>();
 }
 
 int main() {
@@ -735,7 +771,9 @@ int main() {
     test_pointer_to_incomplete_type();
     test_erase_if();
     test_insert();
+    test_insert_range();
     test_gh_4344();
     test_insert_or_assign();
     test_comparison();
+    test_throwing_compare_swap();
 }
diff --git a/tests/std/tests/P0429R9_flat_map_ms_specific/env.lst b/tests/std/tests/P0429R9_flat_map_ms_specific/env.lst
new file mode 100644
index 00000000000..642f530ffad
--- /dev/null
+++ b/tests/std/tests/P0429R9_flat_map_ms_specific/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\usual_latest_matrix.lst
diff --git a/tests/std/tests/P0429R9_flat_map_ms_specific/test.compile.pass.cpp b/tests/std/tests/P0429R9_flat_map_ms_specific/test.compile.pass.cpp
new file mode 100644
index 00000000000..cdba07f3cbe
--- /dev/null
+++ b/tests/std/tests/P0429R9_flat_map_ms_specific/test.compile.pass.cpp
@@ -0,0 +1,109 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <cstddef>
+#include <deque>
+#include <flat_map>
+#include <functional>
+#include <memory>
+#include <type_traits>
+#include <vector>
+
+using namespace std;
+
+// Test MSVC STL-specific SCARY-ness
+
+template <class T>
+struct MyAllocator {
+    using value_type = T;
+
+    MyAllocator() = default;
+    template <class U>
+    MyAllocator(const MyAllocator<U>&) noexcept {}
+
+    T* allocate(size_t n) {
+        return allocator<T>{}.allocate(n);
+    }
+
+    void deallocate(T* p, size_t n) noexcept {
+        allocator<T>{}.deallocate(p, n);
+    }
+
+    template <class U>
+    friend constexpr bool operator==(const MyAllocator&, const MyAllocator<U>&) noexcept {
+        return true;
+    }
+};
+
+template <bool>
+struct flat_map_unique_if_impl;
+template <>
+struct flat_map_unique_if_impl<true> {
+    template <class Key, class Mapped, class Comp, class KeyCont, class MappedCont>
+    using type = flat_map<Key, Mapped, Comp, KeyCont, MappedCont>;
+};
+template <>
+struct flat_map_unique_if_impl<false> {
+    template <class Key, class Mapped, class Comp, class KeyCont, class MappedCont>
+    using type = flat_multimap<Key, Mapped, Comp, KeyCont, MappedCont>;
+};
+
+template <bool IsUnique, class Key, class Mapped, class Comp, class KeyCont, class MappedCont>
+using flat_map_unique_if = flat_map_unique_if_impl<IsUnique>::template type<Key, Mapped, Comp, KeyCont, MappedCont>;
+
+template <bool IsUnique, class Comparator, class Alloc1, class Alloc2>
+void test_scary_ness_one() {
+    using Iter = flat_map<int, int>::iterator;
+    using OtherIter =
+        flat_map_unique_if<IsUnique, int, int, Comparator, vector<int, Alloc1>, vector<int, Alloc2>>::iterator;
+    static_assert(is_same_v<Iter, OtherIter>);
+
+    using ConstIter = flat_map<int, int>::const_iterator;
+    using OtherConstIter =
+        flat_map_unique_if<IsUnique, int, int, Comparator, vector<int, Alloc1>, vector<int, Alloc2>>::const_iterator;
+    static_assert(is_same_v<ConstIter, OtherConstIter>);
+
+    using Cont = flat_map<int, int, less<int>, vector<int, Alloc1>, vector<int, Alloc2>>::containers;
+    using OtherCont =
+        flat_map_unique_if<IsUnique, int, int, Comparator, vector<int, Alloc1>, vector<int, Alloc2>>::containers;
+    static_assert(is_same_v<Cont, OtherCont>);
+
+    using ValueComp = flat_map<int, int, Comparator, vector<int, Alloc1>, vector<int, Alloc2>>::value_compare;
+    using OtherValueComp1 =
+        flat_map_unique_if<IsUnique, int, int, Comparator, vector<int, Alloc1>, vector<int, Alloc2>>::value_compare;
+    using OtherValueComp2 = flat_map_unique_if<IsUnique, int, int, Comparator, vector<int>, vector<int>>::value_compare;
+    using OtherValueComp3 =
+        flat_map_unique_if<IsUnique, int, int, Comparator, vector<int, Alloc1>, deque<int, Alloc2>>::value_compare;
+    using OtherValueComp4 =
+        flat_map_unique_if<IsUnique, int, int, Comparator, deque<int, Alloc1>, vector<int, Alloc2>>::value_compare;
+    static_assert(is_same_v<ValueComp, OtherValueComp1>);
+    static_assert(is_same_v<ValueComp, OtherValueComp2>);
+    static_assert(is_same_v<ValueComp, OtherValueComp3>);
+    static_assert(is_same_v<ValueComp, OtherValueComp4>);
+}
+
+void test_scary_ness() {
+    test_scary_ness_one<true, greater<int>, allocator<int>, allocator<int>>();
+    test_scary_ness_one<true, greater<int>, allocator<int>, MyAllocator<int>>();
+    test_scary_ness_one<true, greater<int>, MyAllocator<int>, allocator<int>>();
+
+    test_scary_ness_one<true, less<>, allocator<int>, allocator<int>>();
+    test_scary_ness_one<true, less<>, allocator<int>, MyAllocator<int>>();
+    test_scary_ness_one<true, less<>, MyAllocator<int>, allocator<int>>();
+
+    test_scary_ness_one<true, greater<>, allocator<int>, allocator<int>>();
+    test_scary_ness_one<true, greater<>, allocator<int>, MyAllocator<int>>();
+    test_scary_ness_one<true, greater<>, MyAllocator<int>, allocator<int>>();
+
+    test_scary_ness_one<false, greater<int>, allocator<int>, allocator<int>>();
+    test_scary_ness_one<false, greater<int>, allocator<int>, MyAllocator<int>>();
+    test_scary_ness_one<false, greater<int>, MyAllocator<int>, allocator<int>>();
+
+    test_scary_ness_one<false, less<>, allocator<int>, allocator<int>>();
+    test_scary_ness_one<false, less<>, allocator<int>, MyAllocator<int>>();
+    test_scary_ness_one<false, less<>, MyAllocator<int>, allocator<int>>();
+
+    test_scary_ness_one<false, greater<>, allocator<int>, allocator<int>>();
+    test_scary_ness_one<false, greater<>, allocator<int>, MyAllocator<int>>();
+    test_scary_ness_one<false, greater<>, MyAllocator<int>, allocator<int>>();
+}
diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index 4617fb2bc2b..8790079811a 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -4,6 +4,7 @@
 #include <algorithm>
 #include <cassert>
 #include <climits>
+#include <concepts>
 #include <cstdlib>
 #include <deque>
 #include <flat_set>
@@ -213,8 +214,10 @@ void assert_noexcept_requirements(T& s) {
     static_assert(noexcept(s.max_size()));
 
     if constexpr (!is_const_v<T>) {
-        static_assert(noexcept(s.swap(s)));
-        static_assert(noexcept(ranges::swap(s, s))); // using ADL-swap
+        constexpr bool is_noexcept =
+            is_nothrow_swappable_v<typename T::container_type> && is_nothrow_swappable_v<typename T::key_compare>;
+        static_assert(noexcept(s.swap(s)) == is_noexcept);
+        static_assert(noexcept(ranges::swap(s, s)) == is_noexcept); // using ADL-swap
         static_assert(noexcept(s.clear()));
     }
 }
@@ -414,10 +417,12 @@ void test_insert_1() {
         assert_all_requirements_and_equals(a, {0, 1, 2, 5});
         a.insert_range(vec);
         assert_all_requirements_and_equals(a, {0, 1, 2, 5});
+        a.insert_range(sorted_unique, vector<int>{2, 5, 8});
+        assert_all_requirements_and_equals(a, {0, 1, 2, 5, 8});
         a.insert({6, 2, 3});
-        assert_all_requirements_and_equals(a, {0, 1, 2, 3, 5, 6});
+        assert_all_requirements_and_equals(a, {0, 1, 2, 3, 5, 6, 8});
         a.insert(sorted_unique, {4, 5});
-        assert_all_requirements_and_equals(a, {0, 1, 2, 3, 4, 5, 6});
+        assert_all_requirements_and_equals(a, {0, 1, 2, 3, 4, 5, 6, 8});
     }
     {
         flat_multiset<int, lt, C> a{5, 5};
@@ -436,10 +441,12 @@ void test_insert_1() {
         assert_all_requirements_and_equals(a, {0, 0, 0, 1, 1, 1, 2, 2, 2, 2, 5, 5});
         a.insert_range(vec);
         assert_all_requirements_and_equals(a, {0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 2, 5, 5});
+        a.insert_range(sorted_equivalent, vector<int>{2, 8, 8});
+        assert_all_requirements_and_equals(a, {0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 5, 5, 8, 8});
         a.insert({6, 2, 3});
-        assert_all_requirements_and_equals(a, {0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 5, 5, 6});
+        assert_all_requirements_and_equals(a, {0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 3, 5, 5, 6, 8, 8});
         a.insert(sorted_equivalent, {4, 5});
-        assert_all_requirements_and_equals(a, {0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 4, 5, 5, 5, 6});
+        assert_all_requirements_and_equals(a, {0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 3, 4, 5, 5, 5, 6, 8, 8});
     }
 }
 
@@ -1060,6 +1067,83 @@ void test_set_operations_transparent() {
     assert(first + 1 == last);
 }
 
+namespace test_throwing_swap {
+    struct unique_exception {};
+
+    template <class T>
+    struct throwing_less {
+        static bool operator()(const T& left, const T& right) {
+            return left < right;
+        }
+
+        bool throws_;
+    };
+
+    template <class T>
+    void swap(throwing_less<T>& lhs, throwing_less<T>& rhs) {
+        if (lhs.throws_ || rhs.throws_) {
+            throw unique_exception{};
+        }
+    }
+} // namespace test_throwing_swap
+
+template <template <class...> class FlatSetCont, template <class...> class AdaptedCont>
+void test_throwing_compare_single() {
+    using test_throwing_swap::unique_exception;
+    using comparator = test_throwing_swap::throwing_less<int>;
+
+    using set_type = FlatSetCont<int, comparator, AdaptedCont<int, allocator<int>>>;
+    static_assert(!is_nothrow_swappable_v<set_type>);
+    {
+        set_type s1{{1, 2, 3}, comparator{false}};
+        set_type s2{{4, 5, 6}, comparator{false}};
+        s1.swap(s2);
+        assert(ranges::equal(s1, initializer_list<int>{4, 5, 6}));
+        assert(ranges::equal(s2, initializer_list<int>{1, 2, 3}));
+    }
+    {
+        set_type s1{{1, 2, 3}, comparator{false}};
+        set_type s2{{4, 5, 6}, comparator{false}};
+        ranges::swap(s1, s2);
+        assert(ranges::equal(s1, initializer_list<int>{4, 5, 6}));
+        assert(ranges::equal(s2, initializer_list<int>{1, 2, 3}));
+    }
+    {
+        set_type s1{{1, 2, 3}, comparator{true}};
+        set_type s2{{4, 5, 6}, comparator{false}};
+        try {
+            s1.swap(s2);
+            assert(false);
+        } catch (const unique_exception&) {
+            assert(s1.empty());
+            assert(s2.empty());
+        } catch (...) {
+            assert(false);
+        }
+    }
+    {
+        set_type s1{{1, 2, 3}, comparator{true}};
+        set_type s2{{4, 5, 6}, comparator{false}};
+        try {
+            ranges::swap(s1, s2);
+            assert(false);
+        } catch (const unique_exception&) {
+            assert(s1.empty());
+            assert(s2.empty());
+        } catch (...) {
+            assert(false);
+        }
+    }
+}
+
+void test_throwing_compare_swap() {
+    test_throwing_compare_single<flat_set, vector>();
+    test_throwing_compare_single<flat_set, deque>();
+
+    test_throwing_compare_single<flat_multiset, vector>();
+    test_throwing_compare_single<flat_multiset, deque>();
+}
+
 int main() {
     test_spaceship_operator<flat_set<int>>();
     test_spaceship_operator<flat_multiset<int>>();
@@ -1108,4 +1192,6 @@ int main() {
     test_set_operations<flat_multiset>();
     test_set_operations_transparent<flat_set>();
     test_set_operations_transparent<flat_multiset>();
+
+    test_throwing_compare_swap();
 }
diff --git a/tests/std/tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp b/tests/std/tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp
index 798120e7deb..b3036c85751 100644
--- a/tests/std/tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp
+++ b/tests/std/tests/VSO_0157762_feature_test_macros/test.compile.pass.cpp
@@ -352,13 +352,13 @@ STATIC_ASSERT(__cpp_lib_filesystem == 201703L);
 #endif
 
 #if _HAS_CXX23
-STATIC_ASSERT(__cpp_lib_flat_map == 202207L);
+STATIC_ASSERT(__cpp_lib_flat_map == 202511L);
 #elif defined(__cpp_lib_flat_map)
 #error __cpp_lib_flat_map is defined
 #endif
 
 #if _HAS_CXX23
-STATIC_ASSERT(__cpp_lib_flat_set == 202207L);
+STATIC_ASSERT(__cpp_lib_flat_set == 202511L);
 #elif defined(__cpp_lib_flat_set)
 #error __cpp_lib_flat_set is defined
 #endif

From 06b512b9f3a55d8c7197fee4dc8859bed3c7e6bd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vojt=C4=9Bch=20Michal?=
 <50836015+vmichal@users.noreply.github.com>
Date: Mon, 1 Dec 2025 20:44:30 +0100
Subject: [PATCH 070/134] flat_multiset::emplace_hint() shall place as close as
 possible to provided hint (#5926)

---
 stl/inc/flat_set                  | 13 +++++++------
 tests/libcxx/expected_results.txt |  6 ------
 2 files changed, 7 insertions(+), 12 deletions(-)

diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index fe26264da45..086bdcd7abd 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -577,21 +577,22 @@ private:
         } else {
             _STL_INTERNAL_STATIC_ASSERT(is_same_v<remove_cvref_t<_Ty>, _Kty>);
 
-            // look for upper_bound(_Val)
+            // look for closest position just prior to _Where, respecting ordering
             if (_Where == _End || _Compare(_Val, *_Where)) {
                 // _Val < *_Where
                 if (_Where == _Begin || !_Compare(_Val, *(_Where - 1))) {
-                    // _Val >= *(_Where-1) ~ upper_bound is _Where
+                    // _Val >= *(_Where-1) ~ closest valid position is _Where
                 } else {
-                    // _Val < *(_Where-1) ~ upper_bound is in [_Begin,_Where-1]
+                    // _Val < *(_Where-1) ~ closest valid position is upper_bound(_Val) located in [_Begin,_Where-1]
                     _Where = _STD upper_bound(_Begin, _Where - 1, _Val, _Pass_comp());
                 }
+                // _Val < *_Where, so upper_bound is indeed "as close as possible"
+                _STL_INTERNAL_CHECK(_Can_insert(_Where, _Val));
             } else {
-                // _Val >= *_Where ~ upper_bound is in [_Where+1,_End]
-                _Where = _STD upper_bound(_Where + 1, _End, _Val, _Pass_comp());
+                // _Val >= *_Where ~ search for lower_bound in [_Where,_End] to place _Val "as close as possible"
+                _Where = _STD lower_bound(_Where, _End, _Val, _Pass_comp());
             }
 
-            _STL_INTERNAL_CHECK(_Can_insert(_Where, _Val));
             return _Mycont.emplace(_Where, _STD forward<_Ty>(_Val));
         }
     }
diff --git a/tests/libcxx/expected_results.txt b/tests/libcxx/expected_results.txt
index adfd72a9139..caf425bcd34 100644
--- a/tests/libcxx/expected_results.txt
+++ b/tests/libcxx/expected_results.txt
@@ -346,12 +346,6 @@ std/containers/container.adaptors/flat.set/flat.set.cons/move.pass.cpp FAIL
 std/containers/container.adaptors/flat.multiset/flat.multiset.cons/move_assign.pass.cpp FAIL
 std/containers/container.adaptors/flat.set/flat.set.cons/move_assign.pass.cpp FAIL
 
-# FIXME! Assertion failed: r == m.begin() + 2
-std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/emplace_hint.pass.cpp FAIL
-
-# FIXME! Assertion failed: r == m.begin() + 1
-std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_iter_rv.pass.cpp FAIL
-
 # FIXME! warning C4242: 'initializing': conversion from 'int' to '_Ty', possible loss of data
 std/containers/container.adaptors/flat.multiset/flat.multiset.cons/sorted_iter_iter.pass.cpp:0 FAIL
 std/containers/container.adaptors/flat.multiset/flat.multiset.cons/sorted_iter_iter.pass.cpp:1 FAIL

From 2ae511b87ac37cf0012f2396c1ba8686f62db35b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vojt=C4=9Bch=20Michal?=
 <50836015+vmichal@users.noreply.github.com>
Date: Fri, 5 Dec 2025 00:04:51 +0100
Subject: [PATCH 071/134] `flat_[multi]set(initializer_list, ...)` constructors
 shall not invoke underlying container's `initializer_list` ctor (#5935)

---
 stl/inc/flat_set                  | 10 ++++++----
 tests/libcxx/expected_results.txt |  4 ++--
 2 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index 086bdcd7abd..4a1beb6dcf0 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -134,8 +134,10 @@ public:
         : _Mycont(_STD make_obj_using_allocator<container_type>(_Al)), _Mycomp() {}
 
     template <_Iterator_for_container _Iter>
-    _Flat_set_base(_Iter _First, _Iter _Last, const key_compare& _Comp = key_compare())
-        : _Flat_set_base(container_type(_First, _Last), _Comp) {}
+    _Flat_set_base(_Iter _First, _Iter _Last, const key_compare& _Comp = key_compare()) : _Mycont(), _Mycomp(_Comp) {
+        _Mycont.assign(_First, _Last);
+        _Make_invariants_fulfilled();
+    }
     template <_Iterator_for_container _Iter, _Usable_allocator_for<container_type> _Alloc>
     _Flat_set_base(_Iter _First, _Iter _Last, const key_compare& _Comp, const _Alloc& _Al)
         : _Mycont(_STD make_obj_using_allocator<container_type>(_Al)), _Mycomp(_Comp) {
@@ -179,7 +181,7 @@ public:
         : _Flat_set_base(_Tag, _STD make_obj_using_allocator<container_type>(_Al, _First, _Last)) {}
 
     _Flat_set_base(initializer_list<_Kty> _Ilist, const key_compare& _Comp = key_compare())
-        : _Flat_set_base(container_type(_Ilist), _Comp) {}
+        : _Flat_set_base(_Ilist.begin(), _Ilist.end(), _Comp) {}
     template <_Usable_allocator_for<container_type> _Alloc>
     _Flat_set_base(initializer_list<_Kty> _Ilist, const key_compare& _Comp, const _Alloc& _Al)
         : _Flat_set_base(_Ilist.begin(), _Ilist.end(), _Comp, _Al) {}
@@ -188,7 +190,7 @@ public:
         : _Flat_set_base(_Ilist.begin(), _Ilist.end(), _Al) {}
 
     _Flat_set_base(_Sorted_t _Tag, initializer_list<_Kty> _Ilist, const key_compare& _Comp = key_compare())
-        : _Flat_set_base(_Tag, container_type(_Ilist), _Comp) {}
+        : _Flat_set_base(_Tag, _Ilist.begin(), _Ilist.end(), _Comp) {}
     template <_Usable_allocator_for<container_type> _Alloc>
     _Flat_set_base(_Sorted_t _Tag, initializer_list<_Kty> _Ilist, const key_compare& _Comp, const _Alloc& _Al)
         : _Flat_set_base(_Tag, _Ilist.begin(), _Ilist.end(), _Comp, _Al) {}
diff --git a/tests/libcxx/expected_results.txt b/tests/libcxx/expected_results.txt
index caf425bcd34..3f30266df19 100644
--- a/tests/libcxx/expected_results.txt
+++ b/tests/libcxx/expected_results.txt
@@ -343,8 +343,8 @@ std/containers/container.adaptors/flat.multiset/flat.multiset.cons/move.pass.cpp
 std/containers/container.adaptors/flat.set/flat.set.cons/move.pass.cpp FAIL
 
 # FIXME! error: call to implicitly-deleted copy constructor of 'container_type' (aka 'MoveAssignThrows')
-std/containers/container.adaptors/flat.multiset/flat.multiset.cons/move_assign.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.cons/move_assign.pass.cpp FAIL
+std/containers/container.adaptors/flat.multiset/flat.multiset.cons/move_assign.pass.cpp:2 FAIL
+std/containers/container.adaptors/flat.set/flat.set.cons/move_assign.pass.cpp:2 FAIL
 
 # FIXME! warning C4242: 'initializing': conversion from 'int' to '_Ty', possible loss of data
 std/containers/container.adaptors/flat.multiset/flat.multiset.cons/sorted_iter_iter.pass.cpp:0 FAIL

From 7e2032d868b3c20a0fb420b9427abb1e3d517c72 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Thu, 4 Dec 2025 15:31:15 -0800
Subject: [PATCH 072/134] std.ixx: Avoid interleaving conditional includes.

---
 stl/modules/std.ixx | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/stl/modules/std.ixx b/stl/modules/std.ixx
index 127642b9c3a..00b289b5c3c 100644
--- a/stl/modules/std.ixx
+++ b/stl/modules/std.ixx
@@ -58,10 +58,6 @@ export module std;
 #include <exception>
 #include <execution>
 #include <filesystem>
-#if _HAS_CXX23
-#include <flat_map>
-#include <flat_set>
-#endif // _HAS_CXX23
 #include <format>
 #include <forward_list>
 #include <fstream>
@@ -127,6 +123,8 @@ export module std;
 
 #if _HAS_CXX23
 #include <expected>
+#include <flat_map>
+#include <flat_set>
 #include <generator>
 #include <mdspan>
 #include <print>

From 384c44ef0c7d4f218a88baa69b595502f69c912a Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Fri, 5 Dec 2025 00:39:23 -0800
Subject: [PATCH 073/134] Clarify "leaf-most" comment.

Use angle brackets to distinguish `<vector>` as a header.

Explicitly mention `<flat_map>` and `<flat_set>` for searchability.
---
 stl/inc/vector | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stl/inc/vector b/stl/inc/vector
index 3b9f3f7a98f..89c423f54c9 100644
--- a/stl/inc/vector
+++ b/stl/inc/vector
@@ -4056,7 +4056,7 @@ _CONSTEXPR20 _OutIt _Transform_vbool_aligned(
 #undef _INSERT_VECTOR_ANNOTATION
 
 #if _HAS_CXX23
-// This `flat_meow` machinery is here because `vector` is the leaf-most header included by both `flat_meow` headers.
+// This <flat_map> and <flat_set> machinery is here because <vector> is the leaf-most header included by both of them.
 
 _EXPORT_STD struct sorted_unique_t {
     explicit sorted_unique_t() = default;

From b781355f503c094be7830f77d82ec8653d247451 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Fri, 5 Dec 2025 00:57:54 -0800
Subject: [PATCH 074/134] `<vector>`'s `_Clear_guard` shadows/supersedes
 `_Hash::_Clear_guard`.

---
 stl/inc/vector |  2 +-
 stl/inc/xhash  | 23 ++++-------------------
 2 files changed, 5 insertions(+), 20 deletions(-)

diff --git a/stl/inc/vector b/stl/inc/vector
index 89c423f54c9..2994548bd8c 100644
--- a/stl/inc/vector
+++ b/stl/inc/vector
@@ -4086,6 +4086,7 @@ template <class _Compare, class _KeyContainer>
 concept _Valid_compare_for_container = _Not_allocator_for_container<_Compare>
                                     && is_invocable_v<const _Compare&, const typename _KeyContainer::value_type&,
                                         const typename _KeyContainer::value_type&>;
+#endif // ^^^ _HAS_CXX23 ^^^
 
 template <class _Ty>
 struct _NODISCARD _Clear_guard {
@@ -4100,7 +4101,6 @@ struct _NODISCARD _Clear_guard {
         }
     }
 };
-#endif // ^^^ _HAS_CXX23 ^^^
 _STD_END
 
 #pragma pop_macro("new")
diff --git a/stl/inc/xhash b/stl/inc/xhash
index ef3ed86bb53..52c82bcd216 100644
--- a/stl/inc/xhash
+++ b/stl/inc/xhash
@@ -413,21 +413,6 @@ private:
         _Pocma(_Vec._Mypair._Get_first(), _Right._Vec._Mypair._Get_first());
     }
 
-    struct _NODISCARD _Clear_guard {
-        _Hash* _Target;
-
-        explicit _Clear_guard(_Hash* const _Target_) : _Target(_Target_) {}
-
-        _Clear_guard(const _Clear_guard&)            = delete;
-        _Clear_guard& operator=(const _Clear_guard&) = delete;
-
-        ~_Clear_guard() {
-            if (_Target) {
-                _Target->clear();
-            }
-        }
-    };
-
 #ifdef _ENABLE_STL_INTERNAL_CHECK
     struct _NODISCARD _Check_container_invariants_guard {
         const _Hash& _Target;
@@ -507,7 +492,7 @@ public:
             }
         } else if constexpr (_Pocma_val == _Pocma_values::_No_propagate_allocators) {
             if (_Al != _Right_al) {
-                _Clear_guard _Guard{this};
+                _Clear_guard<_Hash> _Guard{this};
                 _Traitsobj     = _Right._Traitsobj;
                 using _Adapter = _Reinterpret_move_iter<typename _Mylist::_Unchecked_iterator, _Mutable_value_type>;
                 _List.template _Assign_cast<_Mutable_value_type&>(
@@ -703,7 +688,7 @@ public:
                 _Pocca_both(_Right);
                 _Vec_proxy._Bind(_Alproxy, _STD addressof(_Vec._Mypair._Myval2));
 
-                _Clear_guard _Guard{this};
+                _Clear_guard<_Hash> _Guard{this};
                 _Traitsobj = _Right._Traitsobj;
                 _List.template _Assign_cast<_Mutable_value_type&>(
                     _Right._List._Unchecked_begin(), _Right._List._Unchecked_end());
@@ -714,7 +699,7 @@ public:
             }
         }
 
-        _Clear_guard _Guard{this};
+        _Clear_guard<_Hash> _Guard{this};
         _Traitsobj = _Right._Traitsobj;
         _Pocca_both(_Right);
         _List.template _Assign_cast<_Mutable_value_type&>(
@@ -1661,7 +1646,7 @@ protected:
         _Mask   = _Buckets - 1;
         _Maxidx = _Buckets;
 
-        _Clear_guard _Guard{this};
+        _Clear_guard<_Hash> _Guard{this};
 
         _Unchecked_iterator _Inserted = _Unchecked_begin();
 

From 44835bafb33e461af147ef74be4e7d1d582b72bc Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Fri, 5 Dec 2025 01:03:36 -0800
Subject: [PATCH 075/134] flat_map: Consistently use CTAD for `_Clear_guard`.

---
 stl/inc/flat_map | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index 441aaa02af5..b2fc9af2b06 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -849,7 +849,7 @@ protected:
         auto _Mut_last       = _View.end();
         const auto _Old_size = size();
 
-        _Clear_guard<_Flat_map_base> _Guard{this};
+        _Clear_guard _Guard{this};
 
         _STD _Seek_wrapped(_Mut_first, _RANGES remove_if(_View, _Pred).begin());
         (void) _Data.keys.erase(_Mut_first._Key_it, _Mut_last._Key_it);

From d4b57d67c470e01923d2a7bddada5f64656446ae Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Fri, 5 Dec 2025 01:28:05 -0800
Subject: [PATCH 076/134] flat_set: Consistently use CTAD and `this/_Other` for
 `_Clear_guard`.

---
 stl/inc/flat_set | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index 4a1beb6dcf0..aabbe973d2a 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -205,7 +205,7 @@ public:
     {}
 
     _Flat_set_base& operator=(const _Flat_set_base& _Other) {
-        _Clear_guard<container_type> _Guard{_STD addressof(_Mycont)};
+        _Clear_guard _Guard{this};
         _Mycont        = _Other._Mycont;
         _Mycomp        = _Other._Mycomp;
         _Guard._Target = nullptr;
@@ -215,8 +215,8 @@ public:
         is_nothrow_move_assignable_v<container_type> && is_nothrow_copy_assignable_v<key_compare>) // strengthened
     {
         if (this != _STD addressof(_Other)) {
-            _Clear_guard<container_type> _Guard{_STD addressof(_Mycont)};
-            _Clear_guard<container_type> _Always_clear{_STD addressof(_Other._Mycont)};
+            _Clear_guard _Guard{this};
+            _Clear_guard _Always_clear{_STD addressof(_Other)};
             _Mycont        = _STD move(_Other._Mycont);
             _Mycomp        = _Other._Mycomp; // intentionally copy comparator, see LWG-2227
             _Guard._Target = nullptr;
@@ -225,7 +225,7 @@ public:
     }
 
     _Derived& operator=(initializer_list<_Kty> _Ilist) {
-        _Clear_guard<container_type> _Guard{_STD addressof(_Mycont)};
+        _Clear_guard _Guard{this};
         _Mycont.assign(_Ilist);
         _Make_invariants_fulfilled();
         _Guard._Target = nullptr;
@@ -345,12 +345,12 @@ public:
     _NODISCARD container_type extract() && noexcept(
         is_nothrow_move_constructible_v<container_type>) /* strengthened */ {
         // always clears the container (N4950 [flat.set.modifiers]/14 and [flat.multiset.modifiers]/10)
-        _Clear_guard<container_type> _Always_clear{_STD addressof(_Mycont)};
+        _Clear_guard _Always_clear{this};
         return _STD move(_Mycont);
     }
     void replace(container_type&& _Cont) {
         _STL_ASSERT(_Is_sorted(_Cont), _Msg_not_sorted);
-        _Clear_guard<container_type> _Guard{_STD addressof(_Mycont)};
+        _Clear_guard _Guard{this};
         _Mycont        = _STD move(_Cont);
         _Guard._Target = nullptr;
     }

From c3e82cb09d3697807a822d2993e74938de6d8515 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Fri, 5 Dec 2025 01:38:14 -0800
Subject: [PATCH 077/134] flat_map and flat_multimap don't need `using
 _MyBase::_Erase_if;`.

---
 stl/inc/flat_map | 2 --
 1 file changed, 2 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index b2fc9af2b06..73b394ce7e8 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -1323,7 +1323,6 @@ public:
 
 private:
     using _MyBase::_Emplace_hint;
-    using _MyBase::_Erase_if;
     using _MyBase::_Insert_exact;
     using _MyBase::_Key_equal;
 
@@ -1527,7 +1526,6 @@ public:
 
 private:
     using _MyBase::_Emplace_hint;
-    using _MyBase::_Erase_if;
     using _MyBase::_Insert_exact;
     using _MyBase::_Key_equal;
 

From d1d9b1c189f3ac64315f0fb6b5ca2b2679a16e83 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Fri, 5 Dec 2025 01:57:42 -0800
Subject: [PATCH 078/134] flat_set: Centralize `_Erase_if`.

Goodbye public `_Get_container_for_erase_if()`.

Use CTAD and `this` for the `_Clear_guard`.

Use `_Pass_fn` only at the outer layer.
---
 stl/inc/flat_set | 32 ++++++++++++++++----------------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index aabbe973d2a..03e7afb2513 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -391,10 +391,6 @@ public:
         return _Mycomp;
     }
 
-    _NODISCARD container_type& _Get_container_for_erase_if() noexcept {
-        return _Mycont;
-    }
-
     // set operations
     // NB: The non-const overloads are intentionally removed for brevity. This will not result in behavioral changes.
     _NODISCARD const_iterator find(const _Kty& _Val) const {
@@ -640,6 +636,20 @@ private:
         }
     }
 
+    template <class _Kty2, class _Keylt2, class _Container2, class _Pred2>
+    friend _Container2::size_type erase_if(flat_set<_Kty2, _Keylt2, _Container2>&, _Pred2);
+    template <class _Kty2, class _Keylt2, class _Container2, class _Pred2>
+    friend _Container2::size_type erase_if(flat_multiset<_Kty2, _Keylt2, _Container2>&, _Pred2);
+
+    template <class _Pred>
+    size_type _Erase_if(_Pred _Predicate) {
+        // Maintain invariants when an exception is thrown (N4950 [flat.set.erasure]/5, [flat.multiset.erasure]/5)
+        _Clear_guard _Guard{this};
+        const auto _Erased_count = _STD _Erase_remove_if(_Mycont, _Predicate);
+        _Guard._Target           = nullptr;
+        return _Erased_count;
+    }
+
     template <class _Ty>
     _NODISCARD const_iterator _Find(const _Ty& _Val) const {
         _STL_INTERNAL_STATIC_ASSERT(_Transparent<key_compare> || is_same_v<_Ty, _Kty>);
@@ -763,22 +773,12 @@ public:
 
 _EXPORT_STD template <class _Kty, class _Keylt, class _Container, class _Pred>
 _Container::size_type erase_if(flat_set<_Kty, _Keylt, _Container>& _Val, _Pred _Predicate) {
-    // clears the container to maintain the invariants when an exception is thrown (N4950 [flat.set.erasure]/5)
-    _Container& _Cont = _Val._Get_container_for_erase_if();
-    _Clear_guard<_Container> _Guard{_STD addressof(_Cont)};
-    const auto _Erased_count = _STD _Erase_remove_if(_Cont, _STD _Pass_fn(_Predicate));
-    _Guard._Target           = nullptr;
-    return _Erased_count;
+    return _Val._Erase_if(_STD _Pass_fn(_Predicate));
 }
 
 _EXPORT_STD template <class _Kty, class _Keylt, class _Container, class _Pred>
 _Container::size_type erase_if(flat_multiset<_Kty, _Keylt, _Container>& _Val, _Pred _Predicate) {
-    // clears the container to maintain the invariants when an exception is thrown (N4950 [flat.multiset.erasure]/5)
-    _Container& _Cont = _Val._Get_container_for_erase_if();
-    _Clear_guard<_Container> _Guard{_STD addressof(_Cont)};
-    const auto _Erased_count = _STD _Erase_remove_if(_Cont, _STD _Pass_fn(_Predicate));
-    _Guard._Target           = nullptr;
-    return _Erased_count;
+    return _Val._Erase_if(_STD _Pass_fn(_Predicate));
 }
 
 template <class _Kty, class _Keylt, class _Container, class _Alloc>

From f4a2c5d8e41ea239433abc8a8514d98520385d67 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Fri, 5 Dec 2025 02:19:27 -0800
Subject: [PATCH 079/134] Need to report a Down With Typename bug to EDG.

---
 stl/inc/flat_map | 2 ++
 stl/inc/flat_set | 5 +++--
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index 73b394ce7e8..330f79c120c 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -1326,6 +1326,7 @@ private:
     using _MyBase::_Insert_exact;
     using _MyBase::_Key_equal;
 
+    // FIXME, typename is an EDG workaround
     template <class _KTy, class _MTy, class _Comp, class _KeyCont, class _MappedCont, class _Pred>
     friend typename flat_map<_KTy, _MTy, _Comp, _KeyCont, _MappedCont>::size_type erase_if(
         flat_map<_KTy, _MTy, _Comp, _KeyCont, _MappedCont>&, _Pred);
@@ -1529,6 +1530,7 @@ private:
     using _MyBase::_Insert_exact;
     using _MyBase::_Key_equal;
 
+    // FIXME, typename is an EDG workaround
     template <class _KTy, class _MTy, class _Comp, class _KeyCont, class _MappedCont, class _Pred>
     friend typename flat_multimap<_KTy, _MTy, _Comp, _KeyCont, _MappedCont>::size_type erase_if(
         flat_multimap<_KTy, _MTy, _Comp, _KeyCont, _MappedCont>&, _Pred);
diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index 03e7afb2513..5f7cf79edae 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -636,10 +636,11 @@ private:
         }
     }
 
+    // FIXME, typename is an EDG workaround
     template <class _Kty2, class _Keylt2, class _Container2, class _Pred2>
-    friend _Container2::size_type erase_if(flat_set<_Kty2, _Keylt2, _Container2>&, _Pred2);
+    friend typename _Container2::size_type erase_if(flat_set<_Kty2, _Keylt2, _Container2>&, _Pred2);
     template <class _Kty2, class _Keylt2, class _Container2, class _Pred2>
-    friend _Container2::size_type erase_if(flat_multiset<_Kty2, _Keylt2, _Container2>&, _Pred2);
+    friend typename _Container2::size_type erase_if(flat_multiset<_Kty2, _Keylt2, _Container2>&, _Pred2);
 
     template <class _Pred>
     size_type _Erase_if(_Pred _Predicate) {

From 10a29be0ea601e83e06b2b8150e4138c5775ec4e Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Fri, 5 Dec 2025 02:22:37 -0800
Subject: [PATCH 080/134] flat_map: `_Erase_if` and the friendship can be
 private to the base class.

---
 stl/inc/flat_map | 52 +++++++++++++++++++++++-------------------------
 1 file changed, 25 insertions(+), 27 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index 330f79c120c..221b046835b 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -842,23 +842,6 @@ protected:
     key_compare _Key_compare;
     containers _Data;
 
-    template <class _Predicate>
-    size_type _Erase_if(_Predicate _Pred) {
-        auto _View           = _View_to_mutate();
-        auto _Mut_first      = _View.begin();
-        auto _Mut_last       = _View.end();
-        const auto _Old_size = size();
-
-        _Clear_guard _Guard{this};
-
-        _STD _Seek_wrapped(_Mut_first, _RANGES remove_if(_View, _Pred).begin());
-        (void) _Data.keys.erase(_Mut_first._Key_it, _Mut_last._Key_it);
-        (void) _Data.values.erase(_Mut_first._Mapped_it, _Mut_last._Mapped_it);
-
-        _Guard._Target = nullptr;
-        return _Old_size - size();
-    }
-
     template <bool _OverwriteIfExists, class _OtherKey, class... _MappedArgTypes>
     iterator _Emplace_hint(const const_iterator _Position, _OtherKey&& _Key_val, _MappedArgTypes&&... _Args) {
         _STL_INTERNAL_STATIC_ASSERT(is_constructible_v<mapped_type, _MappedArgTypes...>
@@ -951,6 +934,31 @@ protected:
     }
 
 private:
+    // FIXME, typename is an EDG workaround
+    template <class _KTy, class _MTy, class _Comp, class _KeyCont, class _MappedCont, class _Pred>
+    friend typename flat_map<_KTy, _MTy, _Comp, _KeyCont, _MappedCont>::size_type erase_if(
+        flat_map<_KTy, _MTy, _Comp, _KeyCont, _MappedCont>&, _Pred);
+    template <class _KTy, class _MTy, class _Comp, class _KeyCont, class _MappedCont, class _Pred>
+    friend typename flat_multimap<_KTy, _MTy, _Comp, _KeyCont, _MappedCont>::size_type erase_if(
+        flat_multimap<_KTy, _MTy, _Comp, _KeyCont, _MappedCont>&, _Pred);
+
+    template <class _Predicate>
+    size_type _Erase_if(_Predicate _Pred) {
+        auto _View           = _View_to_mutate();
+        auto _Mut_first      = _View.begin();
+        auto _Mut_last       = _View.end();
+        const auto _Old_size = size();
+
+        _Clear_guard _Guard{this};
+
+        _STD _Seek_wrapped(_Mut_first, _RANGES remove_if(_View, _Pred).begin());
+        (void) _Data.keys.erase(_Mut_first._Key_it, _Mut_last._Key_it);
+        (void) _Data.values.erase(_Mut_first._Mapped_it, _Mut_last._Mapped_it);
+
+        _Guard._Target = nullptr;
+        return _Old_size - size();
+    }
+
     auto _View_to_mutate() {
         using _Mutating_iterator = _Pairing_iterator_provider<typename key_container_type::iterator,
             typename mapped_container_type::iterator, typename mapped_container_type::iterator>::_Iterator;
@@ -1326,11 +1334,6 @@ private:
     using _MyBase::_Insert_exact;
     using _MyBase::_Key_equal;
 
-    // FIXME, typename is an EDG workaround
-    template <class _KTy, class _MTy, class _Comp, class _KeyCont, class _MappedCont, class _Pred>
-    friend typename flat_map<_KTy, _MTy, _Comp, _KeyCont, _MappedCont>::size_type erase_if(
-        flat_map<_KTy, _MTy, _Comp, _KeyCont, _MappedCont>&, _Pred);
-
     template <class _KeyTy>
     _NODISCARD mapped_type& _At(const _KeyTy& _Key_val) {
         _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
@@ -1530,11 +1533,6 @@ private:
     using _MyBase::_Insert_exact;
     using _MyBase::_Key_equal;
 
-    // FIXME, typename is an EDG workaround
-    template <class _KTy, class _MTy, class _Comp, class _KeyCont, class _MappedCont, class _Pred>
-    friend typename flat_multimap<_KTy, _MTy, _Comp, _KeyCont, _MappedCont>::size_type erase_if(
-        flat_multimap<_KTy, _MTy, _Comp, _KeyCont, _MappedCont>&, _Pred);
-
     template <class _KeyTy, class _MappedTy>
     iterator _Emplace_key_mapped(_KeyTy&& _Key_val, _MappedTy&& _Mapped_val) {
         const auto _Key_it = _STD upper_bound(_Data.keys.begin(), _Data.keys.end(), _Key_val, _Key_compare);

From 853c42cef2d8b761023d3569ae0d8a161eb36082 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Mon, 8 Dec 2025 23:30:24 -0800
Subject: [PATCH 081/134] `<flat_map>`: `_MyBase` => `_Mybase`

---
 stl/inc/flat_map | 60 ++++++++++++++++++++++++------------------------
 1 file changed, 30 insertions(+), 30 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index 221b046835b..9ddd8d5b1e8 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -1143,29 +1143,29 @@ private:
 _EXPORT_STD template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer>
 class flat_map : public _Flat_map_base<true, _Key, _Mapped, _Compare, _KeyContainer, _MappedContainer> {
 private:
-    using _MyBase = _Flat_map_base<true, _Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>;
+    using _Mybase = _Flat_map_base<true, _Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>;
 
-    using _MyBase::_Data;
-    using _MyBase::_Key_compare;
+    using _Mybase::_Data;
+    using _Mybase::_Key_compare;
 
 public:
-    using typename _MyBase::const_iterator;
-    using typename _MyBase::iterator;
-    using typename _MyBase::key_compare;
-    using typename _MyBase::key_type;
-    using typename _MyBase::mapped_type;
-    using typename _MyBase::value_type;
+    using typename _Mybase::const_iterator;
+    using typename _Mybase::iterator;
+    using typename _Mybase::key_compare;
+    using typename _Mybase::key_type;
+    using typename _Mybase::mapped_type;
+    using typename _Mybase::value_type;
 
-    using _MyBase::_MyBase;
-    using _MyBase::clear;
-    using _MyBase::insert;
+    using _Mybase::_Mybase;
+    using _Mybase::clear;
+    using _Mybase::insert;
 
 #if 1 // TRANSITION, P2582R1 (MSVC, Clang, EDG)
     template <_Usable_allocator_for<_KeyContainer, _MappedContainer> _Allocator>
-    flat_map(const flat_map& _Other, const _Allocator& _Al) : _MyBase(_Other, _Al) {}
+    flat_map(const flat_map& _Other, const _Allocator& _Al) : _Mybase(_Other, _Al) {}
 
     template <_Usable_allocator_for<_KeyContainer, _MappedContainer> _Allocator>
-    flat_map(flat_map&& _Other, const _Allocator& _Al) : _MyBase(_STD move(_Other), _Al) {}
+    flat_map(flat_map&& _Other, const _Allocator& _Al) : _Mybase(_STD move(_Other), _Al) {}
 #endif // ^^^ workaround ^^^
 
     flat_map& operator=(initializer_list<value_type> _Ilist) {
@@ -1330,9 +1330,9 @@ public:
     }
 
 private:
-    using _MyBase::_Emplace_hint;
-    using _MyBase::_Insert_exact;
-    using _MyBase::_Key_equal;
+    using _Mybase::_Emplace_hint;
+    using _Mybase::_Insert_exact;
+    using _Mybase::_Key_equal;
 
     template <class _KeyTy>
     _NODISCARD mapped_type& _At(const _KeyTy& _Key_val) {
@@ -1477,25 +1477,25 @@ flat_map<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>::size_type er
 _EXPORT_STD template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer>
 class flat_multimap : public _Flat_map_base<false, _Key, _Mapped, _Compare, _KeyContainer, _MappedContainer> {
 private:
-    using _MyBase = _Flat_map_base<false, _Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>;
+    using _Mybase = _Flat_map_base<false, _Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>;
 
-    using _MyBase::_Data;
-    using _MyBase::_Key_compare;
+    using _Mybase::_Data;
+    using _Mybase::_Key_compare;
 
 public:
-    using typename _MyBase::iterator;
-    using typename _MyBase::value_type;
+    using typename _Mybase::iterator;
+    using typename _Mybase::value_type;
 
-    using _MyBase::_MyBase;
-    using _MyBase::clear;
-    using _MyBase::insert;
+    using _Mybase::_Mybase;
+    using _Mybase::clear;
+    using _Mybase::insert;
 
 #if 1 // TRANSITION, P2582R1 (MSVC, Clang, EDG)
     template <_Usable_allocator_for<_KeyContainer, _MappedContainer> _Allocator>
-    flat_multimap(const flat_multimap& _Other, const _Allocator& _Al) : _MyBase(_Other, _Al) {}
+    flat_multimap(const flat_multimap& _Other, const _Allocator& _Al) : _Mybase(_Other, _Al) {}
 
     template <_Usable_allocator_for<_KeyContainer, _MappedContainer> _Allocator>
-    flat_multimap(flat_multimap&& _Other, const _Allocator& _Al) : _MyBase(_STD move(_Other), _Al) {}
+    flat_multimap(flat_multimap&& _Other, const _Allocator& _Al) : _Mybase(_STD move(_Other), _Al) {}
 #endif // ^^^ workaround ^^^
 
     flat_multimap& operator=(initializer_list<value_type> _Ilist) {
@@ -1529,9 +1529,9 @@ public:
     }
 
 private:
-    using _MyBase::_Emplace_hint;
-    using _MyBase::_Insert_exact;
-    using _MyBase::_Key_equal;
+    using _Mybase::_Emplace_hint;
+    using _Mybase::_Insert_exact;
+    using _Mybase::_Key_equal;
 
     template <class _KeyTy, class _MappedTy>
     iterator _Emplace_key_mapped(_KeyTy&& _Key_val, _MappedTy&& _Mapped_val) {

From a02765f83469d0d4207415a9eb53d8dd52b82f3f Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Mon, 8 Dec 2025 23:48:06 -0800
Subject: [PATCH 082/134] Use `_MSVC_NO_UNIQUE_ADDRESS`.

---
 stl/inc/flat_map | 2 +-
 stl/inc/flat_set | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index 9ddd8d5b1e8..39c41578dcc 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -839,7 +839,7 @@ public:
 
 
 protected:
-    key_compare _Key_compare;
+    _MSVC_NO_UNIQUE_ADDRESS key_compare _Key_compare;
     containers _Data;
 
     template <bool _OverwriteIfExists, class _OtherKey, class... _MappedArgTypes>
diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index 5f7cf79edae..40d18655bf8 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -723,7 +723,7 @@ private:
     }
 
     container_type _Mycont;
-    /* [[no_unique_address]] */ key_compare _Mycomp;
+    _MSVC_NO_UNIQUE_ADDRESS key_compare _Mycomp;
 };
 
 _EXPORT_STD template <class _Kty, class _Keylt, class _Container>

From 4670e797f7817700c08ee2880425e1b516a7dc0e Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Mon, 8 Dec 2025 23:59:14 -0800
Subject: [PATCH 083/134] flat_map: Order _Data before _Key_compare, following
 the Standard.

---
 stl/inc/flat_map | 37 +++++++++++++++++++------------------
 1 file changed, 19 insertions(+), 18 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index 39c41578dcc..36df40d2743 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -327,7 +327,7 @@ public:
 
 public:
     // [flat.map.cons] Constructors
-    explicit _Flat_map_base(const key_compare& _Comp) : _Key_compare(_Comp), _Data() {}
+    explicit _Flat_map_base(const key_compare& _Comp) : _Data(), _Key_compare(_Comp) {}
     _Flat_map_base() : _Flat_map_base(key_compare()) {}
 
     template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
@@ -335,12 +335,13 @@ public:
 
     template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
     _Flat_map_base(const key_compare& _Comp, const _Allocator& _Alloc)
-        : _Key_compare(_Comp), _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Alloc),
-                                   .values = _STD make_obj_using_allocator<mapped_container_type>(_Alloc)} {}
+        : _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Alloc),
+              .values = _STD make_obj_using_allocator<mapped_container_type>(_Alloc)},
+          _Key_compare(_Comp) {}
 
     _Flat_map_base(
         key_container_type _Key_cont, mapped_container_type _Mapped_cont, const key_compare& _Comp = key_compare())
-        : _Key_compare(_Comp), _Data{.keys = _STD move(_Key_cont), .values = _STD move(_Mapped_cont)} {
+        : _Data{.keys = _STD move(_Key_cont), .values = _STD move(_Mapped_cont)}, _Key_compare(_Comp) {
         _Sort();
         if constexpr (_IsUnique) {
             _Dedup();
@@ -369,21 +370,21 @@ public:
 
     _Flat_map_base(_Sorted_t, key_container_type _Key_cont, mapped_container_type _Mapped_cont,
         const key_compare& _Comp = key_compare())
-        : _Key_compare(_Comp), _Data{.keys = _STD move(_Key_cont), .values = _STD move(_Mapped_cont)} {}
+        : _Data{.keys = _STD move(_Key_cont), .values = _STD move(_Mapped_cont)}, _Key_compare(_Comp) {}
 
     template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
     _Flat_map_base(_Sorted_t, const key_container_type& _Key_cont, const mapped_container_type& _Mapped_cont,
         const _Allocator& _Alloc)
-        : _Key_compare(key_compare()),
-          _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Alloc, _Key_cont),
-              .values = _STD make_obj_using_allocator<mapped_container_type>(_Alloc, _Mapped_cont)} {}
+        : _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Alloc, _Key_cont),
+              .values = _STD make_obj_using_allocator<mapped_container_type>(_Alloc, _Mapped_cont)},
+          _Key_compare(key_compare()) {}
 
     template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
     _Flat_map_base(_Sorted_t, const key_container_type& _Key_cont, const mapped_container_type& _Mapped_cont,
         const key_compare& _Comp, const _Allocator& _Alloc)
-        : _Key_compare(_Comp),
-          _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Alloc, _Key_cont),
-              .values = _STD make_obj_using_allocator<mapped_container_type>(_Alloc, _Mapped_cont)} {}
+        : _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Alloc, _Key_cont),
+              .values = _STD make_obj_using_allocator<mapped_container_type>(_Alloc, _Mapped_cont)},
+          _Key_compare(_Comp) {}
 
     template <_Iterator_for_container _InputIterator>
     _Flat_map_base(_InputIterator _First, _InputIterator _Last, const key_compare& _Comp = key_compare())
@@ -468,24 +469,24 @@ public:
         : _Flat_map_base(_Tag, _Ilist, key_compare(), _Alloc) {}
 
     // Copy constructors
-    _Flat_map_base(const _Flat_map_base& _Other) : _Key_compare(_Other._Key_compare), _Data(_Other._Data) {}
+    _Flat_map_base(const _Flat_map_base& _Other) : _Data(_Other._Data), _Key_compare(_Other._Key_compare) {}
 
     template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
     _Flat_map_base(const _Flat_map_base& _Other, const _Allocator& _Alloc)
-        : _Key_compare(_Other._Key_compare),
-          _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Alloc, _Other._Data.keys),
-              .values = _STD make_obj_using_allocator<mapped_container_type>(_Alloc, _Other._Data.values)} {}
+        : _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Alloc, _Other._Data.keys),
+              .values = _STD make_obj_using_allocator<mapped_container_type>(_Alloc, _Other._Data.values)},
+          _Key_compare(_Other._Key_compare) {}
 
     // Move constructors
     _Flat_map_base(_Flat_map_base&& _Other)
         noexcept(is_nothrow_copy_constructible_v<key_compare> && is_nothrow_move_constructible_v<key_compare>
                  && is_nothrow_move_constructible_v<key_container_type>
                  && is_nothrow_move_constructible_v<mapped_container_type>)
-        : _Key_compare(_Other._Key_compare), _Data(_STD move(_Other).extract()) {}
+        : _Data(_STD move(_Other).extract()), _Key_compare(_Other._Key_compare) {}
 
     template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
     _Flat_map_base(_Flat_map_base&& _Other, const _Allocator& _Alloc)
-        : _Key_compare(_Other._Key_compare), _Data{_Other._Extract_using_allocator(_Alloc)} {}
+        : _Data{_Other._Extract_using_allocator(_Alloc)}, _Key_compare(_Other._Key_compare) {}
 
     // Assignment
     _Flat_map_base& operator=(const _Flat_map_base& _Other) {
@@ -839,8 +840,8 @@ public:
 
 
 protected:
-    _MSVC_NO_UNIQUE_ADDRESS key_compare _Key_compare;
     containers _Data;
+    _MSVC_NO_UNIQUE_ADDRESS key_compare _Key_compare;
 
     template <bool _OverwriteIfExists, class _OtherKey, class... _MappedArgTypes>
     iterator _Emplace_hint(const const_iterator _Position, _OtherKey&& _Key_val, _MappedArgTypes&&... _Args) {

From 11a14e80337a3a07b73752d110ef429e89f04961 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Tue, 9 Dec 2025 00:07:33 -0800
Subject: [PATCH 084/134] flat_map: Use braces to construct `value_compare`
 temporaries.

---
 stl/inc/flat_map | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index 36df40d2743..28c933faab9 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -699,7 +699,7 @@ public:
     }
 
     value_compare value_comp() const {
-        return value_compare(_Key_compare);
+        return value_compare{_Key_compare};
     }
 
     const key_container_type& keys() const noexcept {
@@ -969,7 +969,7 @@ private:
 
     void _Sort() {
         _Clear_guard _Guard{this};
-        _RANGES sort(_View_to_mutate(), value_compare(_Key_compare));
+        _RANGES sort(_View_to_mutate(), value_compare{_Key_compare});
         _Guard._Target = nullptr;
     }
 
@@ -1015,11 +1015,11 @@ private:
         if constexpr (_NeedSorting) {
             auto _Sorted_new_elements = _Sorted_view;
             _Sorted_new_elements.advance(_Old_distance);
-            _RANGES sort(_Sorted_new_elements, value_compare(_Key_compare));
+            _RANGES sort(_Sorted_new_elements, value_compare{_Key_compare});
         }
 
         // Merge the newly inserted elements with the existing elements
-        _RANGES inplace_merge(_Sorted_view, _Sorted_view.begin() + _Old_distance, value_compare(_Key_compare));
+        _RANGES inplace_merge(_Sorted_view, _Sorted_view.begin() + _Old_distance, value_compare{_Key_compare});
 
         if constexpr (_IsUnique) {
             _Dedup();

From 9b174b70a7da8ba02b75e3afdb7f038fb9dcbcd2 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Tue, 9 Dec 2025 00:25:19 -0800
Subject: [PATCH 085/134] Add coverage to GH_000545_include_compare.

---
 .../std/tests/GH_000545_include_compare/test.cpp  |  4 ++++
 .../GH_000545_include_compare/test_flat_map.cpp   | 15 +++++++++++++++
 .../GH_000545_include_compare/test_flat_set.cpp   | 15 +++++++++++++++
 3 files changed, 34 insertions(+)
 create mode 100644 tests/std/tests/GH_000545_include_compare/test_flat_map.cpp
 create mode 100644 tests/std/tests/GH_000545_include_compare/test_flat_set.cpp

diff --git a/tests/std/tests/GH_000545_include_compare/test.cpp b/tests/std/tests/GH_000545_include_compare/test.cpp
index 9bba56a9318..021c62debea 100644
--- a/tests/std/tests/GH_000545_include_compare/test.cpp
+++ b/tests/std/tests/GH_000545_include_compare/test.cpp
@@ -6,6 +6,8 @@ void test_chrono();
 void test_coroutine();
 void test_deque();
 void test_filesystem();
+void test_flat_map();
+void test_flat_set();
 void test_forward_list();
 void test_iterator();
 void test_list();
@@ -36,6 +38,8 @@ int main() {
     test_coroutine();
     test_deque();
     test_filesystem();
+    test_flat_map();
+    test_flat_set();
     test_forward_list();
     test_iterator();
     test_list();
diff --git a/tests/std/tests/GH_000545_include_compare/test_flat_map.cpp b/tests/std/tests/GH_000545_include_compare/test_flat_map.cpp
new file mode 100644
index 00000000000..b7a050857aa
--- /dev/null
+++ b/tests/std/tests/GH_000545_include_compare/test_flat_map.cpp
@@ -0,0 +1,15 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <version>
+#if _HAS_CXX23
+
+#include <flat_map>
+
+// Testing LWG-3330 "Include <compare> from most library headers" by intentionally NOT including <compare>
+
+static_assert(std::is_eq(std::partial_ordering::equivalent));
+
+#endif // _HAS_CXX23
+
+void test_flat_map() {}
diff --git a/tests/std/tests/GH_000545_include_compare/test_flat_set.cpp b/tests/std/tests/GH_000545_include_compare/test_flat_set.cpp
new file mode 100644
index 00000000000..aa16a42bb97
--- /dev/null
+++ b/tests/std/tests/GH_000545_include_compare/test_flat_set.cpp
@@ -0,0 +1,15 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <version>
+#if _HAS_CXX23
+
+#include <flat_set>
+
+// Testing LWG-3330 "Include <compare> from most library headers" by intentionally NOT including <compare>
+
+static_assert(std::is_eq(std::partial_ordering::equivalent));
+
+#endif // _HAS_CXX23
+
+void test_flat_set() {}

From 905da0f539bf1e4e4d8b9f9fdb55e0c37cfb9076 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Tue, 9 Dec 2025 00:43:35 -0800
Subject: [PATCH 086/134] Fix GH 5075 `<flat_map>`: Can we separately compare
 key and mapped containers?

---
 stl/inc/flat_map | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index 28c933faab9..86da4758fb3 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -822,10 +822,8 @@ public:
     }
 
     _NODISCARD friend bool operator==(const _Derived& _Left, const _Derived& _Right) {
-        auto& _Left_base  = static_cast<const _Flat_map_base&>(_Left);
-        auto& _Right_base = static_cast<const _Flat_map_base&>(_Right);
-        return _RANGES equal(_Left_base._Data.keys, _Right_base._Data.keys)
-            && _RANGES equal(_Left_base._Data.values, _Right_base._Data.values);
+        return _STD equal(_STD _Get_unwrapped(_STD cbegin(_Left)), _STD _Get_unwrapped(_STD cend(_Left)),
+            _STD _Get_unwrapped(_STD cbegin(_Right)), _STD _Get_unwrapped(_STD cend(_Right)));
     }
 
     _NODISCARD friend auto operator<=>(const _Derived& _Left, const _Derived& _Right) {

From 062c9186334646ee228315388bc7f6c12795690a Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Tue, 9 Dec 2025 00:51:42 -0800
Subject: [PATCH 087/134] Consistently modify containers before comparators.

---
 stl/inc/flat_map | 6 +++---
 stl/inc/flat_set | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index 86da4758fb3..ff77be01a3b 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -491,8 +491,8 @@ public:
     // Assignment
     _Flat_map_base& operator=(const _Flat_map_base& _Other) {
         _Clear_guard _Guard{this};
-        _Key_compare   = _Other._Key_compare;
         _Data          = _Other._Data;
+        _Key_compare   = _Other._Key_compare;
         _Guard._Target = nullptr;
         return *this;
     }
@@ -501,8 +501,8 @@ public:
         is_nothrow_copy_assignable_v<key_compare> && is_nothrow_move_assignable_v<key_compare>
         && is_nothrow_move_assignable_v<key_container_type> && is_nothrow_move_assignable_v<mapped_container_type>) {
         _Clear_guard _Guard{this};
-        _Key_compare   = _Other._Key_compare;
         _Data          = _STD move(_Other).extract();
+        _Key_compare   = _Other._Key_compare;
         _Guard._Target = nullptr;
         return *this;
     }
@@ -567,9 +567,9 @@ public:
         auto& _Other_base = static_cast<_Flat_map_base&>(_Other);
         _Flat_map_swap_clear_guard<_Is_noexcept, containers> _Guard{
             _STD addressof(_Data), _STD addressof(_Other_base._Data)};
-        _RANGES swap(_Key_compare, _Other_base._Key_compare);
         _RANGES swap(_Data.keys, _Other_base._Data.keys);
         _RANGES swap(_Data.values, _Other_base._Data.values);
+        _RANGES swap(_Key_compare, _Other_base._Key_compare);
         _Guard._Dismiss();
     }
 
diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index 40d18655bf8..abf23b6f092 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -375,8 +375,8 @@ public:
         constexpr bool _Is_noexcept = is_nothrow_swappable_v<_Container> && is_nothrow_swappable_v<_Keylt>;
         _Flat_set_swap_clear_guard<_Is_noexcept, _Container> _Guard{
             _STD addressof(_Mycont), _STD addressof(_Other._Mycont)};
-        _RANGES swap(_Mycomp, _Other._Mycomp);
         _RANGES swap(_Mycont, _Other._Mycont);
+        _RANGES swap(_Mycomp, _Other._Mycomp);
         _Guard._Dismiss();
     }
     void clear() noexcept {

From 17f1f5d16f77937cb2dcba24aeecc679e0a0ac4d Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Tue, 9 Dec 2025 00:55:51 -0800
Subject: [PATCH 088/134] Consistently comment "// intentionally copy
 comparator, see LWG-2227".

---
 stl/inc/flat_map | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index ff77be01a3b..5dc56b0bd7a 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -482,11 +482,15 @@ public:
         noexcept(is_nothrow_copy_constructible_v<key_compare> && is_nothrow_move_constructible_v<key_compare>
                  && is_nothrow_move_constructible_v<key_container_type>
                  && is_nothrow_move_constructible_v<mapped_container_type>)
-        : _Data(_STD move(_Other).extract()), _Key_compare(_Other._Key_compare) {}
+        : _Data(_STD move(_Other).extract()),
+          _Key_compare(_Other._Key_compare) // intentionally copy comparator, see LWG-2227
+    {}
 
     template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
     _Flat_map_base(_Flat_map_base&& _Other, const _Allocator& _Alloc)
-        : _Data{_Other._Extract_using_allocator(_Alloc)}, _Key_compare(_Other._Key_compare) {}
+        : _Data{_Other._Extract_using_allocator(_Alloc)},
+          _Key_compare(_Other._Key_compare) // intentionally copy comparator, see LWG-2227
+    {}
 
     // Assignment
     _Flat_map_base& operator=(const _Flat_map_base& _Other) {
@@ -502,7 +506,7 @@ public:
         && is_nothrow_move_assignable_v<key_container_type> && is_nothrow_move_assignable_v<mapped_container_type>) {
         _Clear_guard _Guard{this};
         _Data          = _STD move(_Other).extract();
-        _Key_compare   = _Other._Key_compare;
+        _Key_compare   = _Other._Key_compare; // intentionally copy comparator, see LWG-2227
         _Guard._Target = nullptr;
         return *this;
     }

From 9a4563e682095dec683f1dbe0b6092b280f8cb3b Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Tue, 9 Dec 2025 01:02:38 -0800
Subject: [PATCH 089/134] Construct from _Flat_set_base _Other instead of
 _Derived _Set.

---
 stl/inc/flat_set | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index abf23b6f092..ffe6b867d70 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -95,12 +95,12 @@ public:
     _Flat_set_base() : _Mycont(), _Mycomp() {}
 
     template <_Usable_allocator_for<container_type> _Alloc>
-    _Flat_set_base(const _Derived& _Set, const _Alloc& _Al)
-        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al, _Set._Mycont)), _Mycomp(_Set._Mycomp) {}
+    _Flat_set_base(const _Flat_set_base& _Other, const _Alloc& _Al)
+        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al, _Other._Mycont)), _Mycomp(_Other._Mycomp) {}
     template <_Usable_allocator_for<container_type> _Alloc>
-    _Flat_set_base(_Derived&& _Set, const _Alloc& _Al)
-        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al, _STD move(_Set).extract())),
-          _Mycomp(_Set._Mycomp) // intentionally copy comparator, see LWG-2227
+    _Flat_set_base(_Flat_set_base&& _Other, const _Alloc& _Al)
+        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al, _STD move(_Other).extract())),
+          _Mycomp(_Other._Mycomp) // intentionally copy comparator, see LWG-2227
     {}
 
     explicit _Flat_set_base(container_type _Cont, const key_compare& _Comp = key_compare())

From 61bde137cfd360c0922922e42339120e21d7d8e9 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Tue, 9 Dec 2025 01:24:49 -0800
Subject: [PATCH 090/134] flat_map: Refine _Emplace_hint
 _STL_INTERNAL_STATIC_ASSERT.

Separately assert X and Y.

This is an internal member function, so "Overwriting is not supported" should be an internal check. Users should never be able to trigger that.
---
 stl/inc/flat_map | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index 5dc56b0bd7a..24fedea1093 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -847,11 +847,13 @@ protected:
 
     template <bool _OverwriteIfExists, class _OtherKey, class... _MappedArgTypes>
     iterator _Emplace_hint(const const_iterator _Position, _OtherKey&& _Key_val, _MappedArgTypes&&... _Args) {
-        _STL_INTERNAL_STATIC_ASSERT(is_constructible_v<mapped_type, _MappedArgTypes...>
-                                    && (is_same_v<remove_cvref_t<_OtherKey>, key_type>
-                                        || (is_constructible_v<key_type, _OtherKey> && _Transparent<key_compare>) ));
-        static_assert(_IsUnique || !_OverwriteIfExists,
-            "Overwriting is not supported when the container allows multiple copies of a key.");
+        _STL_INTERNAL_STATIC_ASSERT(is_constructible_v<mapped_type, _MappedArgTypes...>);
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<remove_cvref_t<_OtherKey>, key_type>
+                                    || (is_constructible_v<key_type, _OtherKey> && _Transparent<key_compare>) );
+
+        // Overwriting is not supported when the container allows multiple copies of a key.
+        _STL_INTERNAL_STATIC_ASSERT(_IsUnique || !_OverwriteIfExists);
+
         const const_iterator _Begin = cbegin();
         const const_iterator _End   = cend();
 

From bbd8a7b862e8b5bfe657ab801e50bc03dca1b48b Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Tue, 9 Dec 2025 01:26:37 -0800
Subject: [PATCH 091/134] Update flat_map::at exceptions to match classic.
 (Without "<K, T>" which isn't valuable.)

---
 stl/inc/flat_map | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index 24fedea1093..564bff29a01 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -1344,7 +1344,7 @@ private:
         _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
         const auto _Position = this->find(_Key_val);
         if (_Position == this->end()) {
-            _Xout_of_range("std::flat_map::at: the specified key does not exist.");
+            _Xout_of_range("invalid flat_map key");
         }
 
         return _Position->second;
@@ -1355,7 +1355,7 @@ private:
         _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
         const auto _Position = this->find(_Key_val);
         if (_Position == this->end()) {
-            _Xout_of_range("std::flat_map::at: the specified key does not exist.");
+            _Xout_of_range("invalid flat_map key");
         }
 
         return _Position->second;

From ae1b19754dbf842b8de4754689130c58b4c4e1d1 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Tue, 9 Dec 2025 01:49:29 -0800
Subject: [PATCH 092/134] Overhaul static_asserts and Standard citations.

---
 stl/inc/flat_map | 20 ++++++++++++++++----
 stl/inc/flat_set | 15 ++++++++-------
 2 files changed, 24 insertions(+), 11 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index 564bff29a01..9830fcc7630 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -316,11 +316,23 @@ public:
     using const_reverse_iterator = _STD reverse_iterator<const_iterator>;
 
     static_assert(is_same_v<key_type, typename key_container_type::value_type>,
-        "key_type should be the element type of key_container_type");
+        "key_type and key_container_type::value_type must be the same. "
+        "(N5014 [flat.map.overview]/8, [flat.multimap.overview]/8)");
     static_assert(is_same_v<mapped_type, typename mapped_container_type::value_type>,
-        "mapped_type should be the element type of mapped_container_type");
-    static_assert(!_Is_vector_bool<key_container_type> && !_Is_vector_bool<mapped_container_type>,
-        "vector<bool, A> cannot be adapted because it is not a sequence container.");
+        "mapped_type and mapped_container_type::value_type must be the same. "
+        "(N5014 [flat.map.overview]/8, [flat.multimap.overview]/8)");
+    static_assert(!_Is_vector_bool<key_container_type>,
+        "key_container_type cannot be vector<bool> because it is not a sequence container. "
+        "(N5014 [flat.map.overview]/7, [flat.multimap.overview]/7)");
+    static_assert(!_Is_vector_bool<mapped_container_type>,
+        "mapped_container_type cannot be vector<bool> because it is not a sequence container. "
+        "(N5014 [flat.map.overview]/7, [flat.multimap.overview]/7)");
+    static_assert(random_access_iterator<typename key_container_type::const_iterator>,
+        "key_container_type must support random-access iterators in order to be adapted. "
+        "(N5014 [flat.map.overview]/7, [flat.multimap.overview]/7)");
+    static_assert(random_access_iterator<typename mapped_container_type::const_iterator>,
+        "mapped_container_type must support random-access iterators in order to be adapted. "
+        "(N5014 [flat.map.overview]/7, [flat.multimap.overview]/7)");
 
     using value_compare = _Flat_map_value_compare_provider<key_type, mapped_type, key_compare>::value_compare;
     using containers    = _Flat_map_container_provider<key_container_type, mapped_container_type>::containers;
diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index ffe6b867d70..b854d65b5b6 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -70,10 +70,14 @@ private:
 
 public:
     static_assert(same_as<_Kty, typename _Container::value_type>,
-        "The C++ Standard dictates that the Key type must be the "
-        "same as the container's value type [flatset.overview]");
-    static_assert(
-        !_Is_vector_bool<_Container>, "vector<bool, A> cannot be adapted because it is not a sequence container.");
+        "key_type and container_type::value_type must be the same. "
+        "(N5014 [flat.set.overview]/8, [flat.multiset.overview]/8)");
+    static_assert(!_Is_vector_bool<_Container>,
+        "vector<bool> cannot be adapted because it is not a sequence container. "
+        "(N5014 [flat.set.overview]/7, [flat.multiset.overview]/7)");
+    static_assert(random_access_iterator<typename _Container::const_iterator>,
+        "Sequence containers must support random-access iterators in order to be adapted. "
+        "(N5014 [flat.set.overview]/7, [flat.multiset.overview]/7)");
 
     using key_type               = _Kty;
     using value_type             = _Kty;
@@ -89,9 +93,6 @@ public:
     using reverse_iterator       = const_reverse_iterator;
     using container_type         = _Container;
 
-    static_assert(random_access_iterator<iterator>, "The C++ Standard forbids containers without random "
-                                                    "access iterators from being adapted. See [flatset.overview].");
-
     _Flat_set_base() : _Mycont(), _Mycomp() {}
 
     template <_Usable_allocator_for<container_type> _Alloc>

From 6b59aa143eb5974b6df709fe443f5aa89db32e2e Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Tue, 9 Dec 2025 02:32:34 -0800
Subject: [PATCH 093/134] Push/undef/pop "msvc".

---
 stl/inc/flat_map | 7 +++++++
 stl/inc/flat_set | 7 +++++++
 2 files changed, 14 insertions(+)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index 9830fcc7630..77d6736e8db 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -27,6 +27,10 @@ _STL_DISABLE_CLANG_WARNINGS
 #pragma push_macro("new")
 #undef new
 
+// TRANSITION, non-_Ugly attribute tokens
+#pragma push_macro("msvc")
+#undef msvc
+
 _STD_BEGIN
 template <class _Key, class _Mapped, class _KeyCompare>
 struct _Flat_map_value_compare_provider {
@@ -1657,6 +1661,9 @@ flat_multimap<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>::size_ty
 }
 _STD_END
 
+// TRANSITION, non-_Ugly attribute tokens
+#pragma pop_macro("msvc")
+
 #pragma pop_macro("new")
 _STL_RESTORE_CLANG_WARNINGS
 #pragma warning(pop)
diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index b854d65b5b6..eb9017af000 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -23,6 +23,10 @@ _STL_DISABLE_CLANG_WARNINGS
 #pragma push_macro("new")
 #undef new
 
+// TRANSITION, non-_Ugly attribute tokens
+#pragma push_macro("msvc")
+#undef msvc
+
 _STD_BEGIN
 template <bool _IsNoexcept, class _Container>
 struct _NODISCARD _Flat_set_swap_clear_guard {
@@ -877,6 +881,9 @@ flat_multiset(sorted_equivalent_t, initializer_list<_Kty>, _Compare = _Compare()
 
 _STD_END
 
+// TRANSITION, non-_Ugly attribute tokens
+#pragma pop_macro("msvc")
+
 #pragma pop_macro("new")
 _STL_RESTORE_CLANG_WARNINGS
 #pragma warning(pop)

From 860ccb31f9e5f640282f88897ca8696a829dc3a8 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Thu, 11 Dec 2025 16:12:43 -0800
Subject: [PATCH 094/134] Enable passing tests! <3 <3 <3 =^..^=

---
 tests/libcxx/expected_results.txt | 76 -------------------------------
 1 file changed, 76 deletions(-)

diff --git a/tests/libcxx/expected_results.txt b/tests/libcxx/expected_results.txt
index 85a3e121149..c14ef17f01b 100644
--- a/tests/libcxx/expected_results.txt
+++ b/tests/libcxx/expected_results.txt
@@ -266,62 +266,6 @@ std/input.output/syncstream/osyncstream/thread/several_threads.pass.cpp:1 SKIPPE
 std/depr/depr.c.headers/uchar_h.compile.pass.cpp FAIL
 std/strings/c.strings/cuchar.compile.pass.cpp FAIL
 
-# P0429R9 <flat_map>
-
-# FIXME! warning C4242: 'initializing': conversion from '_Ty' to '_Ty2', possible loss of data
-std/containers/container.adaptors/flat.map/flat.map.cons/copy_assign.pass.cpp:0 FAIL
-std/containers/container.adaptors/flat.map/flat.map.cons/copy_assign.pass.cpp:1 FAIL
-std/containers/container.adaptors/flat.map/flat.map.cons/deduct.pass.cpp:0 FAIL
-std/containers/container.adaptors/flat.map/flat.map.cons/deduct.pass.cpp:1 FAIL
-std/containers/container.adaptors/flat.map/flat.map.cons/deduct_pmr.pass.cpp:0 FAIL
-std/containers/container.adaptors/flat.map/flat.map.cons/deduct_pmr.pass.cpp:1 FAIL
-std/containers/container.adaptors/flat.map/flat.map.cons/initializer_list.pass.cpp:0 FAIL
-std/containers/container.adaptors/flat.map/flat.map.cons/initializer_list.pass.cpp:1 FAIL
-std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter.pass.cpp:0 FAIL
-std/containers/container.adaptors/flat.map/flat.map.cons/iter_iter.pass.cpp:1 FAIL
-std/containers/container.adaptors/flat.map/flat.map.cons/move_assign.pass.cpp:0 FAIL
-std/containers/container.adaptors/flat.map/flat.map.cons/move_assign.pass.cpp:1 FAIL
-std/containers/container.adaptors/flat.map/flat.map.cons/pmr.pass.cpp:0 FAIL
-std/containers/container.adaptors/flat.map/flat.map.cons/pmr.pass.cpp:1 FAIL
-std/containers/container.adaptors/flat.map/flat.map.cons/range.pass.cpp:0 FAIL
-std/containers/container.adaptors/flat.map/flat.map.cons/range.pass.cpp:1 FAIL
-std/containers/container.adaptors/flat.map/flat.map.cons/sorted_container.pass.cpp:0 FAIL
-std/containers/container.adaptors/flat.map/flat.map.cons/sorted_container.pass.cpp:1 FAIL
-std/containers/container.adaptors/flat.map/flat.map.cons/sorted_initializer_list.pass.cpp:0 FAIL
-std/containers/container.adaptors/flat.map/flat.map.cons/sorted_initializer_list.pass.cpp:1 FAIL
-std/containers/container.adaptors/flat.map/flat.map.cons/sorted_iter_iter.pass.cpp:0 FAIL
-std/containers/container.adaptors/flat.map/flat.map.cons/sorted_iter_iter.pass.cpp:1 FAIL
-std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_key.pass.cpp:0 FAIL
-std/containers/container.adaptors/flat.map/flat.map.modifiers/erase_key.pass.cpp:1 FAIL
-std/containers/container.adaptors/flat.multimap/flat.multimap.cons/copy_assign.pass.cpp:0 FAIL
-std/containers/container.adaptors/flat.multimap/flat.multimap.cons/copy_assign.pass.cpp:1 FAIL
-std/containers/container.adaptors/flat.multimap/flat.multimap.cons/deduct.pass.cpp:0 FAIL
-std/containers/container.adaptors/flat.multimap/flat.multimap.cons/deduct.pass.cpp:1 FAIL
-std/containers/container.adaptors/flat.multimap/flat.multimap.cons/deduct_pmr.pass.cpp:0 FAIL
-std/containers/container.adaptors/flat.multimap/flat.multimap.cons/deduct_pmr.pass.cpp:1 FAIL
-std/containers/container.adaptors/flat.multimap/flat.multimap.cons/initializer_list.pass.cpp:0 FAIL
-std/containers/container.adaptors/flat.multimap/flat.multimap.cons/initializer_list.pass.cpp:1 FAIL
-std/containers/container.adaptors/flat.multimap/flat.multimap.cons/iter_iter.pass.cpp:0 FAIL
-std/containers/container.adaptors/flat.multimap/flat.multimap.cons/iter_iter.pass.cpp:1 FAIL
-std/containers/container.adaptors/flat.multimap/flat.multimap.cons/move_assign.pass.cpp:0 FAIL
-std/containers/container.adaptors/flat.multimap/flat.multimap.cons/move_assign.pass.cpp:1 FAIL
-std/containers/container.adaptors/flat.multimap/flat.multimap.cons/pmr.pass.cpp:0 FAIL
-std/containers/container.adaptors/flat.multimap/flat.multimap.cons/pmr.pass.cpp:1 FAIL
-std/containers/container.adaptors/flat.multimap/flat.multimap.cons/range.pass.cpp:0 FAIL
-std/containers/container.adaptors/flat.multimap/flat.multimap.cons/range.pass.cpp:1 FAIL
-std/containers/container.adaptors/flat.multimap/flat.multimap.cons/sorted_container.pass.cpp:0 FAIL
-std/containers/container.adaptors/flat.multimap/flat.multimap.cons/sorted_container.pass.cpp:1 FAIL
-std/containers/container.adaptors/flat.multimap/flat.multimap.cons/sorted_initializer_list.pass.cpp:0 FAIL
-std/containers/container.adaptors/flat.multimap/flat.multimap.cons/sorted_initializer_list.pass.cpp:1 FAIL
-std/containers/container.adaptors/flat.multimap/flat.multimap.cons/sorted_iter_iter.pass.cpp:0 FAIL
-std/containers/container.adaptors/flat.multimap/flat.multimap.cons/sorted_iter_iter.pass.cpp:1 FAIL
-std/containers/container.adaptors/flat.multimap/flat.multimap.modifiers/erase_key.pass.cpp:0 FAIL
-std/containers/container.adaptors/flat.multimap/flat.multimap.modifiers/erase_key.pass.cpp:1 FAIL
-
-# FIXME! error: conversion function from 'pair<_Unrefwrap_t<int>, _Unrefwrap_t<int>>' to 'pair<const int &, const char &>' invokes a deleted function
-std/containers/container.adaptors/flat.map/flat.map.observers/comp.pass.cpp:2 FAIL
-std/containers/container.adaptors/flat.multimap/flat.multimap.observers/comp.pass.cpp:2 FAIL
-
 # P0533R9 constexpr For <cmath> And <cstdlib>
 std/language.support/support.limits/support.limits.general/cmath.version.compile.pass.cpp FAIL
 std/language.support/support.limits/support.limits.general/cstdlib.version.compile.pass.cpp FAIL
@@ -339,26 +283,6 @@ std/numerics/numeric.ops/numeric.ops.sat/saturate_cast.pass.cpp FAIL
 std/numerics/numeric.ops/numeric.ops.sat/sub_sat.compile.pass.cpp FAIL
 std/numerics/numeric.ops/numeric.ops.sat/sub_sat.pass.cpp FAIL
 
-# P1222R4 <flat_set>
-
-# FIXME! error: static assertion failed due to requirement '!std::is_nothrow_move_constructible_v<std::flat_MEOW<int, ThrowingMoveComp, std::vector<int, std::allocator<int>>>>'
-std/containers/container.adaptors/flat.multiset/flat.multiset.cons/move.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.cons/move.pass.cpp FAIL
-
-# FIXME! error: call to implicitly-deleted copy constructor of 'container_type' (aka 'MoveAssignThrows')
-std/containers/container.adaptors/flat.multiset/flat.multiset.cons/move_assign.pass.cpp:2 FAIL
-std/containers/container.adaptors/flat.set/flat.set.cons/move_assign.pass.cpp:2 FAIL
-
-# FIXME! warning C4242: 'initializing': conversion from 'int' to '_Ty', possible loss of data
-std/containers/container.adaptors/flat.multiset/flat.multiset.cons/sorted_iter_iter.pass.cpp:0 FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.cons/sorted_iter_iter.pass.cpp:1 FAIL
-std/containers/container.adaptors/flat.set/flat.set.cons/sorted_iter_iter.pass.cpp:0 FAIL
-std/containers/container.adaptors/flat.set/flat.set.cons/sorted_iter_iter.pass.cpp:1 FAIL
-
-# FIXME! Looks like test code isn't defending itself against evil overloaded comma operators.
-std/containers/container.adaptors/flat.multiset/flat.multiset.iterators/iterator.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.iterators/iterator.pass.cpp FAIL
-
 # P2255R2 "Type Traits To Detect References Binding To Temporaries"
 # (type_traits.version.compile.pass.cpp still fails for Clang due to LLVM-48860)
 std/language.support/support.limits/support.limits.general/type_traits.version.compile.pass.cpp FAIL

From 18e1eb5360e9179104f6a03d9b663c2a38083af4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vojt=C4=9Bch=20Michal?= <vojta.michall@email.cz>
Date: Fri, 12 Dec 2025 19:03:32 +0100
Subject: [PATCH 095/134] `<flat_map>` `<flat_set>`: Add `_NODISCARD`, remove
 nested `_Clear_guard`, add precondition checks etc. (#5953)

* Add _NODISCARD to flat_map and flat_set.

* Don't query the nothrow_move_constructibility of flat_map::key_compare when it is only copied.

* flat_map::_Extract_using_allocator should be rvalue-ref qualified.

* Make flat_map::extract consistent with flat_set::extract.

* flat_set::_Erase should not pessimize performance for different _Ty and _Kty.

* Some libcxx tests have to be FAILed due to throwing move constructor of comparator.

* Remove nested _Clear_guards form flat_map

* Make newlines between functions in <flat_set> consistent (remove between
short repetitive functions)

* Add precondition checks to flat_map

* consistently use typedef key_compare instead of template parameter _Compare in flat_map code.

* Fix formatting.

* _Flat_map_base::_Is_sorted should not be template.

* Wrap _Flat_map_base::_Key_compare with _Pass_fn when calling standard algorithms (e.g. lower_bound)

* Correct formatting.

* Introduce a helper function to call _Pass_fn in flat_map.

* Start to unify implementation of deduplication between flat_map and flat_set.

* Make begin/end available when including <flat_map>

* Reference correct standard WP in comments.

* Correct formatting.

* Use ranges::sort instead of std::sort.

* Mention that FAILed libcxx tests are due to different resolution of LWG-2227

* Fix/update citations.

* Consistently use the `_Always_clear` name.

* All shall love `adjacent_find()` and despair.

* Categorize LWG-2227 divergence as "likely bogus tests", not "missing STL features".

---------

Co-authored-by: Stephan T. Lavavej <stl@microsoft.com>
---
 stl/inc/flat_map                  | 209 ++++++++++++++++++------------
 stl/inc/flat_set                  |  26 ++--
 tests/libcxx/expected_results.txt |   5 +
 3 files changed, 142 insertions(+), 98 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index 77d6736e8db..1e6eac4961b 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -19,6 +19,7 @@ _EMIT_STL_WARNING(STL4038, "The contents of <flat_map> are available only with C
 #include <utility>
 #include <vector>
 #include <xmemory>
+#include <xutility>
 
 #pragma pack(push, _CRT_PACKING)
 #pragma warning(push, _STL_WARNING_LEVEL)
@@ -36,7 +37,8 @@ template <class _Key, class _Mapped, class _KeyCompare>
 struct _Flat_map_value_compare_provider {
     struct value_compare {
     public:
-        bool operator()(pair<const _Key&, const _Mapped&> _Left, pair<const _Key&, const _Mapped&> _Right) const {
+        _NODISCARD bool operator()(
+            pair<const _Key&, const _Mapped&> _Left, pair<const _Key&, const _Mapped&> _Right) const {
             return _Key_comparator(_Left.first, _Right.first);
         }
 
@@ -97,7 +99,7 @@ struct _Pairing_iterator_provider {
         public:
             explicit _Arrow_proxy(const reference& _Rx) noexcept : _Ref{_Rx} {}
 
-            const reference* operator->() const noexcept {
+            _NODISCARD const reference* operator->() const noexcept {
                 return _STD addressof(_Ref);
             }
 
@@ -108,16 +110,16 @@ struct _Pairing_iterator_provider {
     public:
         using pointer = _Arrow_proxy;
 
-        reference operator*() const {
+        _NODISCARD reference operator*() const {
             return reference{*_Key_it, *_Mapped_it};
         }
 
-        friend pair<iter_rvalue_reference_t<_KeyIter>, iter_rvalue_reference_t<_MappedIter>> iter_move(
+        _NODISCARD friend pair<iter_rvalue_reference_t<_KeyIter>, iter_rvalue_reference_t<_MappedIter>> iter_move(
             const _Iterator& _It) {
             return {_RANGES iter_move(_It._Key_it), _RANGES iter_move(_It._Mapped_it)};
         }
 
-        pointer operator->() const {
+        _NODISCARD pointer operator->() const {
             return pointer{**this};
         }
 
@@ -133,11 +135,11 @@ struct _Pairing_iterator_provider {
             return _Old;
         }
 
-        bool operator==(const _Iterator& _Right) const {
+        _NODISCARD bool operator==(const _Iterator& _Right) const {
             return _Key_it == _Right._Key_it;
         }
 
-        auto operator<=>(const _Iterator& _Right) const {
+        _NODISCARD auto operator<=>(const _Iterator& _Right) const {
             return _Synth_three_way{}(_Key_it, _Right._Key_it);
         }
 
@@ -165,41 +167,41 @@ struct _Pairing_iterator_provider {
             return *this;
         }
 
-        _Iterator operator+(const difference_type _Off) const {
+        _NODISCARD _Iterator operator+(const difference_type _Off) const {
             auto _Old = *this;
             _Old += _Off;
             return _Old;
         }
 
-        _Iterator operator-(const difference_type _Off) const {
+        _NODISCARD _Iterator operator-(const difference_type _Off) const {
             auto _Old = *this;
             _Old -= _Off;
             return _Old;
         }
 
-        reference operator[](const difference_type _Off) const {
+        _NODISCARD reference operator[](const difference_type _Off) const {
             return *(*this + _Off);
         }
 
-        difference_type operator-(const _Iterator& _Right) const {
+        _NODISCARD difference_type operator-(const _Iterator& _Right) const {
             return _Key_it - _Right._Key_it;
         }
 
-        friend _Iterator operator+(const difference_type _Off, const _Iterator& _Right) {
+        _NODISCARD friend _Iterator operator+(const difference_type _Off, const _Iterator& _Right) {
             return _Right + _Off;
         }
 
-        operator _Const_iterator() const
+        _NODISCARD operator _Const_iterator() const
             requires (!is_same_v<_MappedIter, _MappedConvIter>)
         {
             return _Const_iterator{_Key_it, _Mapped_it};
         }
 
-        const _KeyIter& _Key_iterator() const noexcept {
+        _NODISCARD const _KeyIter& _Key_iterator() const noexcept {
             return _Key_it;
         }
 
-        const _MappedIter& _Mapped_iterator() const noexcept {
+        _NODISCARD const _MappedIter& _Mapped_iterator() const noexcept {
             return _Mapped_it;
         }
 
@@ -298,6 +300,8 @@ private:
     using _Derived  = conditional_t<_IsUnique, flat_map<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>,
          flat_multimap<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>>;
 
+    static constexpr const char* _Msg_not_sorted = _IsUnique ? "Keys were not sorted-unique!" : "Keys were not sorted!";
+
 public:
     using key_type              = _Key;
     using mapped_type           = _Mapped;
@@ -358,49 +362,47 @@ public:
     _Flat_map_base(
         key_container_type _Key_cont, mapped_container_type _Mapped_cont, const key_compare& _Comp = key_compare())
         : _Data{.keys = _STD move(_Key_cont), .values = _STD move(_Mapped_cont)}, _Key_compare(_Comp) {
-        _Sort();
-        if constexpr (_IsUnique) {
-            _Dedup();
-        }
+        _STL_ASSERT(_Data.keys.size() == _Data.values.size(), "key_cont.size() != mapped_cont.size()");
+        _Sort_and_erase_dupes_if_not_multi();
     }
 
     template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
     _Flat_map_base(
         const key_container_type& _Key_cont, const mapped_container_type& _Mapped_cont, const _Allocator& _Alloc)
         : _Flat_map_base(_Sorted_t{}, _Key_cont, _Mapped_cont, _Alloc) {
-        _Sort();
-        if constexpr (_IsUnique) {
-            _Dedup();
-        }
+        _Sort_and_erase_dupes_if_not_multi();
     }
 
     template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
     _Flat_map_base(const key_container_type& _Key_cont, const mapped_container_type& _Mapped_cont,
         const key_compare& _Comp, const _Allocator& _Alloc)
         : _Flat_map_base(_Sorted_t{}, _Key_cont, _Mapped_cont, _Comp, _Alloc) {
-        _Sort();
-        if constexpr (_IsUnique) {
-            _Dedup();
-        }
+        _Sort_and_erase_dupes_if_not_multi();
     }
 
     _Flat_map_base(_Sorted_t, key_container_type _Key_cont, mapped_container_type _Mapped_cont,
         const key_compare& _Comp = key_compare())
-        : _Data{.keys = _STD move(_Key_cont), .values = _STD move(_Mapped_cont)}, _Key_compare(_Comp) {}
+        : _Data{.keys = _STD move(_Key_cont), .values = _STD move(_Mapped_cont)}, _Key_compare(_Comp) {
+        _STL_ASSERT(_Data.keys.size() == _Data.values.size(), "key_cont.size() != mapped_cont.size()");
+    }
 
     template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
     _Flat_map_base(_Sorted_t, const key_container_type& _Key_cont, const mapped_container_type& _Mapped_cont,
         const _Allocator& _Alloc)
         : _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Alloc, _Key_cont),
               .values = _STD make_obj_using_allocator<mapped_container_type>(_Alloc, _Mapped_cont)},
-          _Key_compare(key_compare()) {}
+          _Key_compare(key_compare()) {
+        _STL_ASSERT(_Data.keys.size() == _Data.values.size(), "key_cont.size() != mapped_cont.size()");
+    }
 
     template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
     _Flat_map_base(_Sorted_t, const key_container_type& _Key_cont, const mapped_container_type& _Mapped_cont,
         const key_compare& _Comp, const _Allocator& _Alloc)
         : _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Alloc, _Key_cont),
               .values = _STD make_obj_using_allocator<mapped_container_type>(_Alloc, _Mapped_cont)},
-          _Key_compare(_Comp) {}
+          _Key_compare(_Comp) {
+        _STL_ASSERT(_Data.keys.size() == _Data.values.size(), "key_cont.size() != mapped_cont.size()");
+    }
 
     template <_Iterator_for_container _InputIterator>
     _Flat_map_base(_InputIterator _First, _InputIterator _Last, const key_compare& _Comp = key_compare())
@@ -495,8 +497,7 @@ public:
 
     // Move constructors
     _Flat_map_base(_Flat_map_base&& _Other)
-        noexcept(is_nothrow_copy_constructible_v<key_compare> && is_nothrow_move_constructible_v<key_compare>
-                 && is_nothrow_move_constructible_v<key_container_type>
+        noexcept(is_nothrow_copy_constructible_v<key_compare> && is_nothrow_move_constructible_v<key_container_type>
                  && is_nothrow_move_constructible_v<mapped_container_type>)
         : _Data(_STD move(_Other).extract()),
           _Key_compare(_Other._Key_compare) // intentionally copy comparator, see LWG-2227
@@ -504,7 +505,7 @@ public:
 
     template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
     _Flat_map_base(_Flat_map_base&& _Other, const _Allocator& _Alloc)
-        : _Data{_Other._Extract_using_allocator(_Alloc)},
+        : _Data{_STD move(_Other)._Extract_using_allocator(_Alloc)},
           _Key_compare(_Other._Key_compare) // intentionally copy comparator, see LWG-2227
     {}
 
@@ -517,9 +518,9 @@ public:
         return *this;
     }
 
-    _Flat_map_base& operator=(_Flat_map_base&& _Other) noexcept(
-        is_nothrow_copy_assignable_v<key_compare> && is_nothrow_move_assignable_v<key_compare>
-        && is_nothrow_move_assignable_v<key_container_type> && is_nothrow_move_assignable_v<mapped_container_type>) {
+    _Flat_map_base& operator=(_Flat_map_base&& _Other)
+        noexcept(is_nothrow_copy_assignable_v<key_compare> && is_nothrow_move_assignable_v<key_container_type>
+                 && is_nothrow_move_assignable_v<mapped_container_type>) {
         _Clear_guard _Guard{this};
         _Data          = _STD move(_Other).extract();
         _Key_compare   = _Other._Key_compare; // intentionally copy comparator, see LWG-2227
@@ -581,9 +582,9 @@ public:
 
     void swap(_Derived& _Other)
         noexcept(is_nothrow_swappable_v<_KeyContainer> && is_nothrow_swappable_v<_MappedContainer>
-                 && is_nothrow_swappable_v<_Compare>) {
+                 && is_nothrow_swappable_v<key_compare>) {
         constexpr bool _Is_noexcept = is_nothrow_swappable_v<_KeyContainer> && is_nothrow_swappable_v<_MappedContainer>
-                                   && is_nothrow_swappable_v<_Compare>;
+                                   && is_nothrow_swappable_v<key_compare>;
         auto& _Other_base = static_cast<_Flat_map_base&>(_Other);
         _Flat_map_swap_clear_guard<_Is_noexcept, containers> _Guard{
             _STD addressof(_Data), _STD addressof(_Other_base._Data)};
@@ -694,19 +695,24 @@ public:
         return _Erase_key(_STD forward<_OtherKey>(_Key_val));
     }
 
-    containers extract() && {
-        _Clear_guard _Guard{this};
+    _NODISCARD containers extract() && noexcept(
+        is_nothrow_move_constructible_v<key_container_type>
+        && is_nothrow_move_constructible_v<mapped_container_type>) /* strengthened */ {
+        // always clears the container (N5014 [flat.map.modifiers]/34 and [flat.multimap.overview]/4)
+        _Clear_guard _Always_clear{this};
         return _STD move(_Data);
     }
 
     template <class _Allocator>
-    containers _Extract_using_allocator(const _Allocator& _Alloc) {
-        _Clear_guard _Guard{this};
+    _NODISCARD containers _Extract_using_allocator(const _Allocator& _Alloc) && {
+        _Clear_guard _Always_clear{this};
         return containers{.keys = _STD make_obj_using_allocator<key_container_type>(_Alloc, _STD move(_Data.keys)),
             .values = _STD make_obj_using_allocator<mapped_container_type>(_Alloc, _STD move(_Data.values))};
     }
 
     void replace(key_container_type&& _Key_cont, mapped_container_type&& _Mapped_cont) {
+        _STL_ASSERT(_Key_cont.size() == _Mapped_cont.size(), "key_cont.size() != mapped_cont.size()");
+        _STL_ASSERT(_Is_sorted(_Key_cont), _Msg_not_sorted);
         _Clear_guard _Guard{this};
         _Data.keys     = _STD move(_Key_cont);
         _Data.values   = _STD move(_Mapped_cont);
@@ -714,19 +720,19 @@ public:
     }
 
     // observers
-    key_compare key_comp() const {
+    _NODISCARD key_compare key_comp() const {
         return _Key_compare;
     }
 
-    value_compare value_comp() const {
+    _NODISCARD value_compare value_comp() const {
         return value_compare{_Key_compare};
     }
 
-    const key_container_type& keys() const noexcept {
+    _NODISCARD const key_container_type& keys() const noexcept {
         return _Data.keys;
     }
 
-    const mapped_container_type& values() const noexcept {
+    _NODISCARD const mapped_container_type& values() const noexcept {
         return _Data.values;
     }
 
@@ -861,8 +867,13 @@ protected:
     containers _Data;
     _MSVC_NO_UNIQUE_ADDRESS key_compare _Key_compare;
 
+    _NODISCARD auto _Pass_key_comp() const noexcept {
+        return _STD _Pass_fn(_Key_compare);
+    }
+
     template <bool _OverwriteIfExists, class _OtherKey, class... _MappedArgTypes>
-    iterator _Emplace_hint(const const_iterator _Position, _OtherKey&& _Key_val, _MappedArgTypes&&... _Args) {
+    _NODISCARD iterator _Emplace_hint(
+        const const_iterator _Position, _OtherKey&& _Key_val, _MappedArgTypes&&... _Args) {
         _STL_INTERNAL_STATIC_ASSERT(is_constructible_v<mapped_type, _MappedArgTypes...>);
         _STL_INTERNAL_STATIC_ASSERT(is_same_v<remove_cvref_t<_OtherKey>, key_type>
                                     || (is_constructible_v<key_type, _OtherKey> && _Transparent<key_compare>) );
@@ -945,7 +956,7 @@ protected:
     }
 
     template <class _KeyTy1, class _KeyTy2>
-    bool _Key_equal(_KeyTy1&& _Left, _KeyTy2&& _Right) const {
+    _NODISCARD bool _Key_equal(_KeyTy1&& _Left, _KeyTy2&& _Right) const {
         _STL_INTERNAL_STATIC_ASSERT(
             (is_same_v<remove_cvref_t<_KeyTy1>, key_type> && is_same_v<remove_cvref_t<_KeyTy2>, key_type>)
             || (is_constructible_v<key_type, _KeyTy1> && is_constructible_v<key_type, _KeyTy2>
@@ -964,7 +975,7 @@ private:
         flat_multimap<_KTy, _MTy, _Comp, _KeyCont, _MappedCont>&, _Pred);
 
     template <class _Predicate>
-    size_type _Erase_if(_Predicate _Pred) {
+    _NODISCARD size_type _Erase_if(_Predicate _Pred) {
         auto _View           = _View_to_mutate();
         auto _Mut_first      = _View.begin();
         auto _Mut_last       = _View.end();
@@ -980,34 +991,67 @@ private:
         return _Old_size - size();
     }
 
-    auto _View_to_mutate() {
+    _NODISCARD auto _View_to_mutate() {
         using _Mutating_iterator = _Pairing_iterator_provider<typename key_container_type::iterator,
             typename mapped_container_type::iterator, typename mapped_container_type::iterator>::_Iterator;
         return _RANGES subrange<_Mutating_iterator>{_Mutating_iterator{_Data.keys.begin(), _Data.values.begin()},
             _Mutating_iterator{_Data.keys.end(), _Data.values.end()}};
     }
 
-    void _Sort() {
-        _Clear_guard _Guard{this};
-        _RANGES sort(_View_to_mutate(), value_compare{_Key_compare});
-        _Guard._Target = nullptr;
+    _NODISCARD bool _Is_sorted(
+        typename key_container_type::const_iterator _It, const typename key_container_type::const_iterator _End) const {
+        if constexpr (_IsUnique) {
+            // sorted-unique
+            auto _Negated = [this](const key_type& _Lhs, const key_type& _Rhs) { return !_Key_compare(_Lhs, _Rhs); };
+            return _STD adjacent_find(_It, _End, _Negated) == _End;
+        } else {
+            return _STD is_sorted(_It, _End, _Pass_key_comp());
+        }
+    }
+
+    _NODISCARD bool _Is_sorted(const key_container_type& _Cont) const {
+        return _Is_sorted(_Cont.begin(), _Cont.end());
     }
 
-    void _Dedup() {
+    void _Sort_and_erase_dupes_if_not_multi() {
         _Clear_guard _Guard{this};
-        auto _Sorted_view = _View_to_mutate();
-        auto _Subrange    = _RANGES unique(_Sorted_view, [this](const_reference _Left, const_reference _Right) {
-            return this->_Key_equal(_Left.first, _Right.first);
-        });
-        const auto _Remaining_count = _Subrange.begin() - _Sorted_view.begin();
-        _Data.keys.erase(_Data.keys.begin() + static_cast<_RANGES range_difference_t<_KeyContainer>>(_Remaining_count),
-            _Data.keys.end());
-        _Data.values.erase(
-            _Data.values.begin() + static_cast<_RANGES range_difference_t<_MappedContainer>>(_Remaining_count),
-            _Data.values.end());
+
+        // O(N) if already sorted.
+        const auto _Begin_unsorted =
+            _STD is_sorted_until(_STD cbegin(_Data.keys), _STD cend(_Data.keys), _Pass_key_comp());
+        const difference_type _Num_sorted = _Begin_unsorted - _STD cbegin(_Data.keys);
+
+        auto _View                        = _View_to_mutate();
+        const auto _Begin                 = _STD begin(_View);
+        const auto _Begin_unsorted_values = _Begin + _Num_sorted;
+        const auto _End                   = _STD end(_View);
+
+        _RANGES sort(_Begin_unsorted_values, _End, value_compare{_Key_compare});
+        _RANGES inplace_merge(_Begin, _Begin_unsorted_values, _End, value_compare{_Key_compare});
+
+        _Erase_dupes_if_not_multi();
+
+        _STL_INTERNAL_CHECK(_Is_sorted(_Data.keys));
+
         _Guard._Target = nullptr;
     }
 
+    void _Erase_dupes_if_not_multi() {
+        if constexpr (_IsUnique) {
+            auto _Sorted_view = _View_to_mutate();
+            auto _Subrange    = _RANGES unique(_Sorted_view, [this](const_reference _Left, const_reference _Right) {
+                return this->_Key_equal(_Left.first, _Right.first);
+            });
+            const auto _Remaining_count = _Subrange.begin() - _Sorted_view.begin();
+            _Data.keys.erase(
+                _Data.keys.begin() + static_cast<_RANGES range_difference_t<_KeyContainer>>(_Remaining_count),
+                _Data.keys.end());
+            _Data.values.erase(
+                _Data.values.begin() + static_cast<_RANGES range_difference_t<_MappedContainer>>(_Remaining_count),
+                _Data.values.end());
+        }
+    }
+
     template <bool _NeedSorting, class _InputIterator, class _Sentinel>
     void _Insert_range(_InputIterator _First, _Sentinel _Last) {
         _Clear_guard _Guard{this};
@@ -1041,15 +1085,14 @@ private:
         // Merge the newly inserted elements with the existing elements
         _RANGES inplace_merge(_Sorted_view, _Sorted_view.begin() + _Old_distance, value_compare{_Key_compare});
 
-        if constexpr (_IsUnique) {
-            _Dedup();
-        }
+        _Erase_dupes_if_not_multi();
+        _STL_INTERNAL_CHECK(_Is_sorted(_Data.keys));
 
         _Guard._Target = nullptr;
     }
 
     template <class _KeyTy>
-    size_type _Erase_key(_KeyTy&& _Key_val) {
+    _NODISCARD size_type _Erase_key(_KeyTy&& _Key_val) {
         const auto _Equal_pos = equal_range(_STD forward<_KeyTy>(_Key_val));
         const auto _Count     = static_cast<size_type>(_Equal_pos.second - _Equal_pos.first);
         erase(_Equal_pos.first, _Equal_pos.second);
@@ -1094,8 +1137,8 @@ private:
     _NODISCARD iterator _Lower_bound(const _KeyTy& _Key_val) {
         _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
         const auto _Key_unchecked_begin = _STD _Get_unwrapped(_STD cbegin(_Data.keys));
-        const auto _Key_unchecked_it =
-            _STD lower_bound(_Key_unchecked_begin, _STD _Get_unwrapped(_STD cend(_Data.keys)), _Key_val, _Key_compare);
+        const auto _Key_unchecked_it    = _STD lower_bound(
+               _Key_unchecked_begin, _STD _Get_unwrapped(_STD cend(_Data.keys)), _Key_val, _Pass_key_comp());
         const auto _Dist = _Key_unchecked_it - _Key_unchecked_begin;
 
         auto _Key_it = _STD cbegin(_Data.keys);
@@ -1108,8 +1151,8 @@ private:
     _NODISCARD const_iterator _Lower_bound(const _KeyTy& _Key_val) const {
         _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
         const auto _Key_unchecked_begin = _STD _Get_unwrapped(_STD cbegin(_Data.keys));
-        const auto _Key_unchecked_it =
-            _STD lower_bound(_Key_unchecked_begin, _STD _Get_unwrapped(_STD cend(_Data.keys)), _Key_val, _Key_compare);
+        const auto _Key_unchecked_it    = _STD lower_bound(
+               _Key_unchecked_begin, _STD _Get_unwrapped(_STD cend(_Data.keys)), _Key_val, _Pass_key_comp());
         const auto _Dist = _Key_unchecked_it - _Key_unchecked_begin;
 
         auto _Key_it = _STD cbegin(_Data.keys);
@@ -1123,8 +1166,8 @@ private:
     _NODISCARD iterator _Upper_bound(const _KeyTy& _Key_val) {
         _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
         const auto _Key_unchecked_begin = _STD _Get_unwrapped(_STD cbegin(_Data.keys));
-        const auto _Key_unchecked_it =
-            _STD upper_bound(_Key_unchecked_begin, _STD _Get_unwrapped(_STD cend(_Data.keys)), _Key_val, _Key_compare);
+        const auto _Key_unchecked_it    = _STD upper_bound(
+               _Key_unchecked_begin, _STD _Get_unwrapped(_STD cend(_Data.keys)), _Key_val, _Pass_key_comp());
         const auto _Dist = _Key_unchecked_it - _Key_unchecked_begin;
 
         auto _Key_it = _STD cbegin(_Data.keys);
@@ -1137,8 +1180,8 @@ private:
     _NODISCARD const_iterator _Upper_bound(const _KeyTy& _Key_val) const {
         _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
         const auto _Key_unchecked_begin = _STD _Get_unwrapped(_STD cbegin(_Data.keys));
-        const auto _Key_unchecked_it =
-            _STD upper_bound(_Key_unchecked_begin, _STD _Get_unwrapped(_STD cend(_Data.keys)), _Key_val, _Key_compare);
+        const auto _Key_unchecked_it    = _STD upper_bound(
+               _Key_unchecked_begin, _STD _Get_unwrapped(_STD cend(_Data.keys)), _Key_val, _Pass_key_comp());
         const auto _Dist = _Key_unchecked_it - _Key_unchecked_begin;
 
         auto _Key_it = _STD cbegin(_Data.keys);
@@ -1354,6 +1397,7 @@ private:
     using _Mybase::_Emplace_hint;
     using _Mybase::_Insert_exact;
     using _Mybase::_Key_equal;
+    using _Mybase::_Pass_key_comp;
 
     template <class _KeyTy>
     _NODISCARD mapped_type& _At(const _KeyTy& _Key_val) {
@@ -1378,8 +1422,8 @@ private:
     }
 
     template <class _KeyTy, class... _MappedArgTypes>
-    pair<iterator, bool> _Try_emplace(_KeyTy&& _Key_val, _MappedArgTypes&&... _Mapped_args) {
-        auto _Key_it = _STD lower_bound(_Data.keys.begin(), _Data.keys.end(), _Key_val, _Key_compare);
+    _NODISCARD pair<iterator, bool> _Try_emplace(_KeyTy&& _Key_val, _MappedArgTypes&&... _Mapped_args) {
+        auto _Key_it = _STD lower_bound(_Data.keys.begin(), _Data.keys.end(), _Key_val, _Pass_key_comp());
         if (_Key_it != _Data.keys.end() && !_Key_compare(_STD forward<_KeyTy>(_Key_val), *_Key_it)) {
             // Already exists
             return {this->begin() + (_Key_it - _Data.keys.begin()), false};
@@ -1396,7 +1440,7 @@ private:
     }
 
     template <class _KeyTy, class _MappedTy>
-    pair<iterator, bool> _Insert_or_assign(_KeyTy&& _Key_val, _MappedTy&& _Mapped_val) {
+    _NODISCARD pair<iterator, bool> _Insert_or_assign(_KeyTy&& _Key_val, _MappedTy&& _Mapped_val) {
         auto _Res = _Try_emplace(_STD forward<_KeyTy>(_Key_val), _STD forward<_MappedTy>(_Mapped_val));
         if (!_Res.second) { // Already exists
             _Res.first->second = _STD forward<_MappedTy>(_Mapped_val);
@@ -1553,10 +1597,11 @@ private:
     using _Mybase::_Emplace_hint;
     using _Mybase::_Insert_exact;
     using _Mybase::_Key_equal;
+    using _Mybase::_Pass_key_comp;
 
     template <class _KeyTy, class _MappedTy>
-    iterator _Emplace_key_mapped(_KeyTy&& _Key_val, _MappedTy&& _Mapped_val) {
-        const auto _Key_it = _STD upper_bound(_Data.keys.begin(), _Data.keys.end(), _Key_val, _Key_compare);
+    _NODISCARD iterator _Emplace_key_mapped(_KeyTy&& _Key_val, _MappedTy&& _Mapped_val) {
+        const auto _Key_it = _STD upper_bound(_Data.keys.begin(), _Data.keys.end(), _Key_val, _Pass_key_comp());
         const auto _Index  = _Key_it - _Data.keys.begin();
 
         {
diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index eb9017af000..08fbf79e031 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -259,6 +259,7 @@ public:
     _NODISCARD const_iterator cend() const noexcept {
         return _Mycont.end();
     }
+
     _NODISCARD const_reverse_iterator crbegin() const noexcept {
         return rbegin();
     }
@@ -339,7 +340,6 @@ public:
     void insert_range(_Sorted_t, _Rng&& _Range) {
         _Insert_range<false>(_STD forward<_Rng>(_Range));
     }
-
     void insert(initializer_list<_Kty> _Ilist) {
         _Insert_range<true>(_Ilist.begin(), _Ilist.end());
     }
@@ -349,10 +349,11 @@ public:
 
     _NODISCARD container_type extract() && noexcept(
         is_nothrow_move_constructible_v<container_type>) /* strengthened */ {
-        // always clears the container (N4950 [flat.set.modifiers]/14 and [flat.multiset.modifiers]/10)
+        // always clears the container (N5014 [flat.set.modifiers]/14 and [flat.multiset.modifiers]/10)
         _Clear_guard _Always_clear{this};
         return _STD move(_Mycont);
     }
+
     void replace(container_type&& _Cont) {
         _STL_ASSERT(_Is_sorted(_Cont), _Msg_not_sorted);
         _Clear_guard _Guard{this};
@@ -384,6 +385,7 @@ public:
         _RANGES swap(_Mycomp, _Other._Mycomp);
         _Guard._Dismiss();
     }
+
     void clear() noexcept {
         _Mycont.clear();
     }
@@ -475,15 +477,8 @@ private:
     _NODISCARD bool _Is_sorted(const_iterator _It, const const_iterator _End) const {
         if constexpr (_IsUnique) {
             // sorted-unique
-            if (_It == _End) {
-                return true;
-            }
-            while (++_It != _End) {
-                if (!_Compare(*(_It - 1), *_It)) {
-                    return false;
-                }
-            }
-            return true;
+            auto _Negated = [this](const key_type& _Lhs, const key_type& _Rhs) { return !_Compare(_Lhs, _Rhs); };
+            return _STD adjacent_find(_It, _End, _Negated) == _End;
         } else {
             return _STD is_sorted(_It, _End, _Pass_comp());
         }
@@ -625,7 +620,7 @@ private:
     _NODISCARD size_type _Erase(const _Ty& _Val) {
         _STL_INTERNAL_STATIC_ASSERT(_Transparent<key_compare> || is_same_v<_Ty, _Kty>);
 
-        if constexpr (_IsUnique && is_same_v<_Ty, _Kty>) {
+        if constexpr (_IsUnique) {
             const const_iterator _Where = lower_bound(_Val);
             if (_Where != cend() && !_Compare(_Val, *_Where)) {
                 _Mycont.erase(_Where);
@@ -648,8 +643,8 @@ private:
     friend typename _Container2::size_type erase_if(flat_multiset<_Kty2, _Keylt2, _Container2>&, _Pred2);
 
     template <class _Pred>
-    size_type _Erase_if(_Pred _Predicate) {
-        // Maintain invariants when an exception is thrown (N4950 [flat.set.erasure]/5, [flat.multiset.erasure]/5)
+    _NODISCARD size_type _Erase_if(_Pred _Predicate) {
+        // Maintain invariants when an exception is thrown (N5014 [flat.set.erasure]/5, [flat.multiset.erasure]/5)
         _Clear_guard _Guard{this};
         const auto _Erased_count = _STD _Erase_remove_if(_Mycont, _Predicate);
         _Guard._Target           = nullptr;
@@ -688,7 +683,7 @@ private:
         if constexpr (_NeedSorting) {
             _STD sort(_Old_end, _End, _Pass_comp());
         } else {
-            _STL_ASSERT(_Is_sorted(_Old_end, _End), _Msg_not_sorted);
+            _STL_INTERNAL_CHECK(_Is_sorted(_Old_end, _End));
         }
 
         _STD inplace_merge(_Begin, _Old_end, _End, _Pass_comp());
@@ -781,7 +776,6 @@ _EXPORT_STD template <class _Kty, class _Keylt, class _Container, class _Pred>
 _Container::size_type erase_if(flat_set<_Kty, _Keylt, _Container>& _Val, _Pred _Predicate) {
     return _Val._Erase_if(_STD _Pass_fn(_Predicate));
 }
-
 _EXPORT_STD template <class _Kty, class _Keylt, class _Container, class _Pred>
 _Container::size_type erase_if(flat_multiset<_Kty, _Keylt, _Container>& _Val, _Pred _Predicate) {
     return _Val._Erase_if(_STD _Pass_fn(_Predicate));
diff --git a/tests/libcxx/expected_results.txt b/tests/libcxx/expected_results.txt
index c14ef17f01b..f3b52a90def 100644
--- a/tests/libcxx/expected_results.txt
+++ b/tests/libcxx/expected_results.txt
@@ -793,6 +793,11 @@ std/time/time.clock/time.clock.file/to_from_sys.pass.cpp FAIL
 # libc++'s filesystem::path::iterator models bidirectional_iterator, which is not guaranteed by the Standard
 std/input.output/filesystems/class.path/range_concept_conformance.compile.pass.cpp FAIL
 
+# MSVC's STL and libc++ speculatively implement LWG-2227 (not yet resolved) in different ways.
+# static_assert(!std::is_nothrow_move_constructible_v<C>) with C = std::flat_(multi)map<int, int, ThrowingMoveComp>
+std/containers/container.adaptors/flat.map/flat.map.cons/move_noexcept.pass.cpp FAIL
+std/containers/container.adaptors/flat.multimap/flat.multimap.cons/move_noexcept.pass.cpp FAIL
+
 # libc++ speculatively implemented an old proposed resolution for LWG-3645.
 # This test is bogus according to the wording that was ultimately accepted for C++23.
 std/strings/basic.string/string.capacity/resize_and_overwrite.pass.cpp FAIL

From eff33b68887e0ec85d9e21a6b22b935bf637c521 Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34@live.cn>
Date: Mon, 5 Jan 2026 23:17:02 +0800
Subject: [PATCH 096/134] `<flat_set>`: Make `flat_(multi)set` insertion
 exception-safe for non-standard sequence containers (#5972)

Co-authored-by: Stephan T. Lavavej <stl@microsoft.com>
---
 stl/inc/flat_set                  | 29 +++++++++++++++++++++--------
 stl/inc/xmemory                   |  8 ++++++--
 tests/libcxx/expected_results.txt | 11 ++---------
 3 files changed, 29 insertions(+), 19 deletions(-)

diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index 08fbf79e031..496bf624fea 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -57,6 +57,18 @@ struct _NODISCARD _Flat_set_swap_clear_guard<true, _Container> {
     void _Dismiss() noexcept {}
 };
 
+template <class _Container, class _Ty>
+_NODISCARD auto _Emplace_with_clear_guard(_Container& _Cont, typename _Container::const_iterator _Where, _Ty&& _Val) {
+    if constexpr (_Has_guaranteed_single_insertion<_Container>) {
+        return _Cont.emplace(_Where, _STD forward<_Ty>(_Val));
+    } else {
+        _Clear_guard _Guard{_STD addressof(_Cont)};
+        auto _Iter     = _Cont.emplace(_Where, _STD forward<_Ty>(_Val));
+        _Guard._Target = nullptr;
+        return _Iter;
+    }
+}
+
 _EXPORT_STD template <class _Kty, class _Keylt = less<_Kty>, class _Container = vector<_Kty>>
 class flat_set;
 
@@ -279,8 +291,6 @@ public:
     }
 
     // modifiers
-    // FIXME, the "insert" and "erase" methods may not be able to restore the invariant, if the underlying
-    // container is unable to provide strong guarantee for "erase" and "insert" methods.
     template <class... _Args>
     auto emplace(_Args&&... _Vals) {
         constexpr bool _Is_key_type = _In_place_key_extract_set<_Kty, remove_cvref_t<_Args>...>::_Extractable;
@@ -361,6 +371,9 @@ public:
         _Guard._Target = nullptr;
     }
 
+    // FIXME, the "erase" member functions need clear guards to restore the invariant when the underlying
+    // container doesn't provide the strong guarantee for its "erase" member functions.
+
     // NB: `erase(iterator)` is identical to `erase(const_iterator)`
     iterator erase(const_iterator _Where) {
         return _Mycont.erase(_Where);
@@ -516,7 +529,7 @@ private:
 
             if constexpr (is_same_v<remove_cvref_t<_Ty>, _Kty>) {
                 _STL_INTERNAL_CHECK(_Can_insert(_Where, _Val));
-                return pair{_Mycont.emplace(_Where, _STD forward<_Ty>(_Val)), true};
+                return pair{_STD _Emplace_with_clear_guard(_Mycont, _Where, _STD forward<_Ty>(_Val)), true};
             } else {
                 // heterogeneous insertion
                 // FIXME: The standard only requires `find(_Val) == find(_Keyval)` (per N4958 [flat.set.modifiers]/2),
@@ -526,11 +539,11 @@ private:
                 _STL_ASSERT(_Can_insert(_Where, _Keyval),
                     "The conversion from the heterogeneous key to key_type should "
                     "be consistent with the heterogeneous lookup!");
-                return pair{_Mycont.emplace(_Where, _STD move(_Keyval)), true};
+                return pair{_STD _Emplace_with_clear_guard(_Mycont, _Where, _STD move(_Keyval)), true};
             }
         } else {
             _STL_INTERNAL_STATIC_ASSERT(is_same_v<remove_cvref_t<_Ty>, _Kty>);
-            return _Mycont.emplace(upper_bound(_Val), _STD forward<_Ty>(_Val));
+            return _STD _Emplace_with_clear_guard(_Mycont, upper_bound(_Val), _STD forward<_Ty>(_Val));
         }
     }
 
@@ -560,7 +573,7 @@ private:
 
             if constexpr (is_same_v<remove_cvref_t<_Ty>, _Kty>) {
                 _STL_INTERNAL_CHECK(_Can_insert(_Where, _Val));
-                return _Mycont.emplace(_Where, _STD forward<_Ty>(_Val));
+                return _STD _Emplace_with_clear_guard(_Mycont, _Where, _STD forward<_Ty>(_Val));
             } else {
                 // heterogeneous insertion
                 // FIXME: The standard only requires `find(_Val) == find(_Keyval)` (per N4958 [flat.set.modifiers]/2),
@@ -570,7 +583,7 @@ private:
                 _STL_ASSERT(_Can_insert(_Where, _Keyval),
                     "The conversion from the heterogeneous key to key_type should "
                     "be consistent with the heterogeneous lookup!");
-                return _Mycont.emplace(_Where, _STD move(_Keyval));
+                return _STD _Emplace_with_clear_guard(_Mycont, _Where, _STD move(_Keyval));
             }
         } else {
             _STL_INTERNAL_STATIC_ASSERT(is_same_v<remove_cvref_t<_Ty>, _Kty>);
@@ -591,7 +604,7 @@ private:
                 _Where = _STD lower_bound(_Where, _End, _Val, _Pass_comp());
             }
 
-            return _Mycont.emplace(_Where, _STD forward<_Ty>(_Val));
+            return _STD _Emplace_with_clear_guard(_Mycont, _Where, _STD forward<_Ty>(_Val));
         }
     }
 
diff --git a/stl/inc/xmemory b/stl/inc/xmemory
index 66d33446009..80dc6c715c0 100644
--- a/stl/inc/xmemory
+++ b/stl/inc/xmemory
@@ -2762,10 +2762,14 @@ namespace ranges {
 } // namespace ranges
 
 template <class>
-constexpr bool _Has_guaranteed_push_back = false; // N5014 [sequence.reqmts]/104, /108; used by flat_(multi)map::insert.
+constexpr bool _Has_guaranteed_push_back = false; // N5032 [sequence.reqmts]/104, /108; used by flat_(multi)map::insert.
+
+// N5032 [container.reqmts]/66.1; used by various flat_(multi)set inserting functions.
+template <class _Ty>
+constexpr bool _Has_guaranteed_single_insertion = _Has_guaranteed_push_back<_Ty>;
 
 template <class>
-constexpr bool _Has_guaranteed_append_range = false; // N5014 [sequence.reqmts]/112; used by flat_(multi)set::insert.
+constexpr bool _Has_guaranteed_append_range = false; // N5032 [sequence.reqmts]/112; used by flat_(multi)set::insert.
 #endif // _HAS_CXX23
 
 template <class _Elem, class _UTy>
diff --git a/tests/libcxx/expected_results.txt b/tests/libcxx/expected_results.txt
index f3b52a90def..7911c54a3fc 100644
--- a/tests/libcxx/expected_results.txt
+++ b/tests/libcxx/expected_results.txt
@@ -51,15 +51,6 @@ std/strings/basic.string/string.modifiers/string_append/initializer_list.pass.cp
 std/strings/basic.string/string.modifiers/string_assign/string.pass.cpp:0 FAIL
 std/strings/basic.string/string.modifiers/string_assign/string.pass.cpp:1 FAIL
 
-# LLVM-140448: [libc++][test] flat_set std test uses EmplaceUnsafeContainer which is non-standard
-std/containers/container.adaptors/flat.set/flat.set.modifiers/emplace_hint.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.modifiers/emplace.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_cv.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_iter_cv.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_iter_rv.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_rv.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_transparent.pass.cpp FAIL
-
 # LLVM-158302: Clang 20 i686-pc-windows-msvc regression, silent bad codegen for std::current_exception()
 # SKIPPED because this is x86-specific.
 std/language.support/support.exception/except.nested/assign.pass.cpp:2 SKIPPED
@@ -435,6 +426,8 @@ std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_iter_iter.p
 std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_iter_iter.pass.cpp:1 FAIL
 std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_range.pass.cpp:0 FAIL
 std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_range.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_transparent.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_transparent.pass.cpp:1 FAIL
 std/containers/container.adaptors/flat.set/flat.set.observers/comp.pass.cpp:0 FAIL
 std/containers/container.adaptors/flat.set/flat.set.observers/comp.pass.cpp:1 FAIL
 std/containers/container.adaptors/flat.set/flat.set.operations/contains_transparent.pass.cpp:0 FAIL

From 06449cdf7c3395125d0e48176b61cc41db2006a8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vojt=C4=9Bch=20Michal?= <vojta.michall@email.cz>
Date: Mon, 5 Jan 2026 16:53:00 +0100
Subject: [PATCH 097/134] Add test coverage for `<flat_set>` to
 `test_header_units_and_modules.hpp` (#5986)

Co-authored-by: Stephan T. Lavavej <stl@microsoft.com>
---
 .../include/test_header_units_and_modules.hpp | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)

diff --git a/tests/std/include/test_header_units_and_modules.hpp b/tests/std/include/test_header_units_and_modules.hpp
index 0e08cfe0cd5..71aaf6a6632 100644
--- a/tests/std/include/test_header_units_and_modules.hpp
+++ b/tests/std/include/test_header_units_and_modules.hpp
@@ -269,7 +269,24 @@ void test_flat_set() {
     using namespace std;
     puts("Testing <flat_set>.");
 
-    // FIXME! ADD TEST COVERAGE HERE!
+    [[maybe_unused]] constexpr sorted_unique_t unique_tag         = sorted_unique;
+    [[maybe_unused]] constexpr sorted_equivalent_t equivalent_tag = sorted_equivalent;
+
+    constexpr auto simple_truth = [](const auto&) { return true; };
+
+    flat_set<int> fs;
+    fs.emplace(42);
+    fs.emplace(42);
+    assert(fs.size() == 1);
+    assert(erase_if(fs, simple_truth) == 1);
+    assert(fs.empty());
+
+    flat_multiset<int> fms;
+    fms.emplace(42);
+    fms.emplace(42);
+    assert(fms.size() == 2);
+    assert(erase_if(fms, simple_truth) == 2);
+    assert(fms.empty());
 }
 #endif // TEST_STANDARD >= 23
 

From 15d9efff6ff9234f3a3340d1e216f99e4f369552 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vojt=C4=9Bch=20Michal?= <vojta.michall@email.cz>
Date: Mon, 5 Jan 2026 18:13:35 +0100
Subject: [PATCH 098/134] `<flat_map>`: Simplify duplicate definitions of
 lookup functions using explicit object parameter (#5987)

Co-authored-by: Stephan T. Lavavej <stl@microsoft.com>
---
 stl/inc/flat_map                          | 113 ++++++----------------
 tests/std/tests/P0429R9_flat_map/test.cpp |  24 +++++
 2 files changed, 51 insertions(+), 86 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index 1e6eac4961b..d50232d3b1e 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -1099,25 +1099,14 @@ private:
         return _Count;
     }
 
-    template <class _KeyTy>
-    _NODISCARD iterator _Find(const _KeyTy& _Key_val) {
+    template <class _SelfTy, class _KeyTy>
+    _NODISCARD auto _Find(this _SelfTy& _Self, const _KeyTy& _Key_val) {
         _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
-        iterator _Position = lower_bound(_Key_val);
-        if (_Position != end() && !_Key_compare(_Key_val, _Position->first)) {
+        const auto _Position = _Self.lower_bound(_Key_val);
+        if (_Position != _Self.end() && !_Self._Key_compare(_Key_val, _Position->first)) {
             return _Position;
         } else {
-            return end();
-        }
-    }
-
-    template <class _KeyTy>
-    _NODISCARD const_iterator _Find(const _KeyTy& _Key_val) const {
-        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
-        const_iterator _Position = lower_bound(_Key_val);
-        if (_Position != cend() && !_Key_compare(_Key_val, _Position->first)) {
-            return _Position;
-        } else {
-            return cend();
+            return _Self.end();
         }
     }
 
@@ -1133,74 +1122,37 @@ private:
         return find(_Key_val) != cend();
     }
 
-    template <class _KeyTy>
-    _NODISCARD iterator _Lower_bound(const _KeyTy& _Key_val) {
+    template <class _SelfTy, class _KeyTy, class _BoundFn>
+    _NODISCARD auto _Find_bound(this _SelfTy& _Self, const _KeyTy& _Key_val, _BoundFn _Bound_fun) {
         _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
-        const auto _Key_unchecked_begin = _STD _Get_unwrapped(_STD cbegin(_Data.keys));
-        const auto _Key_unchecked_it    = _STD lower_bound(
-               _Key_unchecked_begin, _STD _Get_unwrapped(_STD cend(_Data.keys)), _Key_val, _Pass_key_comp());
+        const auto _Key_unchecked_begin = _STD _Get_unwrapped(_STD cbegin(_Self._Data.keys));
+        const auto _Key_unchecked_it    = _Bound_fun(
+            _Key_unchecked_begin, _STD _Get_unwrapped(_STD cend(_Self._Data.keys)), _Key_val, _Self._Pass_key_comp());
         const auto _Dist = _Key_unchecked_it - _Key_unchecked_begin;
 
-        auto _Key_it = _STD cbegin(_Data.keys);
-        _STD _Seek_wrapped(_Key_it, _Key_unchecked_it);
-        auto _Val_it = _Data.values.begin() + static_cast<_RANGES range_difference_t<_MappedContainer>>(_Dist);
-        return iterator{_STD move(_Key_it), _STD move(_Val_it)};
-    }
-
-    template <class _KeyTy>
-    _NODISCARD const_iterator _Lower_bound(const _KeyTy& _Key_val) const {
-        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
-        const auto _Key_unchecked_begin = _STD _Get_unwrapped(_STD cbegin(_Data.keys));
-        const auto _Key_unchecked_it    = _STD lower_bound(
-               _Key_unchecked_begin, _STD _Get_unwrapped(_STD cend(_Data.keys)), _Key_val, _Pass_key_comp());
-        const auto _Dist = _Key_unchecked_it - _Key_unchecked_begin;
-
-        auto _Key_it = _STD cbegin(_Data.keys);
+        auto _Key_it = _STD cbegin(_Self._Data.keys);
         _STD _Seek_wrapped(_Key_it, _Key_unchecked_it);
         auto _Val_it =
-            _STD cbegin(_Data.values) + static_cast<_RANGES range_difference_t<const _MappedContainer>>(_Dist);
-        return const_iterator{_STD move(_Key_it), _STD move(_Val_it)};
-    }
-
-    template <class _KeyTy>
-    _NODISCARD iterator _Upper_bound(const _KeyTy& _Key_val) {
-        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
-        const auto _Key_unchecked_begin = _STD _Get_unwrapped(_STD cbegin(_Data.keys));
-        const auto _Key_unchecked_it    = _STD upper_bound(
-               _Key_unchecked_begin, _STD _Get_unwrapped(_STD cend(_Data.keys)), _Key_val, _Pass_key_comp());
-        const auto _Dist = _Key_unchecked_it - _Key_unchecked_begin;
+            _STD begin(_Self._Data.values) + static_cast<_RANGES range_difference_t<mapped_container_type>>(_Dist);
 
-        auto _Key_it = _STD cbegin(_Data.keys);
-        _STD _Seek_wrapped(_Key_it, _Key_unchecked_it);
-        auto _Val_it = _Data.values.begin() + static_cast<_RANGES range_difference_t<_MappedContainer>>(_Dist);
-        return iterator{_STD move(_Key_it), _STD move(_Val_it)};
+        using _Maybe_const_iter = conditional_t<is_const_v<_SelfTy>, const_iterator, iterator>;
+        return _Maybe_const_iter{_STD move(_Key_it), _STD move(_Val_it)};
     }
 
-    template <class _KeyTy>
-    _NODISCARD const_iterator _Upper_bound(const _KeyTy& _Key_val) const {
-        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
-        const auto _Key_unchecked_begin = _STD _Get_unwrapped(_STD cbegin(_Data.keys));
-        const auto _Key_unchecked_it    = _STD upper_bound(
-               _Key_unchecked_begin, _STD _Get_unwrapped(_STD cend(_Data.keys)), _Key_val, _Pass_key_comp());
-        const auto _Dist = _Key_unchecked_it - _Key_unchecked_begin;
-
-        auto _Key_it = _STD cbegin(_Data.keys);
-        _STD _Seek_wrapped(_Key_it, _Key_unchecked_it);
-        auto _Val_it =
-            _STD cbegin(_Data.values) + static_cast<_RANGES range_difference_t<const _MappedContainer>>(_Dist);
-        return const_iterator{_STD move(_Key_it), _STD move(_Val_it)};
+    template <class _SelfTy, class _KeyTy>
+    _NODISCARD auto _Lower_bound(this _SelfTy& _Self, const _KeyTy& _Key_val) {
+        return _Self._Find_bound(_Key_val, _RANGES lower_bound);
     }
 
-    template <class _KeyTy>
-    _NODISCARD pair<iterator, iterator> _Equal_range(const _KeyTy& _Key_val) {
-        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
-        return {lower_bound(_Key_val), upper_bound(_Key_val)};
+    template <class _SelfTy, class _KeyTy>
+    _NODISCARD auto _Upper_bound(this _SelfTy& _Self, const _KeyTy& _Key_val) {
+        return _Self._Find_bound(_Key_val, _RANGES upper_bound);
     }
 
-    template <class _KeyTy>
-    _NODISCARD pair<const_iterator, const_iterator> _Equal_range(const _KeyTy& _Key_val) const {
+    template <class _SelfTy, class _KeyTy>
+    _NODISCARD auto _Equal_range(this _SelfTy& _Self, const _KeyTy& _Key_val) {
         _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
-        return {lower_bound(_Key_val), upper_bound(_Key_val)};
+        return pair{_Self.lower_bound(_Key_val), _Self.upper_bound(_Key_val)};
     }
 };
 
@@ -1399,22 +1351,11 @@ private:
     using _Mybase::_Key_equal;
     using _Mybase::_Pass_key_comp;
 
-    template <class _KeyTy>
-    _NODISCARD mapped_type& _At(const _KeyTy& _Key_val) {
-        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
-        const auto _Position = this->find(_Key_val);
-        if (_Position == this->end()) {
-            _Xout_of_range("invalid flat_map key");
-        }
-
-        return _Position->second;
-    }
-
-    template <class _KeyTy>
-    _NODISCARD const mapped_type& _At(const _KeyTy& _Key_val) const {
+    template <class _SelfTy, class _KeyTy>
+    _NODISCARD auto& _At(this _SelfTy& _Self, const _KeyTy& _Key_val) {
         _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
-        const auto _Position = this->find(_Key_val);
-        if (_Position == this->end()) {
+        const auto _Position = _Self.find(_Key_val);
+        if (_Position == _Self.end()) {
             _Xout_of_range("invalid flat_map key");
         }
 
diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index 74e88ddc81d..fac98c6ff64 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -766,6 +766,29 @@ void test_throwing_compare_swap() {
     test_throwing_compare_swap_single<flat_multimap, deque, deque>();
 }
 
+// Test that changes in GH-5987 did not break calls of lookup member functions by using deducing this.
+template <typename T>
+void test_lookup_call_on_temporaries_single() {
+    (void) T{}.lower_bound(42);
+    (void) T{}.lower_bound('a');
+    (void) T{}.upper_bound(42);
+    (void) T{}.upper_bound('a');
+    (void) T{}.equal_range(42);
+    (void) T{}.equal_range('a');
+    (void) T{}.find(42);
+    (void) T{}.find('a');
+}
+
+void test_lookup_call_on_temporaries() {
+    test_lookup_call_on_temporaries_single<flat_map<int, int>>();
+    test_lookup_call_on_temporaries_single<flat_multimap<int, int>>();
+    try {
+        (void) flat_map<int, int>{}.at(42);
+        (void) flat_map<int, int>{}.at('a');
+    } catch (...) {
+    }
+}
+
 int main() {
     test_construction();
     test_pointer_to_incomplete_type();
@@ -776,4 +799,5 @@ int main() {
     test_insert_or_assign();
     test_comparison();
     test_throwing_compare_swap();
+    test_lookup_call_on_temporaries();
 }

From 4975692fde94a5ac13d898c60f3fbb1f9a244ddc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vojt=C4=9Bch=20Michal?= <vojta.michall@email.cz>
Date: Mon, 5 Jan 2026 18:15:44 +0100
Subject: [PATCH 099/134] `<flat_map>`: Ensure different flat_(multi)map
 specializations don't share nested types (remove speculative implementation
 of LWG-3963) (#5988)

---
 stl/inc/flat_map                              | 42 +++++++------------
 tests/std/tests/P0429R9_flat_map/test.cpp     |  5 +++
 .../test.compile.pass.cpp                     | 30 ++++++-------
 3 files changed, 34 insertions(+), 43 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index d50232d3b1e..077f2bb930d 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -33,30 +33,6 @@ _STL_DISABLE_CLANG_WARNINGS
 #undef msvc
 
 _STD_BEGIN
-template <class _Key, class _Mapped, class _KeyCompare>
-struct _Flat_map_value_compare_provider {
-    struct value_compare {
-    public:
-        _NODISCARD bool operator()(
-            pair<const _Key&, const _Mapped&> _Left, pair<const _Key&, const _Mapped&> _Right) const {
-            return _Key_comparator(_Left.first, _Right.first);
-        }
-
-        value_compare(_KeyCompare _Comp) : _Key_comparator(_Comp) {}
-
-    private:
-        _KeyCompare _Key_comparator;
-    };
-};
-
-template <class _KeyContainer, class _MappedContainer>
-struct _Flat_map_container_provider {
-    struct containers {
-        _KeyContainer keys;
-        _MappedContainer values;
-    };
-};
-
 // Implementation
 
 template <bool _IsUnique, class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer>
@@ -342,8 +318,22 @@ public:
         "mapped_container_type must support random-access iterators in order to be adapted. "
         "(N5014 [flat.map.overview]/7, [flat.multimap.overview]/7)");
 
-    using value_compare = _Flat_map_value_compare_provider<key_type, mapped_type, key_compare>::value_compare;
-    using containers    = _Flat_map_container_provider<key_container_type, mapped_container_type>::containers;
+    struct value_compare {
+    public:
+        _NODISCARD bool operator()(const_reference _Left, const_reference _Right) const {
+            return _Key_comparator(_Left.first, _Right.first);
+        }
+
+        value_compare(key_compare _Comp) : _Key_comparator(_Comp) {}
+
+    private:
+        key_compare _Key_comparator;
+    };
+
+    struct containers {
+        key_container_type keys;
+        mapped_container_type values;
+    };
 
 public:
     // [flat.map.cons] Constructors
diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index fac98c6ff64..cc5002dca09 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -16,6 +16,11 @@
 
 using namespace std;
 
+// See GH-5965: Speculative resolution of LWG-3963 "Different flat_(multi)map specializations
+// should be able to share same nested classes" is not likely to be accepted
+static_assert(!is_same_v<flat_map<int, int>::containers, flat_multimap<int, int>::containers>);
+static_assert(!is_same_v<flat_map<int, int>::value_compare, flat_multimap<int, int>::value_compare>);
+
 template <class T, template <class...> class Tmpl>
 constexpr bool is_specialization_v = false;
 template <template <class...> class Tmpl, class... Ts>
diff --git a/tests/std/tests/P0429R9_flat_map_ms_specific/test.compile.pass.cpp b/tests/std/tests/P0429R9_flat_map_ms_specific/test.compile.pass.cpp
index cdba07f3cbe..335c8e14326 100644
--- a/tests/std/tests/P0429R9_flat_map_ms_specific/test.compile.pass.cpp
+++ b/tests/std/tests/P0429R9_flat_map_ms_specific/test.compile.pass.cpp
@@ -51,6 +51,10 @@ struct flat_map_unique_if_impl<false> {
 template <bool IsUnique, class Key, class Mapped, class Comp, class KeyCont, class MappedCont>
 using flat_map_unique_if = flat_map_unique_if_impl<IsUnique>::template type<Key, Mapped, Comp, KeyCont, MappedCont>;
 
+template <typename A, typename B>
+constexpr bool has_different_nested_types = !is_same_v<typename A::value_compare, typename B::value_compare>
+                                         && !is_same_v<typename A::containers, typename B::containers>;
+
 template <bool IsUnique, class Comparator, class Alloc1, class Alloc2>
 void test_scary_ness_one() {
     using Iter = flat_map<int, int>::iterator;
@@ -63,23 +67,15 @@ void test_scary_ness_one() {
         flat_map_unique_if<IsUnique, int, int, Comparator, vector<int, Alloc1>, vector<int, Alloc2>>::const_iterator;
     static_assert(is_same_v<ConstIter, OtherConstIter>);
 
-    using Cont = flat_map<int, int, less<int>, vector<int, Alloc1>, vector<int, Alloc2>>::containers;
-    using OtherCont =
-        flat_map_unique_if<IsUnique, int, int, Comparator, vector<int, Alloc1>, vector<int, Alloc2>>::containers;
-    static_assert(is_same_v<Cont, OtherCont>);
-
-    using ValueComp = flat_map<int, int, Comparator, vector<int, Alloc1>, vector<int, Alloc2>>::value_compare;
-    using OtherValueComp1 =
-        flat_map_unique_if<IsUnique, int, int, Comparator, vector<int, Alloc1>, vector<int, Alloc2>>::value_compare;
-    using OtherValueComp2 = flat_map_unique_if<IsUnique, int, int, Comparator, vector<int>, vector<int>>::value_compare;
-    using OtherValueComp3 =
-        flat_map_unique_if<IsUnique, int, int, Comparator, vector<int, Alloc1>, deque<int, Alloc2>>::value_compare;
-    using OtherValueComp4 =
-        flat_map_unique_if<IsUnique, int, int, Comparator, deque<int, Alloc1>, vector<int, Alloc2>>::value_compare;
-    static_assert(is_same_v<ValueComp, OtherValueComp1>);
-    static_assert(is_same_v<ValueComp, OtherValueComp2>);
-    static_assert(is_same_v<ValueComp, OtherValueComp3>);
-    static_assert(is_same_v<ValueComp, OtherValueComp4>);
+    using Cont       = flat_map_unique_if<IsUnique, int, int, Comparator, vector<int, Alloc1>, vector<int, Alloc2>>;
+    using OtherCont1 = flat_map_unique_if<!IsUnique, int, int, Comparator, vector<int, Alloc1>, vector<int, Alloc2>>;
+    using OtherCont2 = flat_map_unique_if<IsUnique, int, int, Comparator, deque<int>, deque<int>>;
+    using OtherCont3 = flat_map_unique_if<IsUnique, int, int, Comparator, vector<int, Alloc1>, deque<int, Alloc2>>;
+    using OtherCont4 = flat_map_unique_if<IsUnique, int, int, Comparator, deque<int, Alloc1>, vector<int, Alloc2>>;
+    static_assert(has_different_nested_types<Cont, OtherCont1>);
+    static_assert(has_different_nested_types<Cont, OtherCont2>);
+    static_assert(has_different_nested_types<Cont, OtherCont3>);
+    static_assert(has_different_nested_types<Cont, OtherCont4>);
 }
 
 void test_scary_ness() {

From bad73e69145eab763ae59c5b85fe7a303f944ee8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vojt=C4=9Bch=20Michal?= <vojta.michall@email.cz>
Date: Tue, 6 Jan 2026 00:02:54 +0100
Subject: [PATCH 100/134] `<flat_map>`: Unify implementation of `emplace` and
 `insert` between `flat_map` and `flat_multimap` (#5989)

Co-authored-by: Stephan T. Lavavej <stl@microsoft.com>
---
 stl/inc/flat_map | 185 +++++++++++++++++++----------------------------
 stl/inc/flat_set |   4 +-
 2 files changed, 76 insertions(+), 113 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index 077f2bb930d..d5d8da367e8 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -603,6 +603,30 @@ public:
         return _STD min(_Data.keys.max_size(), _Data.values.max_size());
     }
 
+    // [flat.map.modifiers] Modifiers
+    template <class... _ArgTypes>
+    auto emplace(_ArgTypes&&... _Args)
+        requires is_constructible_v<value_type, _ArgTypes...>
+    {
+        value_type _Val(_STD forward<_ArgTypes>(_Args)...);
+        return _Try_emplace(_STD move(_Val.first), _STD move(_Val.second));
+    }
+
+    auto insert(const value_type& _Pair_val) {
+        return _Try_emplace(_Pair_val.first, _Pair_val.second);
+    }
+
+    auto insert(value_type&& _Pair_val) {
+        return _Try_emplace(_STD move(_Pair_val.first), _STD move(_Pair_val.second));
+    }
+
+    template <class _PairValTy>
+    auto insert(_PairValTy&& _Pair_val)
+        requires is_constructible_v<value_type, _PairValTy>
+    {
+        return emplace(_STD forward<_PairValTy>(_Pair_val));
+    }
+
     template <class... _ArgTypes>
     iterator emplace_hint(const_iterator _Position, _ArgTypes&&... _Args)
         requires is_constructible_v<value_type, _ArgTypes...>
@@ -861,6 +885,35 @@ protected:
         return _STD _Pass_fn(_Key_compare);
     }
 
+    template <class _OtherKey, class... _MappedArgTypes>
+    _NODISCARD conditional_t<_IsUnique, pair<iterator, bool>, iterator> _Try_emplace(
+        _OtherKey&& _Key_val, _MappedArgTypes&&... _Mapped_args) {
+        _STL_INTERNAL_STATIC_ASSERT(is_constructible_v<mapped_type, _MappedArgTypes...>);
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<remove_cvref_t<_OtherKey>, key_type>
+                                    || (is_constructible_v<key_type, _OtherKey> && _Transparent<key_compare>) );
+
+        const auto _Key_it = _RANGES upper_bound(_Data.keys, _Key_val, _Pass_key_comp());
+        const auto _Index  = _RANGES distance(_Data.keys.begin(), _Key_it);
+        if constexpr (_IsUnique) {
+            if (_Key_it != _Data.keys.begin()
+                && !_Key_compare(*_RANGES prev(_Key_it), _STD forward<_OtherKey>(_Key_val))) {
+                // Previous element is equivalent to key, no insert needed
+                return {this->begin() + (_Index - 1), false};
+            }
+        }
+
+        // Need to insert
+        key_type _Key_to_insert(_STD forward<_OtherKey>(_Key_val));
+        mapped_type _Mapped_to_insert(_STD forward<_MappedArgTypes>(_Mapped_args)...);
+        _Insert_exact(_STD cbegin(*this) + _Index, _STD move(_Key_to_insert), _STD move(_Mapped_to_insert));
+
+        if constexpr (_IsUnique) {
+            return {this->begin() + _Index, true};
+        } else {
+            return this->begin() + _Index;
+        }
+    }
+
     template <bool _OverwriteIfExists, class _OtherKey, class... _MappedArgTypes>
     _NODISCARD iterator _Emplace_hint(
         const const_iterator _Position, _OtherKey&& _Key_val, _MappedArgTypes&&... _Args) {
@@ -1151,10 +1204,11 @@ class flat_map : public _Flat_map_base<true, _Key, _Mapped, _Compare, _KeyContai
 private:
     using _Mybase = _Flat_map_base<true, _Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>;
 
-    using _Mybase::_Data;
-    using _Mybase::_Key_compare;
-
 public:
+    using _Mybase::_Mybase;
+    flat_map(const flat_map&) = default;
+    flat_map(flat_map&&)      = default;
+
     using typename _Mybase::const_iterator;
     using typename _Mybase::iterator;
     using typename _Mybase::key_compare;
@@ -1162,10 +1216,6 @@ public:
     using typename _Mybase::mapped_type;
     using typename _Mybase::value_type;
 
-    using _Mybase::_Mybase;
-    using _Mybase::clear;
-    using _Mybase::insert;
-
 #if 1 // TRANSITION, P2582R1 (MSVC, Clang, EDG)
     template <_Usable_allocator_for<_KeyContainer, _MappedContainer> _Allocator>
     flat_map(const flat_map& _Other, const _Allocator& _Al) : _Mybase(_Other, _Al) {}
@@ -1174,12 +1224,15 @@ public:
     flat_map(flat_map&& _Other, const _Allocator& _Al) : _Mybase(_STD move(_Other), _Al) {}
 #endif // ^^^ workaround ^^^
 
-    flat_map& operator=(initializer_list<value_type> _Ilist) {
-        clear();
-        insert(_Ilist.begin(), _Ilist.end());
+    flat_map& operator=(const initializer_list<value_type> _Ilist) {
+        this->clear();
+        this->insert(_Ilist.begin(), _Ilist.end());
         return *this;
     }
 
+    flat_map& operator=(const flat_map&) = default;
+    flat_map& operator=(flat_map&&)      = default;
+
     // [flat.map.access] Access
     mapped_type& operator[](const key_type& _Key_val)
         requires is_default_constructible_v<mapped_type>
@@ -1223,39 +1276,16 @@ public:
     }
 
     // [flat.map.modifiers] Modifiers
-    template <class... _ArgTypes>
-    pair<iterator, bool> emplace(_ArgTypes&&... _Args)
-        requires is_constructible_v<value_type, _ArgTypes...>
-    {
-        value_type _Val(_STD forward<_ArgTypes>(_Args)...);
-        return try_emplace(_STD move(_Val.first), _STD move(_Val.second));
-    }
-
-    pair<iterator, bool> insert(const value_type& _Pair_val) {
-        return try_emplace(_Pair_val.first, _Pair_val.second);
-    }
-
-    pair<iterator, bool> insert(value_type&& _Pair_val) {
-        return try_emplace(_STD move(_Pair_val.first), _STD move(_Pair_val.second));
-    }
-
-    template <class _PairValTy>
-    pair<iterator, bool> insert(_PairValTy&& _Pair_val)
-        requires is_constructible_v<value_type, _PairValTy>
-    {
-        return emplace(_STD forward<_PairValTy>(_Pair_val));
-    }
-
     template <class... _MappedArgTypes>
         requires is_constructible_v<mapped_type, _MappedArgTypes&&...>
     pair<iterator, bool> try_emplace(const key_type& _Key_val, _MappedArgTypes&&... _Mapped_args) {
-        return _Try_emplace(_Key_val, _STD forward<_MappedArgTypes>(_Mapped_args)...);
+        return this->_Try_emplace(_Key_val, _STD forward<_MappedArgTypes>(_Mapped_args)...);
     }
 
     template <class... _MappedArgTypes>
         requires is_constructible_v<mapped_type, _MappedArgTypes&&...>
     pair<iterator, bool> try_emplace(key_type&& _Key_val, _MappedArgTypes&&... _Mapped_args) {
-        return _Try_emplace(_STD move(_Key_val), _STD forward<_MappedArgTypes>(_Mapped_args)...);
+        return this->_Try_emplace(_STD move(_Key_val), _STD forward<_MappedArgTypes>(_Mapped_args)...);
     }
 
     template <class _OtherKey, class... _MappedArgTypes>
@@ -1263,7 +1293,7 @@ public:
               && is_constructible_v<mapped_type, _MappedArgTypes...> && (!is_convertible_v<_OtherKey, const_iterator>)
               && (!is_convertible_v<_OtherKey, iterator>)
     pair<iterator, bool> try_emplace(_OtherKey&& _Key_val, _MappedArgTypes&&... _Mapped_args) {
-        return _Try_emplace(_STD forward<_OtherKey>(_Key_val), _STD forward<_MappedArgTypes>(_Mapped_args)...);
+        return this->_Try_emplace(_STD forward<_OtherKey>(_Key_val), _STD forward<_MappedArgTypes>(_Mapped_args)...);
     }
 
     template <class... _MappedArgTypes>
@@ -1336,11 +1366,6 @@ public:
     }
 
 private:
-    using _Mybase::_Emplace_hint;
-    using _Mybase::_Insert_exact;
-    using _Mybase::_Key_equal;
-    using _Mybase::_Pass_key_comp;
-
     template <class _SelfTy, class _KeyTy>
     _NODISCARD auto& _At(this _SelfTy& _Self, const _KeyTy& _Key_val) {
         _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
@@ -1352,27 +1377,9 @@ private:
         return _Position->second;
     }
 
-    template <class _KeyTy, class... _MappedArgTypes>
-    _NODISCARD pair<iterator, bool> _Try_emplace(_KeyTy&& _Key_val, _MappedArgTypes&&... _Mapped_args) {
-        auto _Key_it = _STD lower_bound(_Data.keys.begin(), _Data.keys.end(), _Key_val, _Pass_key_comp());
-        if (_Key_it != _Data.keys.end() && !_Key_compare(_STD forward<_KeyTy>(_Key_val), *_Key_it)) {
-            // Already exists
-            return {this->begin() + (_Key_it - _Data.keys.begin()), false};
-        }
-
-        // Need to insert
-        const auto _Index = _Key_it - _Data.keys.begin();
-        {
-            key_type _Key_to_insert(_STD forward<_KeyTy>(_Key_val));
-            mapped_type _Mapped_to_insert(_STD forward<_MappedArgTypes>(_Mapped_args)...);
-            this->_Insert_exact(_STD cbegin(*this) + _Index, _STD move(_Key_to_insert), _STD move(_Mapped_to_insert));
-        }
-        return {this->begin() + _Index, true};
-    }
-
     template <class _KeyTy, class _MappedTy>
     _NODISCARD pair<iterator, bool> _Insert_or_assign(_KeyTy&& _Key_val, _MappedTy&& _Mapped_val) {
-        auto _Res = _Try_emplace(_STD forward<_KeyTy>(_Key_val), _STD forward<_MappedTy>(_Mapped_val));
+        auto _Res = this->_Try_emplace(_STD forward<_KeyTy>(_Key_val), _STD forward<_MappedTy>(_Mapped_val));
         if (!_Res.second) { // Already exists
             _Res.first->second = _STD forward<_MappedTy>(_Mapped_val);
         }
@@ -1475,16 +1482,12 @@ class flat_multimap : public _Flat_map_base<false, _Key, _Mapped, _Compare, _Key
 private:
     using _Mybase = _Flat_map_base<false, _Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>;
 
-    using _Mybase::_Data;
-    using _Mybase::_Key_compare;
-
 public:
-    using typename _Mybase::iterator;
     using typename _Mybase::value_type;
 
     using _Mybase::_Mybase;
-    using _Mybase::clear;
-    using _Mybase::insert;
+    flat_multimap(const flat_multimap&) = default;
+    flat_multimap(flat_multimap&&)      = default;
 
 #if 1 // TRANSITION, P2582R1 (MSVC, Clang, EDG)
     template <_Usable_allocator_for<_KeyContainer, _MappedContainer> _Allocator>
@@ -1494,54 +1497,14 @@ public:
     flat_multimap(flat_multimap&& _Other, const _Allocator& _Al) : _Mybase(_STD move(_Other), _Al) {}
 #endif // ^^^ workaround ^^^
 
-    flat_multimap& operator=(initializer_list<value_type> _Ilist) {
-        clear();
-        insert(_Ilist.begin(), _Ilist.end());
+    flat_multimap& operator=(const initializer_list<value_type> _Ilist) {
+        this->clear();
+        this->insert(_Ilist.begin(), _Ilist.end());
         return *this;
     }
 
-    // [flat.multimap.modifiers] Modifiers
-    template <class... _ArgTypes>
-    iterator emplace(_ArgTypes&&... _Args)
-        requires is_constructible_v<value_type, _ArgTypes...>
-    {
-        value_type _Val(_STD forward<_ArgTypes>(_Args)...);
-        return _Emplace_key_mapped(_STD move(_Val.first), _STD move(_Val.second));
-    }
-
-    iterator insert(const value_type& _Px) {
-        return _Emplace_key_mapped(_Px.first, _Px.second);
-    }
-
-    iterator insert(value_type&& _Px) {
-        return _Emplace_key_mapped(_STD move(_Px.first), _STD move(_Px.second));
-    }
-
-    template <class _PairValTy>
-    iterator insert(_PairValTy&& _Pair_val)
-        requires is_constructible_v<value_type, _PairValTy>
-    {
-        return emplace(_STD forward<_PairValTy>(_Pair_val));
-    }
-
-private:
-    using _Mybase::_Emplace_hint;
-    using _Mybase::_Insert_exact;
-    using _Mybase::_Key_equal;
-    using _Mybase::_Pass_key_comp;
-
-    template <class _KeyTy, class _MappedTy>
-    _NODISCARD iterator _Emplace_key_mapped(_KeyTy&& _Key_val, _MappedTy&& _Mapped_val) {
-        const auto _Key_it = _STD upper_bound(_Data.keys.begin(), _Data.keys.end(), _Key_val, _Pass_key_comp());
-        const auto _Index  = _Key_it - _Data.keys.begin();
-
-        {
-            _Key _Key_to_insert(_STD forward<_KeyTy>(_Key_val));
-            _Mapped _Mapped_to_insert(_STD forward<_MappedTy>(_Mapped_val));
-            this->_Insert_exact(_STD cbegin(*this) + _Index, _STD move(_Key_to_insert), _STD move(_Mapped_to_insert));
-        }
-        return this->begin() + _Index;
-    }
+    flat_multimap& operator=(const flat_multimap&) = default;
+    flat_multimap& operator=(flat_multimap&&)      = default;
 };
 
 template <_Not_allocator_for_container _KeyContainer, _Not_allocator_for_container _MappedContainer,
diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index 496bf624fea..e5395153837 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -757,7 +757,7 @@ public:
     flat_set(flat_set&& _Other, const _Allocator& _Al) : _Mybase(_STD move(_Other), _Al) {}
 #endif // ^^^ workaround ^^^
 
-    using _Mybase::operator=;
+    using _Mybase::operator=; // for operator=(initializer_list)
     flat_set& operator=(const flat_set&) = default;
     flat_set& operator=(flat_set&&)      = default;
 };
@@ -780,7 +780,7 @@ public:
     flat_multiset(flat_multiset&& _Other, const _Allocator& _Al) : _Mybase(_STD move(_Other), _Al) {}
 #endif // ^^^ workaround ^^^
 
-    using _Mybase::operator=;
+    using _Mybase::operator=; // for operator=(initializer_list)
     flat_multiset& operator=(const flat_multiset&) = default;
     flat_multiset& operator=(flat_multiset&&)      = default;
 };

From aed9711f2de16c45e92eb0ebcbe865d57030c8a8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vojt=C4=9Bch=20Michal?= <vojta.michall@email.cz>
Date: Tue, 6 Jan 2026 01:45:27 +0100
Subject: [PATCH 101/134] `<flat_meow>`: Misc changes: `const` locals and
 parameters, more `_STL_ASSERT` that functions with `_Sorted` tag are called
 with sorted sequences (#5990)

Co-authored-by: Stephan T. Lavavej <stl@microsoft.com>
---
 stl/inc/flat_map                          | 138 ++++++++++++----------
 stl/inc/flat_set                          |  70 ++++++-----
 tests/std/tests/P1222R4_flat_set/test.cpp |   1 +
 3 files changed, 116 insertions(+), 93 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index d5d8da367e8..a8a72666874 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -335,7 +335,6 @@ public:
         mapped_container_type values;
     };
 
-public:
     // [flat.map.cons] Constructors
     explicit _Flat_map_base(const key_compare& _Comp) : _Data(), _Key_compare(_Comp) {}
     _Flat_map_base() : _Flat_map_base(key_compare()) {}
@@ -359,14 +358,15 @@ public:
     template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
     _Flat_map_base(
         const key_container_type& _Key_cont, const mapped_container_type& _Mapped_cont, const _Allocator& _Alloc)
-        : _Flat_map_base(_Sorted_t{}, _Key_cont, _Mapped_cont, _Alloc) {
-        _Sort_and_erase_dupes_if_not_multi();
-    }
+        : _Flat_map_base(_Key_cont, _Mapped_cont, key_compare(), _Alloc) {}
 
     template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
     _Flat_map_base(const key_container_type& _Key_cont, const mapped_container_type& _Mapped_cont,
         const key_compare& _Comp, const _Allocator& _Alloc)
-        : _Flat_map_base(_Sorted_t{}, _Key_cont, _Mapped_cont, _Comp, _Alloc) {
+        : _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Alloc, _Key_cont),
+              .values = _STD make_obj_using_allocator<mapped_container_type>(_Alloc, _Mapped_cont)},
+          _Key_compare(_Comp) {
+        _STL_ASSERT(_Data.keys.size() == _Data.values.size(), "key_cont.size() != mapped_cont.size()");
         _Sort_and_erase_dupes_if_not_multi();
     }
 
@@ -374,16 +374,13 @@ public:
         const key_compare& _Comp = key_compare())
         : _Data{.keys = _STD move(_Key_cont), .values = _STD move(_Mapped_cont)}, _Key_compare(_Comp) {
         _STL_ASSERT(_Data.keys.size() == _Data.values.size(), "key_cont.size() != mapped_cont.size()");
+        _STL_ASSERT(_Is_sorted_and_unique(), _Msg_not_sorted);
     }
 
     template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
-    _Flat_map_base(_Sorted_t, const key_container_type& _Key_cont, const mapped_container_type& _Mapped_cont,
+    _Flat_map_base(_Sorted_t _Tag, const key_container_type& _Key_cont, const mapped_container_type& _Mapped_cont,
         const _Allocator& _Alloc)
-        : _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Alloc, _Key_cont),
-              .values = _STD make_obj_using_allocator<mapped_container_type>(_Alloc, _Mapped_cont)},
-          _Key_compare(key_compare()) {
-        _STL_ASSERT(_Data.keys.size() == _Data.values.size(), "key_cont.size() != mapped_cont.size()");
-    }
+        : _Flat_map_base(_Tag, _Key_cont, _Mapped_cont, key_compare(), _Alloc) {}
 
     template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
     _Flat_map_base(_Sorted_t, const key_container_type& _Key_cont, const mapped_container_type& _Mapped_cont,
@@ -392,23 +389,26 @@ public:
               .values = _STD make_obj_using_allocator<mapped_container_type>(_Alloc, _Mapped_cont)},
           _Key_compare(_Comp) {
         _STL_ASSERT(_Data.keys.size() == _Data.values.size(), "key_cont.size() != mapped_cont.size()");
+        _STL_ASSERT(_Is_sorted_and_unique(), _Msg_not_sorted);
     }
 
     template <_Iterator_for_container _InputIterator>
-    _Flat_map_base(_InputIterator _First, _InputIterator _Last, const key_compare& _Comp = key_compare())
+    _Flat_map_base(const _InputIterator _First, const _InputIterator _Last, const key_compare& _Comp = key_compare())
         : _Flat_map_base(_Comp) {
         insert(_First, _Last);
     }
 
     template <_Iterator_for_container _InputIterator,
         _Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
-    _Flat_map_base(_InputIterator _First, _InputIterator _Last, const _Allocator& _Alloc) : _Flat_map_base(_Alloc) {
+    _Flat_map_base(const _InputIterator _First, const _InputIterator _Last, const _Allocator& _Alloc)
+        : _Flat_map_base(_Alloc) {
         insert(_First, _Last);
     }
 
     template <_Iterator_for_container _InputIterator,
         _Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
-    _Flat_map_base(_InputIterator _First, _InputIterator _Last, const key_compare& _Comp, const _Allocator& _Alloc)
+    _Flat_map_base(
+        const _InputIterator _First, const _InputIterator _Last, const key_compare& _Comp, const _Allocator& _Alloc)
         : _Flat_map_base(_Comp, _Alloc) {
         insert(_First, _Last);
     }
@@ -435,45 +435,46 @@ public:
     }
 
     template <_Iterator_for_container _InputIterator>
-    _Flat_map_base(_Sorted_t, _InputIterator _First, _InputIterator _Last, const key_compare& _Comp = key_compare())
+    _Flat_map_base(
+        _Sorted_t, const _InputIterator _First, const _InputIterator _Last, const key_compare& _Comp = key_compare())
         : _Flat_map_base(_Comp) {
         _Insert_range<false>(_First, _Last);
     }
 
     template <_Iterator_for_container _InputIterator,
         _Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
-    _Flat_map_base(
-        _Sorted_t, _InputIterator _First, _InputIterator _Last, const key_compare& _Comp, const _Allocator& _Alloc)
+    _Flat_map_base(_Sorted_t, const _InputIterator _First, const _InputIterator _Last, const key_compare& _Comp,
+        const _Allocator& _Alloc)
         : _Flat_map_base(_Comp, _Alloc) {
         _Insert_range<false>(_First, _Last);
     }
 
     template <_Iterator_for_container _InputIterator,
         _Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
-    _Flat_map_base(_Sorted_t _Tag, _InputIterator _First, _InputIterator _Last, const _Allocator& _Alloc)
+    _Flat_map_base(_Sorted_t _Tag, const _InputIterator _First, const _InputIterator _Last, const _Allocator& _Alloc)
         : _Flat_map_base(_Tag, _First, _Last, key_compare(), _Alloc) {}
 
-    _Flat_map_base(initializer_list<value_type> _Ilist, const key_compare& _Comp = key_compare())
+    _Flat_map_base(const initializer_list<value_type> _Ilist, const key_compare& _Comp = key_compare())
         : _Flat_map_base(_Ilist.begin(), _Ilist.end(), _Comp) {}
 
     template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
-    _Flat_map_base(initializer_list<value_type> _Ilist, const key_compare& _Comp, const _Allocator& _Alloc)
+    _Flat_map_base(const initializer_list<value_type> _Ilist, const key_compare& _Comp, const _Allocator& _Alloc)
         : _Flat_map_base(_Ilist.begin(), _Ilist.end(), _Comp, _Alloc) {}
 
     template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
-    _Flat_map_base(initializer_list<value_type> _Ilist, const _Allocator& _Alloc)
+    _Flat_map_base(const initializer_list<value_type> _Ilist, const _Allocator& _Alloc)
         : _Flat_map_base(_Ilist, key_compare(), _Alloc) {}
 
-    _Flat_map_base(_Sorted_t _Tag, initializer_list<value_type> _Ilist, const key_compare& _Comp = key_compare())
+    _Flat_map_base(_Sorted_t _Tag, const initializer_list<value_type> _Ilist, const key_compare& _Comp = key_compare())
         : _Flat_map_base(_Tag, _Ilist.begin(), _Ilist.end(), _Comp) {}
 
     template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
     _Flat_map_base(
-        _Sorted_t _Tag, initializer_list<value_type> _Ilist, const key_compare& _Comp, const _Allocator& _Alloc)
+        _Sorted_t _Tag, const initializer_list<value_type> _Ilist, const key_compare& _Comp, const _Allocator& _Alloc)
         : _Flat_map_base(_Tag, _Ilist.begin(), _Ilist.end(), _Comp, _Alloc) {}
 
     template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
-    _Flat_map_base(_Sorted_t _Tag, initializer_list<value_type> _Ilist, const _Allocator& _Alloc)
+    _Flat_map_base(_Sorted_t _Tag, const initializer_list<value_type> _Ilist, const _Allocator& _Alloc)
         : _Flat_map_base(_Tag, _Ilist, key_compare(), _Alloc) {}
 
     // Copy constructors
@@ -511,10 +512,14 @@ public:
     _Flat_map_base& operator=(_Flat_map_base&& _Other)
         noexcept(is_nothrow_copy_assignable_v<key_compare> && is_nothrow_move_assignable_v<key_container_type>
                  && is_nothrow_move_assignable_v<mapped_container_type>) {
-        _Clear_guard _Guard{this};
-        _Data          = _STD move(_Other).extract();
-        _Key_compare   = _Other._Key_compare; // intentionally copy comparator, see LWG-2227
-        _Guard._Target = nullptr;
+
+        if (this != _STD addressof(_Other)) {
+            _Clear_guard _Guard{this};
+            _Clear_guard _Always_clear{_STD addressof(_Other)};
+            _Data          = _STD move(_Other._Data);
+            _Key_compare   = _Other._Key_compare; // intentionally copy comparator, see LWG-2227
+            _Guard._Target = nullptr;
+        }
         return *this;
     }
 
@@ -628,35 +633,35 @@ public:
     }
 
     template <class... _ArgTypes>
-    iterator emplace_hint(const_iterator _Position, _ArgTypes&&... _Args)
+    iterator emplace_hint(const const_iterator _Position, _ArgTypes&&... _Args)
         requires is_constructible_v<value_type, _ArgTypes...>
     {
         value_type _Val(_STD forward<_ArgTypes>(_Args)...);
         return _Emplace_hint<false>(_Position, _STD move(_Val.first), _STD move(_Val.second));
     }
 
-    iterator insert(const_iterator _Position, const value_type& _Pair_val) {
+    iterator insert(const const_iterator _Position, const value_type& _Pair_val) {
         return emplace_hint(_Position, _Pair_val);
     }
 
-    iterator insert(const_iterator _Position, value_type&& _Pair_val) {
+    iterator insert(const const_iterator _Position, value_type&& _Pair_val) {
         return emplace_hint(_Position, _STD move(_Pair_val));
     }
 
     template <class _PairValTy>
-    iterator insert(const_iterator _Position, _PairValTy&& _Pair_val)
+    iterator insert(const const_iterator _Position, _PairValTy&& _Pair_val)
         requires is_constructible_v<value_type, _PairValTy>
     {
         return emplace_hint(_Position, _STD forward<_PairValTy>(_Pair_val));
     }
 
     template <_Iterator_for_container _InputIterator>
-    void insert(_InputIterator _First, _InputIterator _Last) {
+    void insert(const _InputIterator _First, const _InputIterator _Last) {
         _Insert_range<true>(_First, _Last);
     }
 
     template <_Iterator_for_container _InputIterator>
-    void insert(_Sorted_t, _InputIterator _First, _InputIterator _Last) {
+    void insert(_Sorted_t, const _InputIterator _First, const _InputIterator _Last) {
         _Insert_range<false>(_First, _Last);
     }
 
@@ -670,19 +675,19 @@ public:
         _Insert_range<false>(_RANGES begin(_Range), _RANGES end(_Range));
     }
 
-    void insert(initializer_list<value_type> _Ilist) {
+    void insert(const initializer_list<value_type> _Ilist) {
         _Insert_range<true>(_Ilist.begin(), _Ilist.end());
     }
 
-    void insert(_Sorted_t, initializer_list<value_type> _Ilist) {
+    void insert(_Sorted_t, const initializer_list<value_type> _Ilist) {
         _Insert_range<false>(_Ilist.begin(), _Ilist.end());
     }
 
-    iterator erase(iterator _Position) {
+    iterator erase(const iterator _Position) {
         return erase(static_cast<const_iterator>(_Position));
     }
 
-    iterator erase(const_iterator _Position) {
+    iterator erase(const const_iterator _Position) {
         _Clear_guard _Guard{this};
         auto _Key_it   = _Data.keys.erase(_Position._Key_it);
         auto _Val_it   = _Data.values.erase(_Position._Mapped_it);
@@ -690,7 +695,7 @@ public:
         return iterator{_STD move(_Key_it), _STD move(_Val_it)};
     }
 
-    iterator erase(const_iterator _First, const_iterator _Last) {
+    iterator erase(const const_iterator _First, const const_iterator _Last) {
         _Clear_guard _Guard{this};
         auto _Key_it   = _Data.keys.erase(_First._Key_it, _Last._Key_it);
         auto _Val_it   = _Data.values.erase(_First._Mapped_it, _Last._Mapped_it);
@@ -726,7 +731,7 @@ public:
 
     void replace(key_container_type&& _Key_cont, mapped_container_type&& _Mapped_cont) {
         _STL_ASSERT(_Key_cont.size() == _Mapped_cont.size(), "key_cont.size() != mapped_cont.size()");
-        _STL_ASSERT(_Is_sorted(_Key_cont), _Msg_not_sorted);
+        _STL_ASSERT(_Is_sorted_and_unique(_Key_cont), _Msg_not_sorted);
         _Clear_guard _Guard{this};
         _Data.keys     = _STD move(_Key_cont);
         _Data.values   = _STD move(_Mapped_cont);
@@ -964,7 +969,7 @@ protected:
             if (_Hint_order == weak_ordering::less) {
                 if (_New_position != _End && !_Key_compare(_Key_val, *_New_position._Key_it)) {
                     const auto _Dist = _New_position._Key_it - _Begin._Key_it;
-                    auto _It         = begin() + _Dist;
+                    const auto _It   = begin() + _Dist;
                     if constexpr (_OverwriteIfExists) {
                         *_It._Mapped_it = mapped_type(_STD forward<_MappedArgTypes>(_Args)...);
                     }
@@ -973,7 +978,7 @@ protected:
             } else {
                 if (_New_position != _Begin && !_Key_compare(*_STD prev(_New_position._Key_it), _Key_val)) {
                     const auto _Dist = _STD prev(_New_position._Key_it) - _Begin._Key_it;
-                    auto _It         = begin() + _Dist;
+                    const auto _It   = begin() + _Dist;
                     if constexpr (_OverwriteIfExists) {
                         *_It._Mapped_it = mapped_type(_STD forward<_MappedArgTypes>(_Args)...);
                     }
@@ -991,7 +996,7 @@ protected:
         return begin() + _Dist;
     }
 
-    void _Insert_exact(const_iterator _Position, key_type&& _Key_val, mapped_type&& _Mapped_val) {
+    void _Insert_exact(const const_iterator _Position, key_type&& _Key_val, mapped_type&& _Mapped_val) {
         _Clear_guard _Guard{this};
         _Data.keys.insert(_Position._Key_it, _STD move(_Key_val));
         _Data.values.insert(_Position._Mapped_it, _STD move(_Mapped_val));
@@ -1021,14 +1026,14 @@ private:
     _NODISCARD size_type _Erase_if(_Predicate _Pred) {
         auto _View           = _View_to_mutate();
         auto _Mut_first      = _View.begin();
-        auto _Mut_last       = _View.end();
+        const auto _Mut_last = _View.end();
         const auto _Old_size = size();
 
         _Clear_guard _Guard{this};
 
         _STD _Seek_wrapped(_Mut_first, _RANGES remove_if(_View, _Pred).begin());
-        (void) _Data.keys.erase(_Mut_first._Key_it, _Mut_last._Key_it);
-        (void) _Data.values.erase(_Mut_first._Mapped_it, _Mut_last._Mapped_it);
+        _Data.keys.erase(_Mut_first._Key_it, _Mut_last._Key_it);
+        _Data.values.erase(_Mut_first._Mapped_it, _Mut_last._Mapped_it);
 
         _Guard._Target = nullptr;
         return _Old_size - size();
@@ -1041,8 +1046,14 @@ private:
             _Mutating_iterator{_Data.keys.end(), _Data.values.end()}};
     }
 
-    _NODISCARD bool _Is_sorted(
-        typename key_container_type::const_iterator _It, const typename key_container_type::const_iterator _End) const {
+public:
+    _NODISCARD bool _Is_sorted_and_unique() const {
+        return _Is_sorted_and_unique(_Data.keys);
+    }
+
+private:
+    _NODISCARD bool _Is_sorted_and_unique(
+        const key_container_type::const_iterator _It, const key_container_type::const_iterator _End) const {
         if constexpr (_IsUnique) {
             // sorted-unique
             auto _Negated = [this](const key_type& _Lhs, const key_type& _Rhs) { return !_Key_compare(_Lhs, _Rhs); };
@@ -1052,8 +1063,8 @@ private:
         }
     }
 
-    _NODISCARD bool _Is_sorted(const key_container_type& _Cont) const {
-        return _Is_sorted(_Cont.begin(), _Cont.end());
+    _NODISCARD bool _Is_sorted_and_unique(const key_container_type& _Cont) const {
+        return _Is_sorted_and_unique(_Cont.begin(), _Cont.end());
     }
 
     void _Sort_and_erase_dupes_if_not_multi() {
@@ -1074,15 +1085,15 @@ private:
 
         _Erase_dupes_if_not_multi();
 
-        _STL_INTERNAL_CHECK(_Is_sorted(_Data.keys));
+        _STL_INTERNAL_CHECK(_Is_sorted_and_unique());
 
         _Guard._Target = nullptr;
     }
 
     void _Erase_dupes_if_not_multi() {
         if constexpr (_IsUnique) {
-            auto _Sorted_view = _View_to_mutate();
-            auto _Subrange    = _RANGES unique(_Sorted_view, [this](const_reference _Left, const_reference _Right) {
+            auto _Sorted_view    = _View_to_mutate();
+            const auto _Subrange = _RANGES unique(_Sorted_view, [this](const_reference _Left, const_reference _Right) {
                 return this->_Key_equal(_Left.first, _Right.first);
             });
             const auto _Remaining_count = _Subrange.begin() - _Sorted_view.begin();
@@ -1096,7 +1107,7 @@ private:
     }
 
     template <bool _NeedSorting, class _InputIterator, class _Sentinel>
-    void _Insert_range(_InputIterator _First, _Sentinel _Last) {
+    void _Insert_range(_InputIterator _First, const _Sentinel _Last) {
         _Clear_guard _Guard{this};
 
         const auto _Old_distance = static_cast<difference_type>(size());
@@ -1123,13 +1134,18 @@ private:
             auto _Sorted_new_elements = _Sorted_view;
             _Sorted_new_elements.advance(_Old_distance);
             _RANGES sort(_Sorted_new_elements, value_compare{_Key_compare});
+        } else {
+            _STL_ASSERT(_Is_sorted_and_unique(
+                            _Data.keys.begin() + static_cast<key_container_type::difference_type>(_Old_distance),
+                            _Data.keys.end()),
+                _Msg_not_sorted);
         }
 
         // Merge the newly inserted elements with the existing elements
         _RANGES inplace_merge(_Sorted_view, _Sorted_view.begin() + _Old_distance, value_compare{_Key_compare});
 
         _Erase_dupes_if_not_multi();
-        _STL_INTERNAL_CHECK(_Is_sorted(_Data.keys));
+        _STL_INTERNAL_CHECK(_Is_sorted_and_unique());
 
         _Guard._Target = nullptr;
     }
@@ -1297,14 +1313,14 @@ public:
     }
 
     template <class... _MappedArgTypes>
-    iterator try_emplace(const_iterator _Position, const key_type& _Key_val, _MappedArgTypes&&... _Mapped_args)
+    iterator try_emplace(const const_iterator _Position, const key_type& _Key_val, _MappedArgTypes&&... _Mapped_args)
         requires is_constructible_v<mapped_type, _MappedArgTypes...>
     {
         return this->template _Emplace_hint<false>(_Position, _Key_val, _STD forward<_MappedArgTypes>(_Mapped_args)...);
     }
 
     template <class... _MappedArgTypes>
-    iterator try_emplace(const_iterator _Position, key_type&& _Key_val, _MappedArgTypes&&... _Mapped_args)
+    iterator try_emplace(const const_iterator _Position, key_type&& _Key_val, _MappedArgTypes&&... _Mapped_args)
         requires is_constructible_v<mapped_type, _MappedArgTypes&&...>
     {
         return this->template _Emplace_hint<false>(
@@ -1312,7 +1328,7 @@ public:
     }
 
     template <class _OtherKey, class... _MappedArgTypes>
-    iterator try_emplace(const_iterator _Position, _OtherKey&& _Key_val, _MappedArgTypes&&... _Mapped_args)
+    iterator try_emplace(const const_iterator _Position, _OtherKey&& _Key_val, _MappedArgTypes&&... _Mapped_args)
         requires _Transparent<key_compare> && is_constructible_v<key_type, _OtherKey>
               && is_constructible_v<mapped_type, _MappedArgTypes&&...>
     {
@@ -1343,21 +1359,21 @@ public:
     }
 
     template <class _MappedTy>
-    iterator insert_or_assign(const_iterator _Position, const key_type& _Key_val, _MappedTy&& _Mapped_val)
+    iterator insert_or_assign(const const_iterator _Position, const key_type& _Key_val, _MappedTy&& _Mapped_val)
         requires is_assignable_v<mapped_type&, _MappedTy> && is_constructible_v<mapped_type, _MappedTy>
     {
         return this->template _Emplace_hint<true>(_Position, _Key_val, _STD forward<_MappedTy>(_Mapped_val));
     }
 
     template <class _MappedTy>
-    iterator insert_or_assign(const_iterator _Position, key_type&& _Key_val, _MappedTy&& _Mapped_val)
+    iterator insert_or_assign(const const_iterator _Position, key_type&& _Key_val, _MappedTy&& _Mapped_val)
         requires is_assignable_v<mapped_type&, _MappedTy> && is_constructible_v<mapped_type, _MappedTy>
     {
         return this->template _Emplace_hint<true>(_Position, _STD move(_Key_val), _STD forward<_MappedTy>(_Mapped_val));
     }
 
     template <class _OtherKey, class _MappedTy>
-    iterator insert_or_assign(const_iterator _Position, _OtherKey&& _Key_val, _MappedTy&& _Mapped_val)
+    iterator insert_or_assign(const const_iterator _Position, _OtherKey&& _Key_val, _MappedTy&& _Mapped_val)
         requires _Transparent<key_compare> && is_constructible_v<key_type, _OtherKey>
               && is_assignable_v<mapped_type&, _MappedTy> && is_constructible_v<mapped_type, _MappedTy>
     {
diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index e5395153837..790ab35b20a 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -109,7 +109,8 @@ public:
     using reverse_iterator       = const_reverse_iterator;
     using container_type         = _Container;
 
-    _Flat_set_base() : _Mycont(), _Mycomp() {}
+    // [flat.set.cons] Constructors
+    _Flat_set_base() : _Flat_set_base(key_compare()) {}
 
     template <_Usable_allocator_for<container_type> _Alloc>
     _Flat_set_base(const _Flat_set_base& _Other, const _Alloc& _Al)
@@ -133,7 +134,7 @@ public:
 
     _Flat_set_base(_Sorted_t, container_type _Cont, const key_compare& _Comp = key_compare())
         : _Mycont(_STD move(_Cont)), _Mycomp(_Comp) {
-        _STL_ASSERT(_Is_sorted(_Mycont), _Msg_not_sorted);
+        _STL_ASSERT(_Is_sorted_and_unique(), _Msg_not_sorted);
     }
     template <_Usable_allocator_for<container_type> _Alloc>
     _Flat_set_base(_Sorted_t _Tag, const container_type& _Cont, const _Alloc& _Al)
@@ -151,18 +152,19 @@ public:
         : _Mycont(_STD make_obj_using_allocator<container_type>(_Al)), _Mycomp() {}
 
     template <_Iterator_for_container _Iter>
-    _Flat_set_base(_Iter _First, _Iter _Last, const key_compare& _Comp = key_compare()) : _Mycont(), _Mycomp(_Comp) {
+    _Flat_set_base(const _Iter _First, const _Iter _Last, const key_compare& _Comp = key_compare())
+        : _Mycont(), _Mycomp(_Comp) {
         _Mycont.assign(_First, _Last);
         _Make_invariants_fulfilled();
     }
     template <_Iterator_for_container _Iter, _Usable_allocator_for<container_type> _Alloc>
-    _Flat_set_base(_Iter _First, _Iter _Last, const key_compare& _Comp, const _Alloc& _Al)
+    _Flat_set_base(const _Iter _First, const _Iter _Last, const key_compare& _Comp, const _Alloc& _Al)
         : _Mycont(_STD make_obj_using_allocator<container_type>(_Al)), _Mycomp(_Comp) {
         _Mycont.assign(_First, _Last);
         _Make_invariants_fulfilled();
     }
     template <_Iterator_for_container _Iter, _Usable_allocator_for<container_type> _Alloc>
-    _Flat_set_base(_Iter _First, _Iter _Last, const _Alloc& _Al)
+    _Flat_set_base(const _Iter _First, const _Iter _Last, const _Alloc& _Al)
         : _Mycont(_STD make_obj_using_allocator<container_type>(_Al)), _Mycomp() {
         _Mycont.assign(_First, _Last);
         _Make_invariants_fulfilled();
@@ -188,31 +190,31 @@ public:
     }
 
     template <_Iterator_for_container _Iter>
-    _Flat_set_base(_Sorted_t _Tag, _Iter _First, _Iter _Last, const key_compare& _Comp = key_compare())
+    _Flat_set_base(_Sorted_t _Tag, const _Iter _First, const _Iter _Last, const key_compare& _Comp = key_compare())
         : _Flat_set_base(_Tag, container_type(_First, _Last), _Comp) {}
     template <_Iterator_for_container _Iter, _Usable_allocator_for<container_type> _Alloc>
-    _Flat_set_base(_Sorted_t _Tag, _Iter _First, _Iter _Last, const key_compare& _Comp, const _Alloc& _Al)
+    _Flat_set_base(_Sorted_t _Tag, const _Iter _First, const _Iter _Last, const key_compare& _Comp, const _Alloc& _Al)
         : _Flat_set_base(_Tag, _STD make_obj_using_allocator<container_type>(_Al, _First, _Last), _Comp) {}
     template <_Iterator_for_container _Iter, _Usable_allocator_for<container_type> _Alloc>
-    _Flat_set_base(_Sorted_t _Tag, _Iter _First, _Iter _Last, const _Alloc& _Al)
+    _Flat_set_base(_Sorted_t _Tag, const _Iter _First, const _Iter _Last, const _Alloc& _Al)
         : _Flat_set_base(_Tag, _STD make_obj_using_allocator<container_type>(_Al, _First, _Last)) {}
 
-    _Flat_set_base(initializer_list<_Kty> _Ilist, const key_compare& _Comp = key_compare())
+    _Flat_set_base(const initializer_list<_Kty> _Ilist, const key_compare& _Comp = key_compare())
         : _Flat_set_base(_Ilist.begin(), _Ilist.end(), _Comp) {}
     template <_Usable_allocator_for<container_type> _Alloc>
-    _Flat_set_base(initializer_list<_Kty> _Ilist, const key_compare& _Comp, const _Alloc& _Al)
+    _Flat_set_base(const initializer_list<_Kty> _Ilist, const key_compare& _Comp, const _Alloc& _Al)
         : _Flat_set_base(_Ilist.begin(), _Ilist.end(), _Comp, _Al) {}
     template <_Usable_allocator_for<container_type> _Alloc>
-    _Flat_set_base(initializer_list<_Kty> _Ilist, const _Alloc& _Al)
+    _Flat_set_base(const initializer_list<_Kty> _Ilist, const _Alloc& _Al)
         : _Flat_set_base(_Ilist.begin(), _Ilist.end(), _Al) {}
 
-    _Flat_set_base(_Sorted_t _Tag, initializer_list<_Kty> _Ilist, const key_compare& _Comp = key_compare())
+    _Flat_set_base(_Sorted_t _Tag, const initializer_list<_Kty> _Ilist, const key_compare& _Comp = key_compare())
         : _Flat_set_base(_Tag, _Ilist.begin(), _Ilist.end(), _Comp) {}
     template <_Usable_allocator_for<container_type> _Alloc>
-    _Flat_set_base(_Sorted_t _Tag, initializer_list<_Kty> _Ilist, const key_compare& _Comp, const _Alloc& _Al)
+    _Flat_set_base(_Sorted_t _Tag, const initializer_list<_Kty> _Ilist, const key_compare& _Comp, const _Alloc& _Al)
         : _Flat_set_base(_Tag, _Ilist.begin(), _Ilist.end(), _Comp, _Al) {}
     template <_Usable_allocator_for<container_type> _Alloc>
-    _Flat_set_base(_Sorted_t _Tag, initializer_list<_Kty> _Ilist, const _Alloc& _Al)
+    _Flat_set_base(_Sorted_t _Tag, const initializer_list<_Kty> _Ilist, const _Alloc& _Al)
         : _Flat_set_base(_Tag, _Ilist.begin(), _Ilist.end(), _Al) {}
 
     _Flat_set_base(const _Flat_set_base&) = default;
@@ -241,7 +243,7 @@ public:
         return *this;
     }
 
-    _Derived& operator=(initializer_list<_Kty> _Ilist) {
+    _Derived& operator=(const initializer_list<_Kty> _Ilist) {
         _Clear_guard _Guard{this};
         _Mycont.assign(_Ilist);
         _Make_invariants_fulfilled();
@@ -301,7 +303,7 @@ public:
         }
     }
     template <class... _Args>
-    iterator emplace_hint(const_iterator _Hint, _Args&&... _Vals) {
+    iterator emplace_hint(const const_iterator _Hint, _Args&&... _Vals) {
         constexpr bool _Is_key_type = _In_place_key_extract_set<_Kty, remove_cvref_t<_Args>...>::_Extractable;
         if constexpr (_Is_key_type) {
             return _Emplace_hint(_Hint, _STD forward<_Args>(_Vals)...);
@@ -322,24 +324,24 @@ public:
         return _Emplace(_STD forward<_Other>(_Val));
     }
 
-    iterator insert(const_iterator _Hint, const _Kty& _Val) {
+    iterator insert(const const_iterator _Hint, const _Kty& _Val) {
         return _Emplace_hint(_Hint, _Val);
     }
-    iterator insert(const_iterator _Hint, _Kty&& _Val) {
+    iterator insert(const const_iterator _Hint, _Kty&& _Val) {
         return _Emplace_hint(_Hint, _STD move(_Val));
     }
     template <_Different_from<_Kty> _Other>
         requires _IsUnique && _Transparent<key_compare> && is_constructible_v<_Kty, _Other>
-    iterator insert(const_iterator _Hint, _Other&& _Val) {
+    iterator insert(const const_iterator _Hint, _Other&& _Val) {
         return _Emplace_hint(_Hint, _STD forward<_Other>(_Val));
     }
 
     template <_Iterator_for_container _Iter>
-    void insert(_Iter _First, _Iter _Last) {
+    void insert(const _Iter _First, const _Iter _Last) {
         _Insert_range<true>(_First, _Last);
     }
     template <_Iterator_for_container _Iter>
-    void insert(_Sorted_t, _Iter _First, _Iter _Last) {
+    void insert(_Sorted_t, const _Iter _First, const _Iter _Last) {
         _Insert_range<false>(_First, _Last);
     }
     template <_Container_compatible_range<_Kty> _Rng>
@@ -350,10 +352,10 @@ public:
     void insert_range(_Sorted_t, _Rng&& _Range) {
         _Insert_range<false>(_STD forward<_Rng>(_Range));
     }
-    void insert(initializer_list<_Kty> _Ilist) {
+    void insert(const initializer_list<_Kty> _Ilist) {
         _Insert_range<true>(_Ilist.begin(), _Ilist.end());
     }
-    void insert(_Sorted_t, initializer_list<_Kty> _Ilist) {
+    void insert(_Sorted_t, const initializer_list<_Kty> _Ilist) {
         _Insert_range<false>(_Ilist.begin(), _Ilist.end());
     }
 
@@ -365,7 +367,7 @@ public:
     }
 
     void replace(container_type&& _Cont) {
-        _STL_ASSERT(_Is_sorted(_Cont), _Msg_not_sorted);
+        _STL_ASSERT(_Is_sorted_and_unique(_Cont), _Msg_not_sorted);
         _Clear_guard _Guard{this};
         _Mycont        = _STD move(_Cont);
         _Guard._Target = nullptr;
@@ -375,7 +377,7 @@ public:
     // container doesn't provide the strong guarantee for its "erase" member functions.
 
     // NB: `erase(iterator)` is identical to `erase(const_iterator)`
-    iterator erase(const_iterator _Where) {
+    iterator erase(const const_iterator _Where) {
         return _Mycont.erase(_Where);
     }
     size_type erase(const _Kty& _Val) {
@@ -386,7 +388,7 @@ public:
     size_type erase(_Other&& _Val) {
         return _Erase(_Val);
     }
-    iterator erase(const_iterator _First, const_iterator _Last) {
+    iterator erase(const const_iterator _First, const const_iterator _Last) {
         return _Mycont.erase(_First, _Last);
     }
 
@@ -486,8 +488,12 @@ public:
         _Lhs.swap(_Rhs);
     }
 
+    _NODISCARD bool _Is_sorted_and_unique() const {
+        return _Is_sorted_and_unique(_Mycont);
+    }
+
 private:
-    _NODISCARD bool _Is_sorted(const_iterator _It, const const_iterator _End) const {
+    _NODISCARD bool _Is_sorted_and_unique(const const_iterator _It, const const_iterator _End) const {
         if constexpr (_IsUnique) {
             // sorted-unique
             auto _Negated = [this](const key_type& _Lhs, const key_type& _Rhs) { return !_Compare(_Lhs, _Rhs); };
@@ -497,8 +503,8 @@ private:
         }
     }
 
-    _NODISCARD bool _Is_sorted(const container_type& _Cont) const {
-        return _Is_sorted(_Cont.begin(), _Cont.end());
+    _NODISCARD bool _Is_sorted_and_unique(const container_type& _Cont) const {
+        return _Is_sorted_and_unique(_Cont.begin(), _Cont.end());
     }
 
     template <class _Ty>
@@ -696,13 +702,13 @@ private:
         if constexpr (_NeedSorting) {
             _STD sort(_Old_end, _End, _Pass_comp());
         } else {
-            _STL_INTERNAL_CHECK(_Is_sorted(_Old_end, _End));
+            _STL_ASSERT(_Is_sorted_and_unique(_Old_end, _End), _Msg_not_sorted);
         }
 
         _STD inplace_merge(_Begin, _Old_end, _End, _Pass_comp());
         _Erase_dupes_if_not_multi();
 
-        _STL_INTERNAL_CHECK(_Is_sorted(_Mycont));
+        _STL_INTERNAL_CHECK(_Is_sorted_and_unique());
     }
 
     void _Make_invariants_fulfilled() {
@@ -720,7 +726,7 @@ private:
         _STD inplace_merge(_Begin, _Begin_unsorted, _End, _Pass_comp());
         _Erase_dupes_if_not_multi();
 
-        _STL_INTERNAL_CHECK(_Is_sorted(_Mycont));
+        _STL_INTERNAL_CHECK(_Is_sorted_and_unique());
     }
 
     template <class _Lty, class _Rty>
diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index 8790079811a..40f7786a126 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -243,6 +243,7 @@ void assert_all_requirements(const T& s) {
             }
         }
     }
+    assert(s._Is_sorted_and_unique());
 }
 
 template <class T>

From 8aba27de3fb3972dc56c497c08f977138a6fcd49 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vojt=C4=9Bch=20Michal?= <vojta.michall@email.cz>
Date: Thu, 8 Jan 2026 21:28:00 +0100
Subject: [PATCH 102/134] `<flat_set>`: `flat_set::emplace` and `emplace_hint`
 should be constrained. (#5999)

---
 stl/inc/flat_set | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index 790ab35b20a..7d9c7fbd13d 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -294,7 +294,9 @@ public:
 
     // modifiers
     template <class... _Args>
-    auto emplace(_Args&&... _Vals) {
+    auto emplace(_Args&&... _Vals)
+        requires is_constructible_v<value_type, _Args...>
+    {
         constexpr bool _Is_key_type = _In_place_key_extract_set<_Kty, remove_cvref_t<_Args>...>::_Extractable;
         if constexpr (_Is_key_type) {
             return _Emplace(_STD forward<_Args>(_Vals)...);
@@ -303,7 +305,9 @@ public:
         }
     }
     template <class... _Args>
-    iterator emplace_hint(const const_iterator _Hint, _Args&&... _Vals) {
+    iterator emplace_hint(const const_iterator _Hint, _Args&&... _Vals)
+        requires is_constructible_v<value_type, _Args...>
+    {
         constexpr bool _Is_key_type = _In_place_key_extract_set<_Kty, remove_cvref_t<_Args>...>::_Extractable;
         if constexpr (_Is_key_type) {
             return _Emplace_hint(_Hint, _STD forward<_Args>(_Vals)...);

From f8ff3c63d3469bfd4de03a76704e005eb2adae9d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vojt=C4=9Bch=20Michal?= <vojta.michall@email.cz>
Date: Thu, 8 Jan 2026 21:58:14 +0100
Subject: [PATCH 103/134] `<flat_meow>`: Don't do extra work in `count()`,
 `contains()`, and `equal_range()` (#5994)

Co-authored-by: Stephan T. Lavavej <stl@microsoft.com>
---
 stl/inc/flat_map                          | 80 +++++++++++++----------
 stl/inc/flat_set                          | 38 ++++++++---
 tests/std/tests/P0429R9_flat_map/test.cpp | 34 ++++++++++
 tests/std/tests/P1222R4_flat_set/test.cpp | 34 ++++++++++
 4 files changed, 141 insertions(+), 45 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index a8a72666874..8689d7ce180 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -897,7 +897,7 @@ protected:
         _STL_INTERNAL_STATIC_ASSERT(is_same_v<remove_cvref_t<_OtherKey>, key_type>
                                     || (is_constructible_v<key_type, _OtherKey> && _Transparent<key_compare>) );
 
-        const auto _Key_it = _RANGES upper_bound(_Data.keys, _Key_val, _Pass_key_comp());
+        const auto _Key_it = _STD upper_bound(_Data.keys.begin(), _Data.keys.end(), _Key_val, _Pass_key_comp());
         const auto _Index  = _RANGES distance(_Data.keys.begin(), _Key_it);
         if constexpr (_IsUnique) {
             if (_Key_it != _Data.keys.begin()
@@ -963,22 +963,22 @@ protected:
             return begin() + _Dist;
         }
 
-        const auto _New_position = _Hint_order == weak_ordering::less ? _STD as_const(*this).lower_bound(_Key_val)
-                                                                      : _STD as_const(*this).upper_bound(_Key_val);
+        const auto _New_position = _Iterator_from_key_iterator(
+            _Hint_order == weak_ordering::less
+                ? _STD lower_bound(_Position._Key_it, _STD cend(_Data.keys), _Key_val, _Pass_key_comp())
+                : _STD upper_bound(_STD cbegin(_Data.keys), _Position._Key_it, _Key_val, _Pass_key_comp()));
+
         if constexpr (_IsUnique) {
             if (_Hint_order == weak_ordering::less) {
                 if (_New_position != _End && !_Key_compare(_Key_val, *_New_position._Key_it)) {
-                    const auto _Dist = _New_position._Key_it - _Begin._Key_it;
-                    const auto _It   = begin() + _Dist;
                     if constexpr (_OverwriteIfExists) {
-                        *_It._Mapped_it = mapped_type(_STD forward<_MappedArgTypes>(_Args)...);
+                        *_New_position._Mapped_it = mapped_type(_STD forward<_MappedArgTypes>(_Args)...);
                     }
-                    return _It;
+                    return _New_position;
                 }
             } else {
                 if (_New_position != _Begin && !_Key_compare(*_STD prev(_New_position._Key_it), _Key_val)) {
-                    const auto _Dist = _STD prev(_New_position._Key_it) - _Begin._Key_it;
-                    const auto _It   = begin() + _Dist;
+                    const auto _It = _STD prev(_New_position);
                     if constexpr (_OverwriteIfExists) {
                         *_It._Mapped_it = mapped_type(_STD forward<_MappedArgTypes>(_Args)...);
                     }
@@ -987,7 +987,7 @@ protected:
             }
         }
 
-        const auto _Dist = _New_position - _Begin;
+        const auto _Dist = _New_position - this->begin();
         {
             key_type _Key_to_insert(_STD forward<_OtherKey>(_Key_val));
             mapped_type _Mapped_to_insert(_STD forward<_MappedArgTypes>(_Args)...);
@@ -1161,9 +1161,10 @@ private:
     template <class _SelfTy, class _KeyTy>
     _NODISCARD auto _Find(this _SelfTy& _Self, const _KeyTy& _Key_val) {
         _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
-        const auto _Position = _Self.lower_bound(_Key_val);
-        if (_Position != _Self.end() && !_Self._Key_compare(_Key_val, _Position->first)) {
-            return _Position;
+        const auto _Position =
+            _STD lower_bound(_Self._Data.keys.begin(), _Self._Data.keys.end(), _Key_val, _Self._Pass_key_comp());
+        if (_Position != _Self._Data.keys.end() && !_Self._Key_compare(_Key_val, *_Position)) {
+            return _Self._Iterator_from_key_iterator(_Position);
         } else {
             return _Self.end();
         }
@@ -1172,46 +1173,55 @@ private:
     template <class _KeyTy>
     _NODISCARD size_type _Count(const _KeyTy& _Key_val) const {
         _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
-        return upper_bound(_Key_val) - lower_bound(_Key_val);
+        if constexpr (_IsUnique && is_same_v<_KeyTy, key_type>) { // Optimization restricted due to GH-5992
+            return _Contains(_Key_val);
+        } else {
+            const auto [_First, _Last] =
+                _STD equal_range(_Data.keys.begin(), _Data.keys.end(), _Key_val, _Pass_key_comp());
+            return static_cast<size_type>(_Last - _First);
+        }
     }
 
     template <class _KeyTy>
     _NODISCARD bool _Contains(const _KeyTy& _Key_val) const {
         _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
-        return find(_Key_val) != cend();
-    }
-
-    template <class _SelfTy, class _KeyTy, class _BoundFn>
-    _NODISCARD auto _Find_bound(this _SelfTy& _Self, const _KeyTy& _Key_val, _BoundFn _Bound_fun) {
-        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
-        const auto _Key_unchecked_begin = _STD _Get_unwrapped(_STD cbegin(_Self._Data.keys));
-        const auto _Key_unchecked_it    = _Bound_fun(
-            _Key_unchecked_begin, _STD _Get_unwrapped(_STD cend(_Self._Data.keys)), _Key_val, _Self._Pass_key_comp());
-        const auto _Dist = _Key_unchecked_it - _Key_unchecked_begin;
-
-        auto _Key_it = _STD cbegin(_Self._Data.keys);
-        _STD _Seek_wrapped(_Key_it, _Key_unchecked_it);
-        auto _Val_it =
-            _STD begin(_Self._Data.values) + static_cast<_RANGES range_difference_t<mapped_container_type>>(_Dist);
-
-        using _Maybe_const_iter = conditional_t<is_const_v<_SelfTy>, const_iterator, iterator>;
-        return _Maybe_const_iter{_STD move(_Key_it), _STD move(_Val_it)};
+        return _STD binary_search(_Data.keys.begin(), _Data.keys.end(), _Key_val, _Pass_key_comp());
     }
 
     template <class _SelfTy, class _KeyTy>
     _NODISCARD auto _Lower_bound(this _SelfTy& _Self, const _KeyTy& _Key_val) {
-        return _Self._Find_bound(_Key_val, _RANGES lower_bound);
+        return _Self._Iterator_from_key_iterator(
+            _STD lower_bound(_Self._Data.keys.begin(), _Self._Data.keys.end(), _Key_val, _Self._Pass_key_comp()));
     }
 
     template <class _SelfTy, class _KeyTy>
     _NODISCARD auto _Upper_bound(this _SelfTy& _Self, const _KeyTy& _Key_val) {
-        return _Self._Find_bound(_Key_val, _RANGES upper_bound);
+        return _Self._Iterator_from_key_iterator(
+            _STD upper_bound(_Self._Data.keys.begin(), _Self._Data.keys.end(), _Key_val, _Self._Pass_key_comp()));
     }
 
     template <class _SelfTy, class _KeyTy>
     _NODISCARD auto _Equal_range(this _SelfTy& _Self, const _KeyTy& _Key_val) {
         _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
-        return pair{_Self.lower_bound(_Key_val), _Self.upper_bound(_Key_val)};
+        if constexpr (_IsUnique && is_same_v<_KeyTy, key_type>) { // Optimization restricted due to GH-5992
+            // In a non-multi container, equal_range can have size at most 1
+            const auto _First =
+                _STD lower_bound(_Self._Data.keys.begin(), _Self._Data.keys.end(), _Key_val, _Self._Pass_key_comp());
+            const bool _Missing = _First == _STD end(_Self._Data.keys) || _Self._Key_compare(_Key_val, *_First);
+            return pair{_Self._Iterator_from_key_iterator(_First),
+                _Self._Iterator_from_key_iterator(_Missing ? _First : _STD next(_First))};
+        } else {
+            const auto [_First, _Last] =
+                _STD equal_range(_Self._Data.keys.begin(), _Self._Data.keys.end(), _Key_val, _Self._Pass_key_comp());
+            return pair{_Self._Iterator_from_key_iterator(_First), _Self._Iterator_from_key_iterator(_Last)};
+        }
+    }
+
+    template <class _SelfTy>
+    _NODISCARD conditional_t<is_const_v<_SelfTy>, const_iterator, iterator> _Iterator_from_key_iterator(
+        this _SelfTy& _Self, const key_container_type::const_iterator& _Iter) {
+        const difference_type _Offset = _Iter - _STD cbegin(_Self._Data.keys);
+        return _Self.begin() + _Offset;
     }
 };
 
diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index 7d9c7fbd13d..d860535aae9 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -429,18 +429,12 @@ public:
     }
 
     _NODISCARD size_type count(const _Kty& _Val) const {
-        if constexpr (_IsUnique) {
-            return contains(_Val);
-        } else {
-            const auto [_First, _Last] = equal_range(_Val);
-            return static_cast<size_type>(_Last - _First);
-        }
+        return _Count(_Val);
     }
     template <class _Other>
         requires _Transparent<key_compare>
     _NODISCARD size_type count(const _Other& _Val) const {
-        const auto [_First, _Last] = equal_range(_Val);
-        return static_cast<size_type>(_Last - _First);
+        return _Count(_Val);
     }
 
     _NODISCARD bool contains(const _Kty& _Val) const {
@@ -471,12 +465,12 @@ public:
     }
 
     _NODISCARD pair<const_iterator, const_iterator> equal_range(const _Kty& _Val) const {
-        return _STD equal_range(cbegin(), cend(), _Val, _Pass_comp());
+        return _Equal_range(_Val);
     }
     template <class _Other>
         requires _Transparent<key_compare>
     _NODISCARD pair<const_iterator, const_iterator> equal_range(const _Other& _Val) const {
-        return _STD equal_range(cbegin(), cend(), _Val, _Pass_comp());
+        return _Equal_range(_Val);
     }
 
     _NODISCARD friend bool operator==(const _Derived& _Lhs, const _Derived& _Rhs) {
@@ -687,6 +681,30 @@ private:
         }
     }
 
+    template <class _KeyTy>
+    _NODISCARD size_type _Count(const _KeyTy& _Key_val) const {
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
+        if constexpr (_IsUnique && is_same_v<_KeyTy, key_type>) { // Optimization restricted due to GH-5992
+            return contains(_Key_val);
+        } else {
+            const auto [_First, _Last] = _Equal_range(_Key_val);
+            return static_cast<size_type>(_Last - _First);
+        }
+    }
+
+    template <class _KeyTy>
+    _NODISCARD pair<const_iterator, const_iterator> _Equal_range(const _KeyTy& _Key_val) const {
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
+        if constexpr (_IsUnique && is_same_v<_KeyTy, key_type>) { // Optimization restricted due to GH-5992
+            // In a non-multi container, equal_range can have size at most 1
+            const auto _First   = _STD lower_bound(_Mycont.begin(), _Mycont.end(), _Key_val, _Pass_comp());
+            const bool _Missing = _First == _STD end(_Mycont) || _Mycomp(_Key_val, *_First);
+            return pair{_First, _Missing ? _First : _STD next(_First)};
+        } else {
+            return _STD equal_range(begin(), end(), _Key_val, _Pass_comp());
+        }
+    }
+
     void _Erase_dupes_if_not_multi() {
         if constexpr (_IsUnique) {
             const auto _Equivalent = [this](const _Kty& _Lhs, const _Kty& _Rhs) {
diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index cc5002dca09..3cc8cff261f 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -794,6 +794,39 @@ void test_lookup_call_on_temporaries() {
     }
 }
 
+enum class strange_int {};
+
+// No overload divless::operator()(strange_int, strange_int), does not satisfy std::strict_weak_order
+struct divless {
+    using is_transparent = void;
+
+    template <class X, class Y>
+        requires (is_same_v<X, int> && is_same_v<Y, strange_int>)
+              || (is_same_v<X, strange_int> && is_same_v<Y, int>) || (is_same_v<X, int> && is_same_v<Y, int>)
+    constexpr bool operator()(X x, Y y) const noexcept {
+        if constexpr (is_same_v<X, strange_int>) {
+            return static_cast<int>(x) < y / 10;
+        } else if constexpr (is_same_v<Y, strange_int>) {
+            return x / 10 < static_cast<int>(y);
+        } else {
+            return x < y;
+        }
+    }
+};
+static_assert(!strict_weak_order<divless, int, strange_int>);
+
+// ranges:: algorithms can't be called with divless compare, as it does not satisfy std::strict_weak_order
+void test_generic_count_gh_5992() {
+    {
+        flat_map<int, int, divless> m{{1, 0}, {2, 0}, {11, 0}, {12, 0}};
+        assert(2 == m.count(strange_int{0}));
+    }
+    {
+        flat_multimap<int, int, divless> mm{{1, 0}, {2, 0}, {11, 0}, {12, 0}};
+        assert(2 == mm.count(strange_int{0}));
+    }
+}
+
 int main() {
     test_construction();
     test_pointer_to_incomplete_type();
@@ -805,4 +838,5 @@ int main() {
     test_comparison();
     test_throwing_compare_swap();
     test_lookup_call_on_temporaries();
+    test_generic_count_gh_5992();
 }
diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index 40f7786a126..f3f0fc6eee1 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -1145,6 +1145,39 @@ void test_throwing_compare_swap() {
     test_throwing_compare_single<flat_multiset, deque>();
 }
 
+enum class strange_int {};
+
+// No overload divless::operator()(strange_int, strange_int), does not satisfy std::strict_weak_order
+struct divless {
+    using is_transparent = void;
+
+    template <class X, class Y>
+        requires (is_same_v<X, int> && is_same_v<Y, strange_int>)
+              || (is_same_v<X, strange_int> && is_same_v<Y, int>) || (is_same_v<X, int> && is_same_v<Y, int>)
+    constexpr bool operator()(X x, Y y) const noexcept {
+        if constexpr (is_same_v<X, strange_int>) {
+            return static_cast<int>(x) < y / 10;
+        } else if constexpr (is_same_v<Y, strange_int>) {
+            return x / 10 < static_cast<int>(y);
+        } else {
+            return x < y;
+        }
+    }
+};
+static_assert(!strict_weak_order<divless, int, strange_int>);
+
+// ranges:: algorithms can't be called with divless compare, as it does not satisfy std::strict_weak_order
+void test_generic_count_gh_5992() {
+    {
+        flat_set<int, divless> s{1, 2, 11, 12};
+        assert(2 == s.count(strange_int{0}));
+    }
+    {
+        flat_multiset<int, divless> ms{1, 2, 11, 12};
+        assert(2 == ms.count(strange_int{0}));
+    }
+}
+
 int main() {
     test_spaceship_operator<flat_set<int>>();
     test_spaceship_operator<flat_multiset<int>>();
@@ -1195,4 +1228,5 @@ int main() {
     test_set_operations_transparent<flat_multiset>();
 
     test_throwing_compare_swap();
+    test_generic_count_gh_5992();
 }

From 499235a2a19a43fd5b2275f4a66d96ac17209455 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vojt=C4=9Bch=20Michal?= <vojta.michall@email.cz>
Date: Thu, 8 Jan 2026 22:10:18 +0100
Subject: [PATCH 104/134] `<flat_map>`: Minor cleanups of iterator operations
 in flat_map members `_Erase_if()` etc. (#5996)

Co-authored-by: Stephan T. Lavavej <stl@microsoft.com>
---
 stl/inc/flat_map | 55 ++++++++++++++++++------------------------------
 1 file changed, 21 insertions(+), 34 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index 8689d7ce180..970fd07e77f 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -352,7 +352,7 @@ public:
         key_container_type _Key_cont, mapped_container_type _Mapped_cont, const key_compare& _Comp = key_compare())
         : _Data{.keys = _STD move(_Key_cont), .values = _STD move(_Mapped_cont)}, _Key_compare(_Comp) {
         _STL_ASSERT(_Data.keys.size() == _Data.values.size(), "key_cont.size() != mapped_cont.size()");
-        _Sort_and_erase_dupes_if_not_multi();
+        _Make_invariants_fulfilled();
     }
 
     template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
@@ -367,7 +367,7 @@ public:
               .values = _STD make_obj_using_allocator<mapped_container_type>(_Alloc, _Mapped_cont)},
           _Key_compare(_Comp) {
         _STL_ASSERT(_Data.keys.size() == _Data.values.size(), "key_cont.size() != mapped_cont.size()");
-        _Sort_and_erase_dupes_if_not_multi();
+        _Make_invariants_fulfilled();
     }
 
     _Flat_map_base(_Sorted_t, key_container_type _Key_cont, mapped_container_type _Mapped_cont,
@@ -1024,16 +1024,13 @@ private:
 
     template <class _Predicate>
     _NODISCARD size_type _Erase_if(_Predicate _Pred) {
-        auto _View           = _View_to_mutate();
-        auto _Mut_first      = _View.begin();
-        const auto _Mut_last = _View.end();
-        const auto _Old_size = size();
-
         _Clear_guard _Guard{this};
 
-        _STD _Seek_wrapped(_Mut_first, _RANGES remove_if(_View, _Pred).begin());
-        _Data.keys.erase(_Mut_first._Key_it, _Mut_last._Key_it);
-        _Data.values.erase(_Mut_first._Mapped_it, _Mut_last._Mapped_it);
+        const auto _New_last = _RANGES remove_if(_View_to_mutate(), _Pred).begin();
+        const auto _Old_size = size();
+
+        _Data.keys.erase(_New_last._Key_it, _Data.keys.end());
+        _Data.values.erase(_New_last._Mapped_it, _Data.values.end());
 
         _Guard._Target = nullptr;
         return _Old_size - size();
@@ -1067,42 +1064,34 @@ private:
         return _Is_sorted_and_unique(_Cont.begin(), _Cont.end());
     }
 
-    void _Sort_and_erase_dupes_if_not_multi() {
-        _Clear_guard _Guard{this};
+    void _Make_invariants_fulfilled() {
+        if (empty()) { // FIXME maybe consider if (begin() == end()) for consistency with flat_set
+            return;
+        }
 
         // O(N) if already sorted.
-        const auto _Begin_unsorted =
-            _STD is_sorted_until(_STD cbegin(_Data.keys), _STD cend(_Data.keys), _Pass_key_comp());
-        const difference_type _Num_sorted = _Begin_unsorted - _STD cbegin(_Data.keys);
+        const auto _Num_sorted = _RANGES is_sorted_until(_Data.keys, _Pass_key_comp()) - _Data.keys.begin();
 
         auto _View                        = _View_to_mutate();
-        const auto _Begin                 = _STD begin(_View);
-        const auto _Begin_unsorted_values = _Begin + _Num_sorted;
-        const auto _End                   = _STD end(_View);
+        const auto _Begin_unsorted_values = _STD begin(_View) + _Num_sorted;
 
-        _RANGES sort(_Begin_unsorted_values, _End, value_compare{_Key_compare});
-        _RANGES inplace_merge(_Begin, _Begin_unsorted_values, _End, value_compare{_Key_compare});
+        _RANGES sort(_Begin_unsorted_values, _STD end(_View), value_compare{_Key_compare});
+        _RANGES inplace_merge(_View, _Begin_unsorted_values, value_compare{_Key_compare});
 
         _Erase_dupes_if_not_multi();
 
         _STL_INTERNAL_CHECK(_Is_sorted_and_unique());
-
-        _Guard._Target = nullptr;
     }
 
     void _Erase_dupes_if_not_multi() {
         if constexpr (_IsUnique) {
             auto _Sorted_view    = _View_to_mutate();
-            const auto _Subrange = _RANGES unique(_Sorted_view, [this](const_reference _Left, const_reference _Right) {
+            const auto _New_last = _RANGES unique(_Sorted_view, [this](const_reference _Left, const_reference _Right) {
                 return this->_Key_equal(_Left.first, _Right.first);
-            });
-            const auto _Remaining_count = _Subrange.begin() - _Sorted_view.begin();
-            _Data.keys.erase(
-                _Data.keys.begin() + static_cast<_RANGES range_difference_t<_KeyContainer>>(_Remaining_count),
-                _Data.keys.end());
-            _Data.values.erase(
-                _Data.values.begin() + static_cast<_RANGES range_difference_t<_MappedContainer>>(_Remaining_count),
-                _Data.values.end());
+            }).begin();
+
+            _Data.keys.erase(_New_last._Key_it, _Data.keys.end());
+            _Data.values.erase(_New_last._Mapped_it, _Data.values.end());
         }
     }
 
@@ -1131,9 +1120,7 @@ private:
         // Sort the newly inserted elements
         auto _Sorted_view = _View_to_mutate();
         if constexpr (_NeedSorting) {
-            auto _Sorted_new_elements = _Sorted_view;
-            _Sorted_new_elements.advance(_Old_distance);
-            _RANGES sort(_Sorted_new_elements, value_compare{_Key_compare});
+            _RANGES sort(_STD begin(_Sorted_view) + _Old_distance, _STD end(_Sorted_view), value_compare{_Key_compare});
         } else {
             _STL_ASSERT(_Is_sorted_and_unique(
                             _Data.keys.begin() + static_cast<key_container_type::difference_type>(_Old_distance),

From 7d6bac854fdce8593b7d6cf73410ab9dc58151d7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vojt=C4=9Bch=20Michal?= <vojta.michall@email.cz>
Date: Sun, 11 Jan 2026 23:04:05 +0100
Subject: [PATCH 105/134] `<flat_meow>`: Add tests for all `flat_map`
 constructors, deduction guides and then some (#6000)

Co-authored-by: Stephan T. Lavavej <stl@microsoft.com>
---
 stl/inc/flat_set                              |   2 +-
 .../include/test_container_requirements.hpp   | 189 ++++
 tests/std/tests/P0429R9_flat_map/test.cpp     | 991 +++++++++++++++---
 tests/std/tests/P1222R4_flat_set/test.cpp     | 474 ++++++---
 4 files changed, 1383 insertions(+), 273 deletions(-)
 create mode 100644 tests/std/include/test_container_requirements.hpp

diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index d860535aae9..dd714ed1c50 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -637,7 +637,7 @@ private:
     _NODISCARD size_type _Erase(const _Ty& _Val) {
         _STL_INTERNAL_STATIC_ASSERT(_Transparent<key_compare> || is_same_v<_Ty, _Kty>);
 
-        if constexpr (_IsUnique) {
+        if constexpr (_IsUnique && is_same_v<_Ty, key_type>) { // Optimization restricted due to GH-5992
             const const_iterator _Where = lower_bound(_Val);
             if (_Where != cend() && !_Compare(_Val, *_Where)) {
                 _Mycont.erase(_Where);
diff --git a/tests/std/include/test_container_requirements.hpp b/tests/std/include/test_container_requirements.hpp
new file mode 100644
index 00000000000..cebe64d3ab1
--- /dev/null
+++ b/tests/std/include/test_container_requirements.hpp
@@ -0,0 +1,189 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#pragma once
+
+#include <algorithm>
+#include <cassert>
+#include <compare>
+#include <format>
+#include <iterator>
+#include <print>
+#include <type_traits>
+#include <utility>
+
+// Extracted common functionality from flat_map and flat_set tests.
+// May be extended for other containers if needed.
+
+template <class T>
+void assert_container_requirements(const T& s) {
+    T m = s;
+    assert(m == s);
+
+    static_assert(std::is_same_v<decltype(m = s), T&>);
+    static_assert(std::is_same_v<decltype(m = std::move(m)), T&>);
+    static_assert(std::is_same_v<decltype(m.begin()), typename T::iterator>);
+    static_assert(std::is_same_v<decltype(m.end()), typename T::iterator>);
+    static_assert(std::is_same_v<decltype(s.begin()), typename T::const_iterator>);
+    static_assert(std::is_same_v<decltype(s.end()), typename T::const_iterator>);
+    static_assert(std::is_same_v<decltype(m.cbegin()), typename T::const_iterator>);
+    static_assert(std::is_same_v<decltype(m.cend()), typename T::const_iterator>);
+    static_assert(std::is_same_v<decltype(s.cbegin()), typename T::const_iterator>);
+    static_assert(std::is_same_v<decltype(s.cend()), typename T::const_iterator>);
+    static_assert(std::is_convertible_v<typename T::iterator, typename T::const_iterator>);
+    static_assert(std::is_same_v<decltype(m.begin() <=> m.end()), std::strong_ordering>);
+    static_assert(std::is_same_v<decltype(s.size()), typename T::size_type>);
+    static_assert(std::is_same_v<decltype(s.max_size()), typename T::size_type>);
+    static_assert(std::is_same_v<decltype(*m.begin()), typename T::reference>
+                  || std::is_same_v<decltype(*m.begin()), typename T::const_reference>);
+    static_assert(std::is_same_v<decltype(*m.cbegin()), typename T::const_reference>);
+
+    T my_moved = std::move(m);
+    assert(!(my_moved != s));
+
+    T my_empty{};
+    assert(my_empty.empty());
+
+    T non_empty = s;
+    my_empty.swap(non_empty);
+    assert(non_empty.empty());
+    assert(my_empty == s);
+
+    std::swap(my_empty, non_empty);
+    assert(my_empty.empty());
+    assert(non_empty == s);
+
+    assert(s.cbegin() <= s.cend());
+    assert((s.cbegin() < s.cend()) == !s.empty());
+
+    assert(m.begin() <= m.end());
+    assert((m.begin() < m.end()) == !m.empty());
+
+    assert(static_cast<T::size_type>(s.cend() - s.cbegin()) == s.size());
+}
+
+template <class T>
+void assert_reversible_container_requirements(const T& s) {
+    static_assert(std::is_same_v<std::reverse_iterator<typename T::iterator>, typename T::reverse_iterator>);
+    static_assert(
+        std::is_same_v<std::reverse_iterator<typename T::const_iterator>, typename T::const_reverse_iterator>);
+    static_assert(std::is_same_v<decltype(T{}.rbegin()), typename T::reverse_iterator>);
+    static_assert(std::is_same_v<decltype(T{}.rend()), typename T::reverse_iterator>);
+    static_assert(std::is_same_v<decltype(s.rbegin()), typename T::const_reverse_iterator>);
+    static_assert(std::is_same_v<decltype(s.rend()), typename T::const_reverse_iterator>);
+    static_assert(std::is_same_v<decltype(T{}.crbegin()), typename T::const_reverse_iterator>);
+    static_assert(std::is_same_v<decltype(T{}.crend()), typename T::const_reverse_iterator>);
+    static_assert(std::is_same_v<decltype(s.crbegin()), typename T::const_reverse_iterator>);
+    static_assert(std::is_same_v<decltype(s.crend()), typename T::const_reverse_iterator>);
+    static_assert(std::is_convertible_v<typename T::reverse_iterator, typename T::const_reverse_iterator>);
+}
+
+template <class T>
+concept map_has_nothrow_swappable_containers = requires {
+    typename T::key_container_type;
+    typename T::mapped_container_type;
+    requires std::is_nothrow_swappable_v<typename T::key_container_type>;
+    requires std::is_nothrow_swappable_v<typename T::mapped_container_type>;
+};
+
+template <class T>
+concept set_has_nothrow_swappable_containers = requires {
+    typename T::container_type;
+    requires std::is_nothrow_swappable_v<typename T::container_type>;
+};
+
+template <class T>
+concept has_nothrow_swappable_containers =
+    set_has_nothrow_swappable_containers<T> || map_has_nothrow_swappable_containers<T>;
+
+template <class T>
+void assert_noexcept_requirements(T& s) {
+    static_assert(noexcept(s.begin()));
+    static_assert(noexcept(s.end()));
+    static_assert(noexcept(s.cbegin()));
+    static_assert(noexcept(s.cend()));
+    static_assert(noexcept(s.rbegin()));
+    static_assert(noexcept(s.rend()));
+    static_assert(noexcept(s.crbegin()));
+    static_assert(noexcept(s.crend()));
+
+    static_assert(noexcept(s.empty()));
+    static_assert(noexcept(s.size()));
+    static_assert(noexcept(s.max_size()));
+
+    if constexpr (!std::is_const_v<T>) {
+        constexpr bool is_noexcept =
+            has_nothrow_swappable_containers<T> && std::is_nothrow_swappable_v<typename T::key_compare>;
+        static_assert(noexcept(s.swap(s)) == is_noexcept);
+        static_assert(noexcept(std::ranges::swap(s, s)) == is_noexcept); // using ADL-swap
+        static_assert(noexcept(s.clear()));
+    }
+}
+
+template <bool ExpectedUnique, class T>
+void assert_is_sorted_maybe_unique(const T& s) {
+    const auto val_comp = s.value_comp();
+    const auto begin_it = s.cbegin();
+    const auto end_it   = s.cend();
+
+    // internal check by the container itself
+    assert(s._Is_sorted_and_unique());
+
+    // external check observable by the user
+    assert(std::is_sorted(begin_it, end_it, val_comp));
+    if constexpr (ExpectedUnique) {
+        const auto not_comp  = [&](const auto& left, const auto& right) { return !val_comp(left, right); };
+        const bool is_unique = std::adjacent_find(begin_it, end_it, not_comp) == end_it;
+
+        if constexpr (std::formattable<T, char>) {
+            if (!is_unique) {
+                std::println("Container {} is not unique", s);
+            }
+        }
+        assert(is_unique);
+    }
+}
+
+template <class T>
+void assert_set_requirements() {
+    using iterator        = T::iterator;
+    using const_iterator  = T::const_iterator;
+    using key_type        = T::key_type;
+    using value_type      = T::value_type;
+    using reference       = T::reference;
+    using const_reference = T::const_reference;
+
+    static_assert(std::same_as<std::const_iterator<const_iterator>, const_iterator>);
+    static_assert(std::is_convertible_v<iterator, const_iterator>);
+
+    // additionally:
+    static_assert(std::is_same_v<key_type, value_type>);
+    static_assert(std::same_as<std::const_iterator<iterator>, iterator>);
+    static_assert(std::is_convertible_v<const_iterator, iterator>);
+    static_assert(std::is_same_v<decltype(*std::declval<T>().begin()), const value_type&>);
+    static_assert(std::is_same_v<std::remove_cvref_t<reference>, value_type>);
+    static_assert(std::is_same_v<const_reference, const value_type&>);
+}
+
+template <class T>
+void assert_map_requirements() {
+    using iterator       = T::iterator;
+    using const_iterator = T::const_iterator;
+    using key_type       = T::key_type;
+    using value_type     = T::value_type;
+    using mapped_type    = T::mapped_type;
+
+    static_assert(std::same_as<std::const_iterator<const_iterator>, const_iterator>);
+    static_assert(std::is_convertible_v<iterator, const_iterator>);
+
+    // additionally:
+    static_assert(std::is_same_v<value_type, std::pair<key_type, mapped_type>>);
+}
+
+template <class T>
+void assert_three_way_comparability() {
+    using value_type = T::value_type;
+    if constexpr (std::three_way_comparable<value_type>) {
+        static_assert(std::three_way_comparable<T>);
+    }
+}
diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index 3cc8cff261f..c7e0aba31d0 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -6,14 +6,18 @@
 #include <cassert>
 #include <concepts>
 #include <cstddef>
+#include <cstdlib>
 #include <deque>
 #include <flat_map>
 #include <functional>
 #include <memory>
+#include <print>
 #include <ranges>
 #include <type_traits>
 #include <vector>
 
+#include <test_container_requirements.hpp>
+#include <test_death.hpp>
 using namespace std;
 
 // See GH-5965: Speculative resolution of LWG-3963 "Different flat_(multi)map specializations
@@ -31,45 +35,38 @@ concept IsFlatMap =
     is_specialization_v<remove_cvref_t<T>, flat_map> || is_specialization_v<remove_cvref_t<T>, flat_multimap>;
 
 template <IsFlatMap T>
-bool check_container_requirements(T&&) {
-    return true;
-}
+void assert_all_requirements(const T& s) {
+    assert_container_requirements(s);
+    assert_reversible_container_requirements(s);
+    assert_three_way_comparability<T>();
+    assert_map_requirements<T>();
 
-template <IsFlatMap T>
-consteval bool check_reversible_container_requirements() {
-    using map_t = remove_cvref_t<T>;
-    return is_same_v<reverse_iterator<typename map_t::iterator>, typename map_t::reverse_iterator>
-        && is_same_v<reverse_iterator<typename map_t::const_iterator>, typename map_t::const_reverse_iterator>
-        && is_same_v<decltype(declval<map_t>().begin()), typename map_t::iterator>
-        && is_same_v<decltype(declval<map_t>().end()), typename map_t::iterator>
-        && is_same_v<decltype(declval<map_t>().cbegin()), typename map_t::const_iterator>
-        && is_same_v<decltype(declval<map_t>().cend()), typename map_t::const_iterator>
-        && is_same_v<decltype(declval<map_t>().rbegin()), typename map_t::reverse_iterator>
-        && is_same_v<decltype(declval<map_t>().rend()), typename map_t::reverse_iterator>
-        && is_same_v<decltype(declval<map_t>().crbegin()), typename map_t::const_reverse_iterator>
-        && is_same_v<decltype(declval<map_t>().crend()), typename map_t::const_reverse_iterator>
-        && is_convertible_v<typename map_t::iterator, typename map_t::const_iterator>
-        && is_convertible_v<typename map_t::reverse_iterator, typename map_t::const_reverse_iterator>;
-}
+    assert_noexcept_requirements(s);
+    assert_noexcept_requirements(const_cast<T&>(s));
 
-template <IsFlatMap T>
-constexpr bool check_reversible_container_requirements(T&&) {
-    return check_reversible_container_requirements<T&&>();
+    assert_is_sorted_maybe_unique<_Is_specialization_v<T, flat_map>>(s);
 }
 
 template <IsFlatMap T>
-bool check_requirements(T&& obj) {
-    return check_container_requirements(forward<T>(obj)) && check_reversible_container_requirements(forward<T>(obj));
+[[nodiscard]] bool check_key_content(const T& obj, const typename T::key_container_type& expected) {
+    assert_all_requirements(obj);
+    return ranges::equal(obj.keys(), expected);
 }
 
 template <IsFlatMap T>
-bool check_key_content(const T& obj, const typename T::key_container_type& expected) {
-    return ranges::equal(obj.keys(), expected);
+[[nodiscard]] bool check_value_content(const T& obj, const typename T::mapped_container_type& expected) {
+    return ranges::equal(obj.values(), expected);
 }
 
 template <IsFlatMap T>
-bool check_value_content(const T& obj, const typename T::mapped_container_type& expected) {
-    return ranges::equal(obj.values(), expected);
+[[nodiscard]] bool check_content(const T& obj, const type_identity_t<T>& expected) {
+    assert_all_requirements(obj);
+    if (!ranges::equal(obj, expected)) {
+        println(stderr, "Unexpected content!\nExpected {}", expected);
+        println(stderr, "Actual {}", obj);
+        return false;
+    }
+    return true;
 }
 
 enum class subrange_type : bool {
@@ -89,7 +86,7 @@ struct subrange_t { // represents a closed subrange [first_index, last_index]
 };
 
 template <IsFlatMap T>
-bool check_value_content(
+[[nodiscard]] bool check_value_content(
     const T& obj, const typename T::mapped_container_type& expected, const vector<subrange_t>& subranges) {
     const auto& actual = obj.values();
     if (actual.size() != expected.size()) {
@@ -152,6 +149,26 @@ class MyAllocator : public allocator<T> {
     static inline atomic<size_t> s_allocations{0};
 };
 
+template <class T, class U>
+struct almost_pair {
+    using first_type  = T;
+    using second_type = U;
+
+    T first;
+    U second;
+
+    constexpr operator pair<T, U>() const {
+        return {first, second};
+    }
+};
+
+namespace std {
+    template <class T, class U, size_t N>
+    struct tuple_element<N, almost_pair<T, U>> {
+        using type = conditional_t<N == 1, T, U>;
+    };
+} // namespace std
+
 template <typename T>
 class Packaged {
 private:
@@ -200,141 +217,525 @@ struct TransparentPackagedCompare : PackagedCompare<T> {
     }
 };
 
+struct MyAllocatorCounter {
+    MyAllocatorCounter() : activeAllocations{MyAllocator<int>::getActiveAllocationCount()} {}
+
+    [[nodiscard]] bool check_then_reset() {
+        const bool allocated_some = MyAllocator<int>::getActiveAllocationCount() > activeAllocations;
+        activeAllocations         = MyAllocator<int>::getActiveAllocationCount();
+        return allocated_some;
+    }
+
+    size_t activeAllocations;
+};
+
+struct key_comparer {
+    const auto& extract_key(const auto& obj) const {
+        if constexpr (requires { obj.key; }) {
+            return obj.key;
+        } else {
+            return obj;
+        }
+    }
+
+    bool operator()(const auto& lhs, const auto& rhs) const {
+        return extract_key(lhs) < extract_key(rhs);
+    }
+
+    using is_transparent = int;
+};
+
+template <template <class...> class KeyCont, template <class...> class MappedCont>
 void test_construction() {
+    // Using CTAD, the given MyAllocator is only used by the container when the constructor (deduction guide)
+    // directly accepts KeyContainer and MappedContainer or using two deduction guides:
+    //      flat_map(from_range_t, _Rng&&, _Compare, _Allocator)
+    //      flat_map(from_range_t, _Rng&&, _Allocator)
+    // In other cases we have to fully specify template arguments, such as for flat_map(_Iter, _Iter, _Allocator)
+    using flat_map_my_allocator =
+        flat_map<int, int, less<int>, KeyCont<int, MyAllocator<int>>, MappedCont<int, MyAllocator<int>>>;
+    using flat_multimap_my_allocator =
+        flat_multimap<int, int, less<int>, KeyCont<int, MyAllocator<int>>, MappedCont<int, MyAllocator<int>>>;
+
     {
-        flat_map<int, int> fmap;
-        assert(check_requirements(fmap));
-        assert(check_key_content(fmap, {}));
-        assert(check_value_content(fmap, {}));
-        flat_multimap<int, int> fmmap;
-        assert(check_requirements(fmmap));
-        assert(check_key_content(fmmap, {}));
-        assert(check_value_content(fmmap, {}));
+        // Test flat_map() and flat_map(const key_compare&)
+        const less<int> compare;
+        {
+            flat_map<int, int> fmap;
+            flat_map<int, int> fmap1(compare);
+
+            assert(check_key_content(fmap, {}));
+            assert(check_value_content(fmap, {}));
+            assert(fmap == fmap1);
+        }
+        {
+            flat_multimap<int, int> fmmap;
+            flat_multimap<int, int> fmmap1(compare);
+
+            assert(check_key_content(fmmap, {}));
+            assert(check_value_content(fmmap, {}));
+            assert(fmmap == fmmap1);
+        }
     }
     {
-        vector<int> keys = {0, 1, 2, 3, 4, 2};
-        vector<int> vals = {44, 2324, 635462, 433, 5, 7};
-        flat_map fmap(keys, vals);
-        assert(check_requirements(fmap));
-        assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
-        assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
-        flat_multimap fmmap(keys, vals);
-        assert(check_requirements(fmmap));
-        assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
-        assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5},
-            {
-                {0, 1, subrange_type::equal},
-                {2, 3, subrange_type::permutation},
-                {4, 5, subrange_type::equal},
-            }));
+        // Test flat_map(key_cont, mapped_cont, comp = key_comp())
+        KeyCont<int> keys    = {0, 1, 2, 3, 4, 2};
+        MappedCont<int> vals = {44, 2324, 635462, 433, 5, 7};
+        {
+            flat_map fmap(keys, vals);
+            flat_map fmap1(keys, vals, less<int>{});
+
+            assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
+            assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
+            assert(fmap == fmap1);
+        }
+        {
+            flat_multimap fmmap(keys, vals);
+            flat_multimap fmmap1(keys, vals, less<int>{});
+
+            assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
+            assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5},
+                {
+                    {0, 1, subrange_type::equal},
+                    {2, 3, subrange_type::permutation},
+                    {4, 5, subrange_type::equal},
+                }));
+            assert(fmmap == fmmap1);
+        }
     }
     {
-        vector<int, MyAllocator<int>> keys = {0, 1, 2, 3, 4, 2};
-        vector<int, MyAllocator<int>> vals = {44, 2324, 635462, 433, 5, 7};
-        size_t activeAllocations           = MyAllocator<int>::getActiveAllocationCount();
-        flat_map fmap(keys, vals, MyAllocator<int>());
-        assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
-        assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
-        assert(MyAllocator<int>::getActiveAllocationCount() > activeAllocations);
-        activeAllocations = MyAllocator<int>::getActiveAllocationCount();
-        flat_multimap fmmap(keys, vals); // FIXME, should use MyAllocator<int>(); deduction guides must be constrained
-        assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
-        assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5},
-            {
-                {0, 1, subrange_type::equal},
-                {2, 3, subrange_type::permutation},
-                {4, 5, subrange_type::equal},
-            }));
-        assert(MyAllocator<int>::getActiveAllocationCount() > activeAllocations);
+        // Test flat_map(const key_cont&, const mapped_cont&, const key_comp&, const alloc&)
+        // and  flat_map(const key_cont&, const mapped_cont&, const alloc&)
+        KeyCont<int, MyAllocator<int>> keys    = {0, 1, 2, 3, 4, 2};
+        MappedCont<int, MyAllocator<int>> vals = {44, 2324, 635462, 433, 5, 7};
+        {
+            MyAllocatorCounter allocation_counter;
+            flat_map fmap(keys, vals, MyAllocator<int>{});
+            assert(allocation_counter.check_then_reset());
+            flat_map fmap1(keys, vals, less<int>{}, MyAllocator<int>{});
+            assert(allocation_counter.check_then_reset());
+
+            assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
+            assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
+            assert(fmap == fmap1);
+        }
+        {
+            MyAllocatorCounter allocation_counter;
+            flat_multimap fmmap(keys, vals, MyAllocator<int>{});
+            assert(allocation_counter.check_then_reset());
+            flat_multimap fmmap1(keys, vals, less<int>{}, MyAllocator<int>{});
+            assert(allocation_counter.check_then_reset());
+
+            assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
+            assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5},
+                {
+                    {0, 1, subrange_type::equal},
+                    {2, 3, subrange_type::permutation},
+                    {4, 5, subrange_type::equal},
+                }));
+            assert(fmmap == fmmap1);
+        }
     }
     {
-        static_assert(is_constructible_v<flat_map<int, int>, sorted_unique_t, vector<int>, vector<int>>);
-        vector<int> keys = {0, 1, 2, 3, 38, 242};
-        vector<int> vals = {44, 2324, 635462, 433, 5, 7};
-        flat_map fmap(sorted_unique, keys, vals);
-        assert(check_requirements(fmap));
-        assert(check_key_content(fmap, {0, 1, 2, 3, 38, 242}));
-        assert(check_value_content(fmap, {44, 2324, 635462, 433, 5, 7}));
-        static_assert(!is_constructible_v<flat_multimap<int, int>, sorted_unique_t, vector<int>, vector<int>>);
+        // Test flat_map(_Sorted_t, key_cont, mapped_cont, comp = key_comp())
+        {
+            KeyCont<int> keys    = {0, 1, 2, 3, 38, 242};
+            MappedCont<int> vals = {44, 2324, 635462, 433, 5, 7};
+
+            flat_map fmap(sorted_unique, keys, vals);
+            flat_map fmap1(sorted_unique, keys, vals, less<int>{});
+
+            assert(check_key_content(fmap, {0, 1, 2, 3, 38, 242}));
+            assert(check_value_content(fmap, {44, 2324, 635462, 433, 5, 7}));
+            assert(fmap == fmap1);
+        }
+        {
+            KeyCont<int> keys    = {0, 1, 2, 2, 3, 4};
+            MappedCont<int> vals = {44, 2324, 635462, 7, 433, 5};
+
+            flat_multimap fmmap(sorted_equivalent, keys, vals);
+            flat_multimap fmmap1(sorted_equivalent, keys, vals, less<int>{});
+
+            assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
+            assert(check_value_content(
+                fmmap, {44, 2324, 635462, 7, 433, 5})); // guaranteed by N4971 [flat.multimap.cons]/6
+            assert(fmmap == fmmap1);
+        }
+        {
+            using non_multi = flat_map<int, int, less<int>, KeyCont<int>, MappedCont<int>>;
+            using multi     = flat_multimap<int, int, less<int>, KeyCont<int>, MappedCont<int>>;
+            static_assert(is_constructible_v<non_multi, sorted_unique_t, KeyCont<int>, MappedCont<int>>);
+            static_assert(!is_constructible_v<multi, sorted_unique_t, KeyCont<int>, MappedCont<int>>);
+            static_assert(!is_constructible_v<non_multi, sorted_equivalent_t, KeyCont<int>, MappedCont<int>>);
+            static_assert(is_constructible_v<multi, sorted_equivalent_t, KeyCont<int>, MappedCont<int>>);
+        }
     }
     {
-        static_assert(!is_constructible_v<flat_map<int, int>, sorted_equivalent_t, vector<int>, vector<int>>);
-        static_assert(is_constructible_v<flat_multimap<int, int>, sorted_equivalent_t, vector<int>, vector<int>>);
-        vector<int, MyAllocator<int>> keys = {0, 1, 2, 2, 3, 4};
-        vector<int, MyAllocator<int>> vals = {44, 2324, 635462, 7, 433, 5};
-        flat_multimap fmmap(sorted_equivalent, keys, vals);
-        assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
-        assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5})); // guaranteed by N4971 [flat.multimap.cons]/6
+        // Test flat_map(_Sorted_t, const key_cont&, const mapped_cont&, const key_comp&, const alloc&)
+        // and flat_map(_Sorted_t, const key_cont&, const mapped_cont&, const alloc&)
+        {
+            KeyCont<int, MyAllocator<int>> keys    = {0, 1, 2, 3, 4};
+            MappedCont<int, MyAllocator<int>> vals = {44, 2324, 635462, 433, 5};
+
+            MyAllocatorCounter allocation_counter;
+            flat_map fmap(sorted_unique, keys, vals, MyAllocator<int>{});
+            assert(allocation_counter.check_then_reset());
+            flat_map fmap1(sorted_unique, keys, vals, less<int>{}, MyAllocator<int>{});
+            assert(allocation_counter.check_then_reset());
+
+            assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
+            assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
+            assert(fmap == fmap1);
+        }
+        {
+            KeyCont<int, MyAllocator<int>> keys    = {0, 1, 2, 2, 3, 4};
+            MappedCont<int, MyAllocator<int>> vals = {44, 2324, 635462, 7, 433, 5};
+
+            MyAllocatorCounter allocation_counter;
+            flat_multimap fmmap(sorted_equivalent, keys, vals, MyAllocator<int>{});
+            assert(allocation_counter.check_then_reset());
+            flat_multimap fmmap1(sorted_equivalent, keys, vals, less<int>{}, MyAllocator<int>{});
+            assert(allocation_counter.check_then_reset());
+
+            assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
+            assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5},
+                {
+                    {0, 1, subrange_type::equal},
+                    {2, 3, subrange_type::permutation},
+                    {4, 5, subrange_type::equal},
+                }));
+            assert(fmmap == fmmap1);
+        }
+    }
+    {
+        // Test flat_map(iter, iter, comp = key_compare())
+        almost_pair<int, int> value_types[]{{0, 44}, {1, 2324}, {2, 635462}, {2, 7}, {3, 433}, {4, 5}};
+
+        {
+            flat_map fmap{ranges::begin(value_types), ranges::end(value_types)};
+            flat_map fmap1{ranges::begin(value_types), ranges::end(value_types), less<int>{}};
+
+            assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
+            assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
+            assert(fmap == fmap1);
+        }
+        {
+            flat_multimap fmmap{ranges::begin(value_types), ranges::end(value_types)};
+            flat_multimap fmmap1{ranges::begin(value_types), ranges::end(value_types), less<int>{}};
+
+            assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
+            assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5}));
+            assert(fmmap == fmmap1);
+        }
+    }
+    {
+        // Test flat_map(iter, iter, const key_comp&, const alloc&)
+        // and  flat_map(iter, iter, const alloc&)
+        almost_pair<int, int> value_types[]{{0, 44}, {1, 2324}, {2, 635462}, {2, 7}, {3, 433}, {4, 5}};
+        {
+            MyAllocatorCounter allocation_counter;
+            flat_map_my_allocator fmap{ranges::begin(value_types), ranges::end(value_types), MyAllocator<int>{}};
+            assert(allocation_counter.check_then_reset());
+            flat_map_my_allocator fmap1{
+                ranges::begin(value_types), ranges::end(value_types), less<int>{}, MyAllocator<int>{}};
+            assert(allocation_counter.check_then_reset());
+
+            assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
+            assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
+            assert(fmap == fmap1);
+        }
+        {
+            MyAllocatorCounter allocation_counter;
+            flat_multimap_my_allocator fmmap{ranges::begin(value_types), ranges::end(value_types), MyAllocator<int>{}};
+            assert(allocation_counter.check_then_reset());
+            flat_multimap_my_allocator fmmap1{
+                ranges::begin(value_types), ranges::end(value_types), less<int>{}, MyAllocator<int>{}};
+            assert(allocation_counter.check_then_reset());
+
+            assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
+            assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5}));
+            assert(fmmap == fmmap1);
+        }
+    }
+    {
+        // Test flat_map(from_range_t, _Rng &&, const key_compare&)
+        // and  flat_map(from_range_t, _Rng &&)
+        almost_pair<int, int> value_types[]{{0, 44}, {1, 2324}, {2, 635462}, {2, 7}, {3, 433}, {4, 5}};
+        {
+            flat_map fmap{from_range, value_types};
+            flat_map fmap1{from_range, value_types, less<int>{}};
+
+            assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
+            assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
+            assert(fmap == fmap1);
+        }
+
+        {
+            flat_multimap fmmap{from_range, value_types};
+            flat_multimap fmmap1{from_range, value_types, less<int>{}};
+
+            assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
+            assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5}));
+            assert(fmmap == fmmap1);
+        }
+    }
+    {
+        // Test flat_map(from_range_t, _Rng &&, const key_compare&, const alloc&)
+        // and  flat_map(from_range_t, _Rng &&, const alloc&)
+        // These constructors with allocators have a corresponding deduction guide - can rely on CTAD
+        almost_pair<int, int> value_types[]{{0, 44}, {1, 2324}, {2, 635462}, {2, 7}, {3, 433}, {4, 5}};
+
+        {
+            MyAllocatorCounter allocation_counter;
+            flat_map fmap{from_range, value_types, MyAllocator<int>{}};
+            assert(allocation_counter.check_then_reset());
+            flat_map fmap1{from_range, value_types, less<int>{}, MyAllocator<int>{}};
+            assert(allocation_counter.check_then_reset());
+
+            assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
+            assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
+            assert(fmap == fmap1);
+        }
+        {
+            MyAllocatorCounter allocation_counter;
+            flat_multimap fmmap{from_range, value_types, MyAllocator<int>{}};
+            assert(allocation_counter.check_then_reset());
+            flat_multimap fmmap1{from_range, value_types, less<int>{}, MyAllocator<int>{}};
+            assert(allocation_counter.check_then_reset());
+
+            assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
+            assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5}));
+            assert(fmmap == fmmap1);
+        }
+    }
+    {
+        // Test flat_map(_Sorted_t, iter, iter, comp = key_comp())
+        {
+            almost_pair<int, int> value_types[]{{0, 44}, {1, 2324}, {2, 635462}, {3, 433}, {4, 5}};
+
+            flat_map fmap{sorted_unique, ranges::begin(value_types), ranges::end(value_types)};
+            flat_map fmap1{sorted_unique, ranges::begin(value_types), ranges::end(value_types), less<int>{}};
+
+            assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
+            assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
+            assert(fmap == fmap1);
+        }
+        {
+            almost_pair<int, int> value_types[]{{0, 44}, {1, 2324}, {2, 635462}, {2, 7}, {3, 433}, {4, 5}};
+
+            flat_multimap fmmap{sorted_equivalent, ranges::begin(value_types), ranges::end(value_types)};
+            flat_multimap fmmap1{sorted_equivalent, ranges::begin(value_types), ranges::end(value_types), less<int>{}};
+
+            assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
+            assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5}));
+            assert(fmmap == fmmap1);
+        }
+    }
+    {
+        // Test flat_map(_Sorted_t, iter, iter, const key_comp&, const alloc&)
+        // and flat_map(_Sorted_t, iter, iter, const alloc&)
+        {
+            almost_pair<int, int> value_types[]{{0, 44}, {1, 2324}, {2, 635462}, {3, 433}, {4, 5}};
+
+            MyAllocatorCounter allocation_counter;
+            flat_map_my_allocator fmap{
+                sorted_unique, ranges::begin(value_types), ranges::end(value_types), MyAllocator<int>{}};
+            assert(allocation_counter.check_then_reset());
+            flat_map_my_allocator fmap1{
+                sorted_unique, ranges::begin(value_types), ranges::end(value_types), less<int>{}, MyAllocator<int>{}};
+            assert(allocation_counter.check_then_reset());
+
+            assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
+            assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
+            assert(fmap == fmap1);
+        }
+        {
+            almost_pair<int, int> value_types[]{{0, 44}, {1, 2324}, {2, 635462}, {2, 7}, {3, 433}, {4, 5}};
+
+            MyAllocatorCounter allocation_counter;
+            flat_multimap_my_allocator fmmap{
+                sorted_equivalent, ranges::begin(value_types), ranges::end(value_types), MyAllocator<int>{}};
+            assert(allocation_counter.check_then_reset());
+            flat_multimap_my_allocator fmmap1{sorted_equivalent, ranges::begin(value_types), ranges::end(value_types),
+                less<int>{}, MyAllocator<int>{}};
+            assert(allocation_counter.check_then_reset());
+
+            assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
+            assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5}));
+            assert(fmmap == fmmap1);
+        }
+    }
+    {
+        // Test flat_map(initializer_list, comp = key_comp())
+        {
+            flat_map fmap{{pair{0, 44}, pair{1, 2324}, pair{2, 635462}, pair{2, 7}, pair{3, 433}, pair{4, 5}}};
+            flat_map fmap1{
+                {pair{0, 44}, pair{1, 2324}, pair{2, 635462}, pair{2, 7}, pair{3, 433}, pair{4, 5}}, less<int>{}};
+
+            assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
+            assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
+            assert(fmap == fmap1);
+        }
+        {
+            flat_multimap fmmap{{pair{0, 44}, pair{1, 2324}, pair{2, 635462}, pair{2, 7}, pair{3, 433}, pair{4, 5}}};
+            flat_multimap fmmap1{
+                {pair{0, 44}, pair{1, 2324}, pair{2, 635462}, pair{2, 7}, pair{3, 433}, pair{4, 5}}, less<int>{}};
+
+            assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
+            assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5}));
+            assert(fmmap == fmmap1);
+        }
+    }
+    {
+        // Test flat_map(initializer_list, const key_comp&, const alloc&)
+        // and  flat_map(initializer_list, const alloc&)
+        {
+            MyAllocatorCounter allocation_counter;
+            flat_map_my_allocator fmap{{{0, 44}, {1, 2324}, {2, 635462}, {2, 7}, {3, 433}, {4, 5}}, MyAllocator<int>{}};
+            assert(allocation_counter.check_then_reset());
+            flat_map_my_allocator fmap1{
+                {{0, 44}, {1, 2324}, {2, 635462}, {2, 7}, {3, 433}, {4, 5}}, less<int>{}, MyAllocator<int>{}};
+            assert(allocation_counter.check_then_reset());
+
+            assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
+            assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
+            assert(fmap == fmap1);
+        }
+        {
+            MyAllocatorCounter allocation_counter;
+            flat_multimap_my_allocator fmmap{
+                {{0, 44}, {1, 2324}, {2, 635462}, {2, 7}, {3, 433}, {4, 5}}, MyAllocator<int>{}};
+            assert(allocation_counter.check_then_reset());
+            flat_multimap_my_allocator fmmap1{
+                {{0, 44}, {1, 2324}, {2, 635462}, {2, 7}, {3, 433}, {4, 5}}, less<int>{}, MyAllocator<int>{}};
+            assert(allocation_counter.check_then_reset());
+
+            assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
+            assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5}));
+            assert(fmmap == fmmap1);
+        }
     }
-    // FIXME, test more flat_map and flat_multimap constructors
+    {
+        // Test flat_map(_Sorted_t, initializer_list, comp = key_comp())
+        {
+            flat_map fmap{sorted_unique, {pair{0, 44}, pair{1, 2324}, pair{2, 635462}, pair{3, 433}, pair{4, 5}}};
+            flat_map fmap1{
+                sorted_unique, {pair{0, 44}, pair{1, 2324}, pair{2, 635462}, pair{3, 433}, pair{4, 5}}, less<int>{}};
+
+            assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
+            assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
+            assert(fmap == fmap1);
+        }
+        {
+            flat_multimap fmmap{
+                sorted_equivalent, {pair{0, 44}, pair{1, 2324}, pair{2, 635462}, pair{2, 7}, pair{3, 433}, pair{4, 5}}};
+            flat_multimap fmmap1{sorted_equivalent,
+                {pair{0, 44}, pair{1, 2324}, pair{2, 635462}, pair{2, 7}, pair{3, 433}, pair{4, 5}}, less<int>{}};
+
+            assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
+            assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5}));
+            assert(fmmap == fmmap1);
+        }
+    }
+    {
+        // Test flat_map(_Sorted_t, initializer_list, const key_comp&, const alloc&)
+        // and  flat_map(_Sorted_t, initializer_list, const alloc&)
+        {
+            MyAllocatorCounter allocation_counter;
+            flat_map_my_allocator fmap{
+                sorted_unique, {{0, 44}, {1, 2324}, {2, 635462}, {3, 433}, {4, 5}}, MyAllocator<int>{}};
+            assert(allocation_counter.check_then_reset());
+            flat_map_my_allocator fmap1{
+                sorted_unique, {{0, 44}, {1, 2324}, {2, 635462}, {3, 433}, {4, 5}}, less<int>{}, MyAllocator<int>{}};
+            assert(allocation_counter.check_then_reset());
+
+            assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
+            assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
+            assert(fmap == fmap1);
+        }
+        {
+            MyAllocatorCounter allocation_counter;
+            flat_multimap_my_allocator fmmap{
+                sorted_equivalent, {{0, 44}, {1, 2324}, {2, 635462}, {2, 7}, {3, 433}, {4, 5}}, MyAllocator<int>{}};
+            assert(allocation_counter.check_then_reset());
+            flat_multimap_my_allocator fmmap1{sorted_equivalent,
+                {{0, 44}, {1, 2324}, {2, 635462}, {2, 7}, {3, 433}, {4, 5}}, less<int>{}, MyAllocator<int>{}};
+            assert(allocation_counter.check_then_reset());
+
+            assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
+            assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5}));
+            assert(fmmap == fmmap1);
+        }
+    }
+    // FIXME, verify that all flat_map and flat_multimap constructors are tested
     {
         PackagedCompare<int> comp;
-        flat_map<Packaged<int>, int, PackagedCompare<int>> fmap(comp);
-        assert(check_requirements(fmap));
-        assert(check_key_content(fmap, {}));
-        assert(check_value_content(fmap, {}));
-        flat_multimap<Packaged<int>, int, PackagedCompare<int>> fmmap(comp);
-        assert(check_requirements(fmmap));
-        assert(check_key_content(fmmap, {}));
-        assert(check_value_content(fmmap, {}));
+        {
+            flat_map<Packaged<int>, int, PackagedCompare<int>> fmap;
+            flat_map<Packaged<int>, int, PackagedCompare<int>> fmap1(comp);
+
+            assert(check_key_content(fmap, {}));
+            assert(check_value_content(fmap, {}));
+            assert(fmap == fmap1);
+        }
+        {
+            flat_multimap<Packaged<int>, int, PackagedCompare<int>> fmmap;
+            flat_multimap<Packaged<int>, int, PackagedCompare<int>> fmmap1(comp);
+
+            assert(check_key_content(fmmap, {}));
+            assert(check_value_content(fmmap, {}));
+            assert(fmmap == fmmap1);
+        }
     }
     {
         PackagedCompare<int> comp;
         MyAllocator<Packaged<int>> alloc;
-        flat_map<Packaged<int>, Packaged<int>, PackagedCompare<int>, vector<Packaged<int>, MyAllocator<Packaged<int>>>,
-            vector<Packaged<int>, MyAllocator<Packaged<int>>>>
+        flat_map<Packaged<int>, Packaged<int>, PackagedCompare<int>, KeyCont<Packaged<int>, MyAllocator<Packaged<int>>>,
+            MappedCont<Packaged<int>, MyAllocator<Packaged<int>>>>
             fmap(comp, alloc);
-        assert(check_requirements(fmap));
         assert(check_key_content(fmap, {}));
         assert(check_value_content(fmap, {}));
         flat_multimap<Packaged<int>, Packaged<int>, PackagedCompare<int>,
-            vector<Packaged<int>, MyAllocator<Packaged<int>>>, vector<Packaged<int>, MyAllocator<Packaged<int>>>>
+            KeyCont<Packaged<int>, MyAllocator<Packaged<int>>>, MappedCont<Packaged<int>, MyAllocator<Packaged<int>>>>
             fmmap(comp, alloc);
-        assert(check_requirements(fmmap));
         assert(check_key_content(fmmap, {}));
         assert(check_value_content(fmmap, {}));
     }
     {
         MyAllocator<Packaged<int>> alloc;
-        flat_map<Packaged<int>, Packaged<int>, PackagedCompare<int>, vector<Packaged<int>, MyAllocator<Packaged<int>>>,
-            vector<Packaged<int>, MyAllocator<Packaged<int>>>>
+        flat_map<Packaged<int>, Packaged<int>, PackagedCompare<int>, KeyCont<Packaged<int>, MyAllocator<Packaged<int>>>,
+            MappedCont<Packaged<int>, MyAllocator<Packaged<int>>>>
             fmap(alloc);
-        assert(check_requirements(fmap));
         assert(check_key_content(fmap, {}));
         assert(check_value_content(fmap, {}));
         flat_multimap<Packaged<int>, Packaged<int>, PackagedCompare<int>,
-            vector<Packaged<int>, MyAllocator<Packaged<int>>>, vector<Packaged<int>, MyAllocator<Packaged<int>>>>
+            KeyCont<Packaged<int>, MyAllocator<Packaged<int>>>, MappedCont<Packaged<int>, MyAllocator<Packaged<int>>>>
             fmmap(alloc);
-        assert(check_requirements(fmmap));
         assert(check_key_content(fmmap, {}));
         assert(check_value_content(fmmap, {}));
     }
     {
         MyAllocator<Packaged<int>> alloc;
-        flat_map<Packaged<int>, int, PackagedCompare<int>, vector<Packaged<int>, MyAllocator<Packaged<int>>>,
-            vector<int, MyAllocator<int>>>
+        flat_map<Packaged<int>, int, PackagedCompare<int>, KeyCont<Packaged<int>, MyAllocator<Packaged<int>>>,
+            MappedCont<int, MyAllocator<int>>>
             fmap(alloc);
-        assert(check_requirements(fmap));
         assert(check_key_content(fmap, {}));
         assert(check_value_content(fmap, {}));
-        flat_multimap<Packaged<int>, int, PackagedCompare<int>, vector<Packaged<int>, MyAllocator<Packaged<int>>>,
-            vector<int, MyAllocator<int>>>
+        flat_multimap<Packaged<int>, int, PackagedCompare<int>, KeyCont<Packaged<int>, MyAllocator<Packaged<int>>>,
+            MappedCont<int, MyAllocator<int>>>
             fmmap(alloc);
-        assert(check_requirements(fmmap));
         assert(check_key_content(fmmap, {}));
         assert(check_value_content(fmmap, {}));
     }
     {
         PackagedCompare<int> comp;
         MyAllocator<int> alloc;
-        vector<Packaged<int>, MyAllocator<Packaged<int>>> keys = {0, 1, 2, 3, 4, 2};
-        vector<int, MyAllocator<int>> vals                     = {44, 2324, 635462, 433, 5, 7};
+        KeyCont<Packaged<int>, MyAllocator<Packaged<int>>> keys = {0, 1, 2, 3, 4, 2};
+        MappedCont<int, MyAllocator<int>> vals                  = {44, 2324, 635462, 433, 5, 7};
         flat_map fmap(keys, vals, comp, alloc);
-        assert(check_requirements(fmap));
         assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
         assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
         flat_multimap fmmap(keys, vals, comp, alloc);
-        assert(check_requirements(fmmap));
         assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
         assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5},
             {
@@ -346,14 +747,12 @@ void test_construction() {
     {
         TransparentPackagedCompare<int> comp;
         MyAllocator<int> alloc;
-        vector<Packaged<int>, MyAllocator<Packaged<int>>> keys = {0, 1, 2, 3, 4, 2};
-        vector<int, MyAllocator<int>> vals                     = {44, 2324, 635462, 433, 5, 7};
+        KeyCont<Packaged<int>, MyAllocator<Packaged<int>>> keys = {0, 1, 2, 3, 4, 2};
+        MappedCont<int, MyAllocator<int>> vals                  = {44, 2324, 635462, 433, 5, 7};
         flat_map fmap(keys, vals, comp, alloc);
-        assert(check_requirements(fmap));
         assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
         assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
         flat_multimap fmmap(keys, vals, comp, alloc);
-        assert(check_requirements(fmmap));
         assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
         assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5},
             {
@@ -366,14 +765,14 @@ void test_construction() {
     {
         allocator<int> ator;
 
-        using fm = flat_map<int, int, less<>, vector<int>, vector<int>>;
+        using fm = flat_map<int, int, less<>, KeyCont<int>, MappedCont<int>>;
         fm m0;
         fm m1(m0);
         fm m2(m0, ator);
         fm m3(move(m0));
         fm m4(move(m1), ator);
 
-        using fmm = flat_multimap<int, int, less<>, vector<int>, vector<int>>;
+        using fmm = flat_multimap<int, int, less<>, KeyCont<int>, MappedCont<int>>;
         fmm mm0;
         fmm mm1(mm0);
         fmm mm2(mm0, ator);
@@ -382,10 +781,11 @@ void test_construction() {
     }
 }
 
+template <template <class...> class KeyCont, template <class...> class MappedCont>
 void test_erase_if() {
     {
-        vector<int> keys      = {0, 1, 2, 3, 4, 2};
-        vector<int> vals      = {44, 2324, 635462, 433, 5, 7};
+        KeyCont<int> keys     = {0, 1, 2, 3, 4, 2};
+        MappedCont<int> vals  = {44, 2324, 635462, 433, 5, 7};
         auto even_key_odd_val = [](pair<const int&, const int&> p) { return p.first % 2 == 0 && p.second % 2 != 0; };
         flat_map fmap(keys, vals);
         const auto erased_num = erase_if(fmap, even_key_odd_val);
@@ -687,6 +1087,29 @@ void test_comparison() {
     }
 }
 
+template <template <class...> class Map>
+void test_map_operations_transparent() {
+    struct shouldnt_convert {
+        int key;
+        /* implicit */ [[noreturn]] operator int() const {
+            abort();
+        }
+    };
+
+    Map<int, char, key_comparer> fm{{0, 'a'}, {3, 'g'}, {5, 't'}};
+    assert(check_key_content(fm, {0, 3, 5}));
+    assert(check_value_content(fm, {'a', 'g', 't'}));
+
+    assert(fm.find(shouldnt_convert{0}) != fm.end());
+    assert(fm.count(shouldnt_convert{3}) == 1);
+    assert(!fm.contains(shouldnt_convert{1}));
+    assert(fm.lower_bound(shouldnt_convert{-1}) == fm.begin());
+    assert(fm.lower_bound(shouldnt_convert{8}) == fm.end());
+    assert(fm.upper_bound(shouldnt_convert{2}) == fm.find(3));
+    auto [first, last] = fm.equal_range(shouldnt_convert{5});
+    assert(first + 1 == last);
+}
+
 namespace test_throwing_swap {
     struct unique_exception {};
 
@@ -759,18 +1182,6 @@ void test_throwing_compare_swap_single() {
     }
 }
 
-void test_throwing_compare_swap() {
-    test_throwing_compare_swap_single<flat_map, vector, vector>();
-    test_throwing_compare_swap_single<flat_map, vector, deque>();
-    test_throwing_compare_swap_single<flat_map, deque, vector>();
-    test_throwing_compare_swap_single<flat_map, deque, deque>();
-
-    test_throwing_compare_swap_single<flat_multimap, vector, vector>();
-    test_throwing_compare_swap_single<flat_multimap, vector, deque>();
-    test_throwing_compare_swap_single<flat_multimap, deque, vector>();
-    test_throwing_compare_swap_single<flat_multimap, deque, deque>();
-}
-
 // Test that changes in GH-5987 did not break calls of lookup member functions by using deducing this.
 template <typename T>
 void test_lookup_call_on_temporaries_single() {
@@ -794,6 +1205,79 @@ void test_lookup_call_on_temporaries() {
     }
 }
 
+// Test that hint to emplace/insert is respected, when possible; check returned iterator
+template <template <class...> class KeyC, template <class...> class ValueC>
+void test_insert_hint_is_respected() {
+    using lt = std::less<int>;
+
+    {
+        flat_multimap<int, char, lt, KeyC<int>, ValueC<char>> a{{-1, 'x'}, {-1, 'x'}, {1, 'x'}, {1, 'x'}};
+        bool problem_seen                      = false;
+        const auto assert_inserted_at_position = [&a, &problem_seen](
+                                                     const int expected_index, const auto insert_position) {
+            const auto expected_position = a.begin() + expected_index;
+            if (expected_position != insert_position) {
+                println("Wrong insert position: expected {}, actual {}\nContainer after insert {}", expected_index,
+                    insert_position - a.begin(), a);
+                problem_seen = true;
+            }
+        };
+
+        struct pseudopair {
+            int i;
+            char c;
+
+            operator pair<int, char>() const {
+                return pair{i, c};
+            }
+        };
+
+        pair pair0c{0, 'c'};
+        const pair pair0f{0, 'f'};
+        // hint is greater
+        assert(check_content(a, {{-1, 'x'}, {-1, 'x'}, {1, 'x'}, {1, 'x'}}));
+        assert_inserted_at_position(2, a.emplace_hint(a.end(), 0, 'a'));
+        assert(check_content(a, {{-1, 'x'}, {-1, 'x'}, {0, 'a'}, {1, 'x'}, {1, 'x'}}));
+        assert_inserted_at_position(3, a.emplace_hint(a.find(1), pair{0, 'b'}));
+        assert(check_content(a, {{-1, 'x'}, {-1, 'x'}, {0, 'a'}, {0, 'b'}, {1, 'x'}, {1, 'x'}}));
+        assert_inserted_at_position(4, a.insert(a.upper_bound(0), std::move(pair0c)));
+        assert(check_content(a, {{-1, 'x'}, {-1, 'x'}, {0, 'a'}, {0, 'b'}, {0, 'c'}, {1, 'x'}, {1, 'x'}}));
+        // hint is correct
+        assert_inserted_at_position(4, a.emplace_hint(a.upper_bound(0) - 1, 0, 'd'));
+        assert(check_content(a, {{-1, 'x'}, {-1, 'x'}, {0, 'a'}, {0, 'b'}, {0, 'd'}, {0, 'c'}, {1, 'x'}, {1, 'x'}}));
+        assert_inserted_at_position(3, a.emplace_hint(a.begin() + 3, pseudopair{0, 'e'}));
+        assert(check_content(
+            a, {{-1, 'x'}, {-1, 'x'}, {0, 'a'}, {0, 'e'}, {0, 'b'}, {0, 'd'}, {0, 'c'}, {1, 'x'}, {1, 'x'}}));
+        assert_inserted_at_position(2, a.insert(a.lower_bound(0), pair0f));
+        assert(check_content(
+            a, {{-1, 'x'}, {-1, 'x'}, {0, 'f'}, {0, 'a'}, {0, 'e'}, {0, 'b'}, {0, 'd'}, {0, 'c'}, {1, 'x'}, {1, 'x'}}));
+        // hint is less
+        assert_inserted_at_position(2, a.emplace_hint(a.lower_bound(0) - 1, pair{0, 'g'}));
+        assert(check_content(a, {{-1, 'x'}, {-1, 'x'}, {0, 'g'}, {0, 'f'}, {0, 'a'}, {0, 'e'}, {0, 'b'}, {0, 'd'},
+                                    {0, 'c'}, {1, 'x'}, {1, 'x'}}));
+        assert_inserted_at_position(2, a.insert(a.begin(), pseudopair{0, 'h'}));
+        assert(check_content(a, {{-1, 'x'}, {-1, 'x'}, {0, 'h'}, {0, 'g'}, {0, 'f'}, {0, 'a'}, {0, 'e'}, {0, 'b'},
+                                    {0, 'd'}, {0, 'c'}, {1, 'x'}, {1, 'x'}}));
+
+        assert(!problem_seen);
+
+        assert(4 == erase_if(a, [](const auto pair) { return pair.second <= 'd'; }));
+        assert(check_content(a, {{-1, 'x'}, {-1, 'x'}, {0, 'h'}, {0, 'g'}, {0, 'f'}, {0, 'e'}, {1, 'x'}, {1, 'x'}}));
+        assert(4 == a.erase(0));
+        assert(check_content(a, {{-1, 'x'}, {-1, 'x'}, {1, 'x'}, {1, 'x'}}));
+    }
+}
+
+template <template <class...> class KeyCont, template <class...> class MappedCont>
+void test_key_mapped_cont_combinations() {
+    test_construction<KeyCont, MappedCont>();
+    test_insert_hint_is_respected<KeyCont, MappedCont>();
+    test_throwing_compare_swap_single<flat_map, KeyCont, MappedCont>();
+    test_throwing_compare_swap_single<flat_multimap, KeyCont, MappedCont>();
+    test_erase_if<KeyCont, MappedCont>();
+}
+
+// Test heterogeneous lookup and erase operations when the compare object does not satisfy strict_weak_order (GH-5992)
 enum class strange_int {};
 
 // No overload divless::operator()(strange_int, strange_int), does not satisfy std::strict_weak_order
@@ -816,27 +1300,248 @@ struct divless {
 static_assert(!strict_weak_order<divless, int, strange_int>);
 
 // ranges:: algorithms can't be called with divless compare, as it does not satisfy std::strict_weak_order
-void test_generic_count_gh_5992() {
+void test_non_strict_weak_order_compare() {
     {
-        flat_map<int, int, divless> m{{1, 0}, {2, 0}, {11, 0}, {12, 0}};
-        assert(2 == m.count(strange_int{0}));
+        flat_map<int, int, divless> cont{{1, 0}, {2, 0}, {11, 0}, {12, 0}};
+        assert(2 == cont.count(strange_int{0}));
+
+        assert(cont.contains(strange_int{0}));
+        assert(!cont.contains(strange_int{2}));
+
+        assert(cont.begin() + 2 == cont.lower_bound(strange_int{1}));
+        assert(cont.begin() + 2 == cont.upper_bound(strange_int{0}));
+
+        const auto [first, last] = cont.equal_range(strange_int{0});
+        assert(first == cont.begin());
+        assert(last == cont.begin() + 2);
+
+        assert(cont.end() != cont.find(strange_int{1}));
+        assert(cont.end() == cont.find(strange_int{3}));
+
+        assert(2 == cont.erase(strange_int{0}));
+        assert(check_content(cont, {{11, 0}, {12, 0}}));
     }
     {
-        flat_multimap<int, int, divless> mm{{1, 0}, {2, 0}, {11, 0}, {12, 0}};
-        assert(2 == mm.count(strange_int{0}));
+        flat_multimap<int, int, divless> cont{{1, 0}, {2, 0}, {11, 0}, {12, 0}};
+        assert(2 == cont.count(strange_int{0}));
+
+        assert(cont.contains(strange_int{0}));
+        assert(!cont.contains(strange_int{2}));
+
+        assert(cont.begin() + 2 == cont.lower_bound(strange_int{1}));
+        assert(cont.begin() + 2 == cont.upper_bound(strange_int{0}));
+
+        const auto [first, last] = cont.equal_range(strange_int{0});
+        assert(first == cont.begin());
+        assert(last == cont.begin() + 2);
+
+        assert(cont.end() != cont.find(strange_int{1}));
+        assert(cont.end() == cont.find(strange_int{3}));
+
+        assert(2 == cont.erase(strange_int{0}));
+        assert(check_content(cont, {{11, 0}, {12, 0}}));
     }
 }
 
-int main() {
-    test_construction();
+void run_normal_tests() {
+    test_key_mapped_cont_combinations<vector, vector>();
+    test_key_mapped_cont_combinations<vector, deque>();
+    test_key_mapped_cont_combinations<deque, vector>();
+    test_key_mapped_cont_combinations<deque, deque>();
     test_pointer_to_incomplete_type();
-    test_erase_if();
     test_insert();
     test_insert_range();
     test_gh_4344();
     test_insert_or_assign();
     test_comparison();
-    test_throwing_compare_swap();
+
+    test_map_operations_transparent<flat_map>();
+    test_map_operations_transparent<flat_multimap>();
+
     test_lookup_call_on_temporaries();
-    test_generic_count_gh_5992();
+    test_non_strict_weak_order_compare();
+}
+
+enum class cont_type { multi, unique };
+
+template <cont_type type>
+void test_death_construct_unsorted_initializer_list() {
+    using C = conditional_t<type == cont_type::unique, flat_map<int, char>, flat_multimap<int, char>>;
+    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
+    C cont(sorted, {{137, 'a'}, {42, 'g'}, {3337, 'f'}, {15, 'r'}});
+}
+
+template <cont_type type>
+void test_death_construct_unsorted_iter_iter() {
+    using C = conditional_t<type == cont_type::unique, flat_map<int, char>, flat_multimap<int, char>>;
+    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
+    vector<typename C::value_type> values{{137, 'a'}, {42, 'g'}, {3337, 'f'}, {15, 'r'}};
+    C cont(sorted, values.begin(), values.end());
+}
+
+template <cont_type type>
+void test_death_construct_unsorted_container() {
+    using C = conditional_t<type == cont_type::unique, flat_map<int, char>, flat_multimap<int, char>>;
+    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
+    typename C::key_container_type keys{137, 42, 3337, 15};
+    typename C::mapped_container_type mapped{'a', 'g', 'f', 'r'};
+    C cont(sorted, keys, mapped);
+}
+
+template <cont_type type>
+void test_death_replace_unsorted_container() {
+    using C = conditional_t<type == cont_type::unique, flat_map<int, char>, flat_multimap<int, char>>;
+    C cont;
+    cont.replace({137, 42, 3337, 15}, {'a', 'g', 'f', 'r'});
+}
+
+template <cont_type type>
+void test_death_insert_unsorted_iter_iter() {
+    using C = conditional_t<type == cont_type::unique, flat_map<int, char>, flat_multimap<int, char>>;
+    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
+    vector<typename C::value_type> values{{137, 'a'}, {42, 'g'}, {3337, 'f'}, {15, 'r'}};
+    C cont;
+    cont.insert(sorted, values.begin(), values.end());
+}
+
+template <cont_type type>
+void test_death_insert_unsorted_range() {
+    using C = conditional_t<type == cont_type::unique, flat_map<int, char>, flat_multimap<int, char>>;
+    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
+    vector<typename C::value_type> values{{137, 'a'}, {42, 'g'}, {3337, 'f'}, {15, 'r'}};
+    C cont;
+    cont.insert_range(sorted, values);
+}
+
+template <cont_type type>
+void test_death_insert_unsorted_initializer_list() {
+    using C = conditional_t<type == cont_type::unique, flat_map<int, char>, flat_multimap<int, char>>;
+    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
+    C cont;
+    cont.insert(sorted, {{137, 'a'}, {42, 'g'}, {3337, 'f'}, {15, 'r'}});
+}
+
+template <cont_type type>
+void test_death_construct_duplicates_initializer_list() {
+    using C = conditional_t<type == cont_type::unique, flat_map<int, char>, flat_multimap<int, char>>;
+    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
+    C cont(sorted, {{42, 'a'}, {137, 'g'}, {137, 'f'}, {3337, 'r'}});
+}
+
+template <cont_type type>
+void test_death_construct_duplicates_iter_iter() {
+    using C = conditional_t<type == cont_type::unique, flat_map<int, char>, flat_multimap<int, char>>;
+    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
+    vector<typename C::value_type> values{{42, 'a'}, {137, 'g'}, {137, 'f'}, {3337, 'r'}};
+    C cont(sorted, values.begin(), values.end());
+}
+
+template <cont_type type>
+void test_death_construct_duplicates_container() {
+    using C = conditional_t<type == cont_type::unique, flat_map<int, char>, flat_multimap<int, char>>;
+    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
+    typename C::key_container_type keys{42, 137, 137, 3337};
+    typename C::mapped_container_type mapped{'a', 'g', 'f', 'r'};
+    C cont(sorted, keys, mapped);
+}
+
+template <cont_type type>
+void test_death_replace_duplicates_container() {
+    using C = conditional_t<type == cont_type::unique, flat_map<int, char>, flat_multimap<int, char>>;
+    C cont;
+    cont.replace({42, 137, 137, 3337}, {'a', 'g', 'f', 'r'});
+}
+
+template <cont_type type>
+void test_death_insert_duplicates_iter_iter() {
+    using C = conditional_t<type == cont_type::unique, flat_map<int, char>, flat_multimap<int, char>>;
+    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
+    vector<typename C::value_type> values{{42, 'a'}, {137, 'g'}, {137, 'f'}, {3337, 'r'}};
+    C cont;
+    cont.insert(sorted, values.begin(), values.end());
+}
+
+template <cont_type type>
+void test_death_insert_duplicates_range() {
+    using C = conditional_t<type == cont_type::unique, flat_map<int, char>, flat_multimap<int, char>>;
+    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
+    vector<typename C::value_type> values{{42, 'a'}, {137, 'g'}, {137, 'f'}, {3337, 'r'}};
+    C cont;
+    cont.insert_range(sorted, values);
+}
+
+template <cont_type type>
+void test_death_insert_duplicates_initializer_list() {
+    using C = conditional_t<type == cont_type::unique, flat_map<int, char>, flat_multimap<int, char>>;
+    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
+    C cont;
+    cont.insert(sorted, {{42, 'a'}, {137, 'g'}, {137, 'f'}, {3337, 'r'}});
+}
+
+template <cont_type type>
+void test_death_different_size_ctor() {
+    using C = conditional_t<type == cont_type::unique, flat_map<int, char>, flat_multimap<int, char>>;
+    typename C::key_container_type keys{42, 137, 137, 3337, 0};
+    typename C::mapped_container_type mapped{'a'};
+    C cont(keys, mapped);
+}
+
+template <cont_type type>
+void test_death_different_size_ctor_sorted() {
+    using C = conditional_t<type == cont_type::unique, flat_map<int, char>, flat_multimap<int, char>>;
+    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
+    typename C::key_container_type keys{42, 137, 137, 3337, 0};
+    typename C::mapped_container_type mapped{'a'};
+    C cont(sorted, keys, mapped);
+}
+
+template <cont_type type>
+void test_death_different_size_replace() {
+    using C = conditional_t<type == cont_type::unique, flat_map<int, char>, flat_multimap<int, char>>;
+    C cont;
+    cont.replace({42, 137, 137, 3337, 0}, {'a'});
+}
+
+int main(int argc, char* argv[]) {
+    std_testing::death_test_executive exec([] { run_normal_tests(); });
+
+#if defined(_DEBUG)
+    exec.add_death_tests({
+
+        // Tests shared between flat_set and flat_map - violation of sorted elements
+        test_death_construct_unsorted_initializer_list<cont_type::unique>,
+        test_death_construct_unsorted_initializer_list<cont_type::multi>,
+        test_death_construct_unsorted_iter_iter<cont_type::unique>,
+        test_death_construct_unsorted_iter_iter<cont_type::multi>,
+        test_death_construct_unsorted_container<cont_type::unique>,
+        test_death_construct_unsorted_container<cont_type::multi>,
+        test_death_replace_unsorted_container<cont_type::unique>,
+        test_death_replace_unsorted_container<cont_type::multi>,
+        test_death_insert_unsorted_iter_iter<cont_type::unique>,
+        test_death_insert_unsorted_iter_iter<cont_type::multi>,
+        test_death_insert_unsorted_range<cont_type::unique>,
+        test_death_insert_unsorted_range<cont_type::multi>,
+        test_death_insert_unsorted_initializer_list<cont_type::unique>,
+        test_death_insert_unsorted_initializer_list<cont_type::multi>,
+
+        // Tests shared between flat_set and flat_map - violation of unique elements
+        test_death_construct_duplicates_initializer_list<cont_type::unique>,
+        test_death_construct_duplicates_iter_iter<cont_type::unique>,
+        test_death_construct_duplicates_container<cont_type::unique>,
+        test_death_replace_duplicates_container<cont_type::unique>,
+        test_death_insert_duplicates_iter_iter<cont_type::unique>,
+        test_death_insert_duplicates_range<cont_type::unique>,
+        test_death_insert_duplicates_initializer_list<cont_type::unique>,
+
+        // Tests not present in flat_set - mismatch of length of key and mapped containers
+        test_death_different_size_ctor<cont_type::unique>,
+        test_death_different_size_ctor<cont_type::multi>,
+        test_death_different_size_ctor_sorted<cont_type::unique>,
+        test_death_different_size_ctor_sorted<cont_type::multi>,
+        test_death_different_size_replace<cont_type::unique>,
+        test_death_different_size_replace<cont_type::multi>,
+    });
+#endif // defined(_DEBUG)
+
+    return exec.run(argc, argv);
 }
diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index f3f0fc6eee1..f18ebbaf78e 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -11,6 +11,7 @@
 #include <functional>
 #include <iostream>
 #include <memory>
+#include <print>
 #include <random>
 #include <ranges>
 #include <tuple>
@@ -18,6 +19,8 @@
 #include <utility>
 #include <vector>
 
+#include <test_container_requirements.hpp>
+#include <test_death.hpp>
 #define TEST_ASSERT(...) assert((__VA_ARGS__))
 
 using namespace std;
@@ -127,123 +130,17 @@ class alternative_vector : private vector<T, Alloc> { // not allocator-aware, bu
     }
 };
 
-template <class T>
-void assert_container_requirements(const T& s) {
-    T m = s;
-    assert(m == s);
-
-    static_assert(is_same_v<decltype(m = s), T&>);
-    static_assert(is_same_v<decltype(m = std::move(m)), T&>);
-    static_assert(is_same_v<decltype(m.begin()), typename T::iterator>);
-    static_assert(is_same_v<decltype(m.end()), typename T::iterator>);
-    static_assert(is_same_v<decltype(s.cbegin()), typename T::const_iterator>);
-    static_assert(is_same_v<decltype(m.cend()), typename T::const_iterator>);
-    static_assert(is_convertible_v<typename T::iterator, typename T::const_iterator>);
-    static_assert(is_same_v<decltype(m.begin() <=> m.end()), strong_ordering>);
-    static_assert(is_same_v<decltype(s.size()), typename T::size_type>);
-    static_assert(is_same_v<decltype(s.max_size()), typename T::size_type>);
-    static_assert(is_same_v<decltype(*m.begin()), const typename T::value_type&>);
-    static_assert(is_same_v<decltype(*m.cbegin()), const typename T::value_type&>);
-
-    T my_moved = std::move(m);
-    assert(!(my_moved != s));
-
-    T empty{};
-    assert(empty.empty());
-
-    T non_empty = s;
-    empty.swap(non_empty);
-    assert(non_empty.empty());
-    assert(empty == s);
-
-    std::swap(empty, non_empty);
-    assert(empty.empty());
-    assert(non_empty == s);
-
-    assert(s.cbegin() <= s.cend());
-    assert(s.cbegin() < s.cend() || s.empty());
-
-    assert(m.begin() <= m.end());
-    assert(m.begin() < m.end() || m.empty());
-
-    assert(static_cast<typename T::size_type>(s.cend() - s.cbegin()) == s.size());
-}
-
-template <class T>
-void assert_reversible_container_requirements(const T& s) {
-    static_assert(is_same_v<reverse_iterator<typename T::iterator>, typename T::reverse_iterator>);
-    static_assert(is_same_v<reverse_iterator<typename T::const_iterator>, typename T::const_reverse_iterator>);
-    static_assert(is_same_v<decltype(T{}.rbegin()), typename T::reverse_iterator>);
-    static_assert(is_same_v<decltype(T{}.rend()), typename T::reverse_iterator>);
-    static_assert(is_same_v<decltype(s.rbegin()), typename T::const_reverse_iterator>);
-    static_assert(is_same_v<decltype(s.rend()), typename T::const_reverse_iterator>);
-    static_assert(is_same_v<decltype(s.crbegin()), typename T::const_reverse_iterator>);
-    static_assert(is_same_v<decltype(s.crend()), typename T::const_reverse_iterator>);
-    static_assert(is_convertible_v<typename T::reverse_iterator, typename T::const_reverse_iterator>);
-}
-
-template <class T>
-void assert_set_requirements() {
-    using iterator       = T::iterator;
-    using const_iterator = T::const_iterator;
-    using key_type       = T::key_type;
-    using value_type     = T::value_type;
-
-    static_assert(same_as<std::const_iterator<const_iterator>, const_iterator>);
-    static_assert(is_convertible_v<iterator, const_iterator>);
-
-    // additionally:
-    static_assert(is_same_v<key_type, value_type>);
-    static_assert(same_as<std::const_iterator<iterator>, iterator>);
-    static_assert(is_convertible_v<const_iterator, iterator>);
-}
-
-template <class T>
-void assert_noexcept_requirements(T& s) {
-    static_assert(noexcept(s.begin()));
-    static_assert(noexcept(s.end()));
-    static_assert(noexcept(s.cbegin()));
-    static_assert(noexcept(s.cend()));
-    static_assert(noexcept(s.rbegin()));
-    static_assert(noexcept(s.rend()));
-    static_assert(noexcept(s.crbegin()));
-    static_assert(noexcept(s.crend()));
-
-    static_assert(noexcept(s.empty()));
-    static_assert(noexcept(s.size()));
-    static_assert(noexcept(s.max_size()));
-
-    if constexpr (!is_const_v<T>) {
-        constexpr bool is_noexcept =
-            is_nothrow_swappable_v<typename T::container_type> && is_nothrow_swappable_v<typename T::key_compare>;
-        static_assert(noexcept(s.swap(s)) == is_noexcept);
-        static_assert(noexcept(ranges::swap(s, s)) == is_noexcept); // using ADL-swap
-        static_assert(noexcept(s.clear()));
-    }
-}
-
 template <class T>
 void assert_all_requirements(const T& s) {
     assert_container_requirements(s);
     assert_reversible_container_requirements(s);
+    assert_three_way_comparability<T>();
     assert_set_requirements<T>();
 
     assert_noexcept_requirements(s);
     assert_noexcept_requirements(const_cast<T&>(s));
 
-    auto val_comp = s.value_comp();
-    auto begin_it = s.cbegin();
-    auto end_it   = s.cend();
-    assert(std::is_sorted(begin_it, end_it, val_comp));
-    if constexpr (!_Is_specialization_v<T, flat_multiset>) {
-        if (!s.empty()) {
-            auto it = begin_it;
-            while (++it != end_it) {
-                assert(val_comp(*(it - 1), *it));
-            }
-        }
-    }
-    assert(s._Is_sorted_and_unique());
+    assert_is_sorted_maybe_unique<_Is_specialization_v<T, flat_set>>(s);
 }
 
 template <class T>
@@ -265,23 +162,48 @@ void assert_all_requirements_and_equals(const T& s, const initializer_list<typen
     }
 }
 
+template <class T, class U>
+void assert_all_requirements_and_equals(
+    const T& first, const U& second, const initializer_list<typename T::value_type>& il) {
+    assert_all_requirements_and_equals(first, il);
+    assert_all_requirements_and_equals(second, il);
+    assert(first == second);
+}
+
 template <class C>
 void test_constructors() {
     using lt = std::less<int>;
     using gt = std::greater<int>;
 
-    assert_all_requirements_and_equals(flat_set<int, lt, C>(), {});
-    assert_all_requirements_and_equals(flat_multiset<int, lt, C>(), {});
-    assert_all_requirements_and_equals(flat_set<int, lt, C>(C{3, 7, 1, 85, 222, 1}), {1, 3, 7, 85, 222});
-    assert_all_requirements_and_equals(flat_multiset<int, lt, C>(C{3, 7, 1, 85, 7, 222, 1}), {1, 1, 3, 7, 7, 85, 222});
-    assert_all_requirements_and_equals(flat_set<int, gt, C>(C{1, 2, 3, 3}, gt()), {3, 2, 1});
-    assert_all_requirements_and_equals(flat_multiset<int, gt, C>(C{1, 1, 2, 3}, gt()), {3, 2, 1, 1});
-    assert_all_requirements_and_equals(flat_set<int, gt, C>(sorted_unique, C{30000, 200, 1}, gt()), {30000, 200, 1});
-    assert_all_requirements_and_equals(flat_multiset<int, gt, C>(sorted_equivalent, C{3, 3, -1}, gt()), {3, 3, -1});
-    assert_all_requirements_and_equals(flat_set<int, gt, C>({30000, 200, 1}, gt()), {30000, 200, 1});
-    assert_all_requirements_and_equals(flat_multiset<int, gt, C>({3, 3, -1}, gt()), {3, 3, -1});
-    assert_all_requirements_and_equals(flat_set<int, gt, C>(sorted_unique, {30000, 200, 1}, gt()), {30000, 200, 1});
-    assert_all_requirements_and_equals(flat_multiset<int, gt, C>(sorted_equivalent, {3, 3, -1}, gt()), {3, 3, -1});
+    {
+        // Test flat_set()
+        // and  flat_set(const key_compare&)
+        const lt comp;
+        {
+            flat_set<int, lt, C> fs;
+            flat_set<int, lt, C> fs1(comp);
+            assert_all_requirements_and_equals(fs, fs1, {});
+        }
+        {
+            flat_multiset<int, lt, C> fms;
+            flat_multiset<int, lt, C> fms1(comp);
+            assert_all_requirements_and_equals(fms, fms1, {});
+        }
+    }
+    {
+        // Test flat_set(const container)
+    }
+
+    assert_all_requirements_and_equals(flat_set(C{3, 7, 1, 85, 222, 1}), {1, 3, 7, 85, 222});
+    assert_all_requirements_and_equals(flat_multiset(C{3, 7, 1, 85, 7, 222, 1}), {1, 1, 3, 7, 7, 85, 222});
+    assert_all_requirements_and_equals(flat_set(C{1, 2, 3, 3}, gt{}), {3, 2, 1});
+    assert_all_requirements_and_equals(flat_multiset(C{1, 1, 2, 3}, gt{}), {3, 2, 1, 1});
+    assert_all_requirements_and_equals(flat_set(sorted_unique, C{30000, 200, 1}, gt{}), {30000, 200, 1});
+    assert_all_requirements_and_equals(flat_multiset(sorted_equivalent, C{3, 3, -1}, gt{}), {3, 3, -1});
+    assert_all_requirements_and_equals(flat_set<int, gt, C>({30000, 200, 1}, gt{}), {30000, 200, 1});
+    assert_all_requirements_and_equals(flat_multiset<int, gt, C>({3, 3, -1}, gt{}), {3, 3, -1});
+    assert_all_requirements_and_equals(flat_set<int, gt, C>(sorted_unique, {30000, 200, 1}, gt{}), {30000, 200, 1});
+    assert_all_requirements_and_equals(flat_multiset<int, gt, C>(sorted_equivalent, {3, 3, -1}, gt{}), {3, 3, -1});
 
     flat_set<int> a{};
     a = {1, 7, 7, 7, 2, 100, -1};
@@ -493,6 +415,65 @@ void test_insert_2() {
     }
 }
 
+// Test that hint to emplace/insert is respected, when possible; check returned iterator
+template <class C>
+void test_insert_hint_is_respected() {
+    using lt = std::less<int>;
+
+    {
+        flat_multiset<int, lt, C> a{-1, -1, 1, 1};
+        bool problem_seen                      = false;
+        const auto assert_inserted_at_position = [&a, &problem_seen](
+                                                     const int expected_index, const auto insert_position) {
+            const auto expected_position = a.begin() + expected_index;
+            if (expected_position != insert_position) {
+                println("Wrong insert position: expected {}, actual {}\nContainer after insert {}", expected_index,
+                    insert_position - a.begin(), a);
+                problem_seen = true;
+            }
+        };
+
+        // hint is greater
+        assert_all_requirements_and_equals(a, {-1, -1, 1, 1});
+        assert_inserted_at_position(2, a.insert(a.end(), 0));
+        assert_all_requirements_and_equals(a, {-1, -1, 0, 1, 1});
+        assert_inserted_at_position(3, a.insert(a.find(1), 0));
+        assert_all_requirements_and_equals(a, {-1, -1, 0, 0, 1, 1});
+        assert_inserted_at_position(4, a.insert(a.find(1), 0));
+        assert_all_requirements_and_equals(a, {-1, -1, 0, 0, 0, 1, 1});
+        assert_inserted_at_position(5, a.insert(a.upper_bound(0), 0));
+        assert_all_requirements_and_equals(a, {-1, -1, 0, 0, 0, 0, 1, 1});
+
+        // hint is correct
+        assert_inserted_at_position(5, a.insert(a.upper_bound(0) - 1, 0));
+        assert_all_requirements_and_equals(a, {-1, -1, 0, 0, 0, 0, 0, 1, 1});
+        assert_inserted_at_position(6, a.insert(a.upper_bound(0) - 1, 0));
+        assert_all_requirements_and_equals(a, {-1, -1, 0, 0, 0, 0, 0, 0, 1, 1});
+        assert_inserted_at_position(6, a.insert(a.begin() + 6, 0));
+        assert_all_requirements_and_equals(a, {-1, -1, 0, 0, 0, 0, 0, 0, 0, 1, 1});
+        assert_inserted_at_position(4, a.insert(a.begin() + 4, 0));
+        assert_all_requirements_and_equals(a, {-1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1});
+        assert_inserted_at_position(2, a.insert(a.begin() + 2, 0));
+        assert_all_requirements_and_equals(a, {-1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1});
+        assert_inserted_at_position(2, a.emplace_hint(a.lower_bound(0), 0));
+        assert_all_requirements_and_equals(a, {-1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1});
+
+        // hint is less
+        assert_inserted_at_position(2, a.emplace_hint(a.lower_bound(0) - 1, 0));
+        assert_all_requirements_and_equals(a, {-1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1});
+        assert_inserted_at_position(2, a.insert(a.begin() + 1, 0));
+        assert_all_requirements_and_equals(a, {-1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1});
+        assert_inserted_at_position(2, a.insert(a.begin(), 0));
+        assert_all_requirements_and_equals(a, {-1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1});
+
+        assert(!problem_seen);
+
+        assert(13 == erase_if(a, [](const auto value) { return value == 0; }));
+        assert_all_requirements_and_equals(a, {-1, -1, 1, 1});
+    }
+}
+
+
 struct key_comparer {
     const auto& extract_key(const auto& obj) const {
         if constexpr (requires { obj.key; }) {
@@ -908,11 +889,24 @@ void test_invariant_robustness() {
     }
 }
 
-// TRANSITION, too simple
 void test_erase_1() {
     flat_set<int> fs{1};
-    fs.erase(1);
+    assert(1 == fs.erase(1));
     assert_all_requirements_and_equals(fs, {});
+    int numbers[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+    fs.insert_range(numbers);
+    assert_all_requirements_and_equals(fs, {0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
+    fs.insert_range(numbers);
+    assert_all_requirements_and_equals(fs, {0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
+    assert(0 == fs.erase(-1));
+    assert(0 == fs.erase(10));
+    assert_all_requirements_and_equals(fs, {0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
+    {
+        const auto iter = fs.erase(fs.begin() + 3, fs.begin() + 6);
+        assert(fs.begin() + 3 == iter);
+        assert(6 == *iter);
+        assert_all_requirements_and_equals(fs, {0, 1, 2, 6, 7, 8, 9});
+    }
 }
 
 template <class T>
@@ -923,6 +917,8 @@ struct holder {
     }
 };
 
+static_assert(is_convertible_v<holder<flat_set<int>::const_iterator>, flat_set<int>::const_iterator>);
+
 void test_erase_2() {
     using C = flat_set<int, std::less<>>;
     C fs{0, 1, 2, 3};
@@ -937,6 +933,41 @@ void test_erase_2() {
     assert_all_requirements_and_equals(fs, {3});
 }
 
+template <class Cont, class OtherKey>
+concept can_erase_key = requires(Cont c, OtherKey key) {
+    { c.erase(key) } -> same_as<typename Cont::size_type>;
+};
+template <class Cont>
+concept can_erase_iterator_holder = requires(Cont c) {
+    { c.erase(holder<typename Cont::const_iterator>{c.begin()}) } -> same_as<typename Cont::iterator>;
+};
+// Note that std::less<T> is not transparent, std::less<> and ranges::less are
+
+namespace detail {
+    using C = flat_set<int>;
+    static_assert(same_as<C::iterator, decltype(declval<C>().erase(declval<C::iterator>()))>);
+    static_assert(same_as<C::iterator, decltype(declval<C>().erase(declval<holder<C::iterator>>()))>);
+    static_assert(same_as<C::iterator, decltype(declval<C>().erase(declval<C::const_iterator>()))>);
+    static_assert(same_as<C::iterator, decltype(declval<C>().erase(declval<holder<C::const_iterator>>()))>);
+    static_assert(same_as<C::iterator, decltype(declval<C>().erase(declval<C::iterator>(), declval<C::iterator>()))>);
+    static_assert(same_as<C::size_type, decltype(declval<C>().erase(declval<holder<int>>()))>);
+    static_assert(same_as<C::size_type, decltype(declval<C>().erase(declval<int>()))>);
+
+    // erase key_type
+    static_assert(can_erase_key<flat_set<int, std::less<int>>, int>);
+    static_assert(can_erase_key<flat_set<int, std::less<>>, int>);
+    static_assert(can_erase_key<flat_set<int, ranges::less>, int>);
+    // erase wrapped key_type
+    static_assert(!can_erase_key<flat_set<int, std::less<int>>, holder<int>>);
+    static_assert(can_erase_key<flat_set<int, std::less<>>, holder<int>>);
+    static_assert(can_erase_key<flat_set<int, ranges::less>, holder<int>>);
+    // erase wrapped iterator - the member function template returning size_type must not be selected
+    static_assert(can_erase_iterator_holder<flat_set<int, std::less<int>>>);
+    static_assert(can_erase_iterator_holder<flat_set<int, std::less<>>>);
+    static_assert(can_erase_iterator_holder<flat_set<int, ranges::less>>);
+} // namespace detail
+
+
 template <class C>
 void test_erase_if() {
     constexpr int erased_result[]{1, 3};
@@ -1145,6 +1176,7 @@ void test_throwing_compare_swap() {
     test_throwing_compare_single<flat_multiset, deque>();
 }
 
+// Test heterogeneous lookup and erase operations when the compare object does not satisfy strict_weak_order (GH-5992)
 enum class strange_int {};
 
 // No overload divless::operator()(strange_int, strange_int), does not satisfy std::strict_weak_order
@@ -1167,18 +1199,50 @@ struct divless {
 static_assert(!strict_weak_order<divless, int, strange_int>);
 
 // ranges:: algorithms can't be called with divless compare, as it does not satisfy std::strict_weak_order
-void test_generic_count_gh_5992() {
+void test_non_strict_weak_order_compare() {
     {
-        flat_set<int, divless> s{1, 2, 11, 12};
-        assert(2 == s.count(strange_int{0}));
+        flat_set<int, divless> cont{1, 2, 11, 12};
+        assert(2 == cont.count(strange_int{0}));
+
+        assert(cont.contains(strange_int{0}));
+        assert(!cont.contains(strange_int{2}));
+
+        assert(cont.begin() + 2 == cont.lower_bound(strange_int{1}));
+        assert(cont.begin() + 2 == cont.upper_bound(strange_int{0}));
+
+        const auto [first, last] = cont.equal_range(strange_int{0});
+        assert(first == cont.begin());
+        assert(last == cont.begin() + 2);
+
+        assert(cont.end() != cont.find(strange_int{1}));
+        assert(cont.end() == cont.find(strange_int{3}));
+
+        assert(2 == cont.erase(strange_int{0}));
+        assert_all_requirements_and_equals(cont, {11, 12});
     }
     {
-        flat_multiset<int, divless> ms{1, 2, 11, 12};
-        assert(2 == ms.count(strange_int{0}));
+        flat_multiset<int, divless> cont{1, 2, 11, 12};
+        assert(2 == cont.count(strange_int{0}));
+
+        assert(cont.contains(strange_int{0}));
+        assert(!cont.contains(strange_int{2}));
+
+        assert(cont.begin() + 2 == cont.lower_bound(strange_int{1}));
+        assert(cont.begin() + 2 == cont.upper_bound(strange_int{0}));
+
+        const auto [first, last] = cont.equal_range(strange_int{0});
+        assert(first == cont.begin());
+        assert(last == cont.begin() + 2);
+
+        assert(cont.end() != cont.find(strange_int{1}));
+        assert(cont.end() == cont.find(strange_int{3}));
+
+        assert(2 == cont.erase(strange_int{0}));
+        assert_all_requirements_and_equals(cont, {11, 12});
     }
 }
 
-int main() {
+void run_normal_tests() {
     test_spaceship_operator<flat_set<int>>();
     test_spaceship_operator<flat_multiset<int>>();
     test_spaceship_operator<flat_set<int, std::greater<int>>>();
@@ -1200,6 +1264,8 @@ int main() {
     test_insert_1<deque<int>>();
     test_insert_2<vector<int>>();
     test_insert_2<deque<int>>();
+    test_insert_hint_is_respected<vector<int>>();
+    test_insert_hint_is_respected<deque<int>>();
     test_insert_transparent();
     test_insert_using_invalid_hint();
     test_insert_upper_bound();
@@ -1228,5 +1294,155 @@ int main() {
     test_set_operations_transparent<flat_multiset>();
 
     test_throwing_compare_swap();
-    test_generic_count_gh_5992();
+    test_non_strict_weak_order_compare();
+}
+
+enum class cont_type { multi, unique };
+
+template <cont_type type>
+void test_death_construct_unsorted_initializer_list() {
+    using C = conditional_t<type == cont_type::unique, flat_set<int>, flat_multiset<int>>;
+    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
+    C cont(sorted, {137, 42, 3337, 15});
+}
+
+template <cont_type type>
+void test_death_construct_unsorted_iter_iter() {
+    using C = conditional_t<type == cont_type::unique, flat_set<int>, flat_multiset<int>>;
+    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
+    typename C::container_type values{137, 42, 3337, 15};
+    C cont(sorted, values.begin(), values.end());
+}
+
+template <cont_type type>
+void test_death_construct_unsorted_container() {
+    using C = conditional_t<type == cont_type::unique, flat_set<int>, flat_multiset<int>>;
+    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
+    typename C::container_type values{137, 42, 3337, 15};
+    C cont(sorted, values);
+}
+
+template <cont_type type>
+void test_death_replace_unsorted_container() {
+    using C = conditional_t<type == cont_type::unique, flat_set<int>, flat_multiset<int>>;
+    C cont;
+    cont.replace({137, 42, 3337, 15});
+}
+
+template <cont_type type>
+void test_death_insert_unsorted_iter_iter() {
+    using C = conditional_t<type == cont_type::unique, flat_set<int>, flat_multiset<int>>;
+    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
+    typename C::container_type values{137, 42, 3337, 15};
+    C cont;
+    cont.insert(sorted, values.begin(), values.end());
+}
+
+template <cont_type type>
+void test_death_insert_unsorted_range() {
+    using C = conditional_t<type == cont_type::unique, flat_set<int>, flat_multiset<int>>;
+    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
+    typename C::container_type values{137, 42, 3337, 15};
+    C cont;
+    cont.insert_range(sorted, values);
+}
+
+template <cont_type type>
+void test_death_insert_unsorted_initializer_list() {
+    using C = conditional_t<type == cont_type::unique, flat_set<int>, flat_multiset<int>>;
+    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
+    C cont;
+    cont.insert(sorted, {137, 42, 3337, 15});
+}
+
+template <cont_type type>
+void test_death_construct_duplicates_initializer_list() {
+    using C = conditional_t<type == cont_type::unique, flat_set<int>, flat_multiset<int>>;
+    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
+    C cont(sorted, {42, 137, 137, 3337});
+}
+
+template <cont_type type>
+void test_death_construct_duplicates_iter_iter() {
+    using C = conditional_t<type == cont_type::unique, flat_set<int>, flat_multiset<int>>;
+    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
+    typename C::container_type values{42, 137, 137, 3337};
+    C cont(sorted, values.begin(), values.end());
+}
+
+template <cont_type type>
+void test_death_construct_duplicates_container() {
+    using C = conditional_t<type == cont_type::unique, flat_set<int>, flat_multiset<int>>;
+    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
+    typename C::container_type values{42, 137, 137, 3337};
+    C cont(sorted, values);
+}
+
+template <cont_type type>
+void test_death_replace_duplicates_container() {
+    using C = conditional_t<type == cont_type::unique, flat_set<int>, flat_multiset<int>>;
+    C cont;
+    cont.replace({42, 137, 137, 3337});
+}
+
+template <cont_type type>
+void test_death_insert_duplicates_iter_iter() {
+    using C = conditional_t<type == cont_type::unique, flat_set<int>, flat_multiset<int>>;
+    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
+    typename C::container_type values{42, 137, 137, 3337};
+    C cont;
+    cont.insert(sorted, values.begin(), values.end());
+}
+
+template <cont_type type>
+void test_death_insert_duplicates_range() {
+    using C = conditional_t<type == cont_type::unique, flat_set<int>, flat_multiset<int>>;
+    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
+    typename C::container_type values{42, 137, 137, 3337};
+    C cont;
+    cont.insert_range(sorted, values);
+}
+
+template <cont_type type>
+void test_death_insert_duplicates_initializer_list() {
+    using C = conditional_t<type == cont_type::unique, flat_set<int>, flat_multiset<int>>;
+    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
+    C cont;
+    cont.insert(sorted, {42, 137, 137, 3337});
+}
+
+int main(int argc, char* argv[]) {
+    std_testing::death_test_executive exec([] { run_normal_tests(); });
+
+#if defined(_DEBUG)
+    exec.add_death_tests({
+
+        // Tests shared between flat_set and flat_map - violation of sorted elements
+        test_death_construct_unsorted_initializer_list<cont_type::unique>,
+        test_death_construct_unsorted_initializer_list<cont_type::multi>,
+        test_death_construct_unsorted_iter_iter<cont_type::unique>,
+        test_death_construct_unsorted_iter_iter<cont_type::multi>,
+        test_death_construct_unsorted_container<cont_type::unique>,
+        test_death_construct_unsorted_container<cont_type::multi>,
+        test_death_replace_unsorted_container<cont_type::unique>,
+        test_death_replace_unsorted_container<cont_type::multi>,
+        test_death_insert_unsorted_iter_iter<cont_type::unique>,
+        test_death_insert_unsorted_iter_iter<cont_type::multi>,
+        test_death_insert_unsorted_range<cont_type::unique>,
+        test_death_insert_unsorted_range<cont_type::multi>,
+        test_death_insert_unsorted_initializer_list<cont_type::unique>,
+        test_death_insert_unsorted_initializer_list<cont_type::multi>,
+
+        // Tests shared between flat_set and flat_map - violation of unique elements
+        test_death_construct_duplicates_initializer_list<cont_type::unique>,
+        test_death_construct_duplicates_iter_iter<cont_type::unique>,
+        test_death_construct_duplicates_container<cont_type::unique>,
+        test_death_replace_duplicates_container<cont_type::unique>,
+        test_death_insert_duplicates_iter_iter<cont_type::unique>,
+        test_death_insert_duplicates_range<cont_type::unique>,
+        test_death_insert_duplicates_initializer_list<cont_type::unique>,
+    });
+#endif // defined(_DEBUG)
+
+    return exec.run(argc, argv);
 }

From 353c1692c8d56de4d57e6ad5710d49bdde7b2186 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Mon, 12 Jan 2026 17:21:19 -0800
Subject: [PATCH 106/134] Properly cite EDG bug affecting C++20 Down With
 Typename (#6008)

---
 stl/inc/flat_map | 2 +-
 stl/inc/flat_set | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index 970fd07e77f..3cfd812eab8 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -1014,7 +1014,7 @@ protected:
     }
 
 private:
-    // FIXME, typename is an EDG workaround
+    // typename is a workaround for VSO-2680018 (EDG)
     template <class _KTy, class _MTy, class _Comp, class _KeyCont, class _MappedCont, class _Pred>
     friend typename flat_map<_KTy, _MTy, _Comp, _KeyCont, _MappedCont>::size_type erase_if(
         flat_map<_KTy, _MTy, _Comp, _KeyCont, _MappedCont>&, _Pred);
diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index dd714ed1c50..95857d2ef4b 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -653,7 +653,7 @@ private:
         }
     }
 
-    // FIXME, typename is an EDG workaround
+    // typename is a workaround for VSO-2680018 (EDG)
     template <class _Kty2, class _Keylt2, class _Container2, class _Pred2>
     friend typename _Container2::size_type erase_if(flat_set<_Kty2, _Keylt2, _Container2>&, _Pred2);
     template <class _Kty2, class _Keylt2, class _Container2, class _Pred2>

From fd076f6c8cf48eb4c8049c779072134eacfcbaf6 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Thu, 15 Jan 2026 11:51:19 -0800
Subject: [PATCH 107/134] Update libcxx failures.

---
 tests/libcxx/expected_results.txt | 27 +++++++++++++++------------
 1 file changed, 15 insertions(+), 12 deletions(-)

diff --git a/tests/libcxx/expected_results.txt b/tests/libcxx/expected_results.txt
index 5b5e8aa0b7e..52705a56c91 100644
--- a/tests/libcxx/expected_results.txt
+++ b/tests/libcxx/expected_results.txt
@@ -67,6 +67,9 @@ std/language.support/support.coroutines/coroutine.handle/coroutine.handle.noop/n
 std/concepts/concepts.compare/concept.equalitycomparable/equality_comparable_with.compile.pass.cpp:2 FAIL
 std/language.support/cmp/cmp.concept/three_way_comparable_with.compile.pass.cpp:2 FAIL
 
+# LLVM-176232: The implementation of P3567R2 "flat_meow Fixes" forgot to update `__cpp_lib_flat_set`
+std/language.support/support.limits/support.limits.general/flat_set.version.compile.pass.cpp FAIL
+
 # Non-Standard regex behavior.
 # "It seems likely that the test is still non-conforming due to how libc++ handles the 'w' character class."
 std/re/re.traits/lookup_classname.pass.cpp FAIL
@@ -142,18 +145,6 @@ std/atomics/atomics.ref/member_types.compile.pass.cpp FAIL
 std/thread/futures/futures.promise/uses_allocator.pass.cpp FAIL
 std/thread/futures/futures.task/futures.task.members/ctor2.compile.pass.cpp FAIL
 
-# libc++ has not implemented P3567R2: "flat_meow Fixes"
-std/containers/container.adaptors/flat.map/flat.map.modifiers/swap_free.pass.cpp FAIL
-std/containers/container.adaptors/flat.map/flat.map.modifiers/swap_member.pass.cpp FAIL
-std/containers/container.adaptors/flat.multimap/flat.multimap.modifiers/swap_free.pass.cpp FAIL
-std/containers/container.adaptors/flat.multimap/flat.multimap.modifiers/swap_member.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/swap_free.pass.cpp FAIL
-std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/swap_member.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.modifiers/swap_free.pass.cpp FAIL
-std/containers/container.adaptors/flat.set/flat.set.modifiers/swap_member.pass.cpp FAIL
-std/language.support/support.limits/support.limits.general/flat_map.version.compile.pass.cpp FAIL
-std/language.support/support.limits/support.limits.general/flat_set.version.compile.pass.cpp FAIL
-
 # Various bogosity (LLVM-D141004)
 std/utilities/utility/mem.res/mem.res.pool/mem.res.pool.ctor/ctor_does_not_allocate.pass.cpp FAIL
 std/utilities/utility/mem.res/mem.res.pool/mem.res.pool.ctor/sync_with_default_resource.pass.cpp FAIL
@@ -344,6 +335,8 @@ std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_iter_iter.p
 std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_iter_iter.pass.cpp:1 FAIL
 std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_or_assign_transparent.pass.cpp:0 FAIL
 std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_or_assign_transparent.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_range_sorted_unique.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_range_sorted_unique.pass.cpp:1 FAIL
 std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_range.pass.cpp:0 FAIL
 std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_range.pass.cpp:1 FAIL
 std/containers/container.adaptors/flat.map/flat.map.modifiers/insert_rv.pass.cpp:0 FAIL
@@ -378,6 +371,8 @@ std/containers/container.adaptors/flat.multimap/flat.multimap.modifiers/extract.
 std/containers/container.adaptors/flat.multimap/flat.multimap.modifiers/extract.pass.cpp:1 FAIL
 std/containers/container.adaptors/flat.multimap/flat.multimap.modifiers/insert_iter_iter.pass.cpp:0 FAIL
 std/containers/container.adaptors/flat.multimap/flat.multimap.modifiers/insert_iter_iter.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.multimap/flat.multimap.modifiers/insert_range_sorted_equivalent.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.multimap/flat.multimap.modifiers/insert_range_sorted_equivalent.pass.cpp:1 FAIL
 std/containers/container.adaptors/flat.multimap/flat.multimap.modifiers/insert_range.pass.cpp:0 FAIL
 std/containers/container.adaptors/flat.multimap/flat.multimap.modifiers/insert_range.pass.cpp:1 FAIL
 std/containers/container.adaptors/flat.multimap/flat.multimap.modifiers/insert_rv.pass.cpp:0 FAIL
@@ -406,6 +401,8 @@ std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/extract.
 std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/extract.pass.cpp:1 FAIL
 std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_iter_iter.pass.cpp:0 FAIL
 std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_iter_iter.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_range_sorted_equivalent.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_range_sorted_equivalent.pass.cpp:1 FAIL
 std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_range.pass.cpp:0 FAIL
 std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_range.pass.cpp:1 FAIL
 std/containers/container.adaptors/flat.multiset/flat.multiset.observers/comp.pass.cpp:0 FAIL
@@ -432,6 +429,8 @@ std/containers/container.adaptors/flat.set/flat.set.modifiers/extract.pass.cpp:0
 std/containers/container.adaptors/flat.set/flat.set.modifiers/extract.pass.cpp:1 FAIL
 std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_iter_iter.pass.cpp:0 FAIL
 std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_iter_iter.pass.cpp:1 FAIL
+std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_range_sorted_unique.pass.cpp:0 FAIL
+std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_range_sorted_unique.pass.cpp:1 FAIL
 std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_range.pass.cpp:0 FAIL
 std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_range.pass.cpp:1 FAIL
 std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_transparent.pass.cpp:0 FAIL
@@ -1361,6 +1360,10 @@ std/algorithms/alg.modifying.operations/alg.copy/copy.pass.cpp:1 FAIL
 std/input.output/file.streams/fstreams/filebuf.virtuals/xsputn.pass.cpp:0 FAIL
 std/input.output/file.streams/fstreams/filebuf.virtuals/xsputn.pass.cpp:1 FAIL
 
+# FIXME, not analyzed. _Flat_map_base::_Erase_if's usage of ranges::remove_if is failing to compile.
+std/containers/container.adaptors/flat.map/robust_against_nonbool.compile.pass.cpp FAIL
+std/containers/container.adaptors/flat.multimap/robust_against_nonbool.compile.pass.cpp FAIL
+
 
 # *** XFAILS WHICH PASS ***
 # These tests contain `// XFAIL: msvc` comments, which accurately describe runtime failures for x86 and x64.

From 6634774f4929a630cbd35180855c65710e80aada Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vojt=C4=9Bch=20Michal?= <vojta.michall@email.cz>
Date: Thu, 15 Jan 2026 23:29:09 +0100
Subject: [PATCH 108/134] `<flat_meow>`: Minor cleanups - Use member
 `begin`/`end` when possible, use arithmetic for random access iterators
 (#6001)

Co-authored-by: Stephan T. Lavavej <stl@microsoft.com>
---
 stl/inc/flat_map | 53 ++++++++++++++++++++++++------------------------
 stl/inc/flat_set |  4 ++--
 2 files changed, 28 insertions(+), 29 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index 3cfd812eab8..4ab4085e7e4 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -526,21 +526,21 @@ public:
     // [container.reqmts] iterators
     _NODISCARD iterator begin() noexcept {
         _STL_INTERNAL_STATIC_ASSERT(random_access_iterator<iterator>);
-        return iterator{_STD cbegin(_Data.keys), _Data.values.begin()};
+        return iterator{_Data.keys.cbegin(), _Data.values.begin()};
     }
 
     _NODISCARD const_iterator begin() const noexcept {
         _STL_INTERNAL_STATIC_ASSERT(random_access_iterator<const_iterator>);
         _STL_INTERNAL_STATIC_ASSERT(convertible_to<iterator, const_iterator>);
-        return const_iterator{_STD cbegin(_Data.keys), _Data.values.begin()};
+        return const_iterator{_Data.keys.cbegin(), _Data.values.begin()};
     }
 
     _NODISCARD iterator end() noexcept {
-        return iterator{_STD cend(_Data.keys), _Data.values.end()};
+        return iterator{_Data.keys.cend(), _Data.values.end()};
     }
 
     _NODISCARD const_iterator end() const noexcept {
-        return const_iterator{_STD cend(_Data.keys), _Data.values.end()};
+        return const_iterator{_Data.keys.cend(), _Data.values.end()};
     }
 
     _NODISCARD reverse_iterator rbegin() noexcept {
@@ -560,11 +560,11 @@ public:
     }
 
     _NODISCARD const_iterator cbegin() const noexcept {
-        return const_iterator{_STD cbegin(_Data.keys), _STD cbegin(_Data.values)};
+        return const_iterator{_Data.keys.cbegin(), _Data.values.cbegin()};
     }
 
     _NODISCARD const_iterator cend() const noexcept {
-        return const_iterator{_STD cend(_Data.keys), _STD cend(_Data.values)};
+        return const_iterator{_Data.keys.cend(), _Data.values.cend()};
     }
 
     _NODISCARD const_reverse_iterator crbegin() const noexcept {
@@ -867,14 +867,14 @@ public:
     }
 
     _NODISCARD friend bool operator==(const _Derived& _Left, const _Derived& _Right) {
-        return _STD equal(_STD _Get_unwrapped(_STD cbegin(_Left)), _STD _Get_unwrapped(_STD cend(_Left)),
-            _STD _Get_unwrapped(_STD cbegin(_Right)), _STD _Get_unwrapped(_STD cend(_Right)));
+        return _STD equal(_STD _Get_unwrapped(_Left.cbegin()), _STD _Get_unwrapped(_Left.cend()),
+            _STD _Get_unwrapped(_Right.cbegin()), _STD _Get_unwrapped(_Right.cend()));
     }
 
     _NODISCARD friend auto operator<=>(const _Derived& _Left, const _Derived& _Right) {
-        return _STD lexicographical_compare_three_way(_STD _Get_unwrapped(_STD cbegin(_Left)),
-            _STD _Get_unwrapped(_STD cend(_Left)), _STD _Get_unwrapped(_STD cbegin(_Right)),
-            _STD _Get_unwrapped(_STD cend(_Right)), _Synth_three_way{});
+        return _STD lexicographical_compare_three_way(_STD _Get_unwrapped(_Left.cbegin()),
+            _STD _Get_unwrapped(_Left.cend()), _STD _Get_unwrapped(_Right.cbegin()), _STD _Get_unwrapped(_Right.cend()),
+            _Synth_three_way{});
     }
 
     friend void swap(_Derived& _Left, _Derived& _Right) noexcept(noexcept(_Left.swap(_Right))) {
@@ -898,10 +898,9 @@ protected:
                                     || (is_constructible_v<key_type, _OtherKey> && _Transparent<key_compare>) );
 
         const auto _Key_it = _STD upper_bound(_Data.keys.begin(), _Data.keys.end(), _Key_val, _Pass_key_comp());
-        const auto _Index  = _RANGES distance(_Data.keys.begin(), _Key_it);
+        const auto _Index  = _Key_it - _Data.keys.begin();
         if constexpr (_IsUnique) {
-            if (_Key_it != _Data.keys.begin()
-                && !_Key_compare(*_RANGES prev(_Key_it), _STD forward<_OtherKey>(_Key_val))) {
+            if (_Key_it != _Data.keys.begin() && !_Key_compare(*(_Key_it - 1), _STD forward<_OtherKey>(_Key_val))) {
                 // Previous element is equivalent to key, no insert needed
                 return {this->begin() + (_Index - 1), false};
             }
@@ -910,7 +909,7 @@ protected:
         // Need to insert
         key_type _Key_to_insert(_STD forward<_OtherKey>(_Key_val));
         mapped_type _Mapped_to_insert(_STD forward<_MappedArgTypes>(_Mapped_args)...);
-        _Insert_exact(_STD cbegin(*this) + _Index, _STD move(_Key_to_insert), _STD move(_Mapped_to_insert));
+        _Insert_exact(this->cbegin() + _Index, _STD move(_Key_to_insert), _STD move(_Mapped_to_insert));
 
         if constexpr (_IsUnique) {
             return {this->begin() + _Index, true};
@@ -935,7 +934,7 @@ protected:
         const weak_ordering _Hint_order = [&] {
             if constexpr (_IsUnique) {
                 if (_Position == _End || _Key_compare(_Key_val, *_Position._Key_it)) {
-                    if (_Position == _Begin || _Key_compare(*_STD prev(_Position._Key_it), _Key_val)) {
+                    if (_Position == _Begin || _Key_compare(*(_Position._Key_it - 1), _Key_val)) {
                         return weak_ordering::equivalent;
                     } else {
                         return weak_ordering::greater;
@@ -943,7 +942,7 @@ protected:
                 }
             } else {
                 if (_Position == _End || !_Key_compare(*_Position._Key_it, _Key_val)) {
-                    if (_Position == _Begin || !_Key_compare(_Key_val, *_STD prev(_Position._Key_it))) {
+                    if (_Position == _Begin || !_Key_compare(_Key_val, *(_Position._Key_it - 1))) {
                         return weak_ordering::equivalent;
                     } else {
                         return weak_ordering::greater;
@@ -965,8 +964,8 @@ protected:
 
         const auto _New_position = _Iterator_from_key_iterator(
             _Hint_order == weak_ordering::less
-                ? _STD lower_bound(_Position._Key_it, _STD cend(_Data.keys), _Key_val, _Pass_key_comp())
-                : _STD upper_bound(_STD cbegin(_Data.keys), _Position._Key_it, _Key_val, _Pass_key_comp()));
+                ? _STD lower_bound(_Position._Key_it, _Data.keys.cend(), _Key_val, _Pass_key_comp())
+                : _STD upper_bound(_Data.keys.cbegin(), _Position._Key_it, _Key_val, _Pass_key_comp()));
 
         if constexpr (_IsUnique) {
             if (_Hint_order == weak_ordering::less) {
@@ -977,8 +976,8 @@ protected:
                     return _New_position;
                 }
             } else {
-                if (_New_position != _Begin && !_Key_compare(*_STD prev(_New_position._Key_it), _Key_val)) {
-                    const auto _It = _STD prev(_New_position);
+                if (_New_position != _Begin && !_Key_compare(*(_New_position._Key_it - 1), _Key_val)) {
+                    const auto _It = _New_position - 1;
                     if constexpr (_OverwriteIfExists) {
                         *_It._Mapped_it = mapped_type(_STD forward<_MappedArgTypes>(_Args)...);
                     }
@@ -1073,9 +1072,9 @@ private:
         const auto _Num_sorted = _RANGES is_sorted_until(_Data.keys, _Pass_key_comp()) - _Data.keys.begin();
 
         auto _View                        = _View_to_mutate();
-        const auto _Begin_unsorted_values = _STD begin(_View) + _Num_sorted;
+        const auto _Begin_unsorted_values = _View.begin() + _Num_sorted;
 
-        _RANGES sort(_Begin_unsorted_values, _STD end(_View), value_compare{_Key_compare});
+        _RANGES sort(_Begin_unsorted_values, _View.end(), value_compare{_Key_compare});
         _RANGES inplace_merge(_View, _Begin_unsorted_values, value_compare{_Key_compare});
 
         _Erase_dupes_if_not_multi();
@@ -1120,7 +1119,7 @@ private:
         // Sort the newly inserted elements
         auto _Sorted_view = _View_to_mutate();
         if constexpr (_NeedSorting) {
-            _RANGES sort(_STD begin(_Sorted_view) + _Old_distance, _STD end(_Sorted_view), value_compare{_Key_compare});
+            _RANGES sort(_Sorted_view.begin() + _Old_distance, _Sorted_view.end(), value_compare{_Key_compare});
         } else {
             _STL_ASSERT(_Is_sorted_and_unique(
                             _Data.keys.begin() + static_cast<key_container_type::difference_type>(_Old_distance),
@@ -1194,9 +1193,9 @@ private:
             // In a non-multi container, equal_range can have size at most 1
             const auto _First =
                 _STD lower_bound(_Self._Data.keys.begin(), _Self._Data.keys.end(), _Key_val, _Self._Pass_key_comp());
-            const bool _Missing = _First == _STD end(_Self._Data.keys) || _Self._Key_compare(_Key_val, *_First);
+            const bool _Missing = _First == _Self._Data.keys.end() || _Self._Key_compare(_Key_val, *_First);
             return pair{_Self._Iterator_from_key_iterator(_First),
-                _Self._Iterator_from_key_iterator(_Missing ? _First : _STD next(_First))};
+                _Self._Iterator_from_key_iterator(_Missing ? _First : _First + 1)};
         } else {
             const auto [_First, _Last] =
                 _STD equal_range(_Self._Data.keys.begin(), _Self._Data.keys.end(), _Key_val, _Self._Pass_key_comp());
@@ -1207,7 +1206,7 @@ private:
     template <class _SelfTy>
     _NODISCARD conditional_t<is_const_v<_SelfTy>, const_iterator, iterator> _Iterator_from_key_iterator(
         this _SelfTy& _Self, const key_container_type::const_iterator& _Iter) {
-        const difference_type _Offset = _Iter - _STD cbegin(_Self._Data.keys);
+        const difference_type _Offset = _Iter - _Self._Data.keys.cbegin();
         return _Self.begin() + _Offset;
     }
 };
diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index 95857d2ef4b..5491de0dee9 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -698,8 +698,8 @@ private:
         if constexpr (_IsUnique && is_same_v<_KeyTy, key_type>) { // Optimization restricted due to GH-5992
             // In a non-multi container, equal_range can have size at most 1
             const auto _First   = _STD lower_bound(_Mycont.begin(), _Mycont.end(), _Key_val, _Pass_comp());
-            const bool _Missing = _First == _STD end(_Mycont) || _Mycomp(_Key_val, *_First);
-            return pair{_First, _Missing ? _First : _STD next(_First)};
+            const bool _Missing = _First == _Mycont.end() || _Mycomp(_Key_val, *_First);
+            return pair{_First, _Missing ? _First : _First + 1};
         } else {
             return _STD equal_range(begin(), end(), _Key_val, _Pass_comp());
         }

From d86d691d3a5e652fc539d8352e9a229813f2dc50 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vojt=C4=9Bch=20Michal?= <vojta.michall@email.cz>
Date: Fri, 16 Jan 2026 20:00:47 +0100
Subject: [PATCH 109/134] `<flat_meow>`: Implement natvis visualizers for
 `flat_multimeow`, simplify visualizer for `flat_map` (#6015)

---
 stl/debugger/STL.natvis | 104 +++++-----------------------------------
 1 file changed, 13 insertions(+), 91 deletions(-)

diff --git a/stl/debugger/STL.natvis b/stl/debugger/STL.natvis
index 62949ea748e..aad4b34577e 100644
--- a/stl/debugger/STL.natvis
+++ b/stl/debugger/STL.natvis
@@ -1102,11 +1102,12 @@ SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
   <!-- VC 2015 -->
   <Type Name="std::deque&lt;*&gt;">
-      <DisplayString>{{ size={_Mypair._Myval2._Mysize} }}</DisplayString>
+      <Intrinsic Name="size" Expression="_Mypair._Myval2._Mysize" />
+      <DisplayString>{{ size={size()} }}</DisplayString>
       <Expand>
           <Item Name="[allocator]" ExcludeView="simple">_Mypair</Item>
           <IndexListItems>
-              <Size>_Mypair._Myval2._Mysize</Size>
+              <Size>size()</Size>
               <ValueNode>_Mypair._Myval2._Map[(($i + _Mypair._Myval2._Myoff) / _EEN_DS) % _Mypair._Myval2._Mapsize][($i + _Mypair._Myval2._Myoff) % _EEN_DS]</ValueNode>
           </IndexListItems>
       </Expand>
@@ -2296,75 +2297,21 @@ SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
     </Expand>
   </Type>
 
-  <!-- KeyContainer: vector, MappedContainer: vector -->
-  <Type Name="std::flat_map&lt;*,*,*,std::vector&lt;*&gt;,std::vector&lt;*&gt;&gt;">
-    <Intrinsic Name="size" Expression="(size_t)(_Data.keys._Mypair._Myval2._Mylast - _Data.keys._Mypair._Myval2._Myfirst)"/>
-    <Intrinsic Name="key_at" Expression="&amp;_Data.keys._Mypair._Myval2._Myfirst[index]">
-      <Parameter Name="index" Type="size_t" />
-    </Intrinsic>
-    <Intrinsic Name="value_at" Expression="&amp;_Data.values._Mypair._Myval2._Myfirst[index]">
-      <Parameter Name="index" Type="size_t" />
-    </Intrinsic>
-
-    <DisplayString>{{ size={size()} }}</DisplayString>
-
-    <Expand>
-      <Item Name="[comparator]" ExcludeView="simple">_Key_compare</Item>
-      <Item Name="[size]">size()</Item>
-      <CustomListItems>
-        <Variable Name="i" InitialValue="0" />
-        <Size>size()</Size>
-        <Loop>
-          <Item Name="[{*key_at(i)}]">*value_at(i)</Item>
-          <Exec>++i</Exec>
-        </Loop>
-      </CustomListItems>
-    </Expand>
-  </Type>
-
-  <!-- KeyContainer: std::deque, MappedContainer: std::vector -->
-  <Type Name="std::flat_map&lt;*,*,*,std::deque&lt;*&gt;,std::vector&lt;*&gt;&gt;">
-    <Intrinsic Name="size" Expression="_Data.keys._Mypair._Myval2._Mysize" />
-    <Intrinsic Name="key_at" Expression="&amp;_Data.keys._Mypair._Myval2._Map[((index + _Data.keys._Mypair._Myval2._Myoff) / _Data.keys._EEN_DS) %
-          _Data.keys._Mypair._Myval2._Mapsize][(index + _Data.keys._Mypair._Myval2._Myoff) % _Data.keys._EEN_DS]">
+  <Type Name="std::flat_map&lt;*&gt;">
+   <AlternativeType Name="std::flat_multimap&lt;*&gt;"/>
+    <Intrinsic Name="size" Expression="_Data.keys.size()"/>
+    <Intrinsic Name="key_at" Expression="&amp;_Data.keys[index]">
       <Parameter Name="index" Type="size_t" />
     </Intrinsic>
-    <Intrinsic Name="value_at" Expression="&amp;_Data.values._Mypair._Myval2._Myfirst[index]">
+    <Intrinsic Name="value_at" Expression="&amp;_Data.values[index]">
       <Parameter Name="index" Type="size_t" />
     </Intrinsic>
 
     <DisplayString>{{ size={size()} }}</DisplayString>
 
     <Expand>
-      <Item Name="[comparator]" ExcludeView="simple">_Key_compare</Item>
       <Item Name="[size]">size()</Item>
-      <CustomListItems>
-        <Variable Name="i" InitialValue="0" />
-        <Size>size()</Size>
-        <Loop>
-          <Item Name="[{*key_at(i)}]">*value_at(i)</Item>
-          <Exec>++i</Exec>
-        </Loop>
-      </CustomListItems>
-    </Expand>
-  </Type>
-
-  <!-- KeyContainer: std::vector, MappedContainer: std::deque -->
-  <Type Name="std::flat_map&lt;*,*,*,std::vector&lt;*&gt;,std::deque&lt;*&gt;&gt;">
-    <Intrinsic Name="size" Expression="(size_t)(_Data.keys._Mypair._Myval2._Mylast - _Data.keys._Mypair._Myval2._Myfirst)" />
-    <Intrinsic Name="key_at" Expression="&amp;_Data.keys._Mypair._Myval2._Myfirst[index]">
-      <Parameter Name="index" Type="size_t" />
-    </Intrinsic>
-    <Intrinsic Name="value_at" Expression="&amp;_Data.values._Mypair._Myval2._Map[((index + _Data.values._Mypair._Myval2._Myoff) / _Data.values._EEN_DS) %
-          _Data.values._Mypair._Myval2._Mapsize][(index + _Data.values._Mypair._Myval2._Myoff) % _Data.values._EEN_DS]">
-      <Parameter Name="index" Type="size_t" />
-    </Intrinsic>
-
-    <DisplayString>{{ size={size()} }}</DisplayString>
-
-    <Expand>
       <Item Name="[comparator]" ExcludeView="simple">_Key_compare</Item>
-      <Item Name="[size]">size()</Item>
       <CustomListItems>
         <Variable Name="i" InitialValue="0" />
         <Size>size()</Size>
@@ -2376,37 +2323,11 @@ SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
     </Expand>
   </Type>
 
-  <!-- KeyContainer: std::deque, MappedContainer: std::deque -->
-  <Type Name="std::flat_map&lt;*,*,*,std::deque&lt;*&gt;,std::deque&lt;*&gt;&gt;">
-    <Intrinsic Name="size" Expression="_Data.keys._Mypair._Myval2._Mysize" />
-    <Intrinsic Name="key_at" Expression="&amp;_Data.keys._Mypair._Myval2._Map[((index + _Data.keys._Mypair._Myval2._Myoff) / _Data.keys._EEN_DS) %
-          _Data.keys._Mypair._Myval2._Mapsize][(index + _Data.keys._Mypair._Myval2._Myoff) % _Data.keys._EEN_DS]">
-      <Parameter Name="index" Type="size_t" />
-    </Intrinsic>
-    <Intrinsic Name="value_at" Expression="&amp;_Data.values._Mypair._Myval2._Map[((index + _Data.values._Mypair._Myval2._Myoff) / _Data.values._EEN_DS) %
-          _Data.values._Mypair._Myval2._Mapsize][(index + _Data.values._Mypair._Myval2._Myoff) % _Data.values._EEN_DS]">
-      <Parameter Name="index" Type="size_t" />
-    </Intrinsic>
-
+  <!-- fallback when the primary visualization (above) fails to parse, e.g. some custom containers -->
+  <Type Name="std::flat_map&lt;*&gt;" Priority="MediumLow">
+    <AlternativeType Name="std::flat_multimap&lt;*&gt;"/>
+    <Intrinsic Name="size" Expression="_Data.keys.size()"/>
     <DisplayString>{{ size={size()} }}</DisplayString>
-
-    <Expand>
-      <Item Name="[comparator]" ExcludeView="simple">_Key_compare</Item>
-      <Item Name="[size]">size()</Item>
-      <CustomListItems>
-        <Variable Name="i" InitialValue="0" />
-        <Size>size()</Size>
-        <Loop>
-          <Item Name="[{*key_at(i)}]">*value_at(i)</Item>
-          <Exec>++i</Exec>
-        </Loop>
-      </CustomListItems>
-    </Expand>
-  </Type>
-
-  <!-- fallback for a custom container -->
-  <Type Name="std::flat_map&lt;*&gt;">
-    <DisplayString>{_Data}</DisplayString>
     <Expand>
       <Item Name="[comparator]" ExcludeView="simple">_Key_compare</Item>
       <Item Name="[keys]">_Data.keys</Item>
@@ -2423,6 +2344,7 @@ SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   </Type>
 
   <Type Name="std::flat_set&lt;*&gt;">
+    <AlternativeType Name="std::flat_multiset&lt;*&gt;"/>
     <DisplayString>{_Mycont}</DisplayString>
     <Expand>
       <Item Name="[comparator]" ExcludeView="simple">_Mycomp</Item>

From 906839002475adde3fd98deb14d96cda56c1ff38 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vojt=C4=9Bch=20Michal?= <vojta.michall@email.cz>
Date: Fri, 16 Jan 2026 20:52:00 +0100
Subject: [PATCH 110/134] `<flat_map>`: Fix new libcxx test failure due to
 argument type mismatch when calling `ranges::remove_if` from
 `flat_map::erase_if` (#6017)

Co-authored-by: Stephan T. Lavavej <stl@microsoft.com>
---
 stl/inc/flat_map                  | 4 +++-
 tests/libcxx/expected_results.txt | 4 ----
 2 files changed, 3 insertions(+), 5 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index 4ab4085e7e4..9593e99bec1 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -1025,7 +1025,9 @@ private:
     _NODISCARD size_type _Erase_if(_Predicate _Pred) {
         _Clear_guard _Guard{this};
 
-        const auto _New_last = _RANGES remove_if(_View_to_mutate(), _Pred).begin();
+        // N5032 [flat.map.erasure]/2 and [flat.multimap.erasure]/2
+        const auto _Proj     = [](const auto& _Element) _STATIC_CALL_OPERATOR { return const_reference{_Element}; };
+        const auto _New_last = _RANGES remove_if(_View_to_mutate(), _Pred, _Proj).begin();
         const auto _Old_size = size();
 
         _Data.keys.erase(_New_last._Key_it, _Data.keys.end());
diff --git a/tests/libcxx/expected_results.txt b/tests/libcxx/expected_results.txt
index 52705a56c91..d21b291e7ab 100644
--- a/tests/libcxx/expected_results.txt
+++ b/tests/libcxx/expected_results.txt
@@ -1360,10 +1360,6 @@ std/algorithms/alg.modifying.operations/alg.copy/copy.pass.cpp:1 FAIL
 std/input.output/file.streams/fstreams/filebuf.virtuals/xsputn.pass.cpp:0 FAIL
 std/input.output/file.streams/fstreams/filebuf.virtuals/xsputn.pass.cpp:1 FAIL
 
-# FIXME, not analyzed. _Flat_map_base::_Erase_if's usage of ranges::remove_if is failing to compile.
-std/containers/container.adaptors/flat.map/robust_against_nonbool.compile.pass.cpp FAIL
-std/containers/container.adaptors/flat.multimap/robust_against_nonbool.compile.pass.cpp FAIL
-
 
 # *** XFAILS WHICH PASS ***
 # These tests contain `// XFAIL: msvc` comments, which accurately describe runtime failures for x86 and x64.

From f7961e7691bd12b9d16a395b3636e5516595e3ee Mon Sep 17 00:00:00 2001
From: Alex Guteniev <gutenev@gmail.com>
Date: Tue, 20 Jan 2026 18:16:36 +0200
Subject: [PATCH 111/134] `<flat_set>`, `<flat_map>`: compare for equality
 instead of equivalence for usual types (#6024)

Co-authored-by: Stephan T. Lavavej <stl@microsoft.com>
---
 benchmarks/CMakeLists.txt           |  1 +
 benchmarks/src/flat_meow_assign.cpp | 52 +++++++++++++++++++++++++++++
 stl/inc/__msvc_string_view.hpp      |  6 ++++
 stl/inc/flat_map                    | 15 +++++++--
 stl/inc/flat_set                    | 15 ++++++---
 stl/inc/xstring                     |  6 ++++
 stl/inc/xutility                    | 10 ++++++
 7 files changed, 98 insertions(+), 7 deletions(-)
 create mode 100644 benchmarks/src/flat_meow_assign.cpp

diff --git a/benchmarks/CMakeLists.txt b/benchmarks/CMakeLists.txt
index ff6c3ad1651..04e942926d7 100644
--- a/benchmarks/CMakeLists.txt
+++ b/benchmarks/CMakeLists.txt
@@ -111,6 +111,7 @@ add_benchmark(filesystem src/filesystem.cpp)
 add_benchmark(fill src/fill.cpp)
 add_benchmark(find_and_count src/find_and_count.cpp)
 add_benchmark(find_first_of src/find_first_of.cpp)
+add_benchmark(flat_meow_assign src/flat_meow_assign.cpp)
 add_benchmark(has_single_bit src/has_single_bit.cpp)
 add_benchmark(includes src/includes.cpp)
 add_benchmark(integer_to_string src/integer_to_string.cpp)
diff --git a/benchmarks/src/flat_meow_assign.cpp b/benchmarks/src/flat_meow_assign.cpp
new file mode 100644
index 00000000000..07b718695f5
--- /dev/null
+++ b/benchmarks/src/flat_meow_assign.cpp
@@ -0,0 +1,52 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <benchmark/benchmark.h>
+#include <flat_map>
+#include <flat_set>
+#include <string>
+
+using namespace std;
+
+void flat_map_strings(benchmark::State& state) {
+    flat_map<string, int> pieces;
+    for (auto _ : state) {
+        pieces = {{"soldier"s, 1}, {"soldier"s, 2}, {"soldier"s, 3}, {"soldier"s, 4}, {"soldier"s, 5}, {"soldier"s, 6},
+            {"soldier"s, 7}, {"soldier"s, 8}, {"tower"s, 9}, {"horse"s, 10}, {"elephant"s, 11}, {"vizier"s, 12},
+            {"king"s, 13}, {"elephant"s, 14}, {"horse"s, 15}, {"tower"s, 16}};
+        benchmark::DoNotOptimize(pieces);
+    }
+}
+
+void flat_set_strings(benchmark::State& state) {
+    flat_set<string> pieces;
+    for (auto _ : state) {
+        pieces = {"soldier"s, "soldier"s, "soldier"s, "soldier"s, "soldier"s, "soldier"s, "soldier"s, "soldier"s,
+            "tower"s, "horse"s, "elephant"s, "vizier"s, "king"s, "elephant"s, "horse"s, "tower"s};
+        benchmark::DoNotOptimize(pieces);
+    }
+}
+
+void flat_map_integers(benchmark::State& state) {
+    flat_map<int, int> pieces;
+    for (auto _ : state) {
+        pieces = {{'s', 1}, {'s', 2}, {'s', 3}, {'s', 4}, {'s', 5}, {'s', 6}, {'s', 7}, {'s', 8}, {'T', 9}, {'H', 10},
+            {'E', 11}, {'V', 12}, {'K', 13}, {'E', 14}, {'H', 15}, {'T', 16}};
+        benchmark::DoNotOptimize(pieces);
+    }
+}
+
+void flat_set_integers(benchmark::State& state) {
+    flat_set<int> pieces;
+    for (auto _ : state) {
+        pieces = {'s', 's', 's', 's', 's', 's', 's', 's', 'T', 'H', 'E', 'V', 'K', 'E', 'H', 'T'};
+        benchmark::DoNotOptimize(pieces);
+    }
+}
+
+BENCHMARK(flat_map_strings);
+BENCHMARK(flat_set_strings);
+BENCHMARK(flat_map_integers);
+BENCHMARK(flat_set_integers);
+
+BENCHMARK_MAIN();
diff --git a/stl/inc/__msvc_string_view.hpp b/stl/inc/__msvc_string_view.hpp
index 587f09a142c..303653318e3 100644
--- a/stl/inc/__msvc_string_view.hpp
+++ b/stl/inc/__msvc_string_view.hpp
@@ -2148,6 +2148,12 @@ inline namespace literals {
     } // namespace string_view_literals
 } // namespace literals
 #endif // _HAS_CXX17
+
+#if _HAS_CXX23
+template <class _Elem, class _Traits>
+constexpr bool _Equivalence_is_equality_impl<basic_string_view<_Elem, _Traits>> =
+    _Is_implementation_handled_char_traits<_Traits>;
+#endif // _HAS_CXX23
 _STD_END
 
 #pragma pop_macro("new")
diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index 9593e99bec1..394fa0394ad 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -1084,12 +1084,21 @@ private:
         _STL_INTERNAL_CHECK(_Is_sorted_and_unique());
     }
 
+    auto _Erase_dupes_if_not_multi_pred() {
+        _STL_INTERNAL_STATIC_ASSERT(_IsUnique);
+        if constexpr (_Equivalence_is_equality<_Compare, _Key>) {
+            return [](const_reference _Left, const_reference _Right)
+                       _STATIC_CALL_OPERATOR { return _Left.first == _Right.first; };
+        } else {
+            return
+                [this](const_reference _Left, const_reference _Right) { return _Key_equal(_Left.first, _Right.first); };
+        }
+    }
+
     void _Erase_dupes_if_not_multi() {
         if constexpr (_IsUnique) {
             auto _Sorted_view    = _View_to_mutate();
-            const auto _New_last = _RANGES unique(_Sorted_view, [this](const_reference _Left, const_reference _Right) {
-                return this->_Key_equal(_Left.first, _Right.first);
-            }).begin();
+            const auto _New_last = _RANGES unique(_Sorted_view, _Erase_dupes_if_not_multi_pred()).begin();
 
             _Data.keys.erase(_New_last._Key_it, _Data.keys.end());
             _Data.values.erase(_New_last._Mapped_it, _Data.values.end());
diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index 5491de0dee9..d5de1e9ff2e 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -705,13 +705,20 @@ private:
         }
     }
 
+    auto _Erase_dupes_if_not_multi_pred() {
+        _STL_INTERNAL_STATIC_ASSERT(_IsUnique);
+        if constexpr (_Equivalence_is_equality<_Keylt, _Kty>) {
+            return equal_to<>{};
+        } else {
+            return
+                [this](const _Kty& _Lhs, const _Kty& _Rhs) { return !_Compare(_Lhs, _Rhs) && !_Compare(_Rhs, _Lhs); };
+        }
+    }
+
     void _Erase_dupes_if_not_multi() {
         if constexpr (_IsUnique) {
-            const auto _Equivalent = [this](const _Kty& _Lhs, const _Kty& _Rhs) {
-                return !_Compare(_Lhs, _Rhs) && !_Compare(_Rhs, _Lhs);
-            };
             const auto _End = _Mycont.end();
-            _Mycont.erase(_STD unique(_Mycont.begin(), _End, _Equivalent), _End);
+            _Mycont.erase(_STD unique(_Mycont.begin(), _End, _Erase_dupes_if_not_multi_pred()), _End);
         }
     }
 
diff --git a/stl/inc/xstring b/stl/inc/xstring
index 1af2f85fe18..1617a4aa381 100644
--- a/stl/inc/xstring
+++ b/stl/inc/xstring
@@ -3236,6 +3236,12 @@ private:
 
 #pragma warning(pop)
 
+#if _HAS_CXX23
+template <class _Elem, class _Traits, class _Alloc>
+constexpr bool _Equivalence_is_equality_impl<basic_string<_Elem, _Traits, _Alloc>> =
+    _Is_implementation_handled_char_traits<_Traits>;
+#endif // _HAS_CXX23
+
 #if _HAS_CXX17
 template <class _Iter, class _Alloc = allocator<_Iter_value_t<_Iter>>,
     enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_allocator<_Alloc>>, int> = 0>
diff --git a/stl/inc/xutility b/stl/inc/xutility
index 6988002faeb..39e202b8c27 100644
--- a/stl/inc/xutility
+++ b/stl/inc/xutility
@@ -7920,6 +7920,16 @@ _NODISCARD constexpr bool _Mul_overflow(const _Int _Left, const _Int _Right, _In
 }
 #endif // _HAS_CXX17
 
+#if _HAS_CXX23
+template <class _Ty>
+constexpr bool _Equivalence_is_equality_impl = is_integral_v<_Ty> || is_pointer_v<_Ty>;
+
+// For ranges::less and ranges::greater, see N5032 [range.cmp]/9, [concept.totallyordered]/1.1, [cmp.concept]/1.2.
+template <class _Compare, class _Key>
+constexpr bool _Equivalence_is_equality =
+    _Is_any_of_v<_Compare, _RANGES less, _RANGES greater>
+    || (_Is_any_of_v<_Compare, less<>, less<_Key>, greater<>, greater<_Key>> && _Equivalence_is_equality_impl<_Key>);
+#endif // _HAS_CXX23
 _STD_END
 
 // TRANSITION, non-_Ugly attribute tokens

From d5d3ac224a3e271d411aa60908a7f5bf32b0bc12 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Wed, 21 Jan 2026 01:14:56 -0800
Subject: [PATCH 112/134] Switch to Standard mode checks.

---
 .../GH_005968_headers_provide_begin_end/test_flat_map.cpp  | 7 +++----
 .../GH_005968_headers_provide_begin_end/test_flat_set.cpp  | 7 +++----
 2 files changed, 6 insertions(+), 8 deletions(-)

diff --git a/tests/std/tests/GH_005968_headers_provide_begin_end/test_flat_map.cpp b/tests/std/tests/GH_005968_headers_provide_begin_end/test_flat_map.cpp
index 76a545f65c4..16dafe71849 100644
--- a/tests/std/tests/GH_005968_headers_provide_begin_end/test_flat_map.cpp
+++ b/tests/std/tests/GH_005968_headers_provide_begin_end/test_flat_map.cpp
@@ -2,8 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 #include <version>
-#if defined(__cpp_lib_flat_map)
-static_assert(false, "When this feature is implemented, update this to a Standard mode check.");
+#if _HAS_CXX23
 
 #include <flat_map>
 
@@ -27,8 +26,8 @@ void test_flat_map() {
     }
 }
 
-#else // ^^^ defined(__cpp_lib_flat_map) / !defined(__cpp_lib_flat_map) vvv
+#else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
 
 void test_flat_map() {}
 
-#endif // ^^^ !defined(__cpp_lib_flat_map) ^^^
+#endif // ^^^ !_HAS_CXX23 ^^^
diff --git a/tests/std/tests/GH_005968_headers_provide_begin_end/test_flat_set.cpp b/tests/std/tests/GH_005968_headers_provide_begin_end/test_flat_set.cpp
index 811f96eeea9..d995b42124a 100644
--- a/tests/std/tests/GH_005968_headers_provide_begin_end/test_flat_set.cpp
+++ b/tests/std/tests/GH_005968_headers_provide_begin_end/test_flat_set.cpp
@@ -2,8 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 #include <version>
-#if defined(__cpp_lib_flat_set)
-static_assert(false, "When this feature is implemented, update this to a Standard mode check.");
+#if _HAS_CXX23
 
 #include <flat_set>
 
@@ -21,8 +20,8 @@ void test_flat_set() {
     }
 }
 
-#else // ^^^ defined(__cpp_lib_flat_set) / !defined(__cpp_lib_flat_set) vvv
+#else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
 
 void test_flat_set() {}
 
-#endif // ^^^ !defined(__cpp_lib_flat_set) ^^^
+#endif // ^^^ !_HAS_CXX23 ^^^

From 85e190eca0800d40cd656fdb4c7cf5346a6b91c3 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Wed, 21 Jan 2026 03:14:04 -0800
Subject: [PATCH 113/134] `<flat_meow>`: Minor cleanups (#6034)

---
 stl/inc/flat_map                              | 24 ++++++++++---------
 tests/std/tests/P0429R9_flat_map/test.cpp     | 14 +++++------
 .../test.compile.pass.cpp                     |  2 +-
 3 files changed, 21 insertions(+), 19 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index 394fa0394ad..2e294d5c822 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -318,15 +318,17 @@ public:
         "mapped_container_type must support random-access iterators in order to be adapted. "
         "(N5014 [flat.map.overview]/7, [flat.multimap.overview]/7)");
 
-    struct value_compare {
+    class value_compare {
     public:
         _NODISCARD bool operator()(const_reference _Left, const_reference _Right) const {
             return _Key_comparator(_Left.first, _Right.first);
         }
 
-        value_compare(key_compare _Comp) : _Key_comparator(_Comp) {}
-
     private:
+        friend _Flat_map_base;
+
+        value_compare(const key_compare& _Comp) : _Key_comparator(_Comp) {}
+
         key_compare _Key_comparator;
     };
 
@@ -902,19 +904,19 @@ protected:
         if constexpr (_IsUnique) {
             if (_Key_it != _Data.keys.begin() && !_Key_compare(*(_Key_it - 1), _STD forward<_OtherKey>(_Key_val))) {
                 // Previous element is equivalent to key, no insert needed
-                return {this->begin() + (_Index - 1), false};
+                return {begin() + (_Index - 1), false};
             }
         }
 
         // Need to insert
         key_type _Key_to_insert(_STD forward<_OtherKey>(_Key_val));
         mapped_type _Mapped_to_insert(_STD forward<_MappedArgTypes>(_Mapped_args)...);
-        _Insert_exact(this->cbegin() + _Index, _STD move(_Key_to_insert), _STD move(_Mapped_to_insert));
+        _Insert_exact(cbegin() + _Index, _STD move(_Key_to_insert), _STD move(_Mapped_to_insert));
 
         if constexpr (_IsUnique) {
-            return {this->begin() + _Index, true};
+            return {begin() + _Index, true};
         } else {
-            return this->begin() + _Index;
+            return begin() + _Index;
         }
     }
 
@@ -986,7 +988,7 @@ protected:
             }
         }
 
-        const auto _Dist = _New_position - this->begin();
+        const auto _Dist = _New_position - begin();
         {
             key_type _Key_to_insert(_STD forward<_OtherKey>(_Key_val));
             mapped_type _Mapped_to_insert(_STD forward<_MappedArgTypes>(_Args)...);
@@ -1260,12 +1262,12 @@ public:
     mapped_type& operator[](const key_type& _Key_val)
         requires is_default_constructible_v<mapped_type>
     {
-        return this->try_emplace(_Key_val).first->second;
+        return try_emplace(_Key_val).first->second;
     }
     mapped_type& operator[](key_type&& _Key_val)
         requires is_default_constructible_v<mapped_type>
     {
-        return this->try_emplace(_STD move(_Key_val)).first->second;
+        return try_emplace(_STD move(_Key_val)).first->second;
     }
 
     template <class _OtherKey>
@@ -1273,7 +1275,7 @@ public:
         requires _Transparent<key_compare> && is_constructible_v<key_type, _OtherKey>
               && is_default_constructible_v<mapped_type>
     {
-        return this->try_emplace(_STD forward<_OtherKey>(_Key_val)).first->second;
+        return try_emplace(_STD forward<_OtherKey>(_Key_val)).first->second;
     }
 
     _NODISCARD mapped_type& at(const key_type& _Key_val) {
diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index c7e0aba31d0..e2a4a9b8733 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -30,7 +30,7 @@ constexpr bool is_specialization_v = false;
 template <template <class...> class Tmpl, class... Ts>
 constexpr bool is_specialization_v<Tmpl<Ts...>, Tmpl> = true;
 
-template <typename T>
+template <class T>
 concept IsFlatMap =
     is_specialization_v<remove_cvref_t<T>, flat_map> || is_specialization_v<remove_cvref_t<T>, flat_multimap>;
 
@@ -120,7 +120,7 @@ template <IsFlatMap T>
     });
 }
 
-template <typename T>
+template <class T>
 class MyAllocator : public allocator<T> {
 public:
     using value_type = T;
@@ -169,14 +169,14 @@ namespace std {
     };
 } // namespace std
 
-template <typename T>
+template <class T>
 class Packaged {
 private:
     T value;
 
 public:
     Packaged() : value() {}
-    template <typename U>
+    template <class U>
         requires constructible_from<T, U&&>
     Packaged(U&& u) : value(forward<U>(u)) {}
 
@@ -197,10 +197,10 @@ class Packaged {
     friend auto operator<=>(const Packaged&, const Packaged&) = default;
 };
 
-template <typename T>
+template <class T>
 struct PackagedCompare : less<Packaged<T>> {};
 
-template <typename T>
+template <class T>
 struct TransparentPackagedCompare : PackagedCompare<T> {
     using is_transparent = void;
 
@@ -1183,7 +1183,7 @@ void test_throwing_compare_swap_single() {
 }
 
 // Test that changes in GH-5987 did not break calls of lookup member functions by using deducing this.
-template <typename T>
+template <class T>
 void test_lookup_call_on_temporaries_single() {
     (void) T{}.lower_bound(42);
     (void) T{}.lower_bound('a');
diff --git a/tests/std/tests/P0429R9_flat_map_ms_specific/test.compile.pass.cpp b/tests/std/tests/P0429R9_flat_map_ms_specific/test.compile.pass.cpp
index 335c8e14326..fd39e6a478c 100644
--- a/tests/std/tests/P0429R9_flat_map_ms_specific/test.compile.pass.cpp
+++ b/tests/std/tests/P0429R9_flat_map_ms_specific/test.compile.pass.cpp
@@ -51,7 +51,7 @@ struct flat_map_unique_if_impl<false> {
 template <bool IsUnique, class Key, class Mapped, class Comp, class KeyCont, class MappedCont>
 using flat_map_unique_if = flat_map_unique_if_impl<IsUnique>::template type<Key, Mapped, Comp, KeyCont, MappedCont>;
 
-template <typename A, typename B>
+template <class A, class B>
 constexpr bool has_different_nested_types = !is_same_v<typename A::value_compare, typename B::value_compare>
                                          && !is_same_v<typename A::containers, typename B::containers>;
 

From d935258605456ca79b68502f42955ca268449f50 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vojt=C4=9Bch=20Michal?= <vojta.michall@email.cz>
Date: Thu, 22 Jan 2026 08:03:35 +0100
Subject: [PATCH 114/134] `<flat_map>`: Make
 `_Pairing_iterator_provider::_Iterator` debugging and unwrapping more
 consistent with the rest of standard library (#6035)

Co-authored-by: Stephan T. Lavavej <stl@microsoft.com>
---
 stl/inc/flat_map                              | 56 +++++++++++-------
 .../test.compile.pass.cpp                     | 59 +++++++++++++++++++
 tests/std/tests/P0429R9_flat_map/test.cpp     | 37 ++++++++++++
 3 files changed, 131 insertions(+), 21 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index 2e294d5c822..b3e4e72c543 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -53,23 +53,27 @@ template <class _KeyIter, class _MappedIter, class _MappedConvIter>
 struct _Pairing_iterator_provider {
     class _Iterator {
     public:
+        using iterator_category = input_iterator_tag;
+        using iterator_concept  = random_access_iterator_tag;
+        using difference_type   = ptrdiff_t;
+        using value_type        = pair<iter_value_t<_KeyIter>, iter_value_t<_MappedIter>>;
+        using reference         = pair<iter_reference_t<_KeyIter>, iter_reference_t<_MappedIter>>;
+
+        _Iterator() = default;
+
+    private:
         template <bool _IsUnique, class _Key, class _Mapped, class _Compare, class _KeyContainer,
             class _MappedContainer>
         friend class _Flat_map_base;
+        template <class _Key, class _Mapped, class _MappedConv>
+        friend struct _Pairing_iterator_provider;
 
-        _Iterator() = default;
         _Iterator(_KeyIter _Key_iter, _MappedIter _Mapped_iter)
             noexcept(is_nothrow_move_constructible_v<_KeyIter> && is_nothrow_move_constructible_v<_MappedIter>)
             : _Key_it(_STD move(_Key_iter)), _Mapped_it(_STD move(_Mapped_iter)) {}
 
-        using iterator_category = input_iterator_tag;
-        using iterator_concept  = random_access_iterator_tag;
-        using difference_type   = ptrdiff_t;
-        using value_type        = pair<iter_value_t<_KeyIter>, iter_value_t<_MappedIter>>;
-        using reference         = pair<iter_reference_t<_KeyIter>, iter_reference_t<_MappedIter>>;
-
-    private:
-        using _Const_iterator = _Pairing_iterator_provider<_KeyIter, _MappedConvIter, _MappedConvIter>::_Iterator;
+        using _Const_iterator     = _Pairing_iterator_provider<_KeyIter, _MappedConvIter, _MappedConvIter>::_Iterator;
+        using _Unwrapped_iterator = _Unwrapped_pairing_iterator<_KeyIter, _MappedIter, _MappedConvIter>;
 
         class _Arrow_proxy {
         public:
@@ -112,10 +116,12 @@ struct _Pairing_iterator_provider {
         }
 
         _NODISCARD bool operator==(const _Iterator& _Right) const {
+            _Compat(_Right);
             return _Key_it == _Right._Key_it;
         }
 
         _NODISCARD auto operator<=>(const _Iterator& _Right) const {
+            _Compat(_Right);
             return _Synth_three_way{}(_Key_it, _Right._Key_it);
         }
 
@@ -160,6 +166,7 @@ struct _Pairing_iterator_provider {
         }
 
         _NODISCARD difference_type operator-(const _Iterator& _Right) const {
+            _Compat(_Right);
             return _Key_it - _Right._Key_it;
         }
 
@@ -173,16 +180,16 @@ struct _Pairing_iterator_provider {
             return _Const_iterator{_Key_it, _Mapped_it};
         }
 
-        _NODISCARD const _KeyIter& _Key_iterator() const noexcept {
-            return _Key_it;
-        }
-
-        _NODISCARD const _MappedIter& _Mapped_iterator() const noexcept {
-            return _Mapped_it;
+        void _Compat([[maybe_unused]] const _Iterator& _Right) const noexcept { // test for compatible iterator pair
+#if _ITERATOR_DEBUG_LEVEL != 0
+            _STL_VERIFY(
+                _Key_it - _Right._Key_it == _Mapped_it - _Right._Mapped_it, "iterators from inconsistent ranges");
+#endif // _ITERATOR_DEBUG_LEVEL != 0
         }
 
         using _Prevent_inheriting_unwrap = _Iterator;
 
+#if _ITERATOR_DEBUG_LEVEL != 0
         friend void _Verify_range(const _Iterator& _First, const _Iterator& _Last) noexcept {
             if constexpr (_Range_verifiable_v<_KeyIter>) {
                 _Verify_range(_First._Key_it, _Last._Key_it); // intentional ADL
@@ -192,9 +199,9 @@ struct _Pairing_iterator_provider {
                 _Verify_range(_First._Mapped_it, _Last._Mapped_it); // intentional ADL
             }
 
-            _STL_VERIFY(_Last._Key_it - _First._Key_it == _Last._Mapped_it - _First._Mapped_it,
-                "iterators from inconsistent ranges");
+            _First._Compat(_Last);
         }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
 
         void _Verify_offset(const difference_type _Off) const noexcept {
             if constexpr (_Offset_verifiable_v<_KeyIter>) {
@@ -213,18 +220,25 @@ struct _Pairing_iterator_provider {
         _NODISCARD auto _Unwrapped() const
             requires _Can_unwrap_pairing_iterator<_KeyIter, _MappedIter, _MappedConvIter>
         {
-            using _Unwrapped_iterator = _Unwrapped_pairing_iterator<_KeyIter, _MappedIter, _MappedConvIter>;
             return _Unwrapped_iterator{_STD _Get_unwrapped(_Key_it), _STD _Get_unwrapped(_Mapped_it)};
         }
 
-        void _Seek_to(const _Unwrapped_pairing_iterator<_KeyIter, _MappedIter, _MappedConvIter>& _Dst)
+        static constexpr bool _Unwrap_when_unverified = _Do_unwrap_when_unverified_v<_KeyIter>
+                                                     && _Do_unwrap_when_unverified_v<_MappedIter>
+                                                     && _Do_unwrap_when_unverified_v<_MappedConvIter>;
+
+        void _Seek_to(const _Unwrapped_iterator& _Dst)
             requires _Can_unwrap_pairing_iterator<_KeyIter, _MappedIter, _MappedConvIter>
         {
-            _STD _Seek_wrapped(_Key_it, _Dst._Key_iterator());
-            _STD _Seek_wrapped(_Mapped_it, _Dst._Mapped_iterator());
+            _STD _Seek_wrapped(_Key_it, _Dst._Key_it);
+            _STD _Seek_wrapped(_Mapped_it, _Dst._Mapped_it);
         }
 
+#ifdef _ENABLE_STL_INTERNAL_CHECK
+    public:
+#else
     private:
+#endif
         _KeyIter _Key_it;
         _MappedIter _Mapped_it;
     };
diff --git a/tests/std/tests/Dev10_709168_marking_iterators_as_checked/test.compile.pass.cpp b/tests/std/tests/Dev10_709168_marking_iterators_as_checked/test.compile.pass.cpp
index 4a4b9435c9a..e137800b970 100644
--- a/tests/std/tests/Dev10_709168_marking_iterators_as_checked/test.compile.pass.cpp
+++ b/tests/std/tests/Dev10_709168_marking_iterators_as_checked/test.compile.pass.cpp
@@ -5,6 +5,8 @@
 #include <cstddef>
 #include <deque>
 #include <filesystem>
+#include <flat_map>
+#include <flat_set>
 #include <forward_list>
 #include <iterator>
 #include <list>
@@ -109,6 +111,14 @@ STATIC_ASSERT(stl_checked == _Range_verifiable_v<span<int>::iterator>);
 STATIC_ASSERT(stl_checked == _Range_verifiable_v<span<int>::reverse_iterator>);
 #endif // _HAS_CXX20
 
+#if _HAS_CXX23
+// Checks for flat_set should trivially pass since it directly uses the underlying container's iterator
+STATIC_ASSERT(stl_checked == _Range_verifiable_v<flat_set<int>::iterator>);
+STATIC_ASSERT(stl_checked == _Range_verifiable_v<flat_set<int>::reverse_iterator>);
+STATIC_ASSERT(stl_checked == _Range_verifiable_v<flat_map<int, int>::iterator>);
+STATIC_ASSERT(stl_checked == _Range_verifiable_v<flat_map<int, int>::reverse_iterator>);
+#endif // _HAS_CXX23
+
 STATIC_ASSERT(!_Range_verifiable_v<::DerivedFrom<string::iterator>>);
 STATIC_ASSERT(!_Range_verifiable_v<::DerivedFrom<string::const_iterator>>);
 STATIC_ASSERT(!_Range_verifiable_v<::DerivedFrom<string::reverse_iterator>>);
@@ -181,6 +191,13 @@ STATIC_ASSERT(!_Range_verifiable_v<::DerivedFrom<span<int>::iterator>>);
 STATIC_ASSERT(!_Range_verifiable_v<::DerivedFrom<span<int>::reverse_iterator>>);
 #endif // _HAS_CXX20
 
+#if _HAS_CXX23
+STATIC_ASSERT(!_Range_verifiable_v<::DerivedFrom<flat_set<int>::iterator>>);
+STATIC_ASSERT(!_Range_verifiable_v<::DerivedFrom<flat_set<int>::reverse_iterator>>);
+STATIC_ASSERT(!_Range_verifiable_v<::DerivedFrom<flat_map<int, int>::iterator>>);
+STATIC_ASSERT(!_Range_verifiable_v<::DerivedFrom<flat_map<int, int>::reverse_iterator>>);
+#endif // _HAS_CXX23
+
 template <class I, bool Expected>
 constexpr bool test_unwrappable() {
     STATIC_ASSERT(_Unwrappable_v<I&> == Expected);
@@ -394,6 +411,13 @@ STATIC_ASSERT(test_unwrappable_for_unverified<span<int>::iterator, !stl_checked>
 STATIC_ASSERT(test_unwrappable_for_unverified<span<int>::reverse_iterator, !stl_checked>());
 #endif // _HAS_CXX20
 
+#if _HAS_CXX23
+STATIC_ASSERT(test_unwrappable_for_unverified<flat_set<int>::iterator, !stl_checked>());
+STATIC_ASSERT(test_unwrappable_for_unverified<flat_set<int>::reverse_iterator, !stl_checked>());
+STATIC_ASSERT(test_unwrappable_for_unverified<flat_map<int, int>::iterator, !stl_checked>());
+STATIC_ASSERT(test_unwrappable_for_unverified<flat_map<int, int>::reverse_iterator, !stl_checked>());
+#endif // _HAS_CXX23
+
 STATIC_ASSERT(test_unwrappable<string::iterator, true>());
 STATIC_ASSERT(test_unwrappable<string::const_iterator, true>());
 STATIC_ASSERT(test_unwrappable<string::reverse_iterator, true>());
@@ -467,6 +491,13 @@ STATIC_ASSERT(test_unwrappable<span<int>::iterator, true>());
 STATIC_ASSERT(test_unwrappable<span<int>::reverse_iterator, true>());
 #endif // _HAS_CXX20
 
+#if _HAS_CXX23
+STATIC_ASSERT(test_unwrappable<flat_set<int>::iterator, true>());
+STATIC_ASSERT(test_unwrappable<flat_set<int>::reverse_iterator, true>());
+STATIC_ASSERT(test_unwrappable<flat_map<int, int>::iterator, true>());
+STATIC_ASSERT(test_unwrappable<flat_map<int, int>::reverse_iterator, true>());
+#endif // _HAS_CXX23
+
 STATIC_ASSERT(test_unwrappable_for_offset<string::iterator, true>());
 STATIC_ASSERT(test_unwrappable_for_offset<string::const_iterator, true>());
 STATIC_ASSERT(test_unwrappable_for_offset<string::reverse_iterator, true>());
@@ -540,6 +571,13 @@ STATIC_ASSERT(test_unwrappable_for_offset<span<int>::iterator, true>());
 STATIC_ASSERT(test_unwrappable_for_offset<span<int>::reverse_iterator, true>());
 #endif // _HAS_CXX20
 
+#if _HAS_CXX23
+STATIC_ASSERT(test_unwrappable_for_offset<flat_set<int>::iterator, true>());
+STATIC_ASSERT(test_unwrappable_for_offset<flat_set<int>::reverse_iterator, true>());
+STATIC_ASSERT(test_unwrappable_for_offset<flat_map<int, int>::iterator, true>());
+STATIC_ASSERT(test_unwrappable_for_offset<flat_map<int, int>::reverse_iterator, true>());
+#endif // _HAS_CXX23
+
 STATIC_ASSERT(test_unwrappable_for_unverified<::DerivedFrom<string::iterator>, false>());
 STATIC_ASSERT(test_unwrappable_for_unverified<::DerivedFrom<string::const_iterator>, false>());
 STATIC_ASSERT(test_unwrappable_for_unverified<::DerivedFrom<string::reverse_iterator>, false>());
@@ -612,6 +650,13 @@ STATIC_ASSERT(test_unwrappable_for_unverified<::DerivedFrom<span<int>::iterator>
 STATIC_ASSERT(test_unwrappable_for_unverified<::DerivedFrom<span<int>::reverse_iterator>, false>());
 #endif // _HAS_CXX20
 
+#if _HAS_CXX23
+STATIC_ASSERT(test_unwrappable_for_unverified<::DerivedFrom<flat_set<int>::iterator>, false>());
+STATIC_ASSERT(test_unwrappable_for_unverified<::DerivedFrom<flat_set<int>::reverse_iterator>, false>());
+STATIC_ASSERT(test_unwrappable_for_unverified<::DerivedFrom<flat_map<int, int>::iterator>, false>());
+STATIC_ASSERT(test_unwrappable_for_unverified<::DerivedFrom<flat_map<int, int>::reverse_iterator>, false>());
+#endif // _HAS_CXX23
+
 STATIC_ASSERT(test_unwrappable<::DerivedFrom<string::iterator>, false>());
 STATIC_ASSERT(test_unwrappable<::DerivedFrom<string::const_iterator>, false>());
 STATIC_ASSERT(test_unwrappable<::DerivedFrom<string::reverse_iterator>, false>());
@@ -684,6 +729,13 @@ STATIC_ASSERT(test_unwrappable<::DerivedFrom<span<int>::iterator>, false>());
 STATIC_ASSERT(test_unwrappable<::DerivedFrom<span<int>::reverse_iterator>, false>());
 #endif // _HAS_CXX20
 
+#if _HAS_CXX23
+STATIC_ASSERT(test_unwrappable<::DerivedFrom<flat_set<int>::iterator>, false>());
+STATIC_ASSERT(test_unwrappable<::DerivedFrom<flat_set<int>::reverse_iterator>, false>());
+STATIC_ASSERT(test_unwrappable<::DerivedFrom<flat_map<int, int>::iterator>, false>());
+STATIC_ASSERT(test_unwrappable<::DerivedFrom<flat_map<int, int>::reverse_iterator>, false>());
+#endif // _HAS_CXX23
+
 STATIC_ASSERT(test_unwrappable_for_offset<::DerivedFrom<string::iterator>, false>());
 STATIC_ASSERT(test_unwrappable_for_offset<::DerivedFrom<string::const_iterator>, false>());
 STATIC_ASSERT(test_unwrappable_for_offset<::DerivedFrom<string::reverse_iterator>, false>());
@@ -755,3 +807,10 @@ STATIC_ASSERT(test_unwrappable_for_offset<::DerivedFrom<std::filesystem::path::c
 STATIC_ASSERT(test_unwrappable_for_offset<::DerivedFrom<span<int>::iterator>, false>());
 STATIC_ASSERT(test_unwrappable_for_offset<::DerivedFrom<span<int>::reverse_iterator>, false>());
 #endif // _HAS_CXX20
+
+#if _HAS_CXX23
+STATIC_ASSERT(test_unwrappable_for_offset<::DerivedFrom<flat_set<int>::iterator>, false>());
+STATIC_ASSERT(test_unwrappable_for_offset<::DerivedFrom<flat_set<int>::reverse_iterator>, false>());
+STATIC_ASSERT(test_unwrappable_for_offset<::DerivedFrom<flat_map<int, int>::iterator>, false>());
+STATIC_ASSERT(test_unwrappable_for_offset<::DerivedFrom<flat_map<int, int>::reverse_iterator>, false>());
+#endif // _HAS_CXX23
diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index e2a4a9b8733..9b2625a1b0d 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -1502,6 +1502,31 @@ void test_death_different_size_replace() {
     cont.replace({42, 137, 137, 3337, 0}, {'a'});
 }
 
+// Reach into the pairing iterator and modify one of the underlying iterators to break invariants
+template <class Iter>
+void vandalize_pairing_iterator(Iter& pairing_iterator) {
+    ++pairing_iterator._Key_it;
+}
+
+enum class iter_test { op_equals, op_spaceship, op_minus };
+
+template <cont_type type, iter_test mode>
+void test_death_iterator_at_different_offset() {
+    using C = conditional_t<type == cont_type::unique, flat_map<int, char>, flat_multimap<int, char>>;
+    C cont{{42, 'a'}, {137, 'g'}, {137, 'r'}, {3337, 'f'}, {7755, 'z'}};
+    auto broken_iter = cont.begin();
+    vandalize_pairing_iterator(broken_iter);
+    if constexpr (mode == iter_test::op_equals) {
+        (void) (cont.end() == broken_iter);
+    } else if constexpr (mode == iter_test::op_spaceship) {
+        (void) (cont.end() <=> broken_iter);
+    } else if constexpr (mode == iter_test::op_minus) {
+        (void) (cont.end() - broken_iter);
+    } else {
+        static_assert(false, "unknown iter_test mode");
+    }
+}
+
 int main(int argc, char* argv[]) {
     std_testing::death_test_executive exec([] { run_normal_tests(); });
 
@@ -1543,5 +1568,17 @@ int main(int argc, char* argv[]) {
     });
 #endif // defined(_DEBUG)
 
+#if _ITERATOR_DEBUG_LEVEL != 0
+    exec.add_death_tests({
+        // Tests specific to flat_map - incompatible key and mapped component of pairing iterator
+        test_death_iterator_at_different_offset<cont_type::unique, iter_test::op_equals>,
+        test_death_iterator_at_different_offset<cont_type::multi, iter_test::op_equals>,
+        test_death_iterator_at_different_offset<cont_type::unique, iter_test::op_spaceship>,
+        test_death_iterator_at_different_offset<cont_type::multi, iter_test::op_spaceship>,
+        test_death_iterator_at_different_offset<cont_type::unique, iter_test::op_minus>,
+        test_death_iterator_at_different_offset<cont_type::multi, iter_test::op_minus>,
+    });
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
     return exec.run(argc, argv);
 }

From 8c5ec8dd8ff367343468cd36ed31f01858d06fc3 Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34@live.cn>
Date: Fri, 23 Jan 2026 02:17:40 +0800
Subject: [PATCH 115/134] Pass a tinier `value_compare`-like comparator to
 algorithms (#6038)

---
 stl/inc/flat_map | 26 ++++++++++++++++++++++----
 1 file changed, 22 insertions(+), 4 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index b3e4e72c543..944d67861b4 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -275,6 +275,21 @@ struct _NODISCARD _Flat_map_swap_clear_guard<true, _Containers> {
     void _Dismiss() noexcept {}
 };
 
+template <class _Compare, class _Key, class _Mapped>
+struct _Value_compare_to_pass_in_flat_map {
+    using _Key_compare =
+        conditional_t<conjunction_v<bool_constant<sizeof(_Compare) <= sizeof(void*)>,
+                          is_trivially_copy_constructible<_Compare>, is_trivially_destructible<_Compare>>,
+            _Compare, const _Compare&>;
+    using _Const_reference = pair<const _Key&, const _Mapped&>;
+
+    _Key_compare _Key_comparator;
+
+    _NODISCARD bool operator()(_Const_reference _Left, _Const_reference _Right) const {
+        return _Key_comparator(_Left.first, _Right.first);
+    }
+};
+
 _EXPORT_STD template <class _Key, class _Mapped, class _Compare = less<_Key>, class _KeyContainer = vector<_Key>,
     class _MappedContainer = vector<_Mapped>>
 class flat_map;
@@ -1066,6 +1081,8 @@ public:
     }
 
 private:
+    using _Value_compare_to_pass = _Value_compare_to_pass_in_flat_map<_Compare, _Key, _Mapped>;
+
     _NODISCARD bool _Is_sorted_and_unique(
         const key_container_type::const_iterator _It, const key_container_type::const_iterator _End) const {
         if constexpr (_IsUnique) {
@@ -1092,8 +1109,8 @@ private:
         auto _View                        = _View_to_mutate();
         const auto _Begin_unsorted_values = _View.begin() + _Num_sorted;
 
-        _RANGES sort(_Begin_unsorted_values, _View.end(), value_compare{_Key_compare});
-        _RANGES inplace_merge(_View, _Begin_unsorted_values, value_compare{_Key_compare});
+        _RANGES sort(_Begin_unsorted_values, _View.end(), _Value_compare_to_pass{_Key_compare});
+        _RANGES inplace_merge(_View, _Begin_unsorted_values, _Value_compare_to_pass{_Key_compare});
 
         _Erase_dupes_if_not_multi();
 
@@ -1146,7 +1163,8 @@ private:
         // Sort the newly inserted elements
         auto _Sorted_view = _View_to_mutate();
         if constexpr (_NeedSorting) {
-            _RANGES sort(_Sorted_view.begin() + _Old_distance, _Sorted_view.end(), value_compare{_Key_compare});
+            _RANGES sort(
+                _Sorted_view.begin() + _Old_distance, _Sorted_view.end(), _Value_compare_to_pass{_Key_compare});
         } else {
             _STL_ASSERT(_Is_sorted_and_unique(
                             _Data.keys.begin() + static_cast<key_container_type::difference_type>(_Old_distance),
@@ -1155,7 +1173,7 @@ private:
         }
 
         // Merge the newly inserted elements with the existing elements
-        _RANGES inplace_merge(_Sorted_view, _Sorted_view.begin() + _Old_distance, value_compare{_Key_compare});
+        _RANGES inplace_merge(_Sorted_view, _Sorted_view.begin() + _Old_distance, _Value_compare_to_pass{_Key_compare});
 
         _Erase_dupes_if_not_multi();
         _STL_INTERNAL_CHECK(_Is_sorted_and_unique());

From 0da1a88ab9d1ac81a2d35c3346369424b5c196f3 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Thu, 22 Jan 2026 17:47:38 -0800
Subject: [PATCH 116/134] `<flat_meow>`: Remove FIXME comments, add
 `_Clear_guard` to `erase()`, test more ctors (#6040)

---
 stl/inc/flat_map                          |  4 +-
 stl/inc/flat_set                          | 24 +++---
 tests/std/tests/P0429R9_flat_map/test.cpp | 96 ++++++++++++++++++++++-
 3 files changed, 110 insertions(+), 14 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index 944d67861b4..8f8d496fd82 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -1099,7 +1099,7 @@ private:
     }
 
     void _Make_invariants_fulfilled() {
-        if (empty()) { // FIXME maybe consider if (begin() == end()) for consistency with flat_set
+        if (empty()) {
             return;
         }
 
@@ -1130,6 +1130,8 @@ private:
 
     void _Erase_dupes_if_not_multi() {
         if constexpr (_IsUnique) {
+            // No _Clear_guard needed. The only callers are _Insert_range() (which has a _Clear_guard)
+            // and _Make_invariants_fulfilled() (which is called only by constructors).
             auto _Sorted_view    = _View_to_mutate();
             const auto _New_last = _RANGES unique(_Sorted_view, _Erase_dupes_if_not_multi_pred()).begin();
 
diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index d5de1e9ff2e..570fe59e4f5 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -377,12 +377,12 @@ public:
         _Guard._Target = nullptr;
     }
 
-    // FIXME, the "erase" member functions need clear guards to restore the invariant when the underlying
-    // container doesn't provide the strong guarantee for its "erase" member functions.
-
     // NB: `erase(iterator)` is identical to `erase(const_iterator)`
     iterator erase(const const_iterator _Where) {
-        return _Mycont.erase(_Where);
+        _Clear_guard _Guard{this};
+        const auto _Ret = _Mycont.erase(_Where);
+        _Guard._Target  = nullptr;
+        return _Ret;
     }
     size_type erase(const _Kty& _Val) {
         return _Erase(_Val);
@@ -393,7 +393,10 @@ public:
         return _Erase(_Val);
     }
     iterator erase(const const_iterator _First, const const_iterator _Last) {
-        return _Mycont.erase(_First, _Last);
+        _Clear_guard _Guard{this};
+        const auto _Ret = _Mycont.erase(_First, _Last);
+        _Guard._Target  = nullptr;
+        return _Ret;
     }
 
     void swap(_Derived& _Other) noexcept(is_nothrow_swappable_v<_Container> && is_nothrow_swappable_v<_Keylt>) {
@@ -536,8 +539,6 @@ private:
                 return pair{_STD _Emplace_with_clear_guard(_Mycont, _Where, _STD forward<_Ty>(_Val)), true};
             } else {
                 // heterogeneous insertion
-                // FIXME: The standard only requires `find(_Val) == find(_Keyval)` (per N4958 [flat.set.modifiers]/2),
-                // which cannot guarantee `_Can_insert(_Where, _Keyval)`.
                 _STL_INTERNAL_STATIC_ASSERT(_Transparent<key_compare> && is_constructible_v<_Kty, _Ty>);
                 _Kty _Keyval(_STD forward<_Ty>(_Val));
                 _STL_ASSERT(_Can_insert(_Where, _Keyval),
@@ -580,8 +581,6 @@ private:
                 return _STD _Emplace_with_clear_guard(_Mycont, _Where, _STD forward<_Ty>(_Val));
             } else {
                 // heterogeneous insertion
-                // FIXME: The standard only requires `find(_Val) == find(_Keyval)` (per N4958 [flat.set.modifiers]/2),
-                // which cannot guarantee `_Can_insert(_Where, _Keyval)`.
                 _STL_INTERNAL_STATIC_ASSERT(_Transparent<key_compare> && is_constructible_v<_Kty, _Ty>);
                 _Kty _Keyval(_STD forward<_Ty>(_Val));
                 _STL_ASSERT(_Can_insert(_Where, _Keyval),
@@ -640,7 +639,9 @@ private:
         if constexpr (_IsUnique && is_same_v<_Ty, key_type>) { // Optimization restricted due to GH-5992
             const const_iterator _Where = lower_bound(_Val);
             if (_Where != cend() && !_Compare(_Val, *_Where)) {
+                _Clear_guard _Guard{this};
                 _Mycont.erase(_Where);
+                _Guard._Target = nullptr;
                 return 1;
             }
             return 0;
@@ -648,7 +649,9 @@ private:
             const auto [_First, _Last] = equal_range(_Val);
 
             const auto _Removed = static_cast<size_type>(_Last - _First);
+            _Clear_guard _Guard{this};
             _Mycont.erase(_First, _Last);
+            _Guard._Target = nullptr;
             return _Removed;
         }
     }
@@ -717,6 +720,9 @@ private:
 
     void _Erase_dupes_if_not_multi() {
         if constexpr (_IsUnique) {
+            // No _Clear_guard needed. The only callers are _Restore_invariants_after_insert() (which is called
+            // only by _Insert_range() which has a _Clear_guard) and _Make_invariants_fulfilled() (which is called
+            // only by constructors which don't need guards and operator=() which has a _Clear_guard).
             const auto _End = _Mycont.end();
             _Mycont.erase(_STD unique(_Mycont.begin(), _End, _Erase_dupes_if_not_multi_pred()), _End);
         }
diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index 9b2625a1b0d..7be0b081067 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -14,6 +14,7 @@
 #include <print>
 #include <ranges>
 #include <type_traits>
+#include <utility>
 #include <vector>
 
 #include <test_container_requirements.hpp>
@@ -278,9 +279,36 @@ void test_construction() {
         }
     }
     {
-        // Test flat_map(key_cont, mapped_cont, comp = key_comp())
+        // Test flat_map(const alloc&)
+        // and  flat_map(const key_comp&, const alloc&)
+        {
+            MyAllocatorCounter allocation_counter;
+            flat_map<int, int> fmap(MyAllocator<int>{});
+            assert(!allocation_counter.check_then_reset());
+            flat_map<int, int> fmap1(less<int>{}, MyAllocator<int>{});
+            assert(!allocation_counter.check_then_reset());
+
+            assert(check_key_content(fmap, {}));
+            assert(check_value_content(fmap, {}));
+            assert(fmap == fmap1);
+        }
+        {
+            MyAllocatorCounter allocation_counter;
+            flat_multimap<int, int> fmmap(MyAllocator<int>{});
+            assert(!allocation_counter.check_then_reset());
+            flat_multimap<int, int> fmmap1(less<int>{}, MyAllocator<int>{});
+            assert(!allocation_counter.check_then_reset());
+
+            assert(check_key_content(fmmap, {}));
+            assert(check_value_content(fmmap, {}));
+            assert(fmmap == fmmap1);
+        }
+    }
+    {
         KeyCont<int> keys    = {0, 1, 2, 3, 4, 2};
         MappedCont<int> vals = {44, 2324, 635462, 433, 5, 7};
+
+        // Test flat_map(key_cont, mapped_cont, comp = key_comp())
         {
             flat_map fmap(keys, vals);
             flat_map fmap1(keys, vals, less<int>{});
@@ -302,12 +330,39 @@ void test_construction() {
                 }));
             assert(fmmap == fmmap1);
         }
+
+        // Test flat_map(const flat_map&)
+        // and  flat_map(flat_map&&)
+        {
+            flat_map fmap(keys, vals);
+            flat_map fmap1(fmap);
+            flat_map fmap2(move(fmap));
+
+            assert(check_key_content(fmap1, {0, 1, 2, 3, 4}));
+            assert(check_value_content(fmap1, {44, 2324, 635462, 433, 5}));
+            assert(fmap1 == fmap2);
+        }
+        {
+            flat_multimap fmmap(keys, vals);
+            flat_multimap fmmap1(fmmap);
+            flat_multimap fmmap2(move(fmmap));
+
+            assert(check_key_content(fmmap1, {0, 1, 2, 2, 3, 4}));
+            assert(check_value_content(fmmap1, {44, 2324, 635462, 7, 433, 5},
+                {
+                    {0, 1, subrange_type::equal},
+                    {2, 3, subrange_type::permutation},
+                    {4, 5, subrange_type::equal},
+                }));
+            assert(fmmap1 == fmmap2);
+        }
     }
     {
-        // Test flat_map(const key_cont&, const mapped_cont&, const key_comp&, const alloc&)
-        // and  flat_map(const key_cont&, const mapped_cont&, const alloc&)
         KeyCont<int, MyAllocator<int>> keys    = {0, 1, 2, 3, 4, 2};
         MappedCont<int, MyAllocator<int>> vals = {44, 2324, 635462, 433, 5, 7};
+
+        // Test flat_map(const key_cont&, const mapped_cont&, const key_comp&, const alloc&)
+        // and  flat_map(const key_cont&, const mapped_cont&, const alloc&)
         {
             MyAllocatorCounter allocation_counter;
             flat_map fmap(keys, vals, MyAllocator<int>{});
@@ -335,6 +390,40 @@ void test_construction() {
                 }));
             assert(fmmap == fmmap1);
         }
+
+        // Test flat_map(const flat_map&, const alloc&)
+        // and  flat_map(flat_map&&, const alloc&)
+        {
+            MyAllocatorCounter allocation_counter;
+            flat_map fmap(keys, vals, MyAllocator<int>{});
+            assert(allocation_counter.check_then_reset());
+            flat_map fmap1(fmap);
+            assert(allocation_counter.check_then_reset());
+            flat_map fmap2(move(fmap));
+            assert(!allocation_counter.check_then_reset());
+
+            assert(check_key_content(fmap1, {0, 1, 2, 3, 4}));
+            assert(check_value_content(fmap1, {44, 2324, 635462, 433, 5}));
+            assert(fmap1 == fmap2);
+        }
+        {
+            MyAllocatorCounter allocation_counter;
+            flat_multimap fmmap(keys, vals, MyAllocator<int>{});
+            assert(allocation_counter.check_then_reset());
+            flat_multimap fmmap1(fmmap);
+            assert(allocation_counter.check_then_reset());
+            flat_multimap fmmap2(move(fmmap));
+            assert(!allocation_counter.check_then_reset());
+
+            assert(check_key_content(fmmap1, {0, 1, 2, 2, 3, 4}));
+            assert(check_value_content(fmmap1, {44, 2324, 635462, 7, 433, 5},
+                {
+                    {0, 1, subrange_type::equal},
+                    {2, 3, subrange_type::permutation},
+                    {4, 5, subrange_type::equal},
+                }));
+            assert(fmmap1 == fmmap2);
+        }
     }
     {
         // Test flat_map(_Sorted_t, key_cont, mapped_cont, comp = key_comp())
@@ -667,7 +756,6 @@ void test_construction() {
             assert(fmmap == fmmap1);
         }
     }
-    // FIXME, verify that all flat_map and flat_multimap constructors are tested
     {
         PackagedCompare<int> comp;
         {

From 21cc7b6d42a162b10283864b83f7199646b7cc3f Mon Sep 17 00:00:00 2001
From: Alex Guteniev <gutenev@gmail.com>
Date: Fri, 23 Jan 2026 17:14:47 +0200
Subject: [PATCH 117/134] `<flat_map>`, `<flat_set>`: Use inverse key_compare
 instead of synthesized equivalence (#6042)

---
 stl/inc/flat_map | 5 +++--
 stl/inc/flat_set | 3 +--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index 8f8d496fd82..503a6573f7c 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -1123,8 +1123,9 @@ private:
             return [](const_reference _Left, const_reference _Right)
                        _STATIC_CALL_OPERATOR { return _Left.first == _Right.first; };
         } else {
-            return
-                [this](const_reference _Left, const_reference _Right) { return _Key_equal(_Left.first, _Right.first); };
+            return [this](const_reference _Left, const_reference _Right) {
+                return !_Key_compare(_Left.first, _Right.first);
+            };
         }
     }
 
diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index 570fe59e4f5..27424b049b6 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -713,8 +713,7 @@ private:
         if constexpr (_Equivalence_is_equality<_Keylt, _Kty>) {
             return equal_to<>{};
         } else {
-            return
-                [this](const _Kty& _Lhs, const _Kty& _Rhs) { return !_Compare(_Lhs, _Rhs) && !_Compare(_Rhs, _Lhs); };
+            return [this](const _Kty& _Lhs, const _Kty& _Rhs) { return !_Compare(_Lhs, _Rhs); };
         }
     }
 

From 94b627b6ef0d6acbca2c51f3eaf808463f4167f3 Mon Sep 17 00:00:00 2001
From: Alex Guteniev <gutenev@gmail.com>
Date: Fri, 23 Jan 2026 22:28:08 +0200
Subject: [PATCH 118/134] `<flat_set>`: Use `_STD equal` instead of `_RANGES
 equal` in `operator==` (#6044)

---
 stl/inc/flat_set | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index 27424b049b6..bf910f4cf3c 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -477,7 +477,7 @@ public:
     }
 
     _NODISCARD friend bool operator==(const _Derived& _Lhs, const _Derived& _Rhs) {
-        return _RANGES equal(_Lhs._Mycont, _Rhs._Mycont);
+        return _STD equal(_Lhs._Mycont.begin(), _Lhs._Mycont.end(), _Rhs._Mycont.begin(), _Rhs._Mycont.end());
     }
 
     _NODISCARD friend auto operator<=>(const _Derived& _Lhs, const _Derived& _Rhs) {

From a1b6e7a49d8edd48b2cbf1f595ddb94830e2cc28 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Fri, 23 Jan 2026 15:27:18 -0800
Subject: [PATCH 119/134] Cleanup/fix `flat_map` tests, update citations
 (#6046)

---
 stl/inc/flat_map                              | 17 ++--
 stl/inc/flat_set                              | 10 +--
 tests/std/tests/P0429R9_flat_map/test.cpp     | 84 ++++++++++---------
 .../test.compile.pass.cpp                     | 29 ++-----
 4 files changed, 65 insertions(+), 75 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index 503a6573f7c..9f9c0fd3640 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -330,22 +330,22 @@ public:
 
     static_assert(is_same_v<key_type, typename key_container_type::value_type>,
         "key_type and key_container_type::value_type must be the same. "
-        "(N5014 [flat.map.overview]/8, [flat.multimap.overview]/8)");
+        "(N5032 [flat.map.overview]/8, [flat.multimap.overview]/8)");
     static_assert(is_same_v<mapped_type, typename mapped_container_type::value_type>,
         "mapped_type and mapped_container_type::value_type must be the same. "
-        "(N5014 [flat.map.overview]/8, [flat.multimap.overview]/8)");
+        "(N5032 [flat.map.overview]/8, [flat.multimap.overview]/8)");
     static_assert(!_Is_vector_bool<key_container_type>,
         "key_container_type cannot be vector<bool> because it is not a sequence container. "
-        "(N5014 [flat.map.overview]/7, [flat.multimap.overview]/7)");
+        "(N5032 [flat.map.overview]/7, [flat.multimap.overview]/7)");
     static_assert(!_Is_vector_bool<mapped_container_type>,
         "mapped_container_type cannot be vector<bool> because it is not a sequence container. "
-        "(N5014 [flat.map.overview]/7, [flat.multimap.overview]/7)");
+        "(N5032 [flat.map.overview]/7, [flat.multimap.overview]/7)");
     static_assert(random_access_iterator<typename key_container_type::const_iterator>,
         "key_container_type must support random-access iterators in order to be adapted. "
-        "(N5014 [flat.map.overview]/7, [flat.multimap.overview]/7)");
+        "(N5032 [flat.map.overview]/7, [flat.multimap.overview]/7)");
     static_assert(random_access_iterator<typename mapped_container_type::const_iterator>,
         "mapped_container_type must support random-access iterators in order to be adapted. "
-        "(N5014 [flat.map.overview]/7, [flat.multimap.overview]/7)");
+        "(N5032 [flat.map.overview]/7, [flat.multimap.overview]/7)");
 
     class value_compare {
     public:
@@ -748,7 +748,7 @@ public:
     _NODISCARD containers extract() && noexcept(
         is_nothrow_move_constructible_v<key_container_type>
         && is_nothrow_move_constructible_v<mapped_container_type>) /* strengthened */ {
-        // always clears the container (N5014 [flat.map.modifiers]/34 and [flat.multimap.overview]/4)
+        // always clears the container (N5032 [flat.map.modifiers]/35 and [flat.multimap.overview]/4)
         _Clear_guard _Always_clear{this};
         return _STD move(_Data);
     }
@@ -1104,7 +1104,8 @@ private:
         }
 
         // O(N) if already sorted.
-        const auto _Num_sorted = _RANGES is_sorted_until(_Data.keys, _Pass_key_comp()) - _Data.keys.begin();
+        const auto _Num_sorted =
+            _STD is_sorted_until(_Data.keys.begin(), _Data.keys.end(), _Pass_key_comp()) - _Data.keys.begin();
 
         auto _View                        = _View_to_mutate();
         const auto _Begin_unsorted_values = _View.begin() + _Num_sorted;
diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index bf910f4cf3c..60d723304e9 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -87,13 +87,13 @@ private:
 public:
     static_assert(same_as<_Kty, typename _Container::value_type>,
         "key_type and container_type::value_type must be the same. "
-        "(N5014 [flat.set.overview]/8, [flat.multiset.overview]/8)");
+        "(N5032 [flat.set.overview]/8, [flat.multiset.overview]/8)");
     static_assert(!_Is_vector_bool<_Container>,
         "vector<bool> cannot be adapted because it is not a sequence container. "
-        "(N5014 [flat.set.overview]/7, [flat.multiset.overview]/7)");
+        "(N5032 [flat.set.overview]/7, [flat.multiset.overview]/7)");
     static_assert(random_access_iterator<typename _Container::const_iterator>,
         "Sequence containers must support random-access iterators in order to be adapted. "
-        "(N5014 [flat.set.overview]/7, [flat.multiset.overview]/7)");
+        "(N5032 [flat.set.overview]/7, [flat.multiset.overview]/7)");
 
     using key_type               = _Kty;
     using value_type             = _Kty;
@@ -365,7 +365,7 @@ public:
 
     _NODISCARD container_type extract() && noexcept(
         is_nothrow_move_constructible_v<container_type>) /* strengthened */ {
-        // always clears the container (N5014 [flat.set.modifiers]/14 and [flat.multiset.modifiers]/10)
+        // always clears the container (N5032 [flat.set.modifiers]/16 and [flat.multiset.modifiers]/15)
         _Clear_guard _Always_clear{this};
         return _STD move(_Mycont);
     }
@@ -664,7 +664,7 @@ private:
 
     template <class _Pred>
     _NODISCARD size_type _Erase_if(_Pred _Predicate) {
-        // Maintain invariants when an exception is thrown (N5014 [flat.set.erasure]/5, [flat.multiset.erasure]/5)
+        // Maintain invariants when an exception is thrown (N5032 [flat.set.erasure]/5, [flat.multiset.erasure]/5)
         _Clear_guard _Guard{this};
         const auto _Erased_count = _STD _Erase_remove_if(_Mycont, _Predicate);
         _Guard._Target           = nullptr;
diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index 7be0b081067..fbd797b28be 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -6,6 +6,7 @@
 #include <cassert>
 #include <concepts>
 #include <cstddef>
+#include <cstdio>
 #include <cstdlib>
 #include <deque>
 #include <flat_map>
@@ -45,7 +46,7 @@ void assert_all_requirements(const T& s) {
     assert_noexcept_requirements(s);
     assert_noexcept_requirements(const_cast<T&>(s));
 
-    assert_is_sorted_maybe_unique<_Is_specialization_v<T, flat_map>>(s);
+    assert_is_sorted_maybe_unique<is_specialization_v<T, flat_map>>(s);
 }
 
 template <IsFlatMap T>
@@ -63,8 +64,7 @@ template <IsFlatMap T>
 [[nodiscard]] bool check_content(const T& obj, const type_identity_t<T>& expected) {
     assert_all_requirements(obj);
     if (!ranges::equal(obj, expected)) {
-        println(stderr, "Unexpected content!\nExpected {}", expected);
-        println(stderr, "Actual {}", obj);
+        println(stderr, "Unexpected content!\nExpected {}\nActual {}", expected, obj);
         return false;
     }
     return true;
@@ -108,8 +108,8 @@ template <IsFlatMap T>
         assert(ranges::adjacent_find(subranges, is_gap_or_overlap) == subranges.end());
     }
 
-    return ranges::all_of(subranges, [&expected, &actual](const subrange_t& subrange) {
-        const auto& [first_index, last_index, type] = subrange;
+    return ranges::all_of(subranges, [&expected, &actual](const subrange_t& sr) {
+        const auto& [first_index, last_index, type] = sr;
         const ranges::subrange actual_subrange{actual.begin() + first_index, actual.begin() + last_index + 1};
         const ranges::subrange expected_subrange{expected.begin() + first_index, expected.begin() + last_index + 1};
 
@@ -122,28 +122,31 @@ template <IsFlatMap T>
 }
 
 template <class T>
-class MyAllocator : public allocator<T> {
+class MyAllocator {
 public:
     using value_type = T;
-    using allocator<T>::allocator;
 
-    static size_t getActiveAllocationCount() {
-        return s_allocations.load();
-    }
+    MyAllocator() = default;
+    template <class U>
+    MyAllocator(const MyAllocator<U>&) noexcept {}
 
-    T* allocate(size_t n) {
-        ++s_allocations;
-        return allocator<T>::allocate(n);
+    [[nodiscard]] static size_t getActiveAllocationCount() {
+        return s_allocations.load();
     }
 
-    T* allocate_at_least(size_t n) {
+    [[nodiscard]] T* allocate(size_t n) {
         ++s_allocations;
-        return allocator<T>::allocate_at_least(n);
+        return allocator<T>{}.allocate(n);
     }
 
     void deallocate(T* p, size_t n) noexcept {
         --s_allocations;
-        allocator<T>::deallocate(p, n);
+        allocator<T>{}.deallocate(p, n);
+    }
+
+    template <class U>
+    [[nodiscard]] friend constexpr bool operator==(const MyAllocator&, const MyAllocator<U>&) noexcept {
+        return true;
     }
 
 private:
@@ -164,9 +167,9 @@ struct almost_pair {
 };
 
 namespace std {
-    template <class T, class U, size_t N>
+    template <size_t N, class T, class U>
     struct tuple_element<N, almost_pair<T, U>> {
-        using type = conditional_t<N == 1, T, U>;
+        using type = conditional_t<N == 0, T, U>;
     };
 } // namespace std
 
@@ -178,7 +181,7 @@ class Packaged {
 public:
     Packaged() : value() {}
     template <class U>
-        requires constructible_from<T, U&&>
+        requires constructible_from<T, U>
     Packaged(U&& u) : value(forward<U>(u)) {}
 
     T get() const {
@@ -260,10 +263,9 @@ void test_construction() {
 
     {
         // Test flat_map() and flat_map(const key_compare&)
-        const less<int> compare;
         {
             flat_map<int, int> fmap;
-            flat_map<int, int> fmap1(compare);
+            flat_map<int, int> fmap1(less<int>{});
 
             assert(check_key_content(fmap, {}));
             assert(check_value_content(fmap, {}));
@@ -271,7 +273,7 @@ void test_construction() {
         }
         {
             flat_multimap<int, int> fmmap;
-            flat_multimap<int, int> fmmap1(compare);
+            flat_multimap<int, int> fmmap1(less<int>{});
 
             assert(check_key_content(fmmap, {}));
             assert(check_value_content(fmmap, {}));
@@ -283,9 +285,9 @@ void test_construction() {
         // and  flat_map(const key_comp&, const alloc&)
         {
             MyAllocatorCounter allocation_counter;
-            flat_map<int, int> fmap(MyAllocator<int>{});
+            flat_map_my_allocator fmap(MyAllocator<int>{});
             assert(!allocation_counter.check_then_reset());
-            flat_map<int, int> fmap1(less<int>{}, MyAllocator<int>{});
+            flat_map_my_allocator fmap1(less<int>{}, MyAllocator<int>{});
             assert(!allocation_counter.check_then_reset());
 
             assert(check_key_content(fmap, {}));
@@ -294,9 +296,9 @@ void test_construction() {
         }
         {
             MyAllocatorCounter allocation_counter;
-            flat_multimap<int, int> fmmap(MyAllocator<int>{});
+            flat_multimap_my_allocator fmmap(MyAllocator<int>{});
             assert(!allocation_counter.check_then_reset());
-            flat_multimap<int, int> fmmap1(less<int>{}, MyAllocator<int>{});
+            flat_multimap_my_allocator fmmap1(less<int>{}, MyAllocator<int>{});
             assert(!allocation_counter.check_then_reset());
 
             assert(check_key_content(fmmap, {}));
@@ -447,7 +449,7 @@ void test_construction() {
 
             assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
             assert(check_value_content(
-                fmmap, {44, 2324, 635462, 7, 433, 5})); // guaranteed by N4971 [flat.multimap.cons]/6
+                fmmap, {44, 2324, 635462, 7, 433, 5})); // guaranteed by N5032 [flat.multimap.cons]/3
             assert(fmmap == fmmap1);
         }
         {
@@ -461,7 +463,7 @@ void test_construction() {
     }
     {
         // Test flat_map(_Sorted_t, const key_cont&, const mapped_cont&, const key_comp&, const alloc&)
-        // and flat_map(_Sorted_t, const key_cont&, const mapped_cont&, const alloc&)
+        // and  flat_map(_Sorted_t, const key_cont&, const mapped_cont&, const alloc&)
         {
             KeyCont<int, MyAllocator<int>> keys    = {0, 1, 2, 3, 4};
             MappedCont<int, MyAllocator<int>> vals = {44, 2324, 635462, 433, 5};
@@ -622,7 +624,7 @@ void test_construction() {
     }
     {
         // Test flat_map(_Sorted_t, iter, iter, const key_comp&, const alloc&)
-        // and flat_map(_Sorted_t, iter, iter, const alloc&)
+        // and  flat_map(_Sorted_t, iter, iter, const alloc&)
         {
             almost_pair<int, int> value_types[]{{0, 44}, {1, 2324}, {2, 635462}, {3, 433}, {4, 5}};
 
@@ -871,16 +873,18 @@ void test_construction() {
 
 template <template <class...> class KeyCont, template <class...> class MappedCont>
 void test_erase_if() {
+    KeyCont<int> keys     = {0, 1, 2, 3, 4, 2};
+    MappedCont<int> vals  = {44, 2324, 635462, 433, 5, 7};
+    auto even_key_odd_val = [](pair<const int&, const int&> p) { return p.first % 2 == 0 && p.second % 2 != 0; };
     {
-        KeyCont<int> keys     = {0, 1, 2, 3, 4, 2};
-        MappedCont<int> vals  = {44, 2324, 635462, 433, 5, 7};
-        auto even_key_odd_val = [](pair<const int&, const int&> p) { return p.first % 2 == 0 && p.second % 2 != 0; };
         flat_map fmap(keys, vals);
         const auto erased_num = erase_if(fmap, even_key_odd_val);
         assert(erased_num == 1);
         assert(fmap.size() == 4);
         assert(check_key_content(fmap, {0, 1, 2, 3}));
         assert(check_value_content(fmap, {44, 2324, 635462, 433}));
+    }
+    {
         flat_multimap fmmap(keys, vals);
         const auto erased_num_m = erase_if(fmmap, even_key_odd_val);
         assert(erased_num_m == 2);
@@ -929,11 +933,11 @@ void test_insert() {
     assert(res3.first->second == 'w');
     assert(res3.second);
 
-    const auto res4 = fm.insert(fm.cbegin(), std::pair<int, char>{30, 'c'});
+    const auto res4 = fm.insert(fm.cbegin(), pair<int, char>{30, 'c'});
     assert(res4->first == 30);
     assert(res4->second == 'c');
 
-    const auto res5 = fm.insert(fm.cbegin(), std::pair<char, char>{static_cast<char>(40), 'd'});
+    const auto res5 = fm.insert(fm.cbegin(), pair<char, char>{static_cast<char>(40), 'd'});
     assert(res5->first == 40);
     assert(res5->second == 'd');
 
@@ -959,12 +963,12 @@ void test_insert() {
     assert(it4->first == 90);
     assert(it4->second == 'w');
 
-    const auto it5 = fmm.insert(fmm.cend(), std::pair<char, char>{static_cast<char>(70), 'q'});
+    const auto it5 = fmm.insert(fmm.cend(), pair<char, char>{static_cast<char>(70), 'q'});
     assert(it5->first == 70);
     assert(it5->second == 'q');
 
     assert(check_key_content(fmm, {10, 10, 70, 70, 90}));
-    // N4981 [associative.reqmts.general]/68 and /72 specify the values of the result to be {'m', 'n', 'p', 'q', 'w'}.
+    // N5032 [associative.reqmts.general]/68 and /72 specify the values of the result to be {'m', 'n', 'p', 'q', 'w'}.
     assert(check_value_content(fmm, {'m', 'n', 'p', 'q', 'w'}));
 }
 
@@ -1296,10 +1300,8 @@ void test_lookup_call_on_temporaries() {
 // Test that hint to emplace/insert is respected, when possible; check returned iterator
 template <template <class...> class KeyC, template <class...> class ValueC>
 void test_insert_hint_is_respected() {
-    using lt = std::less<int>;
-
     {
-        flat_multimap<int, char, lt, KeyC<int>, ValueC<char>> a{{-1, 'x'}, {-1, 'x'}, {1, 'x'}, {1, 'x'}};
+        flat_multimap<int, char, less<int>, KeyC<int>, ValueC<char>> a{{-1, 'x'}, {-1, 'x'}, {1, 'x'}, {1, 'x'}};
         bool problem_seen                      = false;
         const auto assert_inserted_at_position = [&a, &problem_seen](
                                                      const int expected_index, const auto insert_position) {
@@ -1328,7 +1330,7 @@ void test_insert_hint_is_respected() {
         assert(check_content(a, {{-1, 'x'}, {-1, 'x'}, {0, 'a'}, {1, 'x'}, {1, 'x'}}));
         assert_inserted_at_position(3, a.emplace_hint(a.find(1), pair{0, 'b'}));
         assert(check_content(a, {{-1, 'x'}, {-1, 'x'}, {0, 'a'}, {0, 'b'}, {1, 'x'}, {1, 'x'}}));
-        assert_inserted_at_position(4, a.insert(a.upper_bound(0), std::move(pair0c)));
+        assert_inserted_at_position(4, a.insert(a.upper_bound(0), move(pair0c)));
         assert(check_content(a, {{-1, 'x'}, {-1, 'x'}, {0, 'a'}, {0, 'b'}, {0, 'c'}, {1, 'x'}, {1, 'x'}}));
         // hint is correct
         assert_inserted_at_position(4, a.emplace_hint(a.upper_bound(0) - 1, 0, 'd'));
@@ -1349,7 +1351,7 @@ void test_insert_hint_is_respected() {
 
         assert(!problem_seen);
 
-        assert(4 == erase_if(a, [](const auto pair) { return pair.second <= 'd'; }));
+        assert(4 == erase_if(a, [](const auto p) { return p.second <= 'd'; }));
         assert(check_content(a, {{-1, 'x'}, {-1, 'x'}, {0, 'h'}, {0, 'g'}, {0, 'f'}, {0, 'e'}, {1, 'x'}, {1, 'x'}}));
         assert(4 == a.erase(0));
         assert(check_content(a, {{-1, 'x'}, {-1, 'x'}, {1, 'x'}, {1, 'x'}}));
diff --git a/tests/std/tests/P0429R9_flat_map_ms_specific/test.compile.pass.cpp b/tests/std/tests/P0429R9_flat_map_ms_specific/test.compile.pass.cpp
index fd39e6a478c..03f1dc2c165 100644
--- a/tests/std/tests/P0429R9_flat_map_ms_specific/test.compile.pass.cpp
+++ b/tests/std/tests/P0429R9_flat_map_ms_specific/test.compile.pass.cpp
@@ -35,21 +35,9 @@ struct MyAllocator {
     }
 };
 
-template <bool>
-struct flat_map_unique_if_impl;
-template <>
-struct flat_map_unique_if_impl<true> {
-    template <class Key, class Mapped, class Comp, class KeyCont, class MappedCont>
-    using type = flat_map<Key, Mapped, Comp, KeyCont, MappedCont>;
-};
-template <>
-struct flat_map_unique_if_impl<false> {
-    template <class Key, class Mapped, class Comp, class KeyCont, class MappedCont>
-    using type = flat_multimap<Key, Mapped, Comp, KeyCont, MappedCont>;
-};
-
 template <bool IsUnique, class Key, class Mapped, class Comp, class KeyCont, class MappedCont>
-using flat_map_unique_if = flat_map_unique_if_impl<IsUnique>::template type<Key, Mapped, Comp, KeyCont, MappedCont>;
+using flat_map_unique_if = conditional_t<IsUnique, flat_map<Key, Mapped, Comp, KeyCont, MappedCont>,
+    flat_multimap<Key, Mapped, Comp, KeyCont, MappedCont>>;
 
 template <class A, class B>
 constexpr bool has_different_nested_types = !is_same_v<typename A::value_compare, typename B::value_compare>
@@ -57,17 +45,16 @@ constexpr bool has_different_nested_types = !is_same_v<typename A::value_compare
 
 template <bool IsUnique, class Comparator, class Alloc1, class Alloc2>
 void test_scary_ness_one() {
-    using Iter = flat_map<int, int>::iterator;
-    using OtherIter =
-        flat_map_unique_if<IsUnique, int, int, Comparator, vector<int, Alloc1>, vector<int, Alloc2>>::iterator;
+    using Cont = flat_map_unique_if<IsUnique, int, int, Comparator, vector<int, Alloc1>, vector<int, Alloc2>>;
+
+    using Iter      = flat_map<int, int>::iterator;
+    using OtherIter = Cont::iterator;
     static_assert(is_same_v<Iter, OtherIter>);
 
-    using ConstIter = flat_map<int, int>::const_iterator;
-    using OtherConstIter =
-        flat_map_unique_if<IsUnique, int, int, Comparator, vector<int, Alloc1>, vector<int, Alloc2>>::const_iterator;
+    using ConstIter      = flat_map<int, int>::const_iterator;
+    using OtherConstIter = Cont::const_iterator;
     static_assert(is_same_v<ConstIter, OtherConstIter>);
 
-    using Cont       = flat_map_unique_if<IsUnique, int, int, Comparator, vector<int, Alloc1>, vector<int, Alloc2>>;
     using OtherCont1 = flat_map_unique_if<!IsUnique, int, int, Comparator, vector<int, Alloc1>, vector<int, Alloc2>>;
     using OtherCont2 = flat_map_unique_if<IsUnique, int, int, Comparator, deque<int>, deque<int>>;
     using OtherCont3 = flat_map_unique_if<IsUnique, int, int, Comparator, vector<int, Alloc1>, deque<int, Alloc2>>;

From 48712365fb92a4401c27c438efc83e49b8c71d6e Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Tue, 27 Jan 2026 06:54:44 -0800
Subject: [PATCH 120/134] Cleanup/improve `flat_set` tests (#6051)

---
 .../include/test_container_requirements.hpp   |  18 +
 .../test.compile.pass.cpp                     |  18 +-
 tests/std/tests/P0429R9_flat_map/test.cpp     |  81 +--
 tests/std/tests/P1222R4_flat_set/test.cpp     | 533 ++++++++++--------
 .../test.compile.pass.cpp                     |  12 +-
 5 files changed, 372 insertions(+), 290 deletions(-)

diff --git a/tests/std/include/test_container_requirements.hpp b/tests/std/include/test_container_requirements.hpp
index cebe64d3ab1..be234339777 100644
--- a/tests/std/include/test_container_requirements.hpp
+++ b/tests/std/include/test_container_requirements.hpp
@@ -187,3 +187,21 @@ void assert_three_way_comparability() {
         static_assert(std::three_way_comparable<T>);
     }
 }
+
+class key_comparator {
+private:
+    static const auto& extract_key(const auto& obj) {
+        if constexpr (requires { obj.key; }) {
+            return obj.key;
+        } else {
+            return obj;
+        }
+    }
+
+public:
+    bool operator()(const auto& lhs, const auto& rhs) const {
+        return extract_key(lhs) < extract_key(rhs);
+    }
+
+    using is_transparent = int;
+};
diff --git a/tests/std/tests/Dev11_0437519_container_requirements/test.compile.pass.cpp b/tests/std/tests/Dev11_0437519_container_requirements/test.compile.pass.cpp
index 4cfa84a262e..d391f30b16c 100644
--- a/tests/std/tests/Dev11_0437519_container_requirements/test.compile.pass.cpp
+++ b/tests/std/tests/Dev11_0437519_container_requirements/test.compile.pass.cpp
@@ -13,7 +13,7 @@
 // A brief overview of the contents of this file:
 //
 // The first 650 lines or so of this file (everything up to the first use of DEFINE_TEST) are test
-// utilities:  stub allocators, comparers, and other kinds of types with which we can instantiate
+// utilities:  stub allocators, comparators, and other kinds of types with which we can instantiate
 // containers; test types that define a restricted set of operations; and a set of container traits
 // classes that unify the interfaces for the containers so we can use a common set of tests for
 // them (these traits also define a few useful properties for each container so we know what to
@@ -1678,7 +1678,7 @@ NOT_SUPPORTED_SPECIALIZATION(test_ordered_associative_typedefs_for_maps, tag_mul
 NOT_SUPPORTED_SPECIALIZATION(test_ordered_associative_typedefs_for_maps, tag_set);
 
 
-DEFINE_TEST(test_ordered_associative_default_constructor_with_comparer,
+DEFINE_TEST(test_ordered_associative_default_constructor_with_comparator,
 {
     // X(c) and X a(c);
     // Requires:  key_compare is CopyConstructible
@@ -1710,13 +1710,13 @@ DEFINE_TEST(test_ordered_associative_default_constructor_with_comparer,
 });
 
 
-DEFINE_TEST(test_ordered_associative_range_constructor_with_comparer, {
+DEFINE_TEST(test_ordered_associative_range_constructor_with_comparator, {
     // SPEC:  These are the only two operations for which traits are specified for key_compare, but
     // there are many other operations for which key_compare must meet other requirements (e.g. a
     // call to a.key_comp() necessitates that the key_comp type is move constructible.
     //
-    // In the rest of the tests, I have assumed std::less for the comparer, which meets any possible
-    // requirements, but it should be considered whether the comparer requirements should be more
+    // In the rest of the tests, I have assumed std::less for the comparator, which meets any possible
+    // requirements, but it should be considered whether the comparator requirements should be more
     // thoroughly specified.
 
     std::move_iterator<input_iterator<typename Traits::emplace_argument_type>> i;
@@ -1746,7 +1746,7 @@ DEFINE_TEST(test_ordered_associative_initializer_list_assign, {
 });
 
 
-DEFINE_TEST(test_ordered_associative_comparers, {
+DEFINE_TEST(test_ordered_associative_comparators, {
     // a.key_comp()
     // [No Requires clause]
     c_of_erasable const a;
@@ -1926,10 +1926,10 @@ struct check_all_ordered_associative_requirements {
     check_all_ordered_associative_requirements() {
         test_ordered_associative_typedefs<Tag>();
         test_ordered_associative_typedefs_for_maps<Tag>();
-        test_ordered_associative_default_constructor_with_comparer<Tag>();
-        test_ordered_associative_range_constructor_with_comparer<Tag>();
+        test_ordered_associative_default_constructor_with_comparator<Tag>();
+        test_ordered_associative_range_constructor_with_comparator<Tag>();
         test_ordered_associative_initializer_list_assign<Tag>();
-        test_ordered_associative_comparers<Tag>();
+        test_ordered_associative_comparators<Tag>();
         test_ordered_associative_emplace<Tag>();
         test_ordered_associative_insert<Tag>();
         test_ordered_associative_erase<Tag>();
diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index fbd797b28be..54ac624422c 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -233,22 +233,6 @@ struct MyAllocatorCounter {
     size_t activeAllocations;
 };
 
-struct key_comparer {
-    const auto& extract_key(const auto& obj) const {
-        if constexpr (requires { obj.key; }) {
-            return obj.key;
-        } else {
-            return obj;
-        }
-    }
-
-    bool operator()(const auto& lhs, const auto& rhs) const {
-        return extract_key(lhs) < extract_key(rhs);
-    }
-
-    using is_transparent = int;
-};
-
 template <template <class...> class KeyCont, template <class...> class MappedCont>
 void test_construction() {
     // Using CTAD, the given MyAllocator is only used by the container when the constructor (deduction guide)
@@ -1188,7 +1172,7 @@ void test_map_operations_transparent() {
         }
     };
 
-    Map<int, char, key_comparer> fm{{0, 'a'}, {3, 'g'}, {5, 't'}};
+    Map<int, char, key_comparator> fm{{0, 'a'}, {3, 'g'}, {5, 't'}};
     assert(check_key_content(fm, {0, 3, 5}));
     assert(check_value_content(fm, {'a', 'g', 't'}));
 
@@ -1511,61 +1495,48 @@ void test_death_insert_unsorted_initializer_list() {
     cont.insert(sorted, {{137, 'a'}, {42, 'g'}, {3337, 'f'}, {15, 'r'}});
 }
 
-template <cont_type type>
 void test_death_construct_duplicates_initializer_list() {
-    using C = conditional_t<type == cont_type::unique, flat_map<int, char>, flat_multimap<int, char>>;
-    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
-    C cont(sorted, {{42, 'a'}, {137, 'g'}, {137, 'f'}, {3337, 'r'}});
+    using C = flat_map<int, char>;
+    C cont(sorted_unique, {{42, 'a'}, {137, 'g'}, {137, 'f'}, {3337, 'r'}});
 }
 
-template <cont_type type>
 void test_death_construct_duplicates_iter_iter() {
-    using C = conditional_t<type == cont_type::unique, flat_map<int, char>, flat_multimap<int, char>>;
-    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
-    vector<typename C::value_type> values{{42, 'a'}, {137, 'g'}, {137, 'f'}, {3337, 'r'}};
-    C cont(sorted, values.begin(), values.end());
+    using C = flat_map<int, char>;
+    vector<C::value_type> values{{42, 'a'}, {137, 'g'}, {137, 'f'}, {3337, 'r'}};
+    C cont(sorted_unique, values.begin(), values.end());
 }
 
-template <cont_type type>
 void test_death_construct_duplicates_container() {
-    using C = conditional_t<type == cont_type::unique, flat_map<int, char>, flat_multimap<int, char>>;
-    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
-    typename C::key_container_type keys{42, 137, 137, 3337};
-    typename C::mapped_container_type mapped{'a', 'g', 'f', 'r'};
-    C cont(sorted, keys, mapped);
+    using C = flat_map<int, char>;
+    C::key_container_type keys{42, 137, 137, 3337};
+    C::mapped_container_type mapped{'a', 'g', 'f', 'r'};
+    C cont(sorted_unique, keys, mapped);
 }
 
-template <cont_type type>
 void test_death_replace_duplicates_container() {
-    using C = conditional_t<type == cont_type::unique, flat_map<int, char>, flat_multimap<int, char>>;
+    using C = flat_map<int, char>;
     C cont;
     cont.replace({42, 137, 137, 3337}, {'a', 'g', 'f', 'r'});
 }
 
-template <cont_type type>
 void test_death_insert_duplicates_iter_iter() {
-    using C = conditional_t<type == cont_type::unique, flat_map<int, char>, flat_multimap<int, char>>;
-    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
-    vector<typename C::value_type> values{{42, 'a'}, {137, 'g'}, {137, 'f'}, {3337, 'r'}};
+    using C = flat_map<int, char>;
+    vector<C::value_type> values{{42, 'a'}, {137, 'g'}, {137, 'f'}, {3337, 'r'}};
     C cont;
-    cont.insert(sorted, values.begin(), values.end());
+    cont.insert(sorted_unique, values.begin(), values.end());
 }
 
-template <cont_type type>
 void test_death_insert_duplicates_range() {
-    using C = conditional_t<type == cont_type::unique, flat_map<int, char>, flat_multimap<int, char>>;
-    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
-    vector<typename C::value_type> values{{42, 'a'}, {137, 'g'}, {137, 'f'}, {3337, 'r'}};
+    using C = flat_map<int, char>;
+    vector<C::value_type> values{{42, 'a'}, {137, 'g'}, {137, 'f'}, {3337, 'r'}};
     C cont;
-    cont.insert_range(sorted, values);
+    cont.insert_range(sorted_unique, values);
 }
 
-template <cont_type type>
 void test_death_insert_duplicates_initializer_list() {
-    using C = conditional_t<type == cont_type::unique, flat_map<int, char>, flat_multimap<int, char>>;
-    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
+    using C = flat_map<int, char>;
     C cont;
-    cont.insert(sorted, {{42, 'a'}, {137, 'g'}, {137, 'f'}, {3337, 'r'}});
+    cont.insert(sorted_unique, {{42, 'a'}, {137, 'g'}, {137, 'f'}, {3337, 'r'}});
 }
 
 template <cont_type type>
@@ -1640,13 +1611,13 @@ int main(int argc, char* argv[]) {
         test_death_insert_unsorted_initializer_list<cont_type::multi>,
 
         // Tests shared between flat_set and flat_map - violation of unique elements
-        test_death_construct_duplicates_initializer_list<cont_type::unique>,
-        test_death_construct_duplicates_iter_iter<cont_type::unique>,
-        test_death_construct_duplicates_container<cont_type::unique>,
-        test_death_replace_duplicates_container<cont_type::unique>,
-        test_death_insert_duplicates_iter_iter<cont_type::unique>,
-        test_death_insert_duplicates_range<cont_type::unique>,
-        test_death_insert_duplicates_initializer_list<cont_type::unique>,
+        test_death_construct_duplicates_initializer_list,
+        test_death_construct_duplicates_iter_iter,
+        test_death_construct_duplicates_container,
+        test_death_replace_duplicates_container,
+        test_death_insert_duplicates_iter_iter,
+        test_death_insert_duplicates_range,
+        test_death_insert_duplicates_initializer_list,
 
         // Tests not present in flat_set - mismatch of length of key and mapped containers
         test_death_different_size_ctor<cont_type::unique>,
diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index f18ebbaf78e..242a27d47ea 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -3,13 +3,12 @@
 
 #include <algorithm>
 #include <cassert>
-#include <climits>
 #include <concepts>
 #include <cstdlib>
 #include <deque>
 #include <flat_set>
 #include <functional>
-#include <iostream>
+#include <limits>
 #include <memory>
 #include <print>
 #include <random>
@@ -24,12 +23,11 @@
 #define TEST_ASSERT(...) assert((__VA_ARGS__))
 
 using namespace std;
-using namespace ranges;
 
 enum class iterator_pair_construction : bool { no_allocator, with_allocator };
 
 template <class R, class T>
-concept container_compatible_range = input_range<R> && convertible_to<range_reference_t<R>, T>;
+concept container_compatible_range = ranges::input_range<R> && convertible_to<ranges::range_reference_t<R>, T>;
 
 template <class T, class Alloc = allocator<T>,
     iterator_pair_construction Choice = iterator_pair_construction::with_allocator>
@@ -68,7 +66,7 @@ class alternative_vector : private vector<T, Alloc> { // not allocator-aware, bu
     constexpr alternative_vector(allocator_arg_t, const type_identity_t<Alloc>& a, const alternative_vector& other)
         : base_type(other, a) {}
     constexpr alternative_vector(allocator_arg_t, const type_identity_t<Alloc>& a, alternative_vector&& other)
-        : base_type(std::move(other), a) {}
+        : base_type(move(other), a) {}
     constexpr explicit alternative_vector(initializer_list<T> il) : base_type(il) {}
 
     alternative_vector(const alternative_vector&) = default;
@@ -143,98 +141,120 @@ void assert_all_requirements(const T& s) {
     assert_is_sorted_maybe_unique<_Is_specialization_v<T, flat_set>>(s);
 }
 
-template <class T>
-void assert_all_requirements_and_equals(const T& s, const initializer_list<typename T::value_type>& il) {
+template <class T, class U = initializer_list<typename T::value_type>>
+void assert_all_requirements_and_equals(const T& s, const U& correct) {
     assert_all_requirements(s);
 
-    if (!std::equal(s.begin(), s.end(), il.begin(), il.end())) {
-        cout << "Expected: {";
-        for (auto&& e : il) {
-            cout << e << ", ";
-        }
-        cout << "}" << endl;
-        cout << "Got:      {";
-        for (auto&& e : s) {
-            cout << e << ", ";
-        }
-        cout << "}" << endl;
+    if (!ranges::equal(s, correct)) {
+        println("Unexpected content!\nExpected {}\nActual {}", correct, s);
         assert(false);
     }
 }
 
-template <class T, class U>
-void assert_all_requirements_and_equals(
-    const T& first, const U& second, const initializer_list<typename T::value_type>& il) {
-    assert_all_requirements_and_equals(first, il);
-    assert_all_requirements_and_equals(second, il);
-    assert(first == second);
-}
-
 template <class C>
 void test_constructors() {
-    using lt = std::less<int>;
-    using gt = std::greater<int>;
+    using lt = less<int>;
+    using gt = greater<int>;
+
+    // Test flat_set()
+    // and  flat_set(const key_compare&)
+    assert_all_requirements_and_equals(flat_set<int, lt, C>(), {});
+    assert_all_requirements_and_equals(flat_multiset<int, lt, C>(), {});
+    assert_all_requirements_and_equals(flat_set<int, lt, C>(lt{}), {});
+    assert_all_requirements_and_equals(flat_multiset<int, lt, C>(lt{}), {});
 
     {
-        // Test flat_set()
-        // and  flat_set(const key_compare&)
-        const lt comp;
-        {
-            flat_set<int, lt, C> fs;
-            flat_set<int, lt, C> fs1(comp);
-            assert_all_requirements_and_equals(fs, fs1, {});
-        }
-        {
-            flat_multiset<int, lt, C> fms;
-            flat_multiset<int, lt, C> fms1(comp);
-            assert_all_requirements_and_equals(fms, fms1, {});
-        }
-    }
-    {
-        // Test flat_set(const container)
+        // Test flat_set(container_type, const key_compare& = key_compare())
+        flat_set fs1(C{3, 7, 1, 85, 222, 1});
+        flat_multiset fms1(C{3, 7, 1, 85, 7, 222, 1});
+        flat_set fs2(C{1, 2, 3, 3}, gt{});
+        flat_multiset fms2(C{1, 1, 2, 3}, gt{});
+        assert_all_requirements_and_equals(fs1, {1, 3, 7, 85, 222});
+        assert_all_requirements_and_equals(fms1, {1, 1, 3, 7, 7, 85, 222});
+        assert_all_requirements_and_equals(fs2, {3, 2, 1});
+        assert_all_requirements_and_equals(fms2, {3, 2, 1, 1});
+
+        // Test flat_set(const flat_set&)
+        // and  flat_set(flat_set&&)
+        flat_set fs3(fs1);
+        flat_multiset fms3(fms1);
+        flat_set fs4(move(fs2));
+        flat_multiset fms4(move(fms2));
+        assert_all_requirements_and_equals(fs3, {1, 3, 7, 85, 222});
+        assert_all_requirements_and_equals(fms3, {1, 1, 3, 7, 7, 85, 222});
+        assert_all_requirements_and_equals(fs4, {3, 2, 1});
+        assert_all_requirements_and_equals(fms4, {3, 2, 1, 1});
     }
 
-    assert_all_requirements_and_equals(flat_set(C{3, 7, 1, 85, 222, 1}), {1, 3, 7, 85, 222});
-    assert_all_requirements_and_equals(flat_multiset(C{3, 7, 1, 85, 7, 222, 1}), {1, 1, 3, 7, 7, 85, 222});
-    assert_all_requirements_and_equals(flat_set(C{1, 2, 3, 3}, gt{}), {3, 2, 1});
-    assert_all_requirements_and_equals(flat_multiset(C{1, 1, 2, 3}, gt{}), {3, 2, 1, 1});
+    // Test flat_set(sorted_unique_t, container_type, const key_compare& = key_compare())
+    assert_all_requirements_and_equals(flat_set(sorted_unique, C{1, 200, 30000}), {1, 200, 30000});
+    assert_all_requirements_and_equals(flat_multiset(sorted_equivalent, C{-1, 3, 3}), {-1, 3, 3});
     assert_all_requirements_and_equals(flat_set(sorted_unique, C{30000, 200, 1}, gt{}), {30000, 200, 1});
     assert_all_requirements_and_equals(flat_multiset(sorted_equivalent, C{3, 3, -1}, gt{}), {3, 3, -1});
-    assert_all_requirements_and_equals(flat_set<int, gt, C>({30000, 200, 1}, gt{}), {30000, 200, 1});
-    assert_all_requirements_and_equals(flat_multiset<int, gt, C>({3, 3, -1}, gt{}), {3, 3, -1});
+
+    const int arr[] = {2, 7, 18, 28, 18, 28, 45, 90, 45, 23};
+
+    // Test flat_set(InIt, InIt, const key_compare& = key_compare())
+    assert_all_requirements_and_equals(flat_set<int, lt, C>(begin(arr), end(arr)), {2, 7, 18, 23, 28, 45, 90});
+    assert_all_requirements_and_equals(
+        flat_multiset<int, lt, C>(begin(arr), end(arr)), {2, 7, 18, 18, 23, 28, 28, 45, 45, 90});
+    assert_all_requirements_and_equals(flat_set<int, gt, C>(begin(arr), end(arr), gt{}), {90, 45, 28, 23, 18, 7, 2});
+    assert_all_requirements_and_equals(
+        flat_multiset<int, gt, C>(begin(arr), end(arr), gt{}), {90, 45, 45, 28, 28, 23, 18, 18, 7, 2});
+
+    {
+        // Test flat_set(sorted_unique_t, InIt, InIt, const key_compare& = key_compare())
+        const int ua[] = {10, 20, 30}; // unique ascending
+        const int ea[] = {40, 50, 50, 60, 60, 60}; // equivalent ascending
+        const int ud[] = {66, 55, 44}; // unique descending
+        const int ed[] = {33, 22, 22, 11, 11, 11}; // equivalent descending
+        assert_all_requirements_and_equals(flat_set<int, lt, C>(sorted_unique, begin(ua), end(ua)), ua);
+        assert_all_requirements_and_equals(flat_multiset<int, lt, C>(sorted_equivalent, begin(ea), end(ea)), ea);
+        assert_all_requirements_and_equals(flat_set<int, gt, C>(sorted_unique, begin(ud), end(ud), gt{}), ud);
+        assert_all_requirements_and_equals(flat_multiset<int, gt, C>(sorted_equivalent, begin(ed), end(ed), gt{}), ed);
+    }
+
+    // Test flat_set(from_range_t, R&&)
+    // and  flat_set(from_range_t, R&&, const key_compare&)
+    assert_all_requirements_and_equals(flat_set<int, lt, C>(from_range, arr), {2, 7, 18, 23, 28, 45, 90});
+    assert_all_requirements_and_equals(
+        flat_multiset<int, lt, C>(from_range, arr), {2, 7, 18, 18, 23, 28, 28, 45, 45, 90});
+    assert_all_requirements_and_equals(flat_set<int, gt, C>(from_range, arr, gt{}), {90, 45, 28, 23, 18, 7, 2});
+    assert_all_requirements_and_equals(
+        flat_multiset<int, gt, C>(from_range, arr, gt{}), {90, 45, 45, 28, 28, 23, 18, 18, 7, 2});
+
+    // Test flat_set(initializer_list<value_type>, const key_compare& = key_compare())
+    assert_all_requirements_and_equals(flat_set<int, lt, C>({3, 7, 1, 85, 222, 1}), {1, 3, 7, 85, 222});
+    assert_all_requirements_and_equals(flat_multiset<int, lt, C>({3, 7, 1, 85, 7, 222, 1}), {1, 1, 3, 7, 7, 85, 222});
+    assert_all_requirements_and_equals(flat_set<int, gt, C>({1, 2, 3, 3}, gt{}), {3, 2, 1});
+    assert_all_requirements_and_equals(flat_multiset<int, gt, C>({1, 1, 2, 3}, gt{}), {3, 2, 1, 1});
+
+    // Test flat_set(sorted_unique_t, initializer_list<value_type>, const key_compare& = key_compare())
+    assert_all_requirements_and_equals(flat_set<int, lt, C>(sorted_unique, {1, 200, 30000}), {1, 200, 30000});
+    assert_all_requirements_and_equals(flat_multiset<int, lt, C>(sorted_equivalent, {-1, 3, 3}), {-1, 3, 3});
     assert_all_requirements_and_equals(flat_set<int, gt, C>(sorted_unique, {30000, 200, 1}, gt{}), {30000, 200, 1});
     assert_all_requirements_and_equals(flat_multiset<int, gt, C>(sorted_equivalent, {3, 3, -1}, gt{}), {3, 3, -1});
-
-    flat_set<int> a{};
-    a = {1, 7, 7, 7, 2, 100, -1};
-    assert_all_requirements_and_equals(a, {-1, 1, 2, 7, 100});
-    assert_all_requirements_and_equals(flat_set<int>(a, allocator<int>{}), {-1, 1, 2, 7, 100});
-    assert_all_requirements_and_equals(flat_set<int>(std::move(a), allocator<int>{}), {-1, 1, 2, 7, 100});
-    flat_multiset<int> b{};
-    b = {1, 7, 7, 7, 2, 100, -1};
-    assert_all_requirements_and_equals(b, {-1, 1, 2, 7, 7, 7, 100});
-    assert_all_requirements_and_equals(flat_multiset<int>(b, allocator<int>{}), {-1, 1, 2, 7, 7, 7, 100});
-    assert_all_requirements_and_equals(flat_multiset<int>(std::move(b), allocator<int>{}), {-1, 1, 2, 7, 7, 7, 100});
 }
 
 template <iterator_pair_construction Choice>
 void test_allocator_extended_constructors() {
     using vec = alternative_vector<int, allocator<int>, Choice>;
     constexpr allocator<int> ator;
-    constexpr std::less<int> comp;
+    constexpr less<int> comp;
     {
-        using fs = flat_set<int, std::less<int>, vec>;
+        using fs = flat_set<int, less<int>, vec>;
 
         fs s{3, 7, 1, 85, 222, 1};
         fs s_expected{1, 3, 7, 85, 222};
         vec v_raw{3, 7, 1, 85, 222, 1};
         vec v_sorted_unique{1, 3, 7, 85, 222};
 
+        TEST_ASSERT(fs{ator} == fs{});
         TEST_ASSERT(fs{comp, ator} == fs{});
 
         TEST_ASSERT(fs{s, ator} == s_expected);
         TEST_ASSERT(fs{s_expected, ator} == s_expected);
-        TEST_ASSERT(fs{std::move(s), ator} == s_expected);
+        TEST_ASSERT(fs{move(s), ator} == s_expected);
         TEST_ASSERT(fs{fs{s_expected}, ator} == s_expected);
 
         TEST_ASSERT(fs{v_raw, ator} == s_expected);
@@ -258,18 +278,19 @@ void test_allocator_extended_constructors() {
         }
     }
     {
-        using fms = flat_multiset<int, std::less<int>, vec>;
+        using fms = flat_multiset<int, less<int>, vec>;
 
         fms s{3, 7, 1, 85, 222, 1};
         fms s_expected{1, 1, 3, 7, 85, 222};
         vec v_raw{3, 7, 1, 85, 222, 1};
         vec v_sorted_eq{1, 1, 3, 7, 85, 222};
 
+        TEST_ASSERT(fms{ator} == fms{});
         TEST_ASSERT(fms{comp, ator} == fms{});
 
         TEST_ASSERT(fms{s, ator} == s_expected);
         TEST_ASSERT(fms{s_expected, ator} == s_expected);
-        TEST_ASSERT(fms{std::move(s), ator} == s_expected);
+        TEST_ASSERT(fms{move(s), ator} == s_expected);
         TEST_ASSERT(fms{fms{s_expected}, ator} == s_expected);
 
         TEST_ASSERT(fms{v_raw, ator} == s_expected);
@@ -294,6 +315,48 @@ void test_allocator_extended_constructors() {
     }
 }
 
+template <class T>
+void test_iterators_and_capacity() {
+    T t{11, 22, 33, 44};
+    const T& c = t;
+
+    {
+        const int arr[]{11, 22, 33, 44};
+        assert(equal(t.begin(), t.end(), begin(arr), end(arr)));
+        assert(equal(c.begin(), c.end(), begin(arr), end(arr)));
+        assert(equal(t.cbegin(), t.cend(), begin(arr), end(arr)));
+        assert(equal(c.cbegin(), c.cend(), begin(arr), end(arr)));
+    }
+    {
+        const int rev[]{44, 33, 22, 11};
+        assert(equal(t.rbegin(), t.rend(), begin(rev), end(rev)));
+        assert(equal(c.rbegin(), c.rend(), begin(rev), end(rev)));
+        assert(equal(t.crbegin(), t.crend(), begin(rev), end(rev)));
+        assert(equal(c.crbegin(), c.crend(), begin(rev), end(rev)));
+    }
+
+    {
+        const T zero;
+
+        assert(!t.empty());
+        assert(zero.empty());
+
+        assert(t.size() == 4);
+        assert(zero.size() == 0);
+
+        assert(t.max_size() > 10);
+        assert(zero.max_size() > 10);
+    }
+
+    // Finally, test replace() and clear().
+    typename T::container_type primes{17, 29, 47};
+    t.replace(move(primes));
+    assert(t.size() == 3);
+    assert(*t.begin() == 17);
+    t.clear();
+    assert(t.empty());
+}
+
 template <template <class...> class Set>
 void test_always_reversible() {
     // Test that flat_meow is unconditionally reversible.
@@ -312,7 +375,7 @@ void test_always_reversible() {
         using base::base;
     };
 
-    Set<int, std::greater<int>, not_reversible> fs({1, 2, 3});
+    Set<int, greater<int>, not_reversible> fs({1, 2, 3});
     assert_all_requirements_and_equals(fs, {3, 2, 1});
     assert(fs.rbegin() + 3 == fs.rend());
     assert(fs.crend() - fs.crbegin() == 3);
@@ -320,7 +383,7 @@ void test_always_reversible() {
 
 template <class C>
 void test_insert_1() {
-    using lt = std::less<int>;
+    using lt = less<int>;
 
     const vector<int> vec{0, 1, 2};
     {
@@ -375,7 +438,7 @@ void test_insert_1() {
 
 template <class C>
 void test_insert_2() {
-    using lt = std::less<int>;
+    using lt = less<int>;
 
     const int val = 1;
     {
@@ -403,22 +466,37 @@ void test_insert_2() {
         assert_all_requirements_and_equals(a, {0, 0, 0, 1, 5, 6});
     }
 
-    // TRANSITION, too simple
-    using gt = std::greater<int>;
+    using gt = greater<int>;
+    {
+        flat_set<int, gt, C> a{5, 7, 9};
+        assert_all_requirements_and_equals(a, {9, 7, 5});
+        a.emplace_hint(a.end());
+        assert_all_requirements_and_equals(a, {9, 7, 5, 0});
+        a.emplace_hint(a.begin() + 1, 8);
+        assert_all_requirements_and_equals(a, {9, 8, 7, 5, 0});
+        a.insert(a.begin() + 3, 6);
+        assert_all_requirements_and_equals(a, {9, 8, 7, 6, 5, 0});
+        a.insert(a.end() - 1, val);
+        assert_all_requirements_and_equals(a, {9, 8, 7, 6, 5, 1, 0});
+    }
     {
-        flat_set<int, gt, C> a{0, 5};
-        assert_all_requirements_and_equals(a, {5, 0});
-        a.insert(a.begin(), 3);
-        assert_all_requirements_and_equals(a, {5, 3, 0});
-        a.insert(a.end(), 4);
-        assert_all_requirements_and_equals(a, {5, 4, 3, 0});
+        flat_multiset<int, gt, C> a{3, 1, 4, 1, 5, 9};
+        assert_all_requirements_and_equals(a, {9, 5, 4, 3, 1, 1});
+        a.emplace_hint(a.end());
+        assert_all_requirements_and_equals(a, {9, 5, 4, 3, 1, 1, 0});
+        a.emplace_hint(a.begin() + 2, 4);
+        assert_all_requirements_and_equals(a, {9, 5, 4, 4, 3, 1, 1, 0});
+        a.insert(a.begin() + 1, 6);
+        assert_all_requirements_and_equals(a, {9, 6, 5, 4, 4, 3, 1, 1, 0});
+        a.insert(a.end() - 3, val);
+        assert_all_requirements_and_equals(a, {9, 6, 5, 4, 4, 3, 1, 1, 1, 0});
     }
 }
 
 // Test that hint to emplace/insert is respected, when possible; check returned iterator
 template <class C>
 void test_insert_hint_is_respected() {
-    using lt = std::less<int>;
+    using lt = less<int>;
 
     {
         flat_multiset<int, lt, C> a{-1, -1, 1, 1};
@@ -473,32 +551,15 @@ void test_insert_hint_is_respected() {
     }
 }
 
-
-struct key_comparer {
-    const auto& extract_key(const auto& obj) const {
-        if constexpr (requires { obj.key; }) {
-            return obj.key;
-        } else {
-            return obj;
-        }
-    }
-
-    bool operator()(const auto& lhs, const auto& rhs) const {
-        return extract_key(lhs) < extract_key(rhs);
-    }
-
-    using is_transparent = int;
-};
-
-void test_comparer_application() {
-    // The set must rely on its comparer to do the comparisons.
+void test_comparator_application() {
+    // The set must rely on its comparator to do the comparisons.
     struct incomparable {
         int key;
         bool operator<(const incomparable&) const  = delete;
         bool operator==(const incomparable&) const = delete;
     };
 
-    flat_set<incomparable, key_comparer> fs{{0}, {3}, {1}, {0}, {5}};
+    flat_set<incomparable, key_comparator> fs{{0}, {3}, {1}, {0}, {5}};
     assert(fs.contains(0));
     assert(!fs.contains(2));
     fs.insert(fs.begin(), incomparable{4});
@@ -524,7 +585,7 @@ void test_insert_transparent() {
         }
     };
 
-    flat_set<int, key_comparer> fs{0, 3, 5};
+    flat_set<int, key_comparator> fs{0, 3, 5};
     assert_all_requirements_and_equals(fs, {0, 3, 5});
     detect_conversion detector{3};
 
@@ -555,20 +616,20 @@ void test_insert_transparent() {
     assert(detector.converted);
 }
 
-void test_insert_using_invalid_hint() {
-    mt19937 eng(42);
-
-    uniform_int_distribution<int> dist_seq(0, 20);
-
+void test_insert_using_invalid_hint(mt19937_64& eng) {
     vector<int> seq(200);
-    for (int& val : seq) {
-        val = dist_seq(eng);
+
+    {
+        uniform_int_distribution<int> dist_seq(0, 20);
+        for (auto& val : seq) {
+            val = dist_seq(eng);
+        }
     }
 
     {
         flat_multiset<int> with_hint;
         flat_multiset<int> no_hint;
-        for (const int val : seq) {
+        for (const auto& val : seq) {
             uniform_int_distribution<int> dist_idx(0, static_cast<int>(with_hint.size()));
             auto random_hint = with_hint.begin() + dist_idx(eng);
             with_hint.insert(random_hint, val);
@@ -581,7 +642,7 @@ void test_insert_using_invalid_hint() {
     {
         flat_set<int> with_hint;
         flat_set<int> no_hint;
-        for (const int val : seq) {
+        for (const auto& val : seq) {
             uniform_int_distribution<int> dist_idx(0, static_cast<int>(with_hint.size()));
             auto random_hint = with_hint.begin() + dist_idx(eng);
             with_hint.insert(random_hint, val);
@@ -592,7 +653,7 @@ void test_insert_using_invalid_hint() {
     }
 }
 
-void test_insert_upper_bound() {
+void test_insert_upper_bound(mt19937_64& eng) {
     // For flat_multiset's single-element insertion, the key should be inserted before the upper_bound.
     struct test_position {
         int key;
@@ -600,7 +661,6 @@ void test_insert_upper_bound() {
         bool operator==(const test_position&) const = default;
     };
 
-    mt19937 eng(24);
     uniform_int_distribution<int> dist_seq(0, 20);
 
     vector<test_position> seq(200);
@@ -609,20 +669,20 @@ void test_insert_upper_bound() {
         extra = e++;
     }
 
-    flat_multiset<test_position, key_comparer> fs;
+    flat_multiset<test_position, key_comparator> fs;
     for (const auto& val : seq) {
         fs.insert(val);
     }
 
     // The result should be identical to as if doing stable_sort on seq.
-    ranges::stable_sort(seq, key_comparer{});
+    ranges::stable_sort(seq, key_comparator{});
     assert(ranges::equal(fs, seq));
 }
 
 template <class T>
 void test_spaceship_operator() {
     static constexpr bool multi  = _Is_specialization_v<T, flat_multiset>;
-    static constexpr bool invert = is_same_v<typename T::key_compare, std::greater<typename T::key_type>>;
+    static constexpr bool invert = is_same_v<typename T::key_compare, greater<typename T::key_type>>;
 
     T a{3, 2, 2, 1};
     T b{1, 2, 3};
@@ -637,10 +697,16 @@ void test_spaceship_operator() {
 
     T f{1, 2, 3, 4};
     assert((f <=> a) == strong_ordering::greater);
+
+    // also test equality
+    assert(f == f);
+    assert(!(f != f));
+    assert(!(f == a));
+    assert(f != a);
 }
 
 template <class T>
-struct proxy_comparer {
+struct proxy_comparator {
     bool operator()(const T& lhs, const T& rhs) const {
         return m_less ? (lhs < rhs) : (lhs > rhs);
     }
@@ -648,10 +714,10 @@ struct proxy_comparer {
     bool m_less = true;
 };
 
-void test_non_static_comparer() {
-    flat_set<int, proxy_comparer<int>> a{3, 2, 2, 1};
+void test_non_static_comparator() {
+    flat_set<int, proxy_comparator<int>> a{3, 2, 2, 1};
     assert_all_requirements_and_equals(a, {1, 2, 3});
-    auto b = flat_set<int, proxy_comparer<int>>({-1, 5, 9, 9, 9, 9, 9}, proxy_comparer<int>{.m_less = false});
+    flat_set<int, proxy_comparator<int>> b({-1, 5, 9, 9, 9, 9, 9}, proxy_comparator<int>{.m_less = false});
     assert_all_requirements_and_equals(b, {9, 5, -1});
 
     auto aBackup = a;
@@ -660,7 +726,7 @@ void test_non_static_comparer() {
     a.insert_range(vector{7, 7, 3, 3, 2});
     assert_all_requirements_and_equals(a, {9, 7, 5, 3, 2, -1});
 
-    a = std::move(aBackup);
+    a = move(aBackup);
     assert_all_requirements_and_equals(a, {1, 2, 3});
 
     a.insert(-100);
@@ -697,9 +763,9 @@ void test_extract_1() {
     };
 
     will_throw = false;
-    Set<int, std::less<int>, test_exception> fs{4, 3, 2, 1};
+    Set<int, less<int>, test_exception> fs{4, 3, 2, 1};
     assert_all_requirements_and_equals(fs, {1, 2, 3, 4});
-    auto extr = std::move(fs).extract();
+    auto extr = move(fs).extract();
     assert(ranges::equal(extr, vector{1, 2, 3, 4}));
     assert_all_requirements_and_equals(fs, {}); // assert empty
 
@@ -707,7 +773,7 @@ void test_extract_1() {
     assert_all_requirements_and_equals(fs, {1, 2, 3, 4});
     try {
         will_throw = true;
-        (void) std::move(fs).extract();
+        (void) move(fs).extract();
     } catch (...) {
         will_throw = false;
         assert_all_requirements_and_equals(fs, {}); // assert empty
@@ -737,16 +803,16 @@ void test_extract_2() {
         }
     };
 
-    Set<int, std::less<int>, always_copy> fs{4, 3, 2, 1};
+    Set<int, less<int>, always_copy> fs{4, 3, 2, 1};
     assert_all_requirements_and_equals(fs, {1, 2, 3, 4});
-    auto extr = std::move(fs).extract();
+    auto extr = move(fs).extract();
     assert(ranges::equal(extr, vector{1, 2, 3, 4}));
     assert_all_requirements_and_equals(fs, {}); // assert empty
 }
 
 void test_invariant_robustness() {
     static int copy_limit   = 2;
-    constexpr int unlimited = INT_MAX;
+    constexpr int unlimited = (numeric_limits<int>::max)();
 
     struct odd_key {
         static void countdown() {
@@ -796,34 +862,34 @@ void test_invariant_robustness() {
         using base::base;
         odd_container(const odd_container&) = default;
 
-        // this copy-assignment cannot provide strong-guarantee for `this`:
+        // this copy assignment operator cannot provide the strong guarantee for `this`:
         odd_container& operator=(const odd_container& other) {
             resize(other.size());
-            std::copy(other.begin(), other.end(), begin());
+            copy(other.begin(), other.end(), begin());
             return *this;
         }
 
-        // this move-ctor cannot provide strong-guarantee for `other`, and even successful, will leave elements of
-        // `other` in moved-from state:
+        // this move ctor cannot provide the strong guarantee for `other`,
+        // and even if it is successful, it will leave the elements of `other` in a moved-from state:
         odd_container(odd_container&& other) {
             reserve(other.size());
             for (auto& e : other) {
-                push_back(std::move(e));
+                push_back(move(e));
             }
         }
 
-        // this move-assignment cannot provide strong-guarantee for `this` and `other`, and even successful, will leave
-        // elements of `other` in moved-from state:
+        // this move assignment operator cannot provide the strong guarantee for `this` and `other`,
+        // and even if it is successful, it will leave the elements of `other` in a moved-from state:
         odd_container& operator=(odd_container&& other) {
             resize(other.size());
-            std::move(other.begin(), other.end(), begin());
+            move(other.begin(), other.end(), begin());
             return *this;
         }
     };
 
-    using SetT = flat_set<odd_key, key_comparer, odd_container>;
+    using SetT = flat_set<odd_key, key_comparator, odd_container>;
 
-    // copy-assignment
+    // copy assignment
     {
         copy_limit = unlimited;
         SetT fs1{0, 1, 2, 3, 4};
@@ -843,11 +909,12 @@ void test_invariant_robustness() {
         }
         assert(caught);
     }
-    // move-ctor
+
+    // move ctor
     {
         copy_limit = unlimited;
         SetT fs1{0, 1, 2, 3, 4};
-        SetT fs2{std::move(fs1)};
+        SetT fs2{move(fs1)};
 
         assert_all_requirements(fs1);
         assert(ranges::equal(fs2, vector{0, 1, 2, 3, 4}, {}, &odd_key::key));
@@ -855,7 +922,7 @@ void test_invariant_robustness() {
         bool caught = false;
         try {
             copy_limit = 2;
-            SetT fs3{std::move(fs2)}; // will throw after moving 2 odd_key.
+            SetT fs3{move(fs2)}; // will throw after moving 2 odd_key.
         } catch (...) {
             copy_limit = unlimited;
             assert_all_requirements(fs2);
@@ -863,13 +930,14 @@ void test_invariant_robustness() {
         }
         assert(caught);
     }
-    // move-assignment
+
+    // move assignment
     {
         copy_limit = unlimited;
         SetT fs1{0, 1, 2, 3, 4};
         SetT fs2;
         SetT fs3{5, 6, 7, 8, 9};
-        fs2 = std::move(fs1);
+        fs2 = move(fs1);
 
         assert_all_requirements(fs1);
         assert(ranges::equal(fs2, vector{0, 1, 2, 3, 4}, {}, &odd_key::key));
@@ -878,7 +946,7 @@ void test_invariant_robustness() {
         bool caught = false;
         try {
             copy_limit = 2;
-            fs2        = std::move(fs3); // will throw after moving 2 odd_key.
+            fs2        = move(fs3); // will throw after moving 2 odd_key.
         } catch (...) {
             copy_limit = unlimited;
             assert_all_requirements(fs2);
@@ -893,7 +961,7 @@ void test_erase_1() {
     flat_set<int> fs{1};
     assert(1 == fs.erase(1));
     assert_all_requirements_and_equals(fs, {});
-    int numbers[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+    const int numbers[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
     fs.insert_range(numbers);
     assert_all_requirements_and_equals(fs, {0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
     fs.insert_range(numbers);
@@ -913,17 +981,17 @@ template <class T>
 struct holder {
     T t;
     operator T() && {
-        return std::move(t);
+        return move(t);
     }
 };
 
 static_assert(is_convertible_v<holder<flat_set<int>::const_iterator>, flat_set<int>::const_iterator>);
 
 void test_erase_2() {
-    using C = flat_set<int, std::less<>>;
+    using C = flat_set<int, less<>>;
     C fs{0, 1, 2, 3};
     assert_all_requirements_and_equals(fs, {0, 1, 2, 3});
-    // this should be allowed per P2077R3:
+    // this should be allowed per N5032 [associative.reqmts.general]/7.23.2 and /122-125:
     fs.erase(holder<C::const_iterator>{fs.cbegin()});
     assert_all_requirements_and_equals(fs, {1, 2, 3});
     fs.erase(holder<C::iterator>{fs.begin()});
@@ -933,17 +1001,16 @@ void test_erase_2() {
     assert_all_requirements_and_equals(fs, {3});
 }
 
-template <class Cont, class OtherKey>
-concept can_erase_key = requires(Cont c, OtherKey key) {
-    { c.erase(key) } -> same_as<typename Cont::size_type>;
-};
-template <class Cont>
-concept can_erase_iterator_holder = requires(Cont c) {
-    { c.erase(holder<typename Cont::const_iterator>{c.begin()}) } -> same_as<typename Cont::iterator>;
-};
-// Note that std::less<T> is not transparent, std::less<> and ranges::less are
+namespace test_erase_compile_time {
+    template <class Cont, class OtherKey>
+    concept can_erase_key = requires(Cont c, OtherKey key) {
+        { c.erase(key) } -> same_as<typename Cont::size_type>;
+    };
+    template <class Cont>
+    concept can_erase_iterator_holder = requires(Cont c) {
+        { c.erase(holder<typename Cont::const_iterator>{c.begin()}) } -> same_as<typename Cont::iterator>;
+    };
 
-namespace detail {
     using C = flat_set<int>;
     static_assert(same_as<C::iterator, decltype(declval<C>().erase(declval<C::iterator>()))>);
     static_assert(same_as<C::iterator, decltype(declval<C>().erase(declval<holder<C::iterator>>()))>);
@@ -953,20 +1020,23 @@ namespace detail {
     static_assert(same_as<C::size_type, decltype(declval<C>().erase(declval<holder<int>>()))>);
     static_assert(same_as<C::size_type, decltype(declval<C>().erase(declval<int>()))>);
 
+    // Note that std::less<T> is not transparent, while std::less<> and ranges::less are
+
     // erase key_type
-    static_assert(can_erase_key<flat_set<int, std::less<int>>, int>);
-    static_assert(can_erase_key<flat_set<int, std::less<>>, int>);
+    static_assert(can_erase_key<flat_set<int, less<int>>, int>);
+    static_assert(can_erase_key<flat_set<int, less<>>, int>);
     static_assert(can_erase_key<flat_set<int, ranges::less>, int>);
+
     // erase wrapped key_type
-    static_assert(!can_erase_key<flat_set<int, std::less<int>>, holder<int>>);
-    static_assert(can_erase_key<flat_set<int, std::less<>>, holder<int>>);
+    static_assert(!can_erase_key<flat_set<int, less<int>>, holder<int>>);
+    static_assert(can_erase_key<flat_set<int, less<>>, holder<int>>);
     static_assert(can_erase_key<flat_set<int, ranges::less>, holder<int>>);
+
     // erase wrapped iterator - the member function template returning size_type must not be selected
-    static_assert(can_erase_iterator_holder<flat_set<int, std::less<int>>>);
-    static_assert(can_erase_iterator_holder<flat_set<int, std::less<>>>);
+    static_assert(can_erase_iterator_holder<flat_set<int, less<int>>>);
+    static_assert(can_erase_iterator_holder<flat_set<int, less<>>>);
     static_assert(can_erase_iterator_holder<flat_set<int, ranges::less>>);
-} // namespace detail
-
+} // namespace test_erase_compile_time
 
 template <class C>
 void test_erase_if() {
@@ -1026,7 +1096,7 @@ void test_set_operations() {
         // flat_set:
         assert_all_requirements_and_equals(fs, {2, 3, 8, 11, 20});
 
-        assert(fs.find(3) != fs.end());
+        assert(fs.find(3) == fs.begin() + 1);
         assert(fs.find(4) == fs.end());
 
         assert(fs.count(1) == 0);
@@ -1052,7 +1122,7 @@ void test_set_operations() {
         // flat_multiset:
         assert_all_requirements_and_equals(fs, {2, 3, 3, 8, 11, 11, 11, 20});
 
-        assert(fs.find(3) != fs.end());
+        assert(fs.find(3) == fs.begin() + 1);
         assert(fs.find(4) == fs.end());
 
         assert(fs.count(1) == 0);
@@ -1086,17 +1156,26 @@ void test_set_operations_transparent() {
         }
     };
 
-    Set<int, key_comparer> fs{0, 3, 5};
+    Set<int, key_comparator> fs{0, 3, 5};
     assert_all_requirements_and_equals(fs, {0, 3, 5});
 
-    assert(fs.find(shouldnt_convert{0}) != fs.end());
+    assert(fs.find(shouldnt_convert{0}) == fs.begin());
     assert(fs.count(shouldnt_convert{3}) == 1);
     assert(!fs.contains(shouldnt_convert{1}));
     assert(fs.lower_bound(shouldnt_convert{-1}) == fs.begin());
     assert(fs.lower_bound(shouldnt_convert{8}) == fs.end());
     assert(fs.upper_bound(shouldnt_convert{2}) == fs.find(3));
-    auto [first, last] = fs.equal_range(shouldnt_convert{5});
-    assert(first + 1 == last);
+    assert(fs.equal_range(shouldnt_convert{5}) == (pair{fs.begin() + 2, fs.end()}));
+
+    // Also test const overloads:
+    const auto& cfs = fs;
+    assert(cfs.find(shouldnt_convert{0}) == cfs.begin());
+    assert(cfs.count(shouldnt_convert{3}) == 1);
+    assert(!cfs.contains(shouldnt_convert{1}));
+    assert(cfs.lower_bound(shouldnt_convert{-1}) == cfs.begin());
+    assert(cfs.lower_bound(shouldnt_convert{8}) == cfs.end());
+    assert(cfs.upper_bound(shouldnt_convert{2}) == cfs.find(3));
+    assert(cfs.equal_range(shouldnt_convert{5}) == (pair{cfs.begin() + 2, cfs.end()}));
 }
 
 namespace test_throwing_swap {
@@ -1133,6 +1212,13 @@ void test_throwing_compare_single() {
         assert(ranges::equal(s1, initializer_list<int>{4, 5, 6}));
         assert(ranges::equal(s2, initializer_list<int>{1, 2, 3}));
     }
+    {
+        set_type s1{{1, 2, 3}, comparator{false}};
+        set_type s2{{4, 5, 6}, comparator{false}};
+        swap(s1, s2);
+        assert(ranges::equal(s1, initializer_list<int>{4, 5, 6}));
+        assert(ranges::equal(s2, initializer_list<int>{1, 2, 3}));
+    }
     {
         set_type s1{{1, 2, 3}, comparator{false}};
         set_type s2{{4, 5, 6}, comparator{false}};
@@ -1153,6 +1239,19 @@ void test_throwing_compare_single() {
             assert(false);
         }
     }
+    {
+        set_type s1{{1, 2, 3}, comparator{true}};
+        set_type s2{{4, 5, 6}, comparator{false}};
+        try {
+            swap(s1, s2);
+            assert(false);
+        } catch (const unique_exception&) {
+            assert(s1.empty());
+            assert(s2.empty());
+        } catch (...) {
+            assert(false);
+        }
+    }
     {
         set_type s1{{1, 2, 3}, comparator{true}};
         set_type s2{{4, 5, 6}, comparator{false}};
@@ -1214,7 +1313,7 @@ void test_non_strict_weak_order_compare() {
         assert(first == cont.begin());
         assert(last == cont.begin() + 2);
 
-        assert(cont.end() != cont.find(strange_int{1}));
+        assert(cont.begin() + 2 == cont.find(strange_int{1}));
         assert(cont.end() == cont.find(strange_int{3}));
 
         assert(2 == cont.erase(strange_int{0}));
@@ -1234,7 +1333,7 @@ void test_non_strict_weak_order_compare() {
         assert(first == cont.begin());
         assert(last == cont.begin() + 2);
 
-        assert(cont.end() != cont.find(strange_int{1}));
+        assert(cont.begin() + 2 == cont.find(strange_int{1}));
         assert(cont.end() == cont.find(strange_int{3}));
 
         assert(2 == cont.erase(strange_int{0}));
@@ -1243,20 +1342,18 @@ void test_non_strict_weak_order_compare() {
 }
 
 void run_normal_tests() {
-    test_spaceship_operator<flat_set<int>>();
-    test_spaceship_operator<flat_multiset<int>>();
-    test_spaceship_operator<flat_set<int, std::greater<int>>>();
-    test_spaceship_operator<flat_multiset<int, std::greater<int>>>();
-    test_spaceship_operator<flat_set<int, std::less<int>, deque<int>>>();
-    test_spaceship_operator<flat_multiset<int, std::less<int>, deque<int>>>();
-    test_spaceship_operator<flat_set<int, std::greater<int>, deque<int>>>();
-    test_spaceship_operator<flat_multiset<int, std::greater<int>, deque<int>>>();
+    mt19937_64 eng(42);
 
     test_constructors<vector<int>>();
     test_constructors<deque<int>>();
     test_allocator_extended_constructors<iterator_pair_construction::no_allocator>();
     test_allocator_extended_constructors<iterator_pair_construction::with_allocator>();
 
+    test_iterators_and_capacity<flat_set<int>>();
+    test_iterators_and_capacity<flat_multiset<int>>();
+    test_iterators_and_capacity<flat_set<int, less<int>, deque<int>>>();
+    test_iterators_and_capacity<flat_multiset<int, less<int>, deque<int>>>();
+
     test_always_reversible<flat_set>();
     test_always_reversible<flat_multiset>();
 
@@ -1266,21 +1363,30 @@ void run_normal_tests() {
     test_insert_2<deque<int>>();
     test_insert_hint_is_respected<vector<int>>();
     test_insert_hint_is_respected<deque<int>>();
+    test_comparator_application();
     test_insert_transparent();
-    test_insert_using_invalid_hint();
-    test_insert_upper_bound();
+    test_insert_using_invalid_hint(eng);
+    test_insert_upper_bound(eng);
 
-    test_comparer_application();
-    test_non_static_comparer();
+    test_spaceship_operator<flat_set<int>>();
+    test_spaceship_operator<flat_multiset<int>>();
+    test_spaceship_operator<flat_set<int, greater<int>>>();
+    test_spaceship_operator<flat_multiset<int, greater<int>>>();
+    test_spaceship_operator<flat_set<int, less<int>, deque<int>>>();
+    test_spaceship_operator<flat_multiset<int, less<int>, deque<int>>>();
+    test_spaceship_operator<flat_set<int, greater<int>, deque<int>>>();
+    test_spaceship_operator<flat_multiset<int, greater<int>, deque<int>>>();
+
+    test_non_static_comparator();
 
     test_extract_1<flat_set>();
     test_extract_1<flat_multiset>();
     test_extract_2<flat_set>();
     test_extract_2<flat_multiset>();
 
+    test_invariant_robustness();
     test_erase_1();
     test_erase_2();
-    test_invariant_robustness();
 
     test_erase_if<flat_set<int>>();
     test_erase_if<flat_multiset<int>>();
@@ -1355,60 +1461,47 @@ void test_death_insert_unsorted_initializer_list() {
     cont.insert(sorted, {137, 42, 3337, 15});
 }
 
-template <cont_type type>
 void test_death_construct_duplicates_initializer_list() {
-    using C = conditional_t<type == cont_type::unique, flat_set<int>, flat_multiset<int>>;
-    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
-    C cont(sorted, {42, 137, 137, 3337});
+    using C = flat_set<int>;
+    C cont(sorted_unique, {42, 137, 137, 3337});
 }
 
-template <cont_type type>
 void test_death_construct_duplicates_iter_iter() {
-    using C = conditional_t<type == cont_type::unique, flat_set<int>, flat_multiset<int>>;
-    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
-    typename C::container_type values{42, 137, 137, 3337};
-    C cont(sorted, values.begin(), values.end());
+    using C = flat_set<int>;
+    C::container_type values{42, 137, 137, 3337};
+    C cont(sorted_unique, values.begin(), values.end());
 }
 
-template <cont_type type>
 void test_death_construct_duplicates_container() {
-    using C = conditional_t<type == cont_type::unique, flat_set<int>, flat_multiset<int>>;
-    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
-    typename C::container_type values{42, 137, 137, 3337};
-    C cont(sorted, values);
+    using C = flat_set<int>;
+    C::container_type values{42, 137, 137, 3337};
+    C cont(sorted_unique, values);
 }
 
-template <cont_type type>
 void test_death_replace_duplicates_container() {
-    using C = conditional_t<type == cont_type::unique, flat_set<int>, flat_multiset<int>>;
+    using C = flat_set<int>;
     C cont;
     cont.replace({42, 137, 137, 3337});
 }
 
-template <cont_type type>
 void test_death_insert_duplicates_iter_iter() {
-    using C = conditional_t<type == cont_type::unique, flat_set<int>, flat_multiset<int>>;
-    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
-    typename C::container_type values{42, 137, 137, 3337};
+    using C = flat_set<int>;
+    C::container_type values{42, 137, 137, 3337};
     C cont;
-    cont.insert(sorted, values.begin(), values.end());
+    cont.insert(sorted_unique, values.begin(), values.end());
 }
 
-template <cont_type type>
 void test_death_insert_duplicates_range() {
-    using C = conditional_t<type == cont_type::unique, flat_set<int>, flat_multiset<int>>;
-    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
-    typename C::container_type values{42, 137, 137, 3337};
+    using C = flat_set<int>;
+    C::container_type values{42, 137, 137, 3337};
     C cont;
-    cont.insert_range(sorted, values);
+    cont.insert_range(sorted_unique, values);
 }
 
-template <cont_type type>
 void test_death_insert_duplicates_initializer_list() {
-    using C = conditional_t<type == cont_type::unique, flat_set<int>, flat_multiset<int>>;
-    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
+    using C = flat_set<int>;
     C cont;
-    cont.insert(sorted, {42, 137, 137, 3337});
+    cont.insert(sorted_unique, {42, 137, 137, 3337});
 }
 
 int main(int argc, char* argv[]) {
@@ -1434,13 +1527,13 @@ int main(int argc, char* argv[]) {
         test_death_insert_unsorted_initializer_list<cont_type::multi>,
 
         // Tests shared between flat_set and flat_map - violation of unique elements
-        test_death_construct_duplicates_initializer_list<cont_type::unique>,
-        test_death_construct_duplicates_iter_iter<cont_type::unique>,
-        test_death_construct_duplicates_container<cont_type::unique>,
-        test_death_replace_duplicates_container<cont_type::unique>,
-        test_death_insert_duplicates_iter_iter<cont_type::unique>,
-        test_death_insert_duplicates_range<cont_type::unique>,
-        test_death_insert_duplicates_initializer_list<cont_type::unique>,
+        test_death_construct_duplicates_initializer_list,
+        test_death_construct_duplicates_iter_iter,
+        test_death_construct_duplicates_container,
+        test_death_replace_duplicates_container,
+        test_death_insert_duplicates_iter_iter,
+        test_death_insert_duplicates_range,
+        test_death_insert_duplicates_initializer_list,
     });
 #endif // defined(_DEBUG)
 
diff --git a/tests/std/tests/VSO_0191296_allocator_construct/test.compile.pass.cpp b/tests/std/tests/VSO_0191296_allocator_construct/test.compile.pass.cpp
index f407db63e9b..e78577b4164 100644
--- a/tests/std/tests/VSO_0191296_allocator_construct/test.compile.pass.cpp
+++ b/tests/std/tests/VSO_0191296_allocator_construct/test.compile.pass.cpp
@@ -994,7 +994,7 @@ struct check_all_optional_sequence_requirements<Tag, false> {};
 //
 //
 
-DEFINE_TEST(test_ordered_associative_default_constructor_with_comparer,
+DEFINE_TEST(test_ordered_associative_default_constructor_with_comparator,
 {
     // X(c) and X a(c);
     // Requires:  key_compare is CopyConstructible
@@ -1022,13 +1022,13 @@ DEFINE_TEST(test_ordered_associative_default_constructor_with_comparer,
 });
 
 
-DEFINE_TEST(test_ordered_associative_range_constructor_with_comparer, {
+DEFINE_TEST(test_ordered_associative_range_constructor_with_comparator, {
     // SPEC:  These are the only two operations for which traits are specified for key_compare, but
     // there are many other operations for which key_compare must meet other requirements (e.g. a
     // call to a.key_comp() necessitates that the key_comp type is move constructible.
     //
-    // In the rest of the tests, I have assumed std::less for the comparer, which meets any possible
-    // requirements, but it should be considered whether the comparer requirements should be more
+    // In the rest of the tests, I have assumed std::less for the comparator, which meets any possible
+    // requirements, but it should be considered whether the comparator requirements should be more
     // thoroughly specified.
 
     std::move_iterator<typename Traits::emplace_argument_type*> i;
@@ -1076,8 +1076,8 @@ DEFINE_TEST(test_ordered_associative_insert, {
 template <container_tag Tag, bool = (container_traits<Tag>::features & c_is_ordered_associative) != 0>
 struct check_all_ordered_associative_requirements {
     check_all_ordered_associative_requirements() {
-        test_ordered_associative_default_constructor_with_comparer<Tag>();
-        test_ordered_associative_range_constructor_with_comparer<Tag>();
+        test_ordered_associative_default_constructor_with_comparator<Tag>();
+        test_ordered_associative_range_constructor_with_comparator<Tag>();
         test_ordered_associative_emplace<Tag>();
         test_ordered_associative_insert<Tag>();
     }

From b86e0c9b020bc0b6ff3e3492fba4d4653baa5e57 Mon Sep 17 00:00:00 2001
From: Jakub Mazurkiewicz <mazkuba3@gmail.com>
Date: Thu, 29 Jan 2026 15:21:48 +0100
Subject: [PATCH 121/134] `<flat_meow>`: Update older tests (#6056)

Co-authored-by: Stephan T. Lavavej <stl@microsoft.com>
---
 .../P0896R4_ranges_range_machinery/test.cpp   | 20 ++++++-
 .../tests/P1206R7_ranges_to_mappish/test.cpp  | 60 +++++++++++++++++--
 .../tests/P1206R7_ranges_to_settish/test.cpp  | 49 +++++++++++++--
 .../test.cpp                                  | 53 ++++++++--------
 .../test.cpp                                  | 16 ++++-
 .../test.cpp                                  | 36 +++++++++--
 6 files changed, 191 insertions(+), 43 deletions(-)

diff --git a/tests/std/tests/P0896R4_ranges_range_machinery/test.cpp b/tests/std/tests/P0896R4_ranges_range_machinery/test.cpp
index 83bdb64bc35..3d8dd469fe1 100644
--- a/tests/std/tests/P0896R4_ranges_range_machinery/test.cpp
+++ b/tests/std/tests/P0896R4_ranges_range_machinery/test.cpp
@@ -27,6 +27,11 @@
 #include <valarray>
 #include <vector>
 
+#if _HAS_CXX23
+#include <flat_map>
+#include <flat_set>
+#endif // _HAS_CXX23
+
 #include <range_algorithm_support.hpp>
 
 // Note that many tests herein assume:
@@ -836,7 +841,11 @@ constexpr bool test_std_container() {
     }
     static_assert(test_empty<T&, true>());
     if constexpr (std::contiguous_iterator<I>) {
-        static_assert(test_data<T&, V*>());
+        if constexpr (std::is_same_v<I, CI>) {
+            static_assert(test_data<T&, V const*>());
+        } else {
+            static_assert(test_data<T&, V*>());
+        }
         static_assert(test_cdata<T&, V const*>());
     }
     static_assert(!ranges::view<T&>);
@@ -899,6 +908,7 @@ static_assert(test_std_container<std::multimap<int, int>, std::bidirectional_ite
 static_assert(test_std_container<std::multiset<int>, std::bidirectional_iterator_tag>());
 static_assert(test_std_container<std::set<int>, std::bidirectional_iterator_tag>());
 static_assert(test_std_container<std::string, std::contiguous_iterator_tag>());
+// Implementation-specific: unordered_meow uses list's iterators, so they're bidirectional instead of forward.
 static_assert(test_std_container<std::unordered_map<int, int>, std::bidirectional_iterator_tag>());
 static_assert(test_std_container<std::unordered_multimap<int, int>, std::bidirectional_iterator_tag>());
 static_assert(test_std_container<std::unordered_multiset<int>, std::bidirectional_iterator_tag>());
@@ -907,6 +917,14 @@ static_assert(test_std_container<std::vector<int>, std::contiguous_iterator_tag>
 static_assert(test_std_container<std::vector<bool>, std::random_access_iterator_tag>());
 static_assert(test_std_container<std::wstring, std::contiguous_iterator_tag>());
 
+#if _HAS_CXX23
+static_assert(test_std_container<std::flat_map<int, int>, std::random_access_iterator_tag>());
+static_assert(test_std_container<std::flat_multimap<int, int>, std::random_access_iterator_tag>());
+// Implementation-specific: flat_set uses the underlying container's iterators, so they're contiguous here.
+static_assert(test_std_container<std::flat_set<int>, std::contiguous_iterator_tag>());
+static_assert(test_std_container<std::flat_multiset<int>, std::contiguous_iterator_tag>());
+#endif // _HAS_CXX23
+
 // Validate that "old" fancy pointers that fail to model contiguous_iterator don't break contiguity of containers.
 template <class T>
 struct fancy_pointer {
diff --git a/tests/std/tests/P1206R7_ranges_to_mappish/test.cpp b/tests/std/tests/P1206R7_ranges_to_mappish/test.cpp
index 6ba6e3fa3bb..7c15710ded9 100644
--- a/tests/std/tests/P1206R7_ranges_to_mappish/test.cpp
+++ b/tests/std/tests/P1206R7_ranges_to_mappish/test.cpp
@@ -4,11 +4,15 @@
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
+#include <flat_map>
+#include <functional>
 #include <map>
+#include <memory>
 #include <ranges>
 #include <string_view>
 #include <unordered_map>
 #include <utility>
+#include <vector>
 
 #include <range_algorithm_support.hpp>
 
@@ -71,6 +75,20 @@ struct mappish_instantiator {
         template <class Key, class Val, class... Args>
         using apply = std::unordered_multimap<Key, Val, std::hash<Key>, std::equal_to<Key>, Args...>;
     };
+    template <>
+    struct deduce_container_impl<std::flat_map> {
+        template <class Key, class Val, class... Args>
+        using apply = std::flat_map<Key, Val, std::less<Key>,
+            std::vector<Key, typename std::allocator_traits<Args>::template rebind_alloc<Key>...>,
+            std::vector<Val, typename std::allocator_traits<Args>::template rebind_alloc<Val>...>>;
+    };
+    template <>
+    struct deduce_container_impl<std::flat_multimap> {
+        template <class Key, class Val, class... Args>
+        using apply = std::flat_multimap<Key, Val, std::less<Key>,
+            std::vector<Key, typename std::allocator_traits<Args>::template rebind_alloc<Key>...>,
+            std::vector<Val, typename std::allocator_traits<Args>::template rebind_alloc<Val>...>>;
+    };
 
     template <template <class...> class C, class Key, class Val, class... Args>
     using deduce_container = deduce_container_impl<C>::template apply<Key, Val, Args...>;
@@ -145,26 +163,56 @@ struct mappish_instantiator {
 
         using Alloc = myalloc<std::pair<const int, std::string_view>>;
         using T     = deduce_container<C, int, std::string_view, Alloc>;
+        constexpr bool is_flat =
+            std::_Is_specialization_v<T, std::flat_map> || std::_Is_specialization_v<T, std::flat_multimap>;
 
         {
             std::same_as<T> auto c4 = ranges::to<T>(R{some_pairs}, Alloc{13});
-            assert(c4.get_allocator().state == 13);
             assert(ranges::is_permutation(c4, expected, any_pair_eq));
+
+            if constexpr (is_flat) {
+                const auto containers = std::move(c4).extract();
+                assert(containers.keys.get_allocator().state == 13);
+                assert(containers.values.get_allocator().state == 13);
+            } else {
+                assert(c4.get_allocator().state == 13);
+            }
         }
         {
             std::same_as<T> auto c5 = ranges::to<C>(R{some_pairs}, Alloc{13});
-            assert(c5.get_allocator().state == 13);
             assert(ranges::is_permutation(c5, expected, any_pair_eq));
+
+            if constexpr (is_flat) {
+                const auto containers = std::move(c5).extract();
+                assert(containers.keys.get_allocator().state == 13);
+                assert(containers.values.get_allocator().state == 13);
+            } else {
+                assert(c5.get_allocator().state == 13);
+            }
         }
         {
             std::same_as<T> auto c6 = R{some_pairs} | ranges::to<T>(Alloc{13});
-            assert(c6.get_allocator().state == 13);
             assert(ranges::is_permutation(c6, expected, any_pair_eq));
+
+            if constexpr (is_flat) {
+                const auto containers = std::move(c6).extract();
+                assert(containers.keys.get_allocator().state == 13);
+                assert(containers.values.get_allocator().state == 13);
+            } else {
+                assert(c6.get_allocator().state == 13);
+            }
         }
         {
             std::same_as<T> auto c7 = R{some_pairs} | ranges::to<C>(Alloc{13});
-            assert(c7.get_allocator().state == 13);
             assert(ranges::is_permutation(c7, expected, any_pair_eq));
+
+            if constexpr (is_flat) {
+                const auto containers = std::move(c7).extract();
+                assert(containers.keys.get_allocator().state == 13);
+                assert(containers.values.get_allocator().state == 13);
+            } else {
+                assert(c7.get_allocator().state == 13);
+            }
         }
     }
 
@@ -176,6 +224,8 @@ struct mappish_instantiator {
             test_mappish<R, std::multimap, is_multi::yes>();
             test_mappish<R, std::unordered_map, is_multi::no>();
             test_mappish<R, std::unordered_multimap, is_multi::yes>();
+            test_mappish<R, std::flat_map, is_multi::no>();
+            test_mappish<R, std::flat_multimap, is_multi::yes>();
         }
     }
 };
@@ -186,4 +236,6 @@ int main() {
     mappish_instantiator::test_copy_move<std::multimap>();
     mappish_instantiator::test_copy_move<std::unordered_map>();
     mappish_instantiator::test_copy_move<std::unordered_multimap>();
+    mappish_instantiator::test_copy_move<std::flat_map>();
+    mappish_instantiator::test_copy_move<std::flat_multimap>();
 }
diff --git a/tests/std/tests/P1206R7_ranges_to_settish/test.cpp b/tests/std/tests/P1206R7_ranges_to_settish/test.cpp
index df56e6fccc5..9a0371ceec8 100644
--- a/tests/std/tests/P1206R7_ranges_to_settish/test.cpp
+++ b/tests/std/tests/P1206R7_ranges_to_settish/test.cpp
@@ -4,6 +4,9 @@
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
+#include <flat_set>
+#include <functional>
+#include <memory>
 #include <ranges>
 #include <set>
 #include <unordered_set>
@@ -65,6 +68,18 @@ struct settish_instantiator {
         template <class Key, class... Args>
         using apply = std::unordered_multiset<Key, std::hash<Key>, std::equal_to<Key>, Args...>;
     };
+    template <>
+    struct deduce_container_impl<std::flat_set> {
+        template <class Key, class... Args>
+        using apply = std::flat_set<Key, std::less<Key>,
+            std::vector<Key, typename std::allocator_traits<Args>::template rebind_alloc<Key>...>>;
+    };
+    template <>
+    struct deduce_container_impl<std::flat_multiset> {
+        template <class Key, class... Args>
+        using apply = std::flat_multiset<Key, std::less<Key>,
+            std::vector<Key, typename std::allocator_traits<Args>::template rebind_alloc<Key>...>>;
+    };
 
     template <template <class...> class C, class Key, class... Args>
     using deduce_container = deduce_container_impl<C>::template apply<Key, Args...>;
@@ -139,26 +154,48 @@ struct settish_instantiator {
 
         using Alloc = myalloc<int>;
         using T     = deduce_container<C, int, Alloc>;
+        constexpr bool is_flat =
+            std::_Is_specialization_v<T, std::flat_set> || std::_Is_specialization_v<T, std::flat_multiset>;
 
         {
             std::same_as<T> auto c4 = ranges::to<T>(R{some_ints}, Alloc{13});
-            assert(c4.get_allocator().state == 13);
             assert(ranges::is_permutation(c4, expected));
+
+            if constexpr (is_flat) {
+                assert(std::move(c4).extract().get_allocator().state == 13);
+            } else {
+                assert(c4.get_allocator().state == 13);
+            }
         }
         {
             std::same_as<T> auto c5 = ranges::to<C>(R{some_ints}, Alloc{13});
-            assert(c5.get_allocator().state == 13);
             assert(ranges::is_permutation(c5, expected));
+
+            if constexpr (is_flat) {
+                assert(std::move(c5).extract().get_allocator().state == 13);
+            } else {
+                assert(c5.get_allocator().state == 13);
+            }
         }
         {
             std::same_as<T> auto c6 = R{some_ints} | ranges::to<T>(Alloc{13});
-            assert(c6.get_allocator().state == 13);
             assert(ranges::is_permutation(c6, expected));
+
+            if constexpr (is_flat) {
+                assert(std::move(c6).extract().get_allocator().state == 13);
+            } else {
+                assert(c6.get_allocator().state == 13);
+            }
         }
         {
             std::same_as<T> auto c7 = R{some_ints} | ranges::to<C>(Alloc{13});
-            assert(c7.get_allocator().state == 13);
             assert(ranges::is_permutation(c7, expected));
+
+            if constexpr (is_flat) {
+                assert(std::move(c7).extract().get_allocator().state == 13);
+            } else {
+                assert(c7.get_allocator().state == 13);
+            }
         }
     }
 
@@ -168,6 +205,8 @@ struct settish_instantiator {
         test_settish<R, std::multiset, is_multi::yes>();
         test_settish<R, std::unordered_set, is_multi::no>();
         test_settish<R, std::unordered_multiset, is_multi::yes>();
+        test_settish<R, std::flat_set, is_multi::no>();
+        test_settish<R, std::flat_multiset, is_multi::yes>();
     }
 };
 
@@ -177,4 +216,6 @@ int main() {
     settish_instantiator::test_copy_move<std::multiset>();
     settish_instantiator::test_copy_move<std::unordered_set>();
     settish_instantiator::test_copy_move<std::unordered_multiset>();
+    settish_instantiator::test_copy_move<std::flat_set>();
+    settish_instantiator::test_copy_move<std::flat_multiset>();
 }
diff --git a/tests/std/tests/P2286R8_text_formatting_range_map/test.cpp b/tests/std/tests/P2286R8_text_formatting_range_map/test.cpp
index baa2115b514..216a663cbca 100644
--- a/tests/std/tests/P2286R8_text_formatting_range_map/test.cpp
+++ b/tests/std/tests/P2286R8_text_formatting_range_map/test.cpp
@@ -20,6 +20,7 @@
 #include <concepts>
 #include <cstddef>
 #include <cstring>
+#include <flat_map>
 #include <format>
 #include <iterator>
 #include <map>
@@ -325,7 +326,7 @@ void test_char(TestFunction check, ExceptionTest check_exception) {
 
 template <class TestFunction, class ExceptionTest>
 void test_char_to_wchar(TestFunction check, ExceptionTest check_exception) {
-    map<char, char> input{{'a', 'A'}, {'c', 'C'}, {'b', 'B'}};
+    flat_map<char, char> input{{'a', 'A'}, {'c', 'C'}, {'b', 'B'}};
 
     using CharT = wchar_t;
     check(SV("{'a': 'A', 'b': 'B', 'c': 'C'}"), SV("{}"), input);
@@ -646,24 +647,24 @@ void test_int(TestFunction check, ExceptionTest check_exception) {
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void test_floating_point(TestFunction check, ExceptionTest check_exception) {
-    map<double, double> input{{1.0, -1.0}, {-42, 42}};
+    flat_multimap<double, double> input{{11.0, 42.0}, {11.0, -1.0}};
 
-    check(SV("{-42: 42, 1: -1}"), SV("{}"), input);
-    check(SV("{-42: 42, 1: -1}^42"), SV("{}^42"), input);
-    check(SV("{-42: 42, 1: -1}^42"), SV("{:}^42"), input);
+    check(SV("{11: 42, 11: -1}"), SV("{}"), input);
+    check(SV("{11: 42, 11: -1}^42"), SV("{}^42"), input);
+    check(SV("{11: 42, 11: -1}^42"), SV("{:}^42"), input);
 
     // ***** underlying has no format-spec
 
     // *** align-fill & width ***
-    check(SV("{-42: 42, 1: -1}     "), SV("{:21}"), input);
-    check(SV("{-42: 42, 1: -1}*****"), SV("{:*<21}"), input);
-    check(SV("__{-42: 42, 1: -1}___"), SV("{:_^21}"), input);
-    check(SV("#####{-42: 42, 1: -1}"), SV("{:#>21}"), input);
+    check(SV("{11: 42, 11: -1}     "), SV("{:21}"), input);
+    check(SV("{11: 42, 11: -1}*****"), SV("{:*<21}"), input);
+    check(SV("__{11: 42, 11: -1}___"), SV("{:_^21}"), input);
+    check(SV("#####{11: 42, 11: -1}"), SV("{:#>21}"), input);
 
-    check(SV("{-42: 42, 1: -1}     "), SV("{:{}}"), input, 21);
-    check(SV("{-42: 42, 1: -1}*****"), SV("{:*<{}}"), input, 21);
-    check(SV("__{-42: 42, 1: -1}___"), SV("{:_^{}}"), input, 21);
-    check(SV("#####{-42: 42, 1: -1}"), SV("{:#>{}}"), input, 21);
+    check(SV("{11: 42, 11: -1}     "), SV("{:{}}"), input, 21);
+    check(SV("{11: 42, 11: -1}*****"), SV("{:*<{}}"), input, 21);
+    check(SV("__{11: 42, 11: -1}___"), SV("{:_^{}}"), input, 21);
+    check(SV("#####{11: 42, 11: -1}"), SV("{:#>{}}"), input, 21);
 
     check_exception("The format string contains an invalid escape sequence", SV("{:}<}"), input);
     check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
@@ -686,10 +687,10 @@ void test_floating_point(TestFunction check, ExceptionTest check_exception) {
     check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 
     // *** n
-    check(SV("__-42: 42, 1: -1___"), SV("{:_^19n}"), input);
+    check(SV("__11: 42, 11: -1___"), SV("{:_^19n}"), input);
 
     // *** type ***
-    check(SV("__{-42: 42, 1: -1}___"), SV("{:_^21m}"), input); // the m type does the same as the default.
+    check(SV("__{11: 42, 11: -1}___"), SV("{:_^21m}"), input); // the m type does the same as the default.
     check_exception("Type s requires character type as formatting argument", SV("{:s}"), input);
     check_exception("Type ?s requires character type as formatting argument", SV("{:?s}"), input);
 
@@ -698,15 +699,15 @@ void test_floating_point(TestFunction check, ExceptionTest check_exception) {
     }
 
     // ***** Only underlying has a format-spec
-    check(SV("{-42: 42   , 1: -1     }"), SV("{::10}"), input);
-    check(SV("{-42: 42***, 1: -1*****}"), SV("{::*<10}"), input);
-    check(SV("{_-42: 42__, __1: -1___}"), SV("{::_^10}"), input);
-    check(SV("{###-42: 42, #####1: -1}"), SV("{::#>10}"), input);
+    check(SV("{11: 42    , 11: -1    }"), SV("{::10}"), input);
+    check(SV("{11: 42****, 11: -1****}"), SV("{::*<10}"), input);
+    check(SV("{__11: 42__, __11: -1__}"), SV("{::_^10}"), input);
+    check(SV("{####11: 42, ####11: -1}"), SV("{::#>10}"), input);
 
-    check(SV("{-42: 42   , 1: -1     }"), SV("{::{}}"), input, 10);
-    check(SV("{-42: 42***, 1: -1*****}"), SV("{::*<{}}"), input, 10);
-    check(SV("{_-42: 42__, __1: -1___}"), SV("{::_^{}}"), input, 10);
-    check(SV("{###-42: 42, #####1: -1}"), SV("{::#>{}}"), input, 10);
+    check(SV("{11: 42    , 11: -1    }"), SV("{::{}}"), input, 10);
+    check(SV("{11: 42****, 11: -1****}"), SV("{::*<{}}"), input, 10);
+    check(SV("{__11: 42__, __11: -1__}"), SV("{::_^{}}"), input, 10);
+    check(SV("{####11: 42, ####11: -1}"), SV("{::#>{}}"), input, 10);
 
     check_exception("The format string contains an invalid escape sequence", SV("{::}<}"), input);
     check_exception("The fill option contains an invalid value", SV("{::{<}"), input);
@@ -734,9 +735,9 @@ void test_floating_point(TestFunction check, ExceptionTest check_exception) {
     }
 
     // ***** Both have a format-spec
-    check(SV("^^{###-42: 42, #####1: -1}^^^"), SV("{:^^29:#>10}"), input);
-    check(SV("^^{###-42: 42, #####1: -1}^^^"), SV("{:^^{}:#>10}"), input, 29);
-    check(SV("^^{###-42: 42, #####1: -1}^^^"), SV("{:^^{}:#>{}}"), input, 29, 10);
+    check(SV("^^{####11: 42, ####11: -1}^^^"), SV("{:^^29:#>10}"), input);
+    check(SV("^^{####11: 42, ####11: -1}^^^"), SV("{:^^{}:#>10}"), input, 29);
+    check(SV("^^{####11: 42, ####11: -1}^^^"), SV("{:^^{}:#>{}}"), input, 29, 10);
 
     check_exception(
         "The argument index value is too large for the number of arguments supplied", SV("{:^^{}:#>10}"), input);
diff --git a/tests/std/tests/P2286R8_text_formatting_range_set/test.cpp b/tests/std/tests/P2286R8_text_formatting_range_set/test.cpp
index 98c7e9b8ea0..07d57e1b359 100644
--- a/tests/std/tests/P2286R8_text_formatting_range_set/test.cpp
+++ b/tests/std/tests/P2286R8_text_formatting_range_set/test.cpp
@@ -20,6 +20,7 @@
 #include <concepts>
 #include <cstddef>
 #include <cstring>
+#include <flat_set>
 #include <format>
 #include <iterator>
 #include <ranges>
@@ -329,7 +330,7 @@ void test_char_default(TestFunction check, ExceptionTest check_exception) {
 // This does not seem very useful, but it is allowed.
 template <class CharT, class TestFunction, class ExceptionTest>
 void test_char_string(TestFunction check, [[maybe_unused]] ExceptionTest check_exception) {
-    set input{CharT('a'), CharT('c'), CharT('b')}; // input not sorted.
+    flat_set input{CharT('a'), CharT('c'), CharT('b')}; // input not sorted.
 
     check(SV("abc"), SV("{:s}"), input);
 
@@ -454,7 +455,7 @@ void test_char(TestFunction check, ExceptionTest check_exception) {
 
 template <class TestFunction, class ExceptionTest>
 void test_char_to_wchar(TestFunction check, ExceptionTest check_exception) {
-    set input{'a', 'c', 'b'}; // input not sorted.
+    flat_set input{'a', 'c', 'b'}; // input not sorted.
 
     using CharT = wchar_t;
 
@@ -901,6 +902,8 @@ template <class CharT, class TestFunction, class ExceptionTest>
 void test_int(TestFunction check, ExceptionTest check_exception) {
     test_int<CharT>(check, check_exception, set{1, 42, 2, -42}); // unsorted
     test_int<CharT>(check, check_exception, multiset{1, 42, 2, -42}); // unsorted
+    test_int<CharT>(check, check_exception, flat_set{1, 42, 2, -42}); // unsorted
+    test_int<CharT>(check, check_exception, flat_multiset{1, 42, 2, -42}); // unsorted
 }
 
 //
@@ -1025,6 +1028,9 @@ void test_floating_point(TestFunction check, ExceptionTest check_exception) {
     test_floating_point<CharT>(check, check_exception, set{-42.5f, 0.0f, 1.25f, 42.5f});
     test_floating_point<CharT>(check, check_exception, multiset{-42.5, 0.0, 1.25, 42.5});
     test_floating_point<CharT>(check, check_exception, set{-42.5l, 0.0l, 1.25l, 42.5l});
+    test_floating_point<CharT>(check, check_exception, flat_set{-42.5f, 0.0f, 1.25f, 42.5f});
+    test_floating_point<CharT>(check, check_exception, flat_multiset{-42.5, 0.0, 1.25, 42.5});
+    test_floating_point<CharT>(check, check_exception, flat_set{-42.5l, 0.0l, 1.25l, 42.5l});
 }
 
 //
@@ -1248,6 +1254,8 @@ template <class CharT, class TestFunction, class ExceptionTest>
 void test_string(TestFunction check, ExceptionTest check_exception) {
     test_string<CharT>(check, check_exception, set{STR("Hello"), STR("world")});
     test_string<CharT>(check, check_exception, set{SV("Hello"), SV("world")});
+    test_string<CharT>(check, check_exception, flat_set{STR("Hello"), STR("world")});
+    test_string<CharT>(check, check_exception, flat_set{SV("Hello"), SV("world")});
 }
 
 //
@@ -1440,6 +1448,8 @@ template <class CharT, class TestFunction, class ExceptionTest>
 void test_pair_tuple(TestFunction check, ExceptionTest check_exception) {
     test_pair_tuple<CharT>(check, check_exception, set{make_pair(1, CharT('a')), make_pair(42, CharT('*'))});
     test_pair_tuple<CharT>(check, check_exception, set{make_tuple(1, CharT('a')), make_tuple(42, CharT('*'))});
+    test_pair_tuple<CharT>(check, check_exception, flat_set{make_pair(1, CharT('a')), make_pair(42, CharT('*'))});
+    test_pair_tuple<CharT>(check, check_exception, flat_set{make_tuple(1, CharT('a')), make_tuple(42, CharT('*'))});
 }
 
 //
@@ -1558,7 +1568,7 @@ void test_tuple_int(TestFunction check, ExceptionTest check_exception) {
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void test_tuple_int_int_int(TestFunction check, ExceptionTest check_exception) {
-    set input{make_tuple(42, 99, 0), make_tuple(1, 10, 100)}; // unordered
+    flat_set input{make_tuple(42, 99, 0), make_tuple(1, 10, 100)}; // unsorted
 
     check(SV("{(1, 10, 100), (42, 99, 0)}"), SV("{}"), input);
     check(SV("{(1, 10, 100), (42, 99, 0)}^42"), SV("{}^42"), input);
diff --git a/tests/std/tests/VSO_0429900_fast_debug_range_based_for/test.cpp b/tests/std/tests/VSO_0429900_fast_debug_range_based_for/test.cpp
index 644b6b2066b..9197cd235c5 100644
--- a/tests/std/tests/VSO_0429900_fast_debug_range_based_for/test.cpp
+++ b/tests/std/tests/VSO_0429900_fast_debug_range_based_for/test.cpp
@@ -11,11 +11,19 @@
 #include <regex>
 #include <set>
 #include <string>
-#include <string_view>
 #include <unordered_map>
 #include <unordered_set>
 #include <vector>
 
+#if _HAS_CXX17
+#include <string_view>
+#endif // _HAS_CXX17
+
+#if _HAS_CXX23
+#include <flat_map>
+#include <flat_set>
+#endif // _HAS_CXX23
+
 using namespace std;
 
 #define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
@@ -31,10 +39,20 @@ void assert_range_for_impl(Range& c) {
     for (auto&& val : c) {
         STATIC_ASSERT(is_same_v<remove_reference_t<decltype(val)>, remove_reference_t<decltype(*b)>>);
         assert(b != c.end());
-        if (is_same_v<remove_const_t<Range>, vector<bool>>) {
-            assert(*b == val);
-        } else {
-            assert_same_address(*b, val);
+
+        using RC = remove_const_t<Range>;
+#if _HAS_CXX23
+        if constexpr (_Is_specialization_v<RC, flat_map> || _Is_specialization_v<RC, flat_multimap>) {
+            assert_same_address(b->first, val.first);
+            assert_same_address(b->second, val.second);
+        } else
+#endif // _HAS_CXX23
+        {
+            if (is_same_v<RC, vector<bool>>) {
+                assert(*b == val);
+            } else {
+                assert_same_address(*b, val);
+            }
         }
 
         ++b;
@@ -152,11 +170,19 @@ int main() {
     test_case_set_container<set>();
     test_case_set_container<unordered_multiset>();
     test_case_set_container<unordered_set>();
+#if _HAS_CXX23
+    test_case_set_container<flat_set>();
+    test_case_set_container<flat_multiset>();
+#endif // _HAS_CXX23
 
     test_case_map_container<map>();
     test_case_map_container<multimap>();
     test_case_map_container<unordered_map>();
     test_case_map_container<unordered_multimap>();
+#if _HAS_CXX23
+    test_case_map_container<flat_map>();
+    test_case_map_container<flat_multimap>();
+#endif // _HAS_CXX23
 
     cmatch matchResults;
     assert_range_for(matchResults);

From 64904f83fb4a86935bee3826517e3f3762b2435c Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Thu, 29 Jan 2026 09:08:02 -0800
Subject: [PATCH 122/134] `<flat_meow>`: Audit the implementation (#6057)

---
 stl/inc/flat_map                          | 525 +++++++++++-----------
 stl/inc/flat_set                          | 323 +++++++------
 tests/libcxx/expected_results.txt         |   4 +
 tests/std/tests/P1222R4_flat_set/test.cpp |  46 +-
 4 files changed, 476 insertions(+), 422 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index 9f9c0fd3640..b1f4b2f477e 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -33,8 +33,6 @@ _STL_DISABLE_CLANG_WARNINGS
 #undef msvc
 
 _STD_BEGIN
-// Implementation
-
 template <bool _IsUnique, class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer>
 class _Flat_map_base;
 
@@ -275,21 +273,6 @@ struct _NODISCARD _Flat_map_swap_clear_guard<true, _Containers> {
     void _Dismiss() noexcept {}
 };
 
-template <class _Compare, class _Key, class _Mapped>
-struct _Value_compare_to_pass_in_flat_map {
-    using _Key_compare =
-        conditional_t<conjunction_v<bool_constant<sizeof(_Compare) <= sizeof(void*)>,
-                          is_trivially_copy_constructible<_Compare>, is_trivially_destructible<_Compare>>,
-            _Compare, const _Compare&>;
-    using _Const_reference = pair<const _Key&, const _Mapped&>;
-
-    _Key_compare _Key_comparator;
-
-    _NODISCARD bool operator()(_Const_reference _Left, _Const_reference _Right) const {
-        return _Key_comparator(_Left.first, _Right.first);
-    }
-};
-
 _EXPORT_STD template <class _Key, class _Mapped, class _Compare = less<_Key>, class _KeyContainer = vector<_Key>,
     class _MappedContainer = vector<_Mapped>>
 class flat_map;
@@ -308,6 +291,7 @@ private:
     static constexpr const char* _Msg_not_sorted = _IsUnique ? "Keys were not sorted-unique!" : "Keys were not sorted!";
 
 public:
+    // [flat.map.defn] Types
     using key_type              = _Key;
     using mapped_type           = _Mapped;
     using value_type            = pair<key_type, mapped_type>;
@@ -367,17 +351,18 @@ public:
     };
 
     // [flat.map.cons] Constructors
-    explicit _Flat_map_base(const key_compare& _Comp) : _Data(), _Key_compare(_Comp) {}
-    _Flat_map_base() : _Flat_map_base(key_compare()) {}
+    _Flat_map_base() : _Data(), _Key_compare() {}
 
-    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
-    explicit _Flat_map_base(const _Allocator& _Alloc) : _Flat_map_base(key_compare(), _Alloc) {}
+    _Flat_map_base(const _Flat_map_base&) = default;
 
-    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
-    _Flat_map_base(const key_compare& _Comp, const _Allocator& _Alloc)
-        : _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Alloc),
-              .values = _STD make_obj_using_allocator<mapped_container_type>(_Alloc)},
-          _Key_compare(_Comp) {}
+    _Flat_map_base(_Flat_map_base&& _Other)
+        noexcept(is_nothrow_copy_constructible_v<key_compare> && is_nothrow_move_constructible_v<key_container_type>
+                 && is_nothrow_move_constructible_v<mapped_container_type>) // strengthened
+        : _Data(_STD move(_Other).extract()),
+          _Key_compare(_Other._Key_compare) // intentionally copy comparator, see LWG-2227
+    {}
+
+    explicit _Flat_map_base(const key_compare& _Comp) : _Data(), _Key_compare(_Comp) {}
 
     _Flat_map_base(
         key_container_type _Key_cont, mapped_container_type _Mapped_cont, const key_compare& _Comp = key_compare())
@@ -386,6 +371,59 @@ public:
         _Make_invariants_fulfilled();
     }
 
+    _Flat_map_base(_Sorted_t, key_container_type _Key_cont, mapped_container_type _Mapped_cont,
+        const key_compare& _Comp = key_compare())
+        : _Data{.keys = _STD move(_Key_cont), .values = _STD move(_Mapped_cont)}, _Key_compare(_Comp) {
+        _STL_ASSERT(_Data.keys.size() == _Data.values.size(), "key_cont.size() != mapped_cont.size()");
+        _STL_ASSERT(_Is_sorted_and_unique(), _Msg_not_sorted);
+    }
+
+    template <_Iterator_for_container _InputIterator>
+    _Flat_map_base(const _InputIterator _First, const _InputIterator _Last, const key_compare& _Comp = key_compare())
+        : _Data(), _Key_compare(_Comp) {
+        insert(_First, _Last);
+    }
+
+    template <_Iterator_for_container _InputIterator>
+    _Flat_map_base(_Sorted_t _Tag, const _InputIterator _First, const _InputIterator _Last,
+        const key_compare& _Comp = key_compare())
+        : _Data(), _Key_compare(_Comp) {
+        insert(_Tag, _First, _Last);
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    _Flat_map_base(from_range_t, _Rng&& _Range) : _Data(), _Key_compare() {
+        insert_range(_STD forward<_Rng>(_Range));
+    }
+
+    template <_Container_compatible_range<value_type> _Rng>
+    _Flat_map_base(from_range_t, _Rng&& _Range, const key_compare& _Comp) : _Data(), _Key_compare(_Comp) {
+        insert_range(_STD forward<_Rng>(_Range));
+    }
+
+    _Flat_map_base(const initializer_list<value_type> _Ilist, const key_compare& _Comp = key_compare())
+        : _Data(), _Key_compare(_Comp) {
+        insert(_Ilist);
+    }
+
+    _Flat_map_base(_Sorted_t _Tag, const initializer_list<value_type> _Ilist, const key_compare& _Comp = key_compare())
+        : _Data(), _Key_compare(_Comp) {
+        insert(_Tag, _Ilist);
+    }
+
+    // [flat.map.cons.alloc] Constructors with allocators
+    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
+    explicit _Flat_map_base(const _Allocator& _Alloc)
+        : _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Alloc),
+              .values = _STD make_obj_using_allocator<mapped_container_type>(_Alloc)},
+          _Key_compare() {}
+
+    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
+    _Flat_map_base(const key_compare& _Comp, const _Allocator& _Alloc)
+        : _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Alloc),
+              .values = _STD make_obj_using_allocator<mapped_container_type>(_Alloc)},
+          _Key_compare(_Comp) {}
+
     template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
     _Flat_map_base(
         const key_container_type& _Key_cont, const mapped_container_type& _Mapped_cont, const _Allocator& _Alloc)
@@ -401,13 +439,6 @@ public:
         _Make_invariants_fulfilled();
     }
 
-    _Flat_map_base(_Sorted_t, key_container_type _Key_cont, mapped_container_type _Mapped_cont,
-        const key_compare& _Comp = key_compare())
-        : _Data{.keys = _STD move(_Key_cont), .values = _STD move(_Mapped_cont)}, _Key_compare(_Comp) {
-        _STL_ASSERT(_Data.keys.size() == _Data.values.size(), "key_cont.size() != mapped_cont.size()");
-        _STL_ASSERT(_Is_sorted_and_unique(), _Msg_not_sorted);
-    }
-
     template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
     _Flat_map_base(_Sorted_t _Tag, const key_container_type& _Key_cont, const mapped_container_type& _Mapped_cont,
         const _Allocator& _Alloc)
@@ -423,12 +454,27 @@ public:
         _STL_ASSERT(_Is_sorted_and_unique(), _Msg_not_sorted);
     }
 
-    template <_Iterator_for_container _InputIterator>
-    _Flat_map_base(const _InputIterator _First, const _InputIterator _Last, const key_compare& _Comp = key_compare())
-        : _Flat_map_base(_Comp) {
-        insert(_First, _Last);
+    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
+    _Flat_map_base(const _Flat_map_base& _Other, const _Allocator& _Alloc)
+        : _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Alloc, _Other._Data.keys),
+              .values = _STD make_obj_using_allocator<mapped_container_type>(_Alloc, _Other._Data.values)},
+          _Key_compare(_Other._Key_compare) {}
+
+private:
+    template <class _Allocator>
+    _NODISCARD containers _Extract_using_allocator(const _Allocator& _Alloc) && {
+        _Clear_guard _Always_clear{this};
+        return containers{.keys = _STD make_obj_using_allocator<key_container_type>(_Alloc, _STD move(_Data.keys)),
+            .values = _STD make_obj_using_allocator<mapped_container_type>(_Alloc, _STD move(_Data.values))};
     }
 
+public:
+    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
+    _Flat_map_base(_Flat_map_base&& _Other, const _Allocator& _Alloc)
+        : _Data{_STD move(_Other)._Extract_using_allocator(_Alloc)},
+          _Key_compare(_Other._Key_compare) // intentionally copy comparator, see LWG-2227
+    {}
+
     template <_Iterator_for_container _InputIterator,
         _Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
     _Flat_map_base(const _InputIterator _First, const _InputIterator _Last, const _Allocator& _Alloc)
@@ -444,17 +490,24 @@ public:
         insert(_First, _Last);
     }
 
-    template <_Container_compatible_range<value_type> _Rng>
-    _Flat_map_base(from_range_t _From_range, _Rng&& _Range)
-        : _Flat_map_base(_From_range, _STD forward<_Rng>(_Range), key_compare()) {}
+    template <_Iterator_for_container _InputIterator,
+        _Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
+    _Flat_map_base(_Sorted_t _Tag, const _InputIterator _First, const _InputIterator _Last, const _Allocator& _Alloc)
+        : _Flat_map_base(_Alloc) {
+        insert(_Tag, _First, _Last);
+    }
 
-    template <_Container_compatible_range<value_type> _Rng,
+    template <_Iterator_for_container _InputIterator,
         _Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
-    _Flat_map_base(from_range_t _From_range, _Rng&& _Range, const _Allocator& _Alloc)
-        : _Flat_map_base(_From_range, _STD forward<_Rng>(_Range), key_compare(), _Alloc) {}
+    _Flat_map_base(_Sorted_t _Tag, const _InputIterator _First, const _InputIterator _Last, const key_compare& _Comp,
+        const _Allocator& _Alloc)
+        : _Flat_map_base(_Comp, _Alloc) {
+        insert(_Tag, _First, _Last);
+    }
 
-    template <_Container_compatible_range<value_type> _Rng>
-    _Flat_map_base(from_range_t, _Rng&& _Range, const key_compare& _Comp) : _Flat_map_base(_Comp) {
+    template <_Container_compatible_range<value_type> _Rng,
+        _Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
+    _Flat_map_base(from_range_t, _Rng&& _Range, const _Allocator& _Alloc) : _Flat_map_base(_Alloc) {
         insert_range(_STD forward<_Rng>(_Range));
     }
 
@@ -465,73 +518,31 @@ public:
         insert_range(_STD forward<_Rng>(_Range));
     }
 
-    template <_Iterator_for_container _InputIterator>
-    _Flat_map_base(
-        _Sorted_t, const _InputIterator _First, const _InputIterator _Last, const key_compare& _Comp = key_compare())
-        : _Flat_map_base(_Comp) {
-        _Insert_range<false>(_First, _Last);
-    }
-
-    template <_Iterator_for_container _InputIterator,
-        _Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
-    _Flat_map_base(_Sorted_t, const _InputIterator _First, const _InputIterator _Last, const key_compare& _Comp,
-        const _Allocator& _Alloc)
-        : _Flat_map_base(_Comp, _Alloc) {
-        _Insert_range<false>(_First, _Last);
+    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
+    _Flat_map_base(const initializer_list<value_type> _Ilist, const _Allocator& _Alloc) : _Flat_map_base(_Alloc) {
+        insert(_Ilist);
     }
 
-    template <_Iterator_for_container _InputIterator,
-        _Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
-    _Flat_map_base(_Sorted_t _Tag, const _InputIterator _First, const _InputIterator _Last, const _Allocator& _Alloc)
-        : _Flat_map_base(_Tag, _First, _Last, key_compare(), _Alloc) {}
-
-    _Flat_map_base(const initializer_list<value_type> _Ilist, const key_compare& _Comp = key_compare())
-        : _Flat_map_base(_Ilist.begin(), _Ilist.end(), _Comp) {}
-
     template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
     _Flat_map_base(const initializer_list<value_type> _Ilist, const key_compare& _Comp, const _Allocator& _Alloc)
-        : _Flat_map_base(_Ilist.begin(), _Ilist.end(), _Comp, _Alloc) {}
+        : _Flat_map_base(_Comp, _Alloc) {
+        insert(_Ilist);
+    }
 
     template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
-    _Flat_map_base(const initializer_list<value_type> _Ilist, const _Allocator& _Alloc)
-        : _Flat_map_base(_Ilist, key_compare(), _Alloc) {}
-
-    _Flat_map_base(_Sorted_t _Tag, const initializer_list<value_type> _Ilist, const key_compare& _Comp = key_compare())
-        : _Flat_map_base(_Tag, _Ilist.begin(), _Ilist.end(), _Comp) {}
+    _Flat_map_base(_Sorted_t _Tag, const initializer_list<value_type> _Ilist, const _Allocator& _Alloc)
+        : _Flat_map_base(_Alloc) {
+        insert(_Tag, _Ilist);
+    }
 
     template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
     _Flat_map_base(
         _Sorted_t _Tag, const initializer_list<value_type> _Ilist, const key_compare& _Comp, const _Allocator& _Alloc)
-        : _Flat_map_base(_Tag, _Ilist.begin(), _Ilist.end(), _Comp, _Alloc) {}
-
-    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
-    _Flat_map_base(_Sorted_t _Tag, const initializer_list<value_type> _Ilist, const _Allocator& _Alloc)
-        : _Flat_map_base(_Tag, _Ilist, key_compare(), _Alloc) {}
-
-    // Copy constructors
-    _Flat_map_base(const _Flat_map_base& _Other) : _Data(_Other._Data), _Key_compare(_Other._Key_compare) {}
-
-    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
-    _Flat_map_base(const _Flat_map_base& _Other, const _Allocator& _Alloc)
-        : _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Alloc, _Other._Data.keys),
-              .values = _STD make_obj_using_allocator<mapped_container_type>(_Alloc, _Other._Data.values)},
-          _Key_compare(_Other._Key_compare) {}
-
-    // Move constructors
-    _Flat_map_base(_Flat_map_base&& _Other)
-        noexcept(is_nothrow_copy_constructible_v<key_compare> && is_nothrow_move_constructible_v<key_container_type>
-                 && is_nothrow_move_constructible_v<mapped_container_type>)
-        : _Data(_STD move(_Other).extract()),
-          _Key_compare(_Other._Key_compare) // intentionally copy comparator, see LWG-2227
-    {}
-
-    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
-    _Flat_map_base(_Flat_map_base&& _Other, const _Allocator& _Alloc)
-        : _Data{_STD move(_Other)._Extract_using_allocator(_Alloc)},
-          _Key_compare(_Other._Key_compare) // intentionally copy comparator, see LWG-2227
-    {}
+        : _Flat_map_base(_Comp, _Alloc) {
+        insert(_Tag, _Ilist);
+    }
 
-    // Assignment
+    // Assignment operators
     _Flat_map_base& operator=(const _Flat_map_base& _Other) {
         _Clear_guard _Guard{this};
         _Data          = _Other._Data;
@@ -542,8 +553,7 @@ public:
 
     _Flat_map_base& operator=(_Flat_map_base&& _Other)
         noexcept(is_nothrow_copy_assignable_v<key_compare> && is_nothrow_move_assignable_v<key_container_type>
-                 && is_nothrow_move_assignable_v<mapped_container_type>) {
-
+                 && is_nothrow_move_assignable_v<mapped_container_type>) /* strengthened */ {
         if (this != _STD addressof(_Other)) {
             _Clear_guard _Guard{this};
             _Clear_guard _Always_clear{_STD addressof(_Other)};
@@ -554,76 +564,48 @@ public:
         return *this;
     }
 
-    // [container.reqmts] iterators
+    // Iterators
     _NODISCARD iterator begin() noexcept {
         _STL_INTERNAL_STATIC_ASSERT(random_access_iterator<iterator>);
         return iterator{_Data.keys.cbegin(), _Data.values.begin()};
     }
-
     _NODISCARD const_iterator begin() const noexcept {
         _STL_INTERNAL_STATIC_ASSERT(random_access_iterator<const_iterator>);
         _STL_INTERNAL_STATIC_ASSERT(convertible_to<iterator, const_iterator>);
         return const_iterator{_Data.keys.cbegin(), _Data.values.begin()};
     }
-
     _NODISCARD iterator end() noexcept {
         return iterator{_Data.keys.cend(), _Data.values.end()};
     }
-
     _NODISCARD const_iterator end() const noexcept {
         return const_iterator{_Data.keys.cend(), _Data.values.end()};
     }
 
     _NODISCARD reverse_iterator rbegin() noexcept {
-        return _STD make_reverse_iterator(end());
+        return reverse_iterator{end()};
     }
-
     _NODISCARD const_reverse_iterator rbegin() const noexcept {
-        return _STD make_reverse_iterator(end());
+        return const_reverse_iterator{end()};
     }
-
     _NODISCARD reverse_iterator rend() noexcept {
-        return _STD make_reverse_iterator(begin());
+        return reverse_iterator{begin()};
     }
-
     _NODISCARD const_reverse_iterator rend() const noexcept {
-        return _STD make_reverse_iterator(begin());
+        return const_reverse_iterator{begin()};
     }
 
     _NODISCARD const_iterator cbegin() const noexcept {
         return const_iterator{_Data.keys.cbegin(), _Data.values.cbegin()};
     }
-
     _NODISCARD const_iterator cend() const noexcept {
         return const_iterator{_Data.keys.cend(), _Data.values.cend()};
     }
 
     _NODISCARD const_reverse_iterator crbegin() const noexcept {
-        return _STD make_reverse_iterator(cend());
+        return const_reverse_iterator{cend()};
     }
-
     _NODISCARD const_reverse_iterator crend() const noexcept {
-        return _STD make_reverse_iterator(cbegin());
-    }
-
-    void swap(_Derived& _Other)
-        noexcept(is_nothrow_swappable_v<_KeyContainer> && is_nothrow_swappable_v<_MappedContainer>
-                 && is_nothrow_swappable_v<key_compare>) {
-        constexpr bool _Is_noexcept = is_nothrow_swappable_v<_KeyContainer> && is_nothrow_swappable_v<_MappedContainer>
-                                   && is_nothrow_swappable_v<key_compare>;
-        auto& _Other_base = static_cast<_Flat_map_base&>(_Other);
-        _Flat_map_swap_clear_guard<_Is_noexcept, containers> _Guard{
-            _STD addressof(_Data), _STD addressof(_Other_base._Data)};
-        _RANGES swap(_Data.keys, _Other_base._Data.keys);
-        _RANGES swap(_Data.values, _Other_base._Data.values);
-        _RANGES swap(_Key_compare, _Other_base._Key_compare);
-        _Guard._Dismiss();
-    }
-
-    // [container.reqmts] clear
-    void clear() noexcept {
-        _Data.keys.clear();
-        _Data.values.clear();
+        return const_reverse_iterator{cbegin()};
     }
 
     // [flat.map.capacity] Capacity
@@ -636,7 +618,7 @@ public:
     }
 
     _NODISCARD size_type max_size() const noexcept {
-        return _STD min(_Data.keys.max_size(), _Data.values.max_size());
+        return (_STD min) (_Data.keys.max_size(), _Data.values.max_size());
     }
 
     // [flat.map.modifiers] Modifiers
@@ -648,21 +630,6 @@ public:
         return _Try_emplace(_STD move(_Val.first), _STD move(_Val.second));
     }
 
-    auto insert(const value_type& _Pair_val) {
-        return _Try_emplace(_Pair_val.first, _Pair_val.second);
-    }
-
-    auto insert(value_type&& _Pair_val) {
-        return _Try_emplace(_STD move(_Pair_val.first), _STD move(_Pair_val.second));
-    }
-
-    template <class _PairValTy>
-    auto insert(_PairValTy&& _Pair_val)
-        requires is_constructible_v<value_type, _PairValTy>
-    {
-        return emplace(_STD forward<_PairValTy>(_Pair_val));
-    }
-
     template <class... _ArgTypes>
     iterator emplace_hint(const const_iterator _Position, _ArgTypes&&... _Args)
         requires is_constructible_v<value_type, _ArgTypes...>
@@ -671,14 +638,27 @@ public:
         return _Emplace_hint<false>(_Position, _STD move(_Val.first), _STD move(_Val.second));
     }
 
+    auto insert(const value_type& _Pair_val) {
+        return _Try_emplace(_Pair_val.first, _Pair_val.second);
+    }
+    auto insert(value_type&& _Pair_val) {
+        return _Try_emplace(_STD move(_Pair_val.first), _STD move(_Pair_val.second));
+    }
+
     iterator insert(const const_iterator _Position, const value_type& _Pair_val) {
         return emplace_hint(_Position, _Pair_val);
     }
-
     iterator insert(const const_iterator _Position, value_type&& _Pair_val) {
         return emplace_hint(_Position, _STD move(_Pair_val));
     }
 
+    template <class _PairValTy>
+    auto insert(_PairValTy&& _Pair_val)
+        requires is_constructible_v<value_type, _PairValTy>
+    {
+        return emplace(_STD forward<_PairValTy>(_Pair_val));
+    }
+
     template <class _PairValTy>
     iterator insert(const const_iterator _Position, _PairValTy&& _Pair_val)
         requires is_constructible_v<value_type, _PairValTy>
@@ -690,7 +670,6 @@ public:
     void insert(const _InputIterator _First, const _InputIterator _Last) {
         _Insert_range<true>(_First, _Last);
     }
-
     template <_Iterator_for_container _InputIterator>
     void insert(_Sorted_t, const _InputIterator _First, const _InputIterator _Last) {
         _Insert_range<false>(_First, _Last);
@@ -700,7 +679,6 @@ public:
     void insert_range(_Rng&& _Range) {
         _Insert_range<true>(_RANGES begin(_Range), _RANGES end(_Range));
     }
-
     template <_Container_compatible_range<value_type> _Rng>
     void insert_range(_Sorted_t, _Rng&& _Range) {
         _Insert_range<false>(_RANGES begin(_Range), _RANGES end(_Range));
@@ -709,11 +687,27 @@ public:
     void insert(const initializer_list<value_type> _Ilist) {
         _Insert_range<true>(_Ilist.begin(), _Ilist.end());
     }
-
     void insert(_Sorted_t, const initializer_list<value_type> _Ilist) {
         _Insert_range<false>(_Ilist.begin(), _Ilist.end());
     }
 
+    _NODISCARD containers extract() && noexcept(
+        is_nothrow_move_constructible_v<key_container_type>
+        && is_nothrow_move_constructible_v<mapped_container_type>) /* strengthened */ {
+        // always clears the container (N5032 [flat.map.modifiers]/35 and [flat.multimap.overview]/4)
+        _Clear_guard _Always_clear{this};
+        return _STD move(_Data);
+    }
+
+    void replace(key_container_type&& _Key_cont, mapped_container_type&& _Mapped_cont) {
+        _STL_ASSERT(_Key_cont.size() == _Mapped_cont.size(), "key_cont.size() != mapped_cont.size()");
+        _STL_ASSERT(_Is_sorted_and_unique(_Key_cont.begin(), _Key_cont.end()), _Msg_not_sorted);
+        _Clear_guard _Guard{this};
+        _Data.keys     = _STD move(_Key_cont);
+        _Data.values   = _STD move(_Mapped_cont);
+        _Guard._Target = nullptr;
+    }
+
     iterator erase(const iterator _Position) {
         return erase(static_cast<const_iterator>(_Position));
     }
@@ -726,14 +720,6 @@ public:
         return iterator{_STD move(_Key_it), _STD move(_Val_it)};
     }
 
-    iterator erase(const const_iterator _First, const const_iterator _Last) {
-        _Clear_guard _Guard{this};
-        auto _Key_it   = _Data.keys.erase(_First._Key_it, _Last._Key_it);
-        auto _Val_it   = _Data.values.erase(_First._Mapped_it, _Last._Mapped_it);
-        _Guard._Target = nullptr;
-        return iterator{_STD move(_Key_it), _STD move(_Val_it)};
-    }
-
     size_type erase(const key_type& _Key_val) {
         return _Erase_key(_Key_val);
     }
@@ -745,31 +731,35 @@ public:
         return _Erase_key(_STD forward<_OtherKey>(_Key_val));
     }
 
-    _NODISCARD containers extract() && noexcept(
-        is_nothrow_move_constructible_v<key_container_type>
-        && is_nothrow_move_constructible_v<mapped_container_type>) /* strengthened */ {
-        // always clears the container (N5032 [flat.map.modifiers]/35 and [flat.multimap.overview]/4)
-        _Clear_guard _Always_clear{this};
-        return _STD move(_Data);
+    iterator erase(const const_iterator _First, const const_iterator _Last) {
+        _Clear_guard _Guard{this};
+        auto _Key_it   = _Data.keys.erase(_First._Key_it, _Last._Key_it);
+        auto _Val_it   = _Data.values.erase(_First._Mapped_it, _Last._Mapped_it);
+        _Guard._Target = nullptr;
+        return iterator{_STD move(_Key_it), _STD move(_Val_it)};
     }
 
-    template <class _Allocator>
-    _NODISCARD containers _Extract_using_allocator(const _Allocator& _Alloc) && {
-        _Clear_guard _Always_clear{this};
-        return containers{.keys = _STD make_obj_using_allocator<key_container_type>(_Alloc, _STD move(_Data.keys)),
-            .values = _STD make_obj_using_allocator<mapped_container_type>(_Alloc, _STD move(_Data.values))};
+    void swap(_Derived& _Other)
+        noexcept(is_nothrow_swappable_v<key_container_type> && is_nothrow_swappable_v<mapped_container_type>
+                 && is_nothrow_swappable_v<key_compare>) {
+        constexpr bool _Is_noexcept = is_nothrow_swappable_v<key_container_type>
+                                   && is_nothrow_swappable_v<mapped_container_type>
+                                   && is_nothrow_swappable_v<key_compare>;
+        auto& _Other_base = static_cast<_Flat_map_base&>(_Other);
+        _Flat_map_swap_clear_guard<_Is_noexcept, containers> _Guard{
+            _STD addressof(_Data), _STD addressof(_Other_base._Data)};
+        _RANGES swap(_Data.keys, _Other_base._Data.keys);
+        _RANGES swap(_Data.values, _Other_base._Data.values);
+        _RANGES swap(_Key_compare, _Other_base._Key_compare);
+        _Guard._Dismiss();
     }
 
-    void replace(key_container_type&& _Key_cont, mapped_container_type&& _Mapped_cont) {
-        _STL_ASSERT(_Key_cont.size() == _Mapped_cont.size(), "key_cont.size() != mapped_cont.size()");
-        _STL_ASSERT(_Is_sorted_and_unique(_Key_cont), _Msg_not_sorted);
-        _Clear_guard _Guard{this};
-        _Data.keys     = _STD move(_Key_cont);
-        _Data.values   = _STD move(_Mapped_cont);
-        _Guard._Target = nullptr;
+    void clear() noexcept {
+        _Data.keys.clear();
+        _Data.values.clear();
     }
 
-    // observers
+    // Observers
     _NODISCARD key_compare key_comp() const {
         return _Key_compare;
     }
@@ -790,18 +780,15 @@ public:
     _NODISCARD iterator find(const key_type& _Key_val) {
         return _Find(_Key_val);
     }
-
+    _NODISCARD const_iterator find(const key_type& _Key_val) const {
+        return _Find(_Key_val);
+    }
     template <class _OtherKey>
     _NODISCARD iterator find(const _OtherKey& _Key_val)
         requires _Transparent<key_compare>
     {
         return _Find(_Key_val);
     }
-
-    _NODISCARD const_iterator find(const key_type& _Key_val) const {
-        return _Find(_Key_val);
-    }
-
     template <class _OtherKey>
     _NODISCARD const_iterator find(const _OtherKey& _Key_val) const
         requires _Transparent<key_compare>
@@ -812,7 +799,6 @@ public:
     _NODISCARD size_type count(const key_type& _Key_val) const {
         return _Count(_Key_val);
     }
-
     template <class _OtherKey>
     _NODISCARD size_type count(const _OtherKey& _Key_val) const
         requires _Transparent<key_compare>
@@ -823,7 +809,6 @@ public:
     _NODISCARD bool contains(const key_type& _Key_val) const {
         return _Contains(_Key_val);
     }
-
     template <class _OtherKey>
     _NODISCARD bool contains(const _OtherKey& _Key_val) const
         requires _Transparent<key_compare>
@@ -834,18 +819,15 @@ public:
     _NODISCARD iterator lower_bound(const key_type& _Key_val) {
         return _Lower_bound(_Key_val);
     }
-
+    _NODISCARD const_iterator lower_bound(const key_type& _Key_val) const {
+        return _Lower_bound(_Key_val);
+    }
     template <class _OtherKey>
     _NODISCARD iterator lower_bound(const _OtherKey& _Key_val)
         requires _Transparent<key_compare>
     {
         return _Lower_bound(_Key_val);
     }
-
-    _NODISCARD const_iterator lower_bound(const key_type& _Key_val) const {
-        return _Lower_bound(_Key_val);
-    }
-
     template <class _OtherKey>
     _NODISCARD const_iterator lower_bound(const _OtherKey& _Key_val) const
         requires _Transparent<key_compare>
@@ -856,18 +838,15 @@ public:
     _NODISCARD iterator upper_bound(const key_type& _Key_val) {
         return _Upper_bound(_Key_val);
     }
-
+    _NODISCARD const_iterator upper_bound(const key_type& _Key_val) const {
+        return _Upper_bound(_Key_val);
+    }
     template <class _OtherKey>
     _NODISCARD iterator upper_bound(const _OtherKey& _Key_val)
         requires _Transparent<key_compare>
     {
         return _Upper_bound(_Key_val);
     }
-
-    _NODISCARD const_iterator upper_bound(const key_type& _Key_val) const {
-        return _Upper_bound(_Key_val);
-    }
-
     template <class _OtherKey>
     _NODISCARD const_iterator upper_bound(const _OtherKey& _Key_val) const
         requires _Transparent<key_compare>
@@ -878,18 +857,15 @@ public:
     _NODISCARD pair<iterator, iterator> equal_range(const key_type& _Key_val) {
         return _Equal_range(_Key_val);
     }
-
+    _NODISCARD pair<const_iterator, const_iterator> equal_range(const key_type& _Key_val) const {
+        return _Equal_range(_Key_val);
+    }
     template <class _OtherKey>
     _NODISCARD pair<iterator, iterator> equal_range(const _OtherKey& _Key_val)
         requires _Transparent<key_compare>
     {
         return _Equal_range(_Key_val);
     }
-
-    _NODISCARD pair<const_iterator, const_iterator> equal_range(const key_type& _Key_val) const {
-        return _Equal_range(_Key_val);
-    }
-
     template <class _OtherKey>
     _NODISCARD pair<const_iterator, const_iterator> equal_range(const _OtherKey& _Key_val) const
         requires _Transparent<key_compare>
@@ -912,15 +888,7 @@ public:
         _Left.swap(_Right);
     }
 
-
 protected:
-    containers _Data;
-    _MSVC_NO_UNIQUE_ADDRESS key_compare _Key_compare;
-
-    _NODISCARD auto _Pass_key_comp() const noexcept {
-        return _STD _Pass_fn(_Key_compare);
-    }
-
     template <class _OtherKey, class... _MappedArgTypes>
     _NODISCARD conditional_t<_IsUnique, pair<iterator, bool>, iterator> _Try_emplace(
         _OtherKey&& _Key_val, _MappedArgTypes&&... _Mapped_args) {
@@ -931,7 +899,7 @@ protected:
         const auto _Key_it = _STD upper_bound(_Data.keys.begin(), _Data.keys.end(), _Key_val, _Pass_key_comp());
         const auto _Index  = _Key_it - _Data.keys.begin();
         if constexpr (_IsUnique) {
-            if (_Key_it != _Data.keys.begin() && !_Key_compare(*(_Key_it - 1), _STD forward<_OtherKey>(_Key_val))) {
+            if (_Key_it != _Data.keys.begin() && !_Compare_keys(*(_Key_it - 1), _STD forward<_OtherKey>(_Key_val))) {
                 // Previous element is equivalent to key, no insert needed
                 return {begin() + (_Index - 1), false};
             }
@@ -964,16 +932,16 @@ protected:
 
         const weak_ordering _Hint_order = [&] {
             if constexpr (_IsUnique) {
-                if (_Position == _End || _Key_compare(_Key_val, *_Position._Key_it)) {
-                    if (_Position == _Begin || _Key_compare(*(_Position._Key_it - 1), _Key_val)) {
+                if (_Position == _End || _Compare_keys(_Key_val, *_Position._Key_it)) {
+                    if (_Position == _Begin || _Compare_keys(*(_Position._Key_it - 1), _Key_val)) {
                         return weak_ordering::equivalent;
                     } else {
                         return weak_ordering::greater;
                     }
                 }
             } else {
-                if (_Position == _End || !_Key_compare(*_Position._Key_it, _Key_val)) {
-                    if (_Position == _Begin || !_Key_compare(_Key_val, *(_Position._Key_it - 1))) {
+                if (_Position == _End || !_Compare_keys(*_Position._Key_it, _Key_val)) {
+                    if (_Position == _Begin || !_Compare_keys(_Key_val, *(_Position._Key_it - 1))) {
                         return weak_ordering::equivalent;
                     } else {
                         return weak_ordering::greater;
@@ -1000,14 +968,14 @@ protected:
 
         if constexpr (_IsUnique) {
             if (_Hint_order == weak_ordering::less) {
-                if (_New_position != _End && !_Key_compare(_Key_val, *_New_position._Key_it)) {
+                if (_New_position != _End && !_Compare_keys(_Key_val, *_New_position._Key_it)) {
                     if constexpr (_OverwriteIfExists) {
                         *_New_position._Mapped_it = mapped_type(_STD forward<_MappedArgTypes>(_Args)...);
                     }
                     return _New_position;
                 }
             } else {
-                if (_New_position != _Begin && !_Key_compare(*(_New_position._Key_it - 1), _Key_val)) {
+                if (_New_position != _Begin && !_Compare_keys(*(_New_position._Key_it - 1), _Key_val)) {
                     const auto _It = _New_position - 1;
                     if constexpr (_OverwriteIfExists) {
                         *_It._Mapped_it = mapped_type(_STD forward<_MappedArgTypes>(_Args)...);
@@ -1026,6 +994,7 @@ protected:
         return begin() + _Dist;
     }
 
+private:
     void _Insert_exact(const const_iterator _Position, key_type&& _Key_val, mapped_type&& _Mapped_val) {
         _Clear_guard _Guard{this};
         _Data.keys.insert(_Position._Key_it, _STD move(_Key_val));
@@ -1033,27 +1002,14 @@ protected:
         _Guard._Target = nullptr;
     }
 
-    template <class _KeyTy1, class _KeyTy2>
-    _NODISCARD bool _Key_equal(_KeyTy1&& _Left, _KeyTy2&& _Right) const {
-        _STL_INTERNAL_STATIC_ASSERT(
-            (is_same_v<remove_cvref_t<_KeyTy1>, key_type> && is_same_v<remove_cvref_t<_KeyTy2>, key_type>)
-            || (is_constructible_v<key_type, _KeyTy1> && is_constructible_v<key_type, _KeyTy2>
-                && _Transparent<key_compare>) );
-        return !_Key_compare(_STD forward<_KeyTy1>(_Left), _STD forward<_KeyTy2>(_Right))
-            && !_Key_compare(_STD forward<_KeyTy2>(_Right), _STD forward<_KeyTy1>(_Left));
-    }
-
-private:
-    // typename is a workaround for VSO-2680018 (EDG)
+    // size_type is always size_t
     template <class _KTy, class _MTy, class _Comp, class _KeyCont, class _MappedCont, class _Pred>
-    friend typename flat_map<_KTy, _MTy, _Comp, _KeyCont, _MappedCont>::size_type erase_if(
-        flat_map<_KTy, _MTy, _Comp, _KeyCont, _MappedCont>&, _Pred);
+    friend size_t erase_if(flat_map<_KTy, _MTy, _Comp, _KeyCont, _MappedCont>&, _Pred);
     template <class _KTy, class _MTy, class _Comp, class _KeyCont, class _MappedCont, class _Pred>
-    friend typename flat_multimap<_KTy, _MTy, _Comp, _KeyCont, _MappedCont>::size_type erase_if(
-        flat_multimap<_KTy, _MTy, _Comp, _KeyCont, _MappedCont>&, _Pred);
+    friend size_t erase_if(flat_multimap<_KTy, _MTy, _Comp, _KeyCont, _MappedCont>&, _Pred);
 
     template <class _Predicate>
-    _NODISCARD size_type _Erase_if(_Predicate _Pred) {
+    _NODISCARD size_t _Erase_if(_Predicate _Pred) {
         _Clear_guard _Guard{this};
 
         // N5032 [flat.map.erasure]/2 and [flat.multimap.erasure]/2
@@ -1075,28 +1031,40 @@ private:
             _Mutating_iterator{_Data.keys.end(), _Data.values.end()}};
     }
 
+#ifdef _ENABLE_STL_INTERNAL_CHECK
 public:
+#else
+private:
+#endif
     _NODISCARD bool _Is_sorted_and_unique() const {
-        return _Is_sorted_and_unique(_Data.keys);
+        return _Is_sorted_and_unique(_Data.keys.begin(), _Data.keys.end());
     }
 
 private:
-    using _Value_compare_to_pass = _Value_compare_to_pass_in_flat_map<_Compare, _Key, _Mapped>;
-
     _NODISCARD bool _Is_sorted_and_unique(
         const key_container_type::const_iterator _It, const key_container_type::const_iterator _End) const {
         if constexpr (_IsUnique) {
             // sorted-unique
-            auto _Negated = [this](const key_type& _Lhs, const key_type& _Rhs) { return !_Key_compare(_Lhs, _Rhs); };
+            auto _Negated = [this](const key_type& _Lhs, const key_type& _Rhs) { return !_Compare_keys(_Lhs, _Rhs); };
             return _STD adjacent_find(_It, _End, _Negated) == _End;
         } else {
             return _STD is_sorted(_It, _End, _Pass_key_comp());
         }
     }
 
-    _NODISCARD bool _Is_sorted_and_unique(const key_container_type& _Cont) const {
-        return _Is_sorted_and_unique(_Cont.begin(), _Cont.end());
-    }
+    struct _Value_compare_to_pass {
+        static constexpr bool _Efficiently_copyable = conjunction_v<bool_constant<sizeof(_Compare) <= sizeof(void*)>,
+            is_trivially_copy_constructible<_Compare>, is_trivially_destructible<_Compare>>;
+
+        using _Copy_or_ref = conditional_t<_Efficiently_copyable, _Compare, const _Compare&>;
+
+        _Copy_or_ref _Key_comparator;
+
+        template <class _Pair1, class _Pair2>
+        _NODISCARD bool operator()(const _Pair1& _Left, const _Pair2& _Right) const {
+            return _Key_comparator(_Left.first, _Right.first);
+        }
+    };
 
     void _Make_invariants_fulfilled() {
         if (empty()) {
@@ -1121,11 +1089,12 @@ private:
     auto _Erase_dupes_if_not_multi_pred() {
         _STL_INTERNAL_STATIC_ASSERT(_IsUnique);
         if constexpr (_Equivalence_is_equality<_Compare, _Key>) {
-            return [](const_reference _Left, const_reference _Right)
+            return [](const auto& _Left, const auto& _Right)
                        _STATIC_CALL_OPERATOR { return _Left.first == _Right.first; };
         } else {
-            return [this](const_reference _Left, const_reference _Right) {
-                return !_Key_compare(_Left.first, _Right.first);
+            return [this](const auto& _Left, const auto& _Right) {
+                // TRANSITION, not yet reported: `this->` avoids spurious -Wunused-lambda-capture warning with Clang 20
+                return !this->_Compare_keys(_Left.first, _Right.first);
             };
         }
     }
@@ -1151,13 +1120,13 @@ private:
         // Insert the new elements at the end
         for (; _First != _Last; ++_First) {
             value_type _Val = *_First;
-            if constexpr (_Has_guaranteed_push_back<_KeyContainer>) {
+            if constexpr (_Has_guaranteed_push_back<key_container_type>) {
                 _Data.keys.push_back(_STD move(_Val.first));
             } else {
                 _Data.keys.insert(_Data.keys.end(), _STD move(_Val.first));
             }
 
-            if constexpr (_Has_guaranteed_push_back<_MappedContainer>) {
+            if constexpr (_Has_guaranteed_push_back<mapped_container_type>) {
                 _Data.values.push_back(_STD move(_Val.second));
             } else {
                 _Data.values.insert(_Data.values.end(), _STD move(_Val.second));
@@ -1198,7 +1167,7 @@ private:
         _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
         const auto _Position =
             _STD lower_bound(_Self._Data.keys.begin(), _Self._Data.keys.end(), _Key_val, _Self._Pass_key_comp());
-        if (_Position != _Self._Data.keys.end() && !_Self._Key_compare(_Key_val, *_Position)) {
+        if (_Position != _Self._Data.keys.end() && !_Self._Compare_keys(_Key_val, *_Position)) {
             return _Self._Iterator_from_key_iterator(_Position);
         } else {
             return _Self.end();
@@ -1242,7 +1211,7 @@ private:
             // In a non-multi container, equal_range can have size at most 1
             const auto _First =
                 _STD lower_bound(_Self._Data.keys.begin(), _Self._Data.keys.end(), _Key_val, _Self._Pass_key_comp());
-            const bool _Missing = _First == _Self._Data.keys.end() || _Self._Key_compare(_Key_val, *_First);
+            const bool _Missing = _First == _Self._Data.keys.end() || _Self._Compare_keys(_Key_val, *_First);
             return pair{_Self._Iterator_from_key_iterator(_First),
                 _Self._Iterator_from_key_iterator(_Missing ? _First : _First + 1)};
         } else {
@@ -1258,6 +1227,22 @@ private:
         const difference_type _Offset = _Iter - _Self._Data.keys.cbegin();
         return _Self.begin() + _Offset;
     }
+
+    template <class _Lty, class _Rty>
+    _NODISCARD bool _Compare_keys(const _Lty& _Lhs, const _Rty& _Rhs) const
+        noexcept(noexcept(_DEBUG_LT_PRED(_Key_compare, _Lhs, _Rhs))) {
+        _STL_INTERNAL_STATIC_ASSERT(
+            _Transparent<key_compare> || (is_same_v<key_type, _Lty> && is_same_v<key_type, _Rty>) );
+
+        return _DEBUG_LT_PRED(_Key_compare, _Lhs, _Rhs);
+    }
+
+    _NODISCARD auto _Pass_key_comp() const noexcept {
+        return _STD _Pass_fn(_Key_compare);
+    }
+
+    containers _Data;
+    _MSVC_NO_UNIQUE_ADDRESS key_compare _Key_compare;
 };
 
 _EXPORT_STD template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer>
@@ -1285,15 +1270,15 @@ public:
     flat_map(flat_map&& _Other, const _Allocator& _Al) : _Mybase(_STD move(_Other), _Al) {}
 #endif // ^^^ workaround ^^^
 
+    flat_map& operator=(const flat_map&) = default;
+    flat_map& operator=(flat_map&&)      = default;
+
     flat_map& operator=(const initializer_list<value_type> _Ilist) {
         this->clear();
         this->insert(_Ilist.begin(), _Ilist.end());
         return *this;
     }
 
-    flat_map& operator=(const flat_map&) = default;
-    flat_map& operator=(flat_map&&)      = default;
-
     // [flat.map.access] Access
     mapped_type& operator[](const key_type& _Key_val)
         requires is_default_constructible_v<mapped_type>
@@ -1305,7 +1290,6 @@ public:
     {
         return try_emplace(_STD move(_Key_val)).first->second;
     }
-
     template <class _OtherKey>
     mapped_type& operator[](_OtherKey&& _Key_val)
         requires _Transparent<key_compare> && is_constructible_v<key_type, _OtherKey>
@@ -1317,18 +1301,15 @@ public:
     _NODISCARD mapped_type& at(const key_type& _Key_val) {
         return _At(_Key_val);
     }
-
     _NODISCARD const mapped_type& at(const key_type& _Key_val) const {
         return _At(_Key_val);
     }
-
     template <class _OtherKey>
     _NODISCARD mapped_type& at(const _OtherKey& _Key_val)
         requires _Transparent<key_compare>
     {
         return _At(_Key_val);
     }
-
     template <class _OtherKey>
     _NODISCARD const mapped_type& at(const _OtherKey& _Key_val) const
         requires _Transparent<key_compare>
@@ -1526,15 +1507,13 @@ template <class _Key, class _Mapped, _Not_allocator_for_container _Compare = les
 flat_map(sorted_unique_t, initializer_list<pair<_Key, _Mapped>>, _Compare = _Compare())
     -> flat_map<_Key, _Mapped, _Compare>;
 
-// Specialization of uses_allocator
 template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer, class _Allocator>
 struct uses_allocator<flat_map<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>, _Allocator>
     : bool_constant<uses_allocator_v<_KeyContainer, _Allocator> && uses_allocator_v<_MappedContainer, _Allocator>> {};
 
 _EXPORT_STD template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer,
     class _Predicate>
-flat_map<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>::size_type erase_if(
-    flat_map<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>& _Cont, _Predicate _Pred) {
+size_t erase_if(flat_map<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>& _Cont, _Predicate _Pred) {
     return _Cont._Erase_if(_STD _Pass_fn(_Pred));
 }
 
@@ -1558,14 +1537,14 @@ public:
     flat_multimap(flat_multimap&& _Other, const _Allocator& _Al) : _Mybase(_STD move(_Other), _Al) {}
 #endif // ^^^ workaround ^^^
 
+    flat_multimap& operator=(const flat_multimap&) = default;
+    flat_multimap& operator=(flat_multimap&&)      = default;
+
     flat_multimap& operator=(const initializer_list<value_type> _Ilist) {
         this->clear();
         this->insert(_Ilist.begin(), _Ilist.end());
         return *this;
     }
-
-    flat_multimap& operator=(const flat_multimap&) = default;
-    flat_multimap& operator=(flat_multimap&&)      = default;
 };
 
 template <_Not_allocator_for_container _KeyContainer, _Not_allocator_for_container _MappedContainer,
@@ -1578,6 +1557,7 @@ template <_Not_allocator_for_container _KeyContainer, _Not_allocator_for_contain
     _Usable_allocator_for<_KeyContainer, _MappedContainer> _Allocator>
 flat_multimap(_KeyContainer, _MappedContainer, _Allocator) -> flat_multimap<typename _KeyContainer::value_type,
     typename _MappedContainer::value_type, less<typename _KeyContainer::value_type>, _KeyContainer, _MappedContainer>;
+
 template <_Not_allocator_for_container _KeyContainer, _Not_allocator_for_container _MappedContainer,
     _Valid_compare_for_container<_KeyContainer> _Compare,
     _Usable_allocator_for<_KeyContainer, _MappedContainer> _Allocator>
@@ -1596,6 +1576,7 @@ template <_Not_allocator_for_container _KeyContainer, _Not_allocator_for_contain
 flat_multimap(sorted_equivalent_t, _KeyContainer, _MappedContainer, _Allocator)
     -> flat_multimap<typename _KeyContainer::value_type, typename _MappedContainer::value_type,
         less<typename _KeyContainer::value_type>, _KeyContainer, _MappedContainer>;
+
 template <_Not_allocator_for_container _KeyContainer, _Not_allocator_for_container _MappedContainer,
     _Valid_compare_for_container<_KeyContainer> _Compare,
     _Usable_allocator_for<_KeyContainer, _MappedContainer> _Allocator>
@@ -1648,15 +1629,13 @@ template <class _Key, class _Mapped, _Not_allocator_for_container _Compare = les
 flat_multimap(sorted_equivalent_t, initializer_list<pair<_Key, _Mapped>>, _Compare = _Compare())
     -> flat_multimap<_Key, _Mapped, _Compare>;
 
-// Specialization of uses_allocator
 template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer, class _Allocator>
 struct uses_allocator<flat_multimap<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>, _Allocator>
     : bool_constant<uses_allocator_v<_KeyContainer, _Allocator> && uses_allocator_v<_MappedContainer, _Allocator>> {};
 
 _EXPORT_STD template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer,
     class _Predicate>
-flat_multimap<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>::size_type erase_if(
-    flat_multimap<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>& _Cont, _Predicate _Pred) {
+size_t erase_if(flat_multimap<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>& _Cont, _Predicate _Pred) {
     return _Cont._Erase_if(_STD _Pass_fn(_Pred));
 }
 _STD_END
diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index 60d723304e9..0c6e51409d0 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -57,18 +57,6 @@ struct _NODISCARD _Flat_set_swap_clear_guard<true, _Container> {
     void _Dismiss() noexcept {}
 };
 
-template <class _Container, class _Ty>
-_NODISCARD auto _Emplace_with_clear_guard(_Container& _Cont, typename _Container::const_iterator _Where, _Ty&& _Val) {
-    if constexpr (_Has_guaranteed_single_insertion<_Container>) {
-        return _Cont.emplace(_Where, _STD forward<_Ty>(_Val));
-    } else {
-        _Clear_guard _Guard{_STD addressof(_Cont)};
-        auto _Iter     = _Cont.emplace(_Where, _STD forward<_Ty>(_Val));
-        _Guard._Target = nullptr;
-        return _Iter;
-    }
-}
-
 _EXPORT_STD template <class _Kty, class _Keylt = less<_Kty>, class _Container = vector<_Kty>>
 class flat_set;
 
@@ -85,16 +73,7 @@ private:
     static constexpr const char* _Msg_not_sorted = _IsUnique ? "Input was not sorted-unique!" : "Input was not sorted!";
 
 public:
-    static_assert(same_as<_Kty, typename _Container::value_type>,
-        "key_type and container_type::value_type must be the same. "
-        "(N5032 [flat.set.overview]/8, [flat.multiset.overview]/8)");
-    static_assert(!_Is_vector_bool<_Container>,
-        "vector<bool> cannot be adapted because it is not a sequence container. "
-        "(N5032 [flat.set.overview]/7, [flat.multiset.overview]/7)");
-    static_assert(random_access_iterator<typename _Container::const_iterator>,
-        "Sequence containers must support random-access iterators in order to be adapted. "
-        "(N5032 [flat.set.overview]/7, [flat.multiset.overview]/7)");
-
+    // [flat.set.defn] Types
     using key_type               = _Kty;
     using value_type             = _Kty;
     using key_compare            = _Keylt;
@@ -109,120 +88,177 @@ public:
     using reverse_iterator       = const_reverse_iterator;
     using container_type         = _Container;
 
+    static_assert(same_as<key_type, typename container_type::value_type>,
+        "key_type and container_type::value_type must be the same. "
+        "(N5032 [flat.set.overview]/8, [flat.multiset.overview]/8)");
+    static_assert(!_Is_vector_bool<container_type>,
+        "vector<bool> cannot be adapted because it is not a sequence container. "
+        "(N5032 [flat.set.overview]/7, [flat.multiset.overview]/7)");
+    static_assert(random_access_iterator<typename container_type::const_iterator>,
+        "Sequence containers must support random-access iterators in order to be adapted. "
+        "(N5032 [flat.set.overview]/7, [flat.multiset.overview]/7)");
+
     // [flat.set.cons] Constructors
-    _Flat_set_base() : _Flat_set_base(key_compare()) {}
+    _Flat_set_base() : _Mycont(), _Mycomp() {}
 
-    template <_Usable_allocator_for<container_type> _Alloc>
-    _Flat_set_base(const _Flat_set_base& _Other, const _Alloc& _Al)
-        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al, _Other._Mycont)), _Mycomp(_Other._Mycomp) {}
-    template <_Usable_allocator_for<container_type> _Alloc>
-    _Flat_set_base(_Flat_set_base&& _Other, const _Alloc& _Al)
-        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al, _STD move(_Other).extract())),
-          _Mycomp(_Other._Mycomp) // intentionally copy comparator, see LWG-2227
+    _Flat_set_base(const _Flat_set_base&) = default;
+
+    _Flat_set_base(_Flat_set_base&& _Other) noexcept(
+        is_nothrow_move_constructible_v<container_type> && is_nothrow_copy_constructible_v<key_compare>) // strengthened
+        : _Mycont(_STD move(_Other).extract()), _Mycomp(_Other._Mycomp) // intentionally copy comparator, see LWG-2227
     {}
 
+    explicit _Flat_set_base(const key_compare& _Comp) : _Mycont(), _Mycomp(_Comp) {}
+
     explicit _Flat_set_base(container_type _Cont, const key_compare& _Comp = key_compare())
         : _Mycont(_STD move(_Cont)), _Mycomp(_Comp) {
         _Make_invariants_fulfilled();
     }
-    template <_Usable_allocator_for<container_type> _Alloc>
-    _Flat_set_base(const container_type& _Cont, const _Alloc& _Al)
-        : _Flat_set_base(_STD make_obj_using_allocator<container_type>(_Al, _Cont)) {}
-    template <_Usable_allocator_for<container_type> _Alloc>
-    _Flat_set_base(const container_type& _Cont, const key_compare& _Comp, const _Alloc& _Al)
-        : _Flat_set_base(_STD make_obj_using_allocator<container_type>(_Al, _Cont), _Comp) {}
 
     _Flat_set_base(_Sorted_t, container_type _Cont, const key_compare& _Comp = key_compare())
         : _Mycont(_STD move(_Cont)), _Mycomp(_Comp) {
         _STL_ASSERT(_Is_sorted_and_unique(), _Msg_not_sorted);
     }
+
+    template <_Iterator_for_container _Iter>
+    _Flat_set_base(const _Iter _First, const _Iter _Last, const key_compare& _Comp = key_compare())
+        : _Mycont(_First, _Last), _Mycomp(_Comp) {
+        _Make_invariants_fulfilled();
+    }
+
+    template <_Iterator_for_container _Iter>
+    _Flat_set_base(_Sorted_t, const _Iter _First, const _Iter _Last, const key_compare& _Comp = key_compare())
+        : _Mycont(_First, _Last), _Mycomp(_Comp) {
+        _STL_ASSERT(_Is_sorted_and_unique(), _Msg_not_sorted);
+    }
+
+    template <_Container_compatible_range<_Kty> _Rng>
+    _Flat_set_base(from_range_t, _Rng&& _Range) : _Mycont(from_range, _STD forward<_Rng>(_Range)), _Mycomp() {
+        _Make_invariants_fulfilled();
+    }
+
+    template <_Container_compatible_range<_Kty> _Rng>
+    _Flat_set_base(from_range_t, _Rng&& _Range, const key_compare& _Comp)
+        : _Mycont(from_range, _STD forward<_Rng>(_Range)), _Mycomp(_Comp) {
+        _Make_invariants_fulfilled();
+    }
+
+    _Flat_set_base(const initializer_list<_Kty> _Ilist, const key_compare& _Comp = key_compare())
+        : _Mycont(_Ilist.begin(), _Ilist.end()), _Mycomp(_Comp) {
+        _Make_invariants_fulfilled();
+    }
+
+    _Flat_set_base(_Sorted_t, const initializer_list<_Kty> _Ilist, const key_compare& _Comp = key_compare())
+        : _Mycont(_Ilist.begin(), _Ilist.end()), _Mycomp(_Comp) {
+        _STL_ASSERT(_Is_sorted_and_unique(), _Msg_not_sorted);
+    }
+
+    // [flat.set.cons.alloc] Constructors with allocators
     template <_Usable_allocator_for<container_type> _Alloc>
-    _Flat_set_base(_Sorted_t _Tag, const container_type& _Cont, const _Alloc& _Al)
-        : _Flat_set_base(_Tag, _STD make_obj_using_allocator<container_type>(_Al, _Cont)) {}
-    template <_Usable_allocator_for<container_type> _Alloc>
-    _Flat_set_base(_Sorted_t _Tag, const container_type& _Cont, const key_compare& _Comp, const _Alloc& _Al)
-        : _Flat_set_base(_Tag, _STD make_obj_using_allocator<container_type>(_Al, _Cont), _Comp) {}
+    explicit _Flat_set_base(const _Alloc& _Al)
+        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al)), _Mycomp() {}
 
-    explicit _Flat_set_base(const key_compare& _Comp) : _Mycont(), _Mycomp(_Comp) {}
     template <_Usable_allocator_for<container_type> _Alloc>
     _Flat_set_base(const key_compare& _Comp, const _Alloc& _Al)
         : _Mycont(_STD make_obj_using_allocator<container_type>(_Al)), _Mycomp(_Comp) {}
+
     template <_Usable_allocator_for<container_type> _Alloc>
-    explicit _Flat_set_base(const _Alloc& _Al)
-        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al)), _Mycomp() {}
+    _Flat_set_base(const container_type& _Cont, const _Alloc& _Al)
+        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al, _Cont)), _Mycomp() {
+        _Make_invariants_fulfilled();
+    }
 
-    template <_Iterator_for_container _Iter>
-    _Flat_set_base(const _Iter _First, const _Iter _Last, const key_compare& _Comp = key_compare())
-        : _Mycont(), _Mycomp(_Comp) {
-        _Mycont.assign(_First, _Last);
+    template <_Usable_allocator_for<container_type> _Alloc>
+    _Flat_set_base(const container_type& _Cont, const key_compare& _Comp, const _Alloc& _Al)
+        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al, _Cont)), _Mycomp(_Comp) {
+        _Make_invariants_fulfilled();
+    }
+
+    template <_Usable_allocator_for<container_type> _Alloc>
+    _Flat_set_base(_Sorted_t, const container_type& _Cont, const _Alloc& _Al)
+        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al, _Cont)), _Mycomp() {
+        _STL_ASSERT(_Is_sorted_and_unique(), _Msg_not_sorted);
+    }
+
+    template <_Usable_allocator_for<container_type> _Alloc>
+    _Flat_set_base(_Sorted_t, const container_type& _Cont, const key_compare& _Comp, const _Alloc& _Al)
+        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al, _Cont)), _Mycomp(_Comp) {
+        _STL_ASSERT(_Is_sorted_and_unique(), _Msg_not_sorted);
+    }
+
+    template <_Usable_allocator_for<container_type> _Alloc>
+    _Flat_set_base(const _Flat_set_base& _Other, const _Alloc& _Al)
+        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al, _Other._Mycont)), _Mycomp(_Other._Mycomp) {}
+
+    template <_Usable_allocator_for<container_type> _Alloc>
+    _Flat_set_base(_Flat_set_base&& _Other, const _Alloc& _Al)
+        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al, _STD move(_Other).extract())),
+          _Mycomp(_Other._Mycomp) // intentionally copy comparator, see LWG-2227
+    {}
+
+    template <_Iterator_for_container _Iter, _Usable_allocator_for<container_type> _Alloc>
+    _Flat_set_base(const _Iter _First, const _Iter _Last, const _Alloc& _Al)
+        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al, _First, _Last)), _Mycomp() {
         _Make_invariants_fulfilled();
     }
+
     template <_Iterator_for_container _Iter, _Usable_allocator_for<container_type> _Alloc>
     _Flat_set_base(const _Iter _First, const _Iter _Last, const key_compare& _Comp, const _Alloc& _Al)
-        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al)), _Mycomp(_Comp) {
-        _Mycont.assign(_First, _Last);
+        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al, _First, _Last)), _Mycomp(_Comp) {
         _Make_invariants_fulfilled();
     }
+
     template <_Iterator_for_container _Iter, _Usable_allocator_for<container_type> _Alloc>
-    _Flat_set_base(const _Iter _First, const _Iter _Last, const _Alloc& _Al)
-        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al)), _Mycomp() {
-        _Mycont.assign(_First, _Last);
-        _Make_invariants_fulfilled();
+    _Flat_set_base(_Sorted_t, const _Iter _First, const _Iter _Last, const _Alloc& _Al)
+        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al, _First, _Last)), _Mycomp() {
+        _STL_ASSERT(_Is_sorted_and_unique(), _Msg_not_sorted);
+    }
+
+    template <_Iterator_for_container _Iter, _Usable_allocator_for<container_type> _Alloc>
+    _Flat_set_base(_Sorted_t, const _Iter _First, const _Iter _Last, const key_compare& _Comp, const _Alloc& _Al)
+        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al, _First, _Last)), _Mycomp(_Comp) {
+        _STL_ASSERT(_Is_sorted_and_unique(), _Msg_not_sorted);
     }
 
-    template <_Container_compatible_range<_Kty> _Rng>
-    _Flat_set_base(from_range_t, _Rng&& _Range)
-        : _Flat_set_base(container_type(from_range, _STD forward<_Rng>(_Range))) {}
     template <_Container_compatible_range<_Kty> _Rng, _Usable_allocator_for<container_type> _Alloc>
     _Flat_set_base(from_range_t, _Rng&& _Range, const _Alloc& _Al)
-        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al)), _Mycomp() {
-        _Mycont.assign_range(_STD forward<_Rng>(_Range));
+        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al, from_range, _STD forward<_Rng>(_Range))),
+          _Mycomp() {
         _Make_invariants_fulfilled();
     }
-    template <_Container_compatible_range<_Kty> _Rng>
-    _Flat_set_base(from_range_t, _Rng&& _Range, const key_compare& _Comp)
-        : _Flat_set_base(container_type(from_range, _STD forward<_Rng>(_Range)), _Comp) {}
+
     template <_Container_compatible_range<_Kty> _Rng, _Usable_allocator_for<container_type> _Alloc>
     _Flat_set_base(from_range_t, _Rng&& _Range, const key_compare& _Comp, const _Alloc& _Al)
-        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al)), _Mycomp(_Comp) {
-        _Mycont.assign_range(_STD forward<_Rng>(_Range));
+        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al, from_range, _STD forward<_Rng>(_Range))),
+          _Mycomp(_Comp) {
         _Make_invariants_fulfilled();
     }
 
-    template <_Iterator_for_container _Iter>
-    _Flat_set_base(_Sorted_t _Tag, const _Iter _First, const _Iter _Last, const key_compare& _Comp = key_compare())
-        : _Flat_set_base(_Tag, container_type(_First, _Last), _Comp) {}
-    template <_Iterator_for_container _Iter, _Usable_allocator_for<container_type> _Alloc>
-    _Flat_set_base(_Sorted_t _Tag, const _Iter _First, const _Iter _Last, const key_compare& _Comp, const _Alloc& _Al)
-        : _Flat_set_base(_Tag, _STD make_obj_using_allocator<container_type>(_Al, _First, _Last), _Comp) {}
-    template <_Iterator_for_container _Iter, _Usable_allocator_for<container_type> _Alloc>
-    _Flat_set_base(_Sorted_t _Tag, const _Iter _First, const _Iter _Last, const _Alloc& _Al)
-        : _Flat_set_base(_Tag, _STD make_obj_using_allocator<container_type>(_Al, _First, _Last)) {}
-
-    _Flat_set_base(const initializer_list<_Kty> _Ilist, const key_compare& _Comp = key_compare())
-        : _Flat_set_base(_Ilist.begin(), _Ilist.end(), _Comp) {}
-    template <_Usable_allocator_for<container_type> _Alloc>
-    _Flat_set_base(const initializer_list<_Kty> _Ilist, const key_compare& _Comp, const _Alloc& _Al)
-        : _Flat_set_base(_Ilist.begin(), _Ilist.end(), _Comp, _Al) {}
     template <_Usable_allocator_for<container_type> _Alloc>
     _Flat_set_base(const initializer_list<_Kty> _Ilist, const _Alloc& _Al)
-        : _Flat_set_base(_Ilist.begin(), _Ilist.end(), _Al) {}
+        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al, _Ilist.begin(), _Ilist.end())), _Mycomp() {
+        _Make_invariants_fulfilled();
+    }
 
-    _Flat_set_base(_Sorted_t _Tag, const initializer_list<_Kty> _Ilist, const key_compare& _Comp = key_compare())
-        : _Flat_set_base(_Tag, _Ilist.begin(), _Ilist.end(), _Comp) {}
     template <_Usable_allocator_for<container_type> _Alloc>
-    _Flat_set_base(_Sorted_t _Tag, const initializer_list<_Kty> _Ilist, const key_compare& _Comp, const _Alloc& _Al)
-        : _Flat_set_base(_Tag, _Ilist.begin(), _Ilist.end(), _Comp, _Al) {}
+    _Flat_set_base(const initializer_list<_Kty> _Ilist, const key_compare& _Comp, const _Alloc& _Al)
+        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al, _Ilist.begin(), _Ilist.end())), _Mycomp(_Comp) {
+        _Make_invariants_fulfilled();
+    }
+
     template <_Usable_allocator_for<container_type> _Alloc>
-    _Flat_set_base(_Sorted_t _Tag, const initializer_list<_Kty> _Ilist, const _Alloc& _Al)
-        : _Flat_set_base(_Tag, _Ilist.begin(), _Ilist.end(), _Al) {}
+    _Flat_set_base(_Sorted_t, const initializer_list<_Kty> _Ilist, const _Alloc& _Al)
+        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al, _Ilist.begin(), _Ilist.end())), _Mycomp() {
+        _STL_ASSERT(_Is_sorted_and_unique(), _Msg_not_sorted);
+    }
 
-    _Flat_set_base(const _Flat_set_base&) = default;
-    _Flat_set_base(_Flat_set_base&& _Other) noexcept(
-        is_nothrow_move_constructible_v<container_type> && is_nothrow_copy_constructible_v<key_compare>) // strengthened
-        : _Mycont(_STD move(_Other).extract()), _Mycomp(_Other._Mycomp) // intentionally copy comparator, see LWG-2227
-    {}
+    template <_Usable_allocator_for<container_type> _Alloc>
+    _Flat_set_base(_Sorted_t, const initializer_list<_Kty> _Ilist, const key_compare& _Comp, const _Alloc& _Al)
+        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al, _Ilist.begin(), _Ilist.end())), _Mycomp(_Comp) {
+        _STL_ASSERT(_Is_sorted_and_unique(), _Msg_not_sorted);
+    }
 
+    // Assignment operators
     _Flat_set_base& operator=(const _Flat_set_base& _Other) {
         _Clear_guard _Guard{this};
         _Mycont        = _Other._Mycont;
@@ -230,9 +266,9 @@ public:
         _Guard._Target = nullptr;
         return *this;
     }
+
     _Flat_set_base& operator=(_Flat_set_base&& _Other) noexcept(
-        is_nothrow_move_assignable_v<container_type> && is_nothrow_copy_assignable_v<key_compare>) // strengthened
-    {
+        is_nothrow_move_assignable_v<container_type> && is_nothrow_copy_assignable_v<key_compare>) /* strengthened */ {
         if (this != _STD addressof(_Other)) {
             _Clear_guard _Guard{this};
             _Clear_guard _Always_clear{_STD addressof(_Other)};
@@ -243,15 +279,7 @@ public:
         return *this;
     }
 
-    _Derived& operator=(const initializer_list<_Kty> _Ilist) {
-        _Clear_guard _Guard{this};
-        _Mycont.assign(_Ilist);
-        _Make_invariants_fulfilled();
-        _Guard._Target = nullptr;
-        return static_cast<_Derived&>(*this);
-    }
-
-    // iterators
+    // Iterators
     // NB: The non-const overloads are intentionally removed for brevity. This will not result in behavioral changes.
     _NODISCARD const_iterator begin() const noexcept {
         return _Mycont.begin();
@@ -261,10 +289,10 @@ public:
     }
 
     _NODISCARD const_reverse_iterator rbegin() const noexcept {
-        return const_reverse_iterator(end());
+        return const_reverse_iterator{_Mycont.end()};
     }
     _NODISCARD const_reverse_iterator rend() const noexcept {
-        return const_reverse_iterator(begin());
+        return const_reverse_iterator{_Mycont.begin()};
     }
 
     _NODISCARD const_iterator cbegin() const noexcept {
@@ -275,13 +303,13 @@ public:
     }
 
     _NODISCARD const_reverse_iterator crbegin() const noexcept {
-        return rbegin();
+        return const_reverse_iterator{_Mycont.end()};
     }
     _NODISCARD const_reverse_iterator crend() const noexcept {
-        return rend();
+        return const_reverse_iterator{_Mycont.begin()};
     }
 
-    // capacity
+    // Capacity
     _NODISCARD_EMPTY_MEMBER bool empty() const noexcept {
         return _Mycont.empty();
     }
@@ -292,7 +320,7 @@ public:
         return _Mycont.max_size();
     }
 
-    // modifiers
+    // [flat.set.modifiers] Modifiers
     template <class... _Args>
     auto emplace(_Args&&... _Vals)
         requires is_constructible_v<value_type, _Args...>
@@ -304,6 +332,7 @@ public:
             return _Emplace(_Kty(_STD forward<_Args>(_Vals)...));
         }
     }
+
     template <class... _Args>
     iterator emplace_hint(const const_iterator _Hint, _Args&&... _Vals)
         requires is_constructible_v<value_type, _Args...>
@@ -348,6 +377,7 @@ public:
     void insert(_Sorted_t, const _Iter _First, const _Iter _Last) {
         _Insert_range<false>(_First, _Last);
     }
+
     template <_Container_compatible_range<_Kty> _Rng>
     void insert_range(_Rng&& _Range) {
         _Insert_range<true>(_STD forward<_Rng>(_Range));
@@ -356,6 +386,7 @@ public:
     void insert_range(_Sorted_t, _Rng&& _Range) {
         _Insert_range<false>(_STD forward<_Rng>(_Range));
     }
+
     void insert(const initializer_list<_Kty> _Ilist) {
         _Insert_range<true>(_Ilist.begin(), _Ilist.end());
     }
@@ -371,7 +402,7 @@ public:
     }
 
     void replace(container_type&& _Cont) {
-        _STL_ASSERT(_Is_sorted_and_unique(_Cont), _Msg_not_sorted);
+        _STL_ASSERT(_Is_sorted_and_unique(_Cont.begin(), _Cont.end()), _Msg_not_sorted);
         _Clear_guard _Guard{this};
         _Mycont        = _STD move(_Cont);
         _Guard._Target = nullptr;
@@ -384,6 +415,7 @@ public:
         _Guard._Target  = nullptr;
         return _Ret;
     }
+
     size_type erase(const _Kty& _Val) {
         return _Erase(_Val);
     }
@@ -392,6 +424,7 @@ public:
     size_type erase(_Other&& _Val) {
         return _Erase(_Val);
     }
+
     iterator erase(const const_iterator _First, const const_iterator _Last) {
         _Clear_guard _Guard{this};
         const auto _Ret = _Mycont.erase(_First, _Last);
@@ -399,9 +432,10 @@ public:
         return _Ret;
     }
 
-    void swap(_Derived& _Other) noexcept(is_nothrow_swappable_v<_Container> && is_nothrow_swappable_v<_Keylt>) {
-        constexpr bool _Is_noexcept = is_nothrow_swappable_v<_Container> && is_nothrow_swappable_v<_Keylt>;
-        _Flat_set_swap_clear_guard<_Is_noexcept, _Container> _Guard{
+    void swap(_Derived& _Other)
+        noexcept(is_nothrow_swappable_v<container_type> && is_nothrow_swappable_v<key_compare>) {
+        constexpr bool _Is_noexcept = is_nothrow_swappable_v<container_type> && is_nothrow_swappable_v<key_compare>;
+        _Flat_set_swap_clear_guard<_Is_noexcept, container_type> _Guard{
             _STD addressof(_Mycont), _STD addressof(_Other._Mycont)};
         _RANGES swap(_Mycont, _Other._Mycont);
         _RANGES swap(_Mycomp, _Other._Mycomp);
@@ -412,7 +446,7 @@ public:
         _Mycont.clear();
     }
 
-    // observers
+    // Observers
     _NODISCARD key_compare key_comp() const {
         return _Mycomp;
     }
@@ -420,7 +454,7 @@ public:
         return _Mycomp;
     }
 
-    // set operations
+    // Set operations
     // NB: The non-const overloads are intentionally removed for brevity. This will not result in behavioral changes.
     _NODISCARD const_iterator find(const _Kty& _Val) const {
         return _Find(_Val);
@@ -489,8 +523,13 @@ public:
         _Lhs.swap(_Rhs);
     }
 
+#ifdef _ENABLE_STL_INTERNAL_CHECK
+public:
+#else
+private:
+#endif
     _NODISCARD bool _Is_sorted_and_unique() const {
-        return _Is_sorted_and_unique(_Mycont);
+        return _Is_sorted_and_unique(_Mycont.begin(), _Mycont.end());
     }
 
 private:
@@ -504,10 +543,6 @@ private:
         }
     }
 
-    _NODISCARD bool _Is_sorted_and_unique(const container_type& _Cont) const {
-        return _Is_sorted_and_unique(_Cont.begin(), _Cont.end());
-    }
-
     template <class _Ty>
     _NODISCARD bool _Can_insert(const const_iterator _Where, const _Ty& _Val) const {
         _STL_INTERNAL_STATIC_ASSERT(is_same_v<_Ty, _Kty>); // only accepts _Kty
@@ -526,6 +561,18 @@ private:
         }
     }
 
+    template <class _Ty>
+    _NODISCARD iterator _Emplace_with_clear_guard(const const_iterator _Where, _Ty&& _Val) {
+        if constexpr (_Has_guaranteed_single_insertion<container_type>) {
+            return _Mycont.emplace(_Where, _STD forward<_Ty>(_Val));
+        } else {
+            _Clear_guard _Guard{this};
+            auto _Iter     = _Mycont.emplace(_Where, _STD forward<_Ty>(_Val));
+            _Guard._Target = nullptr;
+            return _Iter;
+        }
+    }
+
     template <class _Ty>
     _NODISCARD conditional_t<_IsUnique, pair<iterator, bool>, iterator> _Emplace(_Ty&& _Val) {
         if constexpr (_IsUnique) {
@@ -536,7 +583,7 @@ private:
 
             if constexpr (is_same_v<remove_cvref_t<_Ty>, _Kty>) {
                 _STL_INTERNAL_CHECK(_Can_insert(_Where, _Val));
-                return pair{_STD _Emplace_with_clear_guard(_Mycont, _Where, _STD forward<_Ty>(_Val)), true};
+                return pair{_Emplace_with_clear_guard(_Where, _STD forward<_Ty>(_Val)), true};
             } else {
                 // heterogeneous insertion
                 _STL_INTERNAL_STATIC_ASSERT(_Transparent<key_compare> && is_constructible_v<_Kty, _Ty>);
@@ -544,11 +591,11 @@ private:
                 _STL_ASSERT(_Can_insert(_Where, _Keyval),
                     "The conversion from the heterogeneous key to key_type should "
                     "be consistent with the heterogeneous lookup!");
-                return pair{_STD _Emplace_with_clear_guard(_Mycont, _Where, _STD move(_Keyval)), true};
+                return pair{_Emplace_with_clear_guard(_Where, _STD move(_Keyval)), true};
             }
         } else {
             _STL_INTERNAL_STATIC_ASSERT(is_same_v<remove_cvref_t<_Ty>, _Kty>);
-            return _STD _Emplace_with_clear_guard(_Mycont, upper_bound(_Val), _STD forward<_Ty>(_Val));
+            return _Emplace_with_clear_guard(upper_bound(_Val), _STD forward<_Ty>(_Val));
         }
     }
 
@@ -578,7 +625,7 @@ private:
 
             if constexpr (is_same_v<remove_cvref_t<_Ty>, _Kty>) {
                 _STL_INTERNAL_CHECK(_Can_insert(_Where, _Val));
-                return _STD _Emplace_with_clear_guard(_Mycont, _Where, _STD forward<_Ty>(_Val));
+                return _Emplace_with_clear_guard(_Where, _STD forward<_Ty>(_Val));
             } else {
                 // heterogeneous insertion
                 _STL_INTERNAL_STATIC_ASSERT(_Transparent<key_compare> && is_constructible_v<_Kty, _Ty>);
@@ -586,7 +633,7 @@ private:
                 _STL_ASSERT(_Can_insert(_Where, _Keyval),
                     "The conversion from the heterogeneous key to key_type should "
                     "be consistent with the heterogeneous lookup!");
-                return _STD _Emplace_with_clear_guard(_Mycont, _Where, _STD move(_Keyval));
+                return _Emplace_with_clear_guard(_Where, _STD move(_Keyval));
             }
         } else {
             _STL_INTERNAL_STATIC_ASSERT(is_same_v<remove_cvref_t<_Ty>, _Kty>);
@@ -607,7 +654,7 @@ private:
                 _Where = _STD lower_bound(_Where, _End, _Val, _Pass_comp());
             }
 
-            return _STD _Emplace_with_clear_guard(_Mycont, _Where, _STD forward<_Ty>(_Val));
+            return _Emplace_with_clear_guard(_Where, _STD forward<_Ty>(_Val));
         }
     }
 
@@ -619,11 +666,12 @@ private:
         _Restore_invariants_after_insert<_NeedSorting>(_Old_size);
         _Guard._Target = nullptr;
     }
+
     template <bool _NeedSorting, _Container_compatible_range<_Kty> _Rng>
     void _Insert_range(_Rng&& _Range) {
         const size_type _Old_size = size();
         _Clear_guard _Guard{this};
-        if constexpr (_Has_guaranteed_append_range<_Container>) {
+        if constexpr (_Has_guaranteed_append_range<container_type>) {
             _Mycont.append_range(_STD forward<_Rng>(_Range));
         } else {
             _Mycont.insert_range(_Mycont.end(), _STD forward<_Rng>(_Range));
@@ -701,7 +749,7 @@ private:
         if constexpr (_IsUnique && is_same_v<_KeyTy, key_type>) { // Optimization restricted due to GH-5992
             // In a non-multi container, equal_range can have size at most 1
             const auto _First   = _STD lower_bound(_Mycont.begin(), _Mycont.end(), _Key_val, _Pass_comp());
-            const bool _Missing = _First == _Mycont.end() || _Mycomp(_Key_val, *_First);
+            const bool _Missing = _First == _Mycont.end() || _Compare(_Key_val, *_First);
             return pair{_First, _Missing ? _First : _First + 1};
         } else {
             return _STD equal_range(begin(), end(), _Key_val, _Pass_comp());
@@ -797,9 +845,14 @@ public:
     flat_set(flat_set&& _Other, const _Allocator& _Al) : _Mybase(_STD move(_Other), _Al) {}
 #endif // ^^^ workaround ^^^
 
-    using _Mybase::operator=; // for operator=(initializer_list)
     flat_set& operator=(const flat_set&) = default;
     flat_set& operator=(flat_set&&)      = default;
+
+    flat_set& operator=(const initializer_list<_Kty> _Ilist) {
+        this->clear();
+        this->insert(_Ilist.begin(), _Ilist.end());
+        return *this;
+    }
 };
 
 _EXPORT_STD template <class _Kty, class _Keylt, class _Container>
@@ -820,9 +873,14 @@ public:
     flat_multiset(flat_multiset&& _Other, const _Allocator& _Al) : _Mybase(_STD move(_Other), _Al) {}
 #endif // ^^^ workaround ^^^
 
-    using _Mybase::operator=; // for operator=(initializer_list)
     flat_multiset& operator=(const flat_multiset&) = default;
     flat_multiset& operator=(flat_multiset&&)      = default;
+
+    flat_multiset& operator=(const initializer_list<_Kty> _Ilist) {
+        this->clear();
+        this->insert(_Ilist.begin(), _Ilist.end());
+        return *this;
+    }
 };
 
 _EXPORT_STD template <class _Kty, class _Keylt, class _Container, class _Pred>
@@ -868,21 +926,23 @@ template <_Iterator_for_container _Iter, _Not_allocator_for_container _Compare =
 flat_set(_Iter, _Iter, _Compare = _Compare()) -> flat_set<iter_value_t<_Iter>, _Compare>;
 template <_Iterator_for_container _Iter, _Not_allocator_for_container _Compare = less<iter_value_t<_Iter>>>
 flat_set(sorted_unique_t, _Iter, _Iter, _Compare = _Compare()) -> flat_set<iter_value_t<_Iter>, _Compare>;
+
 // TRANSITION, CWG-2369, should just use constrained template parameters.
 template <_RANGES input_range _Range, _Not_allocator_for_container _Compare = less<_RANGES range_value_t<_Range>>,
     class _Alloc = allocator<_RANGES range_value_t<_Range>>, enable_if_t<_Allocator_for_container<_Alloc>, int> = 0>
 flat_set(from_range_t, _Range&&, _Compare = _Compare(), _Alloc = _Alloc()) -> flat_set<_RANGES range_value_t<_Range>,
     _Compare, vector<_RANGES range_value_t<_Range>, _Rebind_alloc_t<_Alloc, _RANGES range_value_t<_Range>>>>;
+
 // TRANSITION, CWG-2369, should just use constrained template parameters.
 template <_RANGES input_range _Range, class _Alloc, enable_if_t<_Allocator_for_container<_Alloc>, int> = 0>
 flat_set(from_range_t, _Range&&, _Alloc) -> flat_set<_RANGES range_value_t<_Range>, less<_RANGES range_value_t<_Range>>,
     vector<_RANGES range_value_t<_Range>, _Rebind_alloc_t<_Alloc, _RANGES range_value_t<_Range>>>>;
+
 template <class _Kty, _Not_allocator_for_container _Compare = less<_Kty>>
 flat_set(initializer_list<_Kty>, _Compare = _Compare()) -> flat_set<_Kty, _Compare>;
 template <class _Kty, _Not_allocator_for_container _Compare = less<_Kty>>
 flat_set(sorted_unique_t, initializer_list<_Kty>, _Compare = _Compare()) -> flat_set<_Kty, _Compare>;
 
-
 template <_Not_allocator_for_container _Container,
     _Valid_compare_for_container<_Container> _Compare = less<typename _Container::value_type>>
 flat_multiset(_Container, _Compare = _Compare())
@@ -910,17 +970,20 @@ template <_Iterator_for_container _Iter, _Not_allocator_for_container _Compare =
 flat_multiset(_Iter, _Iter, _Compare = _Compare()) -> flat_multiset<iter_value_t<_Iter>, _Compare>;
 template <_Iterator_for_container _Iter, _Not_allocator_for_container _Compare = less<iter_value_t<_Iter>>>
 flat_multiset(sorted_equivalent_t, _Iter, _Iter, _Compare = _Compare()) -> flat_multiset<iter_value_t<_Iter>, _Compare>;
+
 // TRANSITION, CWG-2369, should just use constrained template parameters.
 template <_RANGES input_range _Range, _Not_allocator_for_container _Compare = less<_RANGES range_value_t<_Range>>,
     class _Alloc = allocator<_RANGES range_value_t<_Range>>, enable_if_t<_Allocator_for_container<_Alloc>, int> = 0>
 flat_multiset(from_range_t, _Range&&, _Compare = _Compare(), _Alloc = _Alloc())
     -> flat_multiset<_RANGES range_value_t<_Range>, _Compare,
         vector<_RANGES range_value_t<_Range>, _Rebind_alloc_t<_Alloc, _RANGES range_value_t<_Range>>>>;
+
 // TRANSITION, CWG-2369, should just use constrained template parameters.
 template <_RANGES input_range _Range, class _Alloc, enable_if_t<_Allocator_for_container<_Alloc>, int> = 0>
 flat_multiset(from_range_t, _Range&&, _Alloc)
     -> flat_multiset<_RANGES range_value_t<_Range>, less<_RANGES range_value_t<_Range>>,
         vector<_RANGES range_value_t<_Range>, _Rebind_alloc_t<_Alloc, _RANGES range_value_t<_Range>>>>;
+
 template <class _Kty, _Not_allocator_for_container _Compare = less<_Kty>>
 flat_multiset(initializer_list<_Kty>, _Compare = _Compare()) -> flat_multiset<_Kty, _Compare>;
 template <class _Kty, _Not_allocator_for_container _Compare = less<_Kty>>
diff --git a/tests/libcxx/expected_results.txt b/tests/libcxx/expected_results.txt
index d21b291e7ab..927d723c914 100644
--- a/tests/libcxx/expected_results.txt
+++ b/tests/libcxx/expected_results.txt
@@ -70,6 +70,10 @@ std/language.support/cmp/cmp.concept/three_way_comparable_with.compile.pass.cpp:
 # LLVM-176232: The implementation of P3567R2 "flat_meow Fixes" forgot to update `__cpp_lib_flat_set`
 std/language.support/support.limits/support.limits.general/flat_set.version.compile.pass.cpp FAIL
 
+# LLVM-178624: [libc++][test] flat_set tests have an EvilContainer that's too evil
+std/containers/container.adaptors/flat.multiset/flat.multiset.cons/move.pass.cpp FAIL
+std/containers/container.adaptors/flat.set/flat.set.cons/move.pass.cpp FAIL
+
 # Non-Standard regex behavior.
 # "It seems likely that the test is still non-conforming due to how libc++ handles the 'w' character class."
 std/re/re.traits/lookup_classname.pass.cpp FAIL
diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index 242a27d47ea..bc47cbae256 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -24,13 +24,12 @@
 
 using namespace std;
 
-enum class iterator_pair_construction : bool { no_allocator, with_allocator };
+enum class iterator_pair_construction : bool { allocator_first, allocator_last };
 
 template <class R, class T>
 concept container_compatible_range = ranges::input_range<R> && convertible_to<ranges::range_reference_t<R>, T>;
 
-template <class T, class Alloc = allocator<T>,
-    iterator_pair_construction Choice = iterator_pair_construction::with_allocator>
+template <class T, class Alloc, iterator_pair_construction Choice>
 class alternative_vector : private vector<T, Alloc> { // not allocator-aware, but can be uses-allocator constructed
 private:
     using base_type = vector<T, Alloc>;
@@ -51,23 +50,34 @@ class alternative_vector : private vector<T, Alloc> { // not allocator-aware, bu
 
     constexpr alternative_vector() noexcept(noexcept(Alloc())) : base_type(Alloc()) {}
     constexpr alternative_vector(allocator_arg_t, const Alloc& a) : base_type(a) {}
-    constexpr explicit alternative_vector(size_type n) : base_type(n) {}
+
     constexpr explicit alternative_vector(size_type n, const T& v) : base_type(n, v) {}
+    constexpr explicit alternative_vector(allocator_arg_t, const Alloc& a, size_type n, const T& v)
+        : base_type(n, v, a) {}
+
     template <class InputIt>
     constexpr explicit alternative_vector(InputIt first, InputIt last) : base_type(first, last) {}
     template <class InputIt>
-        requires (Choice == iterator_pair_construction::with_allocator)
+        requires (Choice == iterator_pair_construction::allocator_first)
     constexpr explicit alternative_vector(allocator_arg_t, const Alloc& a, InputIt first, InputIt last)
         : base_type(first, last, a) {}
+    template <class InputIt>
+        requires (Choice == iterator_pair_construction::allocator_last)
+    constexpr explicit alternative_vector(InputIt first, InputIt last, const Alloc& a) : base_type(first, last, a) {}
 
     template <container_compatible_range<T> R>
     constexpr explicit alternative_vector(from_range_t, R&& rg) : base_type(from_range, forward<R>(rg)) {}
+    template <container_compatible_range<T> R>
+    constexpr explicit alternative_vector(allocator_arg_t, const Alloc& a, from_range_t, R&& rg)
+        : base_type(from_range, forward<R>(rg), a) {}
 
     constexpr alternative_vector(allocator_arg_t, const type_identity_t<Alloc>& a, const alternative_vector& other)
         : base_type(other, a) {}
     constexpr alternative_vector(allocator_arg_t, const type_identity_t<Alloc>& a, alternative_vector&& other)
         : base_type(move(other), a) {}
+
     constexpr explicit alternative_vector(initializer_list<T> il) : base_type(il) {}
+    constexpr explicit alternative_vector(allocator_arg_t, const Alloc& a, initializer_list<T> il) : base_type(il, a) {}
 
     alternative_vector(const alternative_vector&) = default;
     alternative_vector(alternative_vector&&)      = default;
@@ -269,13 +279,12 @@ void test_allocator_extended_constructors() {
 
         TEST_ASSERT(fs{sorted_unique, v_sorted_unique, ator} == s_expected);
         TEST_ASSERT(fs{sorted_unique, v_sorted_unique, comp, ator} == s_expected);
-        if constexpr (Choice == iterator_pair_construction::with_allocator) {
-            TEST_ASSERT(fs{sorted_unique, {1, 3, 7, 85, 222}, ator} == s_expected);
-            TEST_ASSERT(fs{sorted_unique, {1, 3, 7, 85, 222}, comp, ator} == s_expected);
 
-            TEST_ASSERT(fs{sorted_unique, v_sorted_unique.begin(), v_sorted_unique.end(), ator} == s_expected);
-            TEST_ASSERT(fs{sorted_unique, v_sorted_unique.begin(), v_sorted_unique.end(), comp, ator} == s_expected);
-        }
+        TEST_ASSERT(fs{sorted_unique, {1, 3, 7, 85, 222}, ator} == s_expected);
+        TEST_ASSERT(fs{sorted_unique, {1, 3, 7, 85, 222}, comp, ator} == s_expected);
+
+        TEST_ASSERT(fs{sorted_unique, v_sorted_unique.begin(), v_sorted_unique.end(), ator} == s_expected);
+        TEST_ASSERT(fs{sorted_unique, v_sorted_unique.begin(), v_sorted_unique.end(), comp, ator} == s_expected);
     }
     {
         using fms = flat_multiset<int, less<int>, vec>;
@@ -305,13 +314,12 @@ void test_allocator_extended_constructors() {
 
         TEST_ASSERT(fms{sorted_equivalent, v_sorted_eq, ator} == s_expected);
         TEST_ASSERT(fms{sorted_equivalent, v_sorted_eq, comp, ator} == s_expected);
-        if constexpr (Choice == iterator_pair_construction::with_allocator) {
-            TEST_ASSERT(fms{sorted_equivalent, {1, 1, 3, 7, 85, 222}, ator} == s_expected);
-            TEST_ASSERT(fms{sorted_equivalent, {1, 1, 3, 7, 85, 222}, comp, ator} == s_expected);
 
-            TEST_ASSERT(fms{sorted_equivalent, v_sorted_eq.begin(), v_sorted_eq.end(), ator} == s_expected);
-            TEST_ASSERT(fms{sorted_equivalent, v_sorted_eq.begin(), v_sorted_eq.end(), comp, ator} == s_expected);
-        }
+        TEST_ASSERT(fms{sorted_equivalent, {1, 1, 3, 7, 85, 222}, ator} == s_expected);
+        TEST_ASSERT(fms{sorted_equivalent, {1, 1, 3, 7, 85, 222}, comp, ator} == s_expected);
+
+        TEST_ASSERT(fms{sorted_equivalent, v_sorted_eq.begin(), v_sorted_eq.end(), ator} == s_expected);
+        TEST_ASSERT(fms{sorted_equivalent, v_sorted_eq.begin(), v_sorted_eq.end(), comp, ator} == s_expected);
     }
 }
 
@@ -1346,8 +1354,8 @@ void run_normal_tests() {
 
     test_constructors<vector<int>>();
     test_constructors<deque<int>>();
-    test_allocator_extended_constructors<iterator_pair_construction::no_allocator>();
-    test_allocator_extended_constructors<iterator_pair_construction::with_allocator>();
+    test_allocator_extended_constructors<iterator_pair_construction::allocator_first>();
+    test_allocator_extended_constructors<iterator_pair_construction::allocator_last>();
 
     test_iterators_and_capacity<flat_set<int>>();
     test_iterators_and_capacity<flat_multiset<int>>();

From a89f3a73911213cbdb439194c8a1f8e562e96827 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Tue, 3 Feb 2026 11:27:37 -0800
Subject: [PATCH 123/134] `<flat_map>`, `<flat_set>`: Mega overhaul! (#6068)

---
 stl/debugger/STL.natvis                   |   7 +-
 stl/inc/flat_map                          | 714 +++++++++++-----------
 stl/inc/flat_set                          | 628 ++++++++++---------
 tests/std/tests/P0429R9_flat_map/test.cpp |   8 +-
 tests/std/tests/P1222R4_flat_set/test.cpp |  85 ++-
 5 files changed, 704 insertions(+), 738 deletions(-)

diff --git a/stl/debugger/STL.natvis b/stl/debugger/STL.natvis
index c61e29cf5e3..9c52f502797 100644
--- a/stl/debugger/STL.natvis
+++ b/stl/debugger/STL.natvis
@@ -1035,7 +1035,6 @@ SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
       </Expand>
   </Type>
 
-  <!-- VC 2015 -->
   <Type Name="std::deque&lt;*&gt;">
       <Intrinsic Name="size" Expression="_Mypair._Myval2._Mysize" />
       <DisplayString>{{ size={size()} }}</DisplayString>
@@ -2305,10 +2304,10 @@ SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
   <Type Name="std::flat_set&lt;*&gt;">
     <AlternativeType Name="std::flat_multiset&lt;*&gt;"/>
-    <DisplayString>{_Mycont}</DisplayString>
+    <DisplayString>{_Data}</DisplayString>
     <Expand>
-      <Item Name="[comparator]" ExcludeView="simple">_Mycomp</Item>
-      <ExpandedItem>_Mycont</ExpandedItem>
+      <Item Name="[comparator]" ExcludeView="simple">_Key_compare</Item>
+      <ExpandedItem>_Data</ExpandedItem>
     </Expand>
   </Type>
 
diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index b1f4b2f477e..7ab9517882c 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -63,7 +63,7 @@ struct _Pairing_iterator_provider {
         template <bool _IsUnique, class _Key, class _Mapped, class _Compare, class _KeyContainer,
             class _MappedContainer>
         friend class _Flat_map_base;
-        template <class _Key, class _Mapped, class _MappedConv>
+        template <class _KeyIter2, class _MappedIter2, class _MappedConvIter2>
         friend struct _Pairing_iterator_provider;
 
         _Iterator(_KeyIter _Key_iter, _MappedIter _Mapped_iter)
@@ -288,7 +288,18 @@ private:
     using _Derived  = conditional_t<_IsUnique, flat_map<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>,
          flat_multimap<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>>;
 
-    static constexpr const char* _Msg_not_sorted = _IsUnique ? "Keys were not sorted-unique!" : "Keys were not sorted!";
+    static constexpr const char* _Msg_not_sorted = //
+        _IsUnique ? "Keys were not sorted-unique! (N5032 [flat.map.overview]/10)"
+                  : "Keys were not sorted! (N5032 [flat.multimap.overview]/10)";
+    static constexpr const char* _Msg_replace_not_sorted =
+        _IsUnique ? "Keys were not sorted-unique! (N5032 [flat.map.modifiers]/37)"
+                  : "Keys were not sorted! (N5032 [flat.map.modifiers]/37, [flat.multimap.overview]/4)";
+    static constexpr const char* _Msg_different_sizes =
+        _IsUnique ? "Containers were different sizes! (N5032 [flat.map.overview]/9)"
+                  : "Containers were different sizes! (N5032 [flat.multimap.overview]/9)";
+    static constexpr const char* _Msg_replace_different_sizes =
+        _IsUnique ? "Containers were different sizes! (N5032 [flat.map.modifiers]/37)"
+                  : "Containers were different sizes! (N5032 [flat.map.modifiers]/37, [flat.multimap.overview]/4)";
 
 public:
     // [flat.map.defn] Types
@@ -333,8 +344,8 @@ public:
 
     class value_compare {
     public:
-        _NODISCARD bool operator()(const_reference _Left, const_reference _Right) const {
-            return _Key_comparator(_Left.first, _Right.first);
+        _NODISCARD bool operator()(const_reference _Lhs, const_reference _Rhs) const {
+            return _Key_comparator(_Lhs.first, _Rhs.first);
         }
 
     private:
@@ -367,26 +378,25 @@ public:
     _Flat_map_base(
         key_container_type _Key_cont, mapped_container_type _Mapped_cont, const key_compare& _Comp = key_compare())
         : _Data{.keys = _STD move(_Key_cont), .values = _STD move(_Mapped_cont)}, _Key_compare(_Comp) {
-        _STL_ASSERT(_Data.keys.size() == _Data.values.size(), "key_cont.size() != mapped_cont.size()");
-        _Make_invariants_fulfilled();
+        _STL_ASSERT(_Data.keys.size() == _Data.values.size(), _Msg_different_sizes);
+        _Establish_invariants();
     }
 
     _Flat_map_base(_Sorted_t, key_container_type _Key_cont, mapped_container_type _Mapped_cont,
         const key_compare& _Comp = key_compare())
         : _Data{.keys = _STD move(_Key_cont), .values = _STD move(_Mapped_cont)}, _Key_compare(_Comp) {
-        _STL_ASSERT(_Data.keys.size() == _Data.values.size(), "key_cont.size() != mapped_cont.size()");
+        _STL_ASSERT(_Data.keys.size() == _Data.values.size(), _Msg_different_sizes);
         _STL_ASSERT(_Is_sorted_and_unique(), _Msg_not_sorted);
     }
 
-    template <_Iterator_for_container _InputIterator>
-    _Flat_map_base(const _InputIterator _First, const _InputIterator _Last, const key_compare& _Comp = key_compare())
+    template <_Iterator_for_container _InIt>
+    _Flat_map_base(const _InIt _First, const _InIt _Last, const key_compare& _Comp = key_compare())
         : _Data(), _Key_compare(_Comp) {
         insert(_First, _Last);
     }
 
-    template <_Iterator_for_container _InputIterator>
-    _Flat_map_base(_Sorted_t _Tag, const _InputIterator _First, const _InputIterator _Last,
-        const key_compare& _Comp = key_compare())
+    template <_Iterator_for_container _InIt>
+    _Flat_map_base(_Sorted_t _Tag, const _InIt _First, const _InIt _Last, const key_compare& _Comp = key_compare())
         : _Data(), _Key_compare(_Comp) {
         insert(_Tag, _First, _Last);
     }
@@ -412,133 +422,123 @@ public:
     }
 
     // [flat.map.cons.alloc] Constructors with allocators
-    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
-    explicit _Flat_map_base(const _Allocator& _Alloc)
-        : _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Alloc),
-              .values = _STD make_obj_using_allocator<mapped_container_type>(_Alloc)},
+    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Alloc>
+    explicit _Flat_map_base(const _Alloc& _Al)
+        : _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Al),
+              .values = _STD make_obj_using_allocator<mapped_container_type>(_Al)},
           _Key_compare() {}
 
-    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
-    _Flat_map_base(const key_compare& _Comp, const _Allocator& _Alloc)
-        : _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Alloc),
-              .values = _STD make_obj_using_allocator<mapped_container_type>(_Alloc)},
+    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Alloc>
+    _Flat_map_base(const key_compare& _Comp, const _Alloc& _Al)
+        : _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Al),
+              .values = _STD make_obj_using_allocator<mapped_container_type>(_Al)},
           _Key_compare(_Comp) {}
 
-    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
-    _Flat_map_base(
-        const key_container_type& _Key_cont, const mapped_container_type& _Mapped_cont, const _Allocator& _Alloc)
-        : _Flat_map_base(_Key_cont, _Mapped_cont, key_compare(), _Alloc) {}
+    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Alloc>
+    _Flat_map_base(const key_container_type& _Key_cont, const mapped_container_type& _Mapped_cont, const _Alloc& _Al)
+        : _Flat_map_base(_Key_cont, _Mapped_cont, key_compare(), _Al) {}
 
-    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
+    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Alloc>
     _Flat_map_base(const key_container_type& _Key_cont, const mapped_container_type& _Mapped_cont,
-        const key_compare& _Comp, const _Allocator& _Alloc)
-        : _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Alloc, _Key_cont),
-              .values = _STD make_obj_using_allocator<mapped_container_type>(_Alloc, _Mapped_cont)},
+        const key_compare& _Comp, const _Alloc& _Al)
+        : _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Al, _Key_cont),
+              .values = _STD make_obj_using_allocator<mapped_container_type>(_Al, _Mapped_cont)},
           _Key_compare(_Comp) {
-        _STL_ASSERT(_Data.keys.size() == _Data.values.size(), "key_cont.size() != mapped_cont.size()");
-        _Make_invariants_fulfilled();
+        _STL_ASSERT(_Data.keys.size() == _Data.values.size(), _Msg_different_sizes);
+        _Establish_invariants();
     }
 
-    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
+    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Alloc>
     _Flat_map_base(_Sorted_t _Tag, const key_container_type& _Key_cont, const mapped_container_type& _Mapped_cont,
-        const _Allocator& _Alloc)
-        : _Flat_map_base(_Tag, _Key_cont, _Mapped_cont, key_compare(), _Alloc) {}
+        const _Alloc& _Al)
+        : _Flat_map_base(_Tag, _Key_cont, _Mapped_cont, key_compare(), _Al) {}
 
-    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
+    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Alloc>
     _Flat_map_base(_Sorted_t, const key_container_type& _Key_cont, const mapped_container_type& _Mapped_cont,
-        const key_compare& _Comp, const _Allocator& _Alloc)
-        : _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Alloc, _Key_cont),
-              .values = _STD make_obj_using_allocator<mapped_container_type>(_Alloc, _Mapped_cont)},
+        const key_compare& _Comp, const _Alloc& _Al)
+        : _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Al, _Key_cont),
+              .values = _STD make_obj_using_allocator<mapped_container_type>(_Al, _Mapped_cont)},
           _Key_compare(_Comp) {
-        _STL_ASSERT(_Data.keys.size() == _Data.values.size(), "key_cont.size() != mapped_cont.size()");
+        _STL_ASSERT(_Data.keys.size() == _Data.values.size(), _Msg_different_sizes);
         _STL_ASSERT(_Is_sorted_and_unique(), _Msg_not_sorted);
     }
 
-    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
-    _Flat_map_base(const _Flat_map_base& _Other, const _Allocator& _Alloc)
-        : _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Alloc, _Other._Data.keys),
-              .values = _STD make_obj_using_allocator<mapped_container_type>(_Alloc, _Other._Data.values)},
+    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Alloc>
+    _Flat_map_base(const _Flat_map_base& _Other, const _Alloc& _Al)
+        : _Data{.keys = _STD make_obj_using_allocator<key_container_type>(_Al, _Other._Data.keys),
+              .values = _STD make_obj_using_allocator<mapped_container_type>(_Al, _Other._Data.values)},
           _Key_compare(_Other._Key_compare) {}
 
 private:
-    template <class _Allocator>
-    _NODISCARD containers _Extract_using_allocator(const _Allocator& _Alloc) && {
+    template <class _Alloc>
+    _NODISCARD containers _Extract_using_allocator(const _Alloc& _Al) && {
         _Clear_guard _Always_clear{this};
-        return containers{.keys = _STD make_obj_using_allocator<key_container_type>(_Alloc, _STD move(_Data.keys)),
-            .values = _STD make_obj_using_allocator<mapped_container_type>(_Alloc, _STD move(_Data.values))};
+        return containers{.keys = _STD make_obj_using_allocator<key_container_type>(_Al, _STD move(_Data.keys)),
+            .values             = _STD make_obj_using_allocator<mapped_container_type>(_Al, _STD move(_Data.values))};
     }
 
 public:
-    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
-    _Flat_map_base(_Flat_map_base&& _Other, const _Allocator& _Alloc)
-        : _Data{_STD move(_Other)._Extract_using_allocator(_Alloc)},
+    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Alloc>
+    _Flat_map_base(_Flat_map_base&& _Other, const _Alloc& _Al)
+        : _Data{_STD move(_Other)._Extract_using_allocator(_Al)},
           _Key_compare(_Other._Key_compare) // intentionally copy comparator, see LWG-2227
     {}
 
-    template <_Iterator_for_container _InputIterator,
-        _Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
-    _Flat_map_base(const _InputIterator _First, const _InputIterator _Last, const _Allocator& _Alloc)
-        : _Flat_map_base(_Alloc) {
+    template <_Iterator_for_container _InIt, _Usable_allocator_for<key_container_type, mapped_container_type> _Alloc>
+    _Flat_map_base(const _InIt _First, const _InIt _Last, const _Alloc& _Al) : _Flat_map_base(_Al) {
         insert(_First, _Last);
     }
 
-    template <_Iterator_for_container _InputIterator,
-        _Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
-    _Flat_map_base(
-        const _InputIterator _First, const _InputIterator _Last, const key_compare& _Comp, const _Allocator& _Alloc)
-        : _Flat_map_base(_Comp, _Alloc) {
+    template <_Iterator_for_container _InIt, _Usable_allocator_for<key_container_type, mapped_container_type> _Alloc>
+    _Flat_map_base(const _InIt _First, const _InIt _Last, const key_compare& _Comp, const _Alloc& _Al)
+        : _Flat_map_base(_Comp, _Al) {
         insert(_First, _Last);
     }
 
-    template <_Iterator_for_container _InputIterator,
-        _Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
-    _Flat_map_base(_Sorted_t _Tag, const _InputIterator _First, const _InputIterator _Last, const _Allocator& _Alloc)
-        : _Flat_map_base(_Alloc) {
+    template <_Iterator_for_container _InIt, _Usable_allocator_for<key_container_type, mapped_container_type> _Alloc>
+    _Flat_map_base(_Sorted_t _Tag, const _InIt _First, const _InIt _Last, const _Alloc& _Al) : _Flat_map_base(_Al) {
         insert(_Tag, _First, _Last);
     }
 
-    template <_Iterator_for_container _InputIterator,
-        _Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
-    _Flat_map_base(_Sorted_t _Tag, const _InputIterator _First, const _InputIterator _Last, const key_compare& _Comp,
-        const _Allocator& _Alloc)
-        : _Flat_map_base(_Comp, _Alloc) {
+    template <_Iterator_for_container _InIt, _Usable_allocator_for<key_container_type, mapped_container_type> _Alloc>
+    _Flat_map_base(_Sorted_t _Tag, const _InIt _First, const _InIt _Last, const key_compare& _Comp, const _Alloc& _Al)
+        : _Flat_map_base(_Comp, _Al) {
         insert(_Tag, _First, _Last);
     }
 
     template <_Container_compatible_range<value_type> _Rng,
-        _Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
-    _Flat_map_base(from_range_t, _Rng&& _Range, const _Allocator& _Alloc) : _Flat_map_base(_Alloc) {
+        _Usable_allocator_for<key_container_type, mapped_container_type> _Alloc>
+    _Flat_map_base(from_range_t, _Rng&& _Range, const _Alloc& _Al) : _Flat_map_base(_Al) {
         insert_range(_STD forward<_Rng>(_Range));
     }
 
     template <_Container_compatible_range<value_type> _Rng,
-        _Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
-    _Flat_map_base(from_range_t, _Rng&& _Range, const key_compare& _Comp, const _Allocator& _Alloc)
-        : _Flat_map_base(_Comp, _Alloc) {
+        _Usable_allocator_for<key_container_type, mapped_container_type> _Alloc>
+    _Flat_map_base(from_range_t, _Rng&& _Range, const key_compare& _Comp, const _Alloc& _Al)
+        : _Flat_map_base(_Comp, _Al) {
         insert_range(_STD forward<_Rng>(_Range));
     }
 
-    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
-    _Flat_map_base(const initializer_list<value_type> _Ilist, const _Allocator& _Alloc) : _Flat_map_base(_Alloc) {
+    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Alloc>
+    _Flat_map_base(const initializer_list<value_type> _Ilist, const _Alloc& _Al) : _Flat_map_base(_Al) {
         insert(_Ilist);
     }
 
-    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
-    _Flat_map_base(const initializer_list<value_type> _Ilist, const key_compare& _Comp, const _Allocator& _Alloc)
-        : _Flat_map_base(_Comp, _Alloc) {
+    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Alloc>
+    _Flat_map_base(const initializer_list<value_type> _Ilist, const key_compare& _Comp, const _Alloc& _Al)
+        : _Flat_map_base(_Comp, _Al) {
         insert(_Ilist);
     }
 
-    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
-    _Flat_map_base(_Sorted_t _Tag, const initializer_list<value_type> _Ilist, const _Allocator& _Alloc)
-        : _Flat_map_base(_Alloc) {
+    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Alloc>
+    _Flat_map_base(_Sorted_t _Tag, const initializer_list<value_type> _Ilist, const _Alloc& _Al) : _Flat_map_base(_Al) {
         insert(_Tag, _Ilist);
     }
 
-    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Allocator>
+    template <_Usable_allocator_for<key_container_type, mapped_container_type> _Alloc>
     _Flat_map_base(
-        _Sorted_t _Tag, const initializer_list<value_type> _Ilist, const key_compare& _Comp, const _Allocator& _Alloc)
-        : _Flat_map_base(_Comp, _Alloc) {
+        _Sorted_t _Tag, const initializer_list<value_type> _Ilist, const key_compare& _Comp, const _Alloc& _Al)
+        : _Flat_map_base(_Comp, _Al) {
         insert(_Tag, _Ilist);
     }
 
@@ -638,40 +638,40 @@ public:
         return _Emplace_hint<false>(_Position, _STD move(_Val.first), _STD move(_Val.second));
     }
 
-    auto insert(const value_type& _Pair_val) {
-        return _Try_emplace(_Pair_val.first, _Pair_val.second);
+    auto insert(const value_type& _Val) {
+        return _Try_emplace(_Val.first, _Val.second);
     }
-    auto insert(value_type&& _Pair_val) {
-        return _Try_emplace(_STD move(_Pair_val.first), _STD move(_Pair_val.second));
+    auto insert(value_type&& _Val) {
+        return _Try_emplace(_STD move(_Val.first), _STD move(_Val.second));
     }
 
-    iterator insert(const const_iterator _Position, const value_type& _Pair_val) {
-        return emplace_hint(_Position, _Pair_val);
+    iterator insert(const const_iterator _Position, const value_type& _Val) {
+        return _Emplace_hint<false>(_Position, _Val.first, _Val.second);
     }
-    iterator insert(const const_iterator _Position, value_type&& _Pair_val) {
-        return emplace_hint(_Position, _STD move(_Pair_val));
+    iterator insert(const const_iterator _Position, value_type&& _Val) {
+        return _Emplace_hint<false>(_Position, _STD move(_Val.first), _STD move(_Val.second));
     }
 
-    template <class _PairValTy>
-    auto insert(_PairValTy&& _Pair_val)
-        requires is_constructible_v<value_type, _PairValTy>
+    template <class _OtherPair>
+    auto insert(_OtherPair&& _Val)
+        requires is_constructible_v<value_type, _OtherPair>
     {
-        return emplace(_STD forward<_PairValTy>(_Pair_val));
+        return emplace(_STD forward<_OtherPair>(_Val));
     }
 
-    template <class _PairValTy>
-    iterator insert(const const_iterator _Position, _PairValTy&& _Pair_val)
-        requires is_constructible_v<value_type, _PairValTy>
+    template <class _OtherPair>
+    iterator insert(const const_iterator _Position, _OtherPair&& _Val)
+        requires is_constructible_v<value_type, _OtherPair>
     {
-        return emplace_hint(_Position, _STD forward<_PairValTy>(_Pair_val));
+        return emplace_hint(_Position, _STD forward<_OtherPair>(_Val));
     }
 
-    template <_Iterator_for_container _InputIterator>
-    void insert(const _InputIterator _First, const _InputIterator _Last) {
+    template <_Iterator_for_container _InIt>
+    void insert(const _InIt _First, const _InIt _Last) {
         _Insert_range<true>(_First, _Last);
     }
-    template <_Iterator_for_container _InputIterator>
-    void insert(_Sorted_t, const _InputIterator _First, const _InputIterator _Last) {
+    template <_Iterator_for_container _InIt>
+    void insert(_Sorted_t, const _InIt _First, const _InIt _Last) {
         _Insert_range<false>(_First, _Last);
     }
 
@@ -700,8 +700,8 @@ public:
     }
 
     void replace(key_container_type&& _Key_cont, mapped_container_type&& _Mapped_cont) {
-        _STL_ASSERT(_Key_cont.size() == _Mapped_cont.size(), "key_cont.size() != mapped_cont.size()");
-        _STL_ASSERT(_Is_sorted_and_unique(_Key_cont.begin(), _Key_cont.end()), _Msg_not_sorted);
+        _STL_ASSERT(_Key_cont.size() == _Mapped_cont.size(), _Msg_replace_different_sizes);
+        _STL_ASSERT(_Is_sorted_and_unique(_Key_cont.begin(), _Key_cont.end()), _Msg_replace_not_sorted);
         _Clear_guard _Guard{this};
         _Data.keys     = _STD move(_Key_cont);
         _Data.values   = _STD move(_Mapped_cont);
@@ -873,19 +873,17 @@ public:
         return _Equal_range(_Key_val);
     }
 
-    _NODISCARD friend bool operator==(const _Derived& _Left, const _Derived& _Right) {
-        return _STD equal(_STD _Get_unwrapped(_Left.cbegin()), _STD _Get_unwrapped(_Left.cend()),
-            _STD _Get_unwrapped(_Right.cbegin()), _STD _Get_unwrapped(_Right.cend()));
+    _NODISCARD friend bool operator==(const _Derived& _Lhs, const _Derived& _Rhs) {
+        return _STD equal(_Lhs.cbegin(), _Lhs.cend(), _Rhs.cbegin(), _Rhs.cend());
     }
 
-    _NODISCARD friend auto operator<=>(const _Derived& _Left, const _Derived& _Right) {
-        return _STD lexicographical_compare_three_way(_STD _Get_unwrapped(_Left.cbegin()),
-            _STD _Get_unwrapped(_Left.cend()), _STD _Get_unwrapped(_Right.cbegin()), _STD _Get_unwrapped(_Right.cend()),
-            _Synth_three_way{});
+    _NODISCARD friend auto operator<=>(const _Derived& _Lhs, const _Derived& _Rhs) {
+        return _STD lexicographical_compare_three_way(
+            _Lhs.cbegin(), _Lhs.cend(), _Rhs.cbegin(), _Rhs.cend(), _Synth_three_way{});
     }
 
-    friend void swap(_Derived& _Left, _Derived& _Right) noexcept(noexcept(_Left.swap(_Right))) {
-        _Left.swap(_Right);
+    friend void swap(_Derived& _Lhs, _Derived& _Rhs) noexcept(noexcept(_Lhs.swap(_Rhs))) {
+        _Lhs.swap(_Rhs);
     }
 
 protected:
@@ -994,43 +992,6 @@ protected:
         return begin() + _Dist;
     }
 
-private:
-    void _Insert_exact(const const_iterator _Position, key_type&& _Key_val, mapped_type&& _Mapped_val) {
-        _Clear_guard _Guard{this};
-        _Data.keys.insert(_Position._Key_it, _STD move(_Key_val));
-        _Data.values.insert(_Position._Mapped_it, _STD move(_Mapped_val));
-        _Guard._Target = nullptr;
-    }
-
-    // size_type is always size_t
-    template <class _KTy, class _MTy, class _Comp, class _KeyCont, class _MappedCont, class _Pred>
-    friend size_t erase_if(flat_map<_KTy, _MTy, _Comp, _KeyCont, _MappedCont>&, _Pred);
-    template <class _KTy, class _MTy, class _Comp, class _KeyCont, class _MappedCont, class _Pred>
-    friend size_t erase_if(flat_multimap<_KTy, _MTy, _Comp, _KeyCont, _MappedCont>&, _Pred);
-
-    template <class _Predicate>
-    _NODISCARD size_t _Erase_if(_Predicate _Pred) {
-        _Clear_guard _Guard{this};
-
-        // N5032 [flat.map.erasure]/2 and [flat.multimap.erasure]/2
-        const auto _Proj     = [](const auto& _Element) _STATIC_CALL_OPERATOR { return const_reference{_Element}; };
-        const auto _New_last = _RANGES remove_if(_View_to_mutate(), _Pred, _Proj).begin();
-        const auto _Old_size = size();
-
-        _Data.keys.erase(_New_last._Key_it, _Data.keys.end());
-        _Data.values.erase(_New_last._Mapped_it, _Data.values.end());
-
-        _Guard._Target = nullptr;
-        return _Old_size - size();
-    }
-
-    _NODISCARD auto _View_to_mutate() {
-        using _Mutating_iterator = _Pairing_iterator_provider<typename key_container_type::iterator,
-            typename mapped_container_type::iterator, typename mapped_container_type::iterator>::_Iterator;
-        return _RANGES subrange<_Mutating_iterator>{_Mutating_iterator{_Data.keys.begin(), _Data.values.begin()},
-            _Mutating_iterator{_Data.keys.end(), _Data.values.end()}};
-    }
-
 #ifdef _ENABLE_STL_INTERNAL_CHECK
 public:
 #else
@@ -1052,70 +1013,94 @@ private:
         }
     }
 
+    _NODISCARD auto _View_to_mutate() {
+        using _Mutating_iterator = _Pairing_iterator_provider<typename key_container_type::iterator,
+            typename mapped_container_type::iterator, typename mapped_container_type::iterator>::_Iterator;
+        return _RANGES subrange<_Mutating_iterator>{_Mutating_iterator{_Data.keys.begin(), _Data.values.begin()},
+            _Mutating_iterator{_Data.keys.end(), _Data.values.end()}};
+    }
+
     struct _Value_compare_to_pass {
-        static constexpr bool _Efficiently_copyable = conjunction_v<bool_constant<sizeof(_Compare) <= sizeof(void*)>,
-            is_trivially_copy_constructible<_Compare>, is_trivially_destructible<_Compare>>;
+        static constexpr bool _Efficiently_copyable = conjunction_v<bool_constant<sizeof(key_compare) <= sizeof(void*)>,
+            is_trivially_copy_constructible<key_compare>, is_trivially_destructible<key_compare>>;
 
-        using _Copy_or_ref = conditional_t<_Efficiently_copyable, _Compare, const _Compare&>;
+        using _Copy_or_ref = conditional_t<_Efficiently_copyable, key_compare, const key_compare&>;
 
         _Copy_or_ref _Key_comparator;
 
         template <class _Pair1, class _Pair2>
-        _NODISCARD bool operator()(const _Pair1& _Left, const _Pair2& _Right) const {
-            return _Key_comparator(_Left.first, _Right.first);
+        _NODISCARD bool operator()(const _Pair1& _Lhs, const _Pair2& _Rhs) const {
+            return _Key_comparator(_Lhs.first, _Rhs.first);
         }
     };
 
-    void _Make_invariants_fulfilled() {
-        if (empty()) {
-            return;
+    _NODISCARD auto _Erase_dupes_if_not_multi_pred() {
+        _STL_INTERNAL_STATIC_ASSERT(_IsUnique);
+        if constexpr (_Equivalence_is_equality<key_compare, key_type>) {
+            return [](const auto& _Lhs, const auto& _Rhs) _STATIC_CALL_OPERATOR { return _Lhs.first == _Rhs.first; };
+        } else {
+            return [this](const auto& _Lhs, const auto& _Rhs) {
+#ifdef __clang__ // TRANSITION, LLVM-81243
+                return !this->_Compare_keys(_Lhs.first, _Rhs.first);
+#else // ^^^ workaround / no workaround vvv
+                return !_Compare_keys(_Lhs.first, _Rhs.first);
+#endif // ^^^ no workaround ^^^
+            };
         }
+    }
 
-        // O(N) if already sorted.
-        const auto _Num_sorted =
-            _STD is_sorted_until(_Data.keys.begin(), _Data.keys.end(), _Pass_key_comp()) - _Data.keys.begin();
-
-        auto _View                        = _View_to_mutate();
-        const auto _Begin_unsorted_values = _View.begin() + _Num_sorted;
-
-        _RANGES sort(_Begin_unsorted_values, _View.end(), _Value_compare_to_pass{_Key_compare});
-        _RANGES inplace_merge(_View, _Begin_unsorted_values, _Value_compare_to_pass{_Key_compare});
-
-        _Erase_dupes_if_not_multi();
+    template <bool _NeedSorting>
+    void _Restore_invariants(const size_type _Old_size) {
+        // No _Clear_guard needed. This is called only by _Insert_range() (which has a _Clear_guard)
+        // and _Establish_invariants() (which is called only by constructors which don't need guards).
 
-        _STL_INTERNAL_CHECK(_Is_sorted_and_unique());
-    }
+        auto _View          = _View_to_mutate();
+        const auto _Begin   = _View.begin();
+        const auto _Old_end = _Begin + static_cast<difference_type>(_Old_size);
+        const auto _End     = _View.end();
 
-    auto _Erase_dupes_if_not_multi_pred() {
-        _STL_INTERNAL_STATIC_ASSERT(_IsUnique);
-        if constexpr (_Equivalence_is_equality<_Compare, _Key>) {
-            return [](const auto& _Left, const auto& _Right)
-                       _STATIC_CALL_OPERATOR { return _Left.first == _Right.first; };
+        if constexpr (_NeedSorting) {
+            _RANGES sort(_Old_end, _End, _Value_compare_to_pass{_Key_compare});
         } else {
-            return [this](const auto& _Left, const auto& _Right) {
-                // TRANSITION, not yet reported: `this->` avoids spurious -Wunused-lambda-capture warning with Clang 20
-                return !this->_Compare_keys(_Left.first, _Right.first);
-            };
+            [[maybe_unused]] const auto _Diff = static_cast<key_container_type::difference_type>(_Old_size);
+            _STL_ASSERT(_Is_sorted_and_unique(_Data.keys.begin() + _Diff, _Data.keys.end()), _Msg_not_sorted);
         }
-    }
 
-    void _Erase_dupes_if_not_multi() {
-        if constexpr (_IsUnique) {
-            // No _Clear_guard needed. The only callers are _Insert_range() (which has a _Clear_guard)
-            // and _Make_invariants_fulfilled() (which is called only by constructors).
-            auto _Sorted_view    = _View_to_mutate();
-            const auto _New_last = _RANGES unique(_Sorted_view, _Erase_dupes_if_not_multi_pred()).begin();
+        _RANGES inplace_merge(_View, _Old_end, _Value_compare_to_pass{_Key_compare});
 
+        if constexpr (_IsUnique) {
+            const auto _New_last = _RANGES unique(_View, _Erase_dupes_if_not_multi_pred()).begin();
             _Data.keys.erase(_New_last._Key_it, _Data.keys.end());
             _Data.values.erase(_New_last._Mapped_it, _Data.values.end());
         }
+
+        _STL_INTERNAL_CHECK(_Is_sorted_and_unique());
+    }
+
+    void _Establish_invariants() {
+        if (_Data.keys.empty()) {
+            return;
+        }
+
+        const auto _Begin        = _Data.keys.begin();
+        const auto _End          = _Data.keys.end();
+        const auto _Sorted_until = _STD is_sorted_until(_Begin, _End, _Pass_key_comp()); // O(N) if already sorted.
+        const auto _Sorted_size  = static_cast<size_type>(_Sorted_until - _Begin);
+        _Restore_invariants<true>(_Sorted_size);
     }
 
-    template <bool _NeedSorting, class _InputIterator, class _Sentinel>
-    void _Insert_range(_InputIterator _First, const _Sentinel _Last) {
+    void _Insert_exact(const const_iterator _Position, key_type&& _Key_val, mapped_type&& _Mapped_val) {
         _Clear_guard _Guard{this};
+        _Data.keys.insert(_Position._Key_it, _STD move(_Key_val));
+        _Data.values.insert(_Position._Mapped_it, _STD move(_Mapped_val));
+        _Guard._Target = nullptr;
+    }
+
+    template <bool _NeedSorting, class _InIt, class _Sentinel>
+    void _Insert_range(_InIt _First, const _Sentinel _Last) {
+        const size_type _Old_size = size();
 
-        const auto _Old_distance = static_cast<difference_type>(size());
+        _Clear_guard _Guard{this};
 
         // Insert the new elements at the end
         for (; _First != _Last; ++_First) {
@@ -1133,35 +1118,44 @@ private:
             }
         }
 
-        // Sort the newly inserted elements
-        auto _Sorted_view = _View_to_mutate();
-        if constexpr (_NeedSorting) {
-            _RANGES sort(
-                _Sorted_view.begin() + _Old_distance, _Sorted_view.end(), _Value_compare_to_pass{_Key_compare});
-        } else {
-            _STL_ASSERT(_Is_sorted_and_unique(
-                            _Data.keys.begin() + static_cast<key_container_type::difference_type>(_Old_distance),
-                            _Data.keys.end()),
-                _Msg_not_sorted);
-        }
-
-        // Merge the newly inserted elements with the existing elements
-        _RANGES inplace_merge(_Sorted_view, _Sorted_view.begin() + _Old_distance, _Value_compare_to_pass{_Key_compare});
-
-        _Erase_dupes_if_not_multi();
-        _STL_INTERNAL_CHECK(_Is_sorted_and_unique());
+        _Restore_invariants<_NeedSorting>(_Old_size);
 
         _Guard._Target = nullptr;
     }
 
     template <class _KeyTy>
-    _NODISCARD size_type _Erase_key(_KeyTy&& _Key_val) {
-        const auto _Equal_pos = equal_range(_STD forward<_KeyTy>(_Key_val));
+    _NODISCARD size_type _Erase_key(const _KeyTy& _Key_val) {
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
+        const auto _Equal_pos = _Equal_range(_Key_val);
         const auto _Count     = static_cast<size_type>(_Equal_pos.second - _Equal_pos.first);
         erase(_Equal_pos.first, _Equal_pos.second);
         return _Count;
     }
 
+    // size_type is always size_t
+    template <class _Key2, class _Mapped2, class _Compare2, class _KeyContainer2, class _MappedContainer2,
+        class _Predicate2>
+    friend size_t erase_if(flat_map<_Key2, _Mapped2, _Compare2, _KeyContainer2, _MappedContainer2>&, _Predicate2);
+    template <class _Key2, class _Mapped2, class _Compare2, class _KeyContainer2, class _MappedContainer2,
+        class _Predicate2>
+    friend size_t erase_if(flat_multimap<_Key2, _Mapped2, _Compare2, _KeyContainer2, _MappedContainer2>&, _Predicate2);
+
+    template <class _Predicate>
+    _NODISCARD size_t _Erase_if(_Predicate _Pred) {
+        _Clear_guard _Guard{this};
+
+        // N5032 [flat.map.erasure]/2 and [flat.multimap.erasure]/2
+        const auto _Proj     = [](const auto& _Element) _STATIC_CALL_OPERATOR { return const_reference{_Element}; };
+        const auto _New_last = _RANGES remove_if(_View_to_mutate(), _Pred, _Proj).begin();
+        const auto _Old_size = size();
+
+        _Data.keys.erase(_New_last._Key_it, _Data.keys.end());
+        _Data.values.erase(_New_last._Mapped_it, _Data.values.end());
+
+        _Guard._Target = nullptr;
+        return _Old_size - size();
+    }
+
     template <class _SelfTy, class _KeyTy>
     _NODISCARD auto _Find(this _SelfTy& _Self, const _KeyTy& _Key_val) {
         _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
@@ -1232,7 +1226,7 @@ private:
     _NODISCARD bool _Compare_keys(const _Lty& _Lhs, const _Rty& _Rhs) const
         noexcept(noexcept(_DEBUG_LT_PRED(_Key_compare, _Lhs, _Rhs))) {
         _STL_INTERNAL_STATIC_ASSERT(
-            _Transparent<key_compare> || (is_same_v<key_type, _Lty> && is_same_v<key_type, _Rty>) );
+            (is_same_v<_Lty, key_type> && is_same_v<_Rty, key_type>) || _Transparent<key_compare>);
 
         return _DEBUG_LT_PRED(_Key_compare, _Lhs, _Rhs);
     }
@@ -1262,14 +1256,6 @@ public:
     using typename _Mybase::mapped_type;
     using typename _Mybase::value_type;
 
-#if 1 // TRANSITION, P2582R1 (MSVC, Clang, EDG)
-    template <_Usable_allocator_for<_KeyContainer, _MappedContainer> _Allocator>
-    flat_map(const flat_map& _Other, const _Allocator& _Al) : _Mybase(_Other, _Al) {}
-
-    template <_Usable_allocator_for<_KeyContainer, _MappedContainer> _Allocator>
-    flat_map(flat_map&& _Other, const _Allocator& _Al) : _Mybase(_STD move(_Other), _Al) {}
-#endif // ^^^ workaround ^^^
-
     flat_map& operator=(const flat_map&) = default;
     flat_map& operator=(flat_map&&)      = default;
 
@@ -1319,13 +1305,13 @@ public:
 
     // [flat.map.modifiers] Modifiers
     template <class... _MappedArgTypes>
-        requires is_constructible_v<mapped_type, _MappedArgTypes&&...>
+        requires is_constructible_v<mapped_type, _MappedArgTypes...>
     pair<iterator, bool> try_emplace(const key_type& _Key_val, _MappedArgTypes&&... _Mapped_args) {
         return this->_Try_emplace(_Key_val, _STD forward<_MappedArgTypes>(_Mapped_args)...);
     }
 
     template <class... _MappedArgTypes>
-        requires is_constructible_v<mapped_type, _MappedArgTypes&&...>
+        requires is_constructible_v<mapped_type, _MappedArgTypes...>
     pair<iterator, bool> try_emplace(key_type&& _Key_val, _MappedArgTypes&&... _Mapped_args) {
         return this->_Try_emplace(_STD move(_Key_val), _STD forward<_MappedArgTypes>(_Mapped_args)...);
     }
@@ -1347,7 +1333,7 @@ public:
 
     template <class... _MappedArgTypes>
     iterator try_emplace(const const_iterator _Position, key_type&& _Key_val, _MappedArgTypes&&... _Mapped_args)
-        requires is_constructible_v<mapped_type, _MappedArgTypes&&...>
+        requires is_constructible_v<mapped_type, _MappedArgTypes...>
     {
         return this->template _Emplace_hint<false>(
             _Position, _STD move(_Key_val), _STD forward<_MappedArgTypes>(_Mapped_args)...);
@@ -1356,55 +1342,56 @@ public:
     template <class _OtherKey, class... _MappedArgTypes>
     iterator try_emplace(const const_iterator _Position, _OtherKey&& _Key_val, _MappedArgTypes&&... _Mapped_args)
         requires _Transparent<key_compare> && is_constructible_v<key_type, _OtherKey>
-              && is_constructible_v<mapped_type, _MappedArgTypes&&...>
+              && is_constructible_v<mapped_type, _MappedArgTypes...>
     {
         return this->template _Emplace_hint<false>(
             _Position, _STD forward<_OtherKey>(_Key_val), _STD forward<_MappedArgTypes>(_Mapped_args)...);
     }
 
-    template <class _MappedTy>
-    pair<iterator, bool> insert_or_assign(const key_type& _Key_val, _MappedTy&& _Mapped_val)
-        requires is_assignable_v<mapped_type&, _MappedTy> && is_constructible_v<mapped_type, _MappedTy>
+    template <class _OtherMapped>
+    pair<iterator, bool> insert_or_assign(const key_type& _Key_val, _OtherMapped&& _Mapped_val)
+        requires is_assignable_v<mapped_type&, _OtherMapped> && is_constructible_v<mapped_type, _OtherMapped>
     {
-        return _Insert_or_assign(_Key_val, _STD forward<_MappedTy>(_Mapped_val));
+        return _Insert_or_assign(_Key_val, _STD forward<_OtherMapped>(_Mapped_val));
     }
 
-    template <class _MappedTy>
-    pair<iterator, bool> insert_or_assign(key_type&& _Key_val, _MappedTy&& _Mapped_val)
-        requires is_assignable_v<mapped_type&, _MappedTy> && is_constructible_v<mapped_type, _MappedTy>
+    template <class _OtherMapped>
+    pair<iterator, bool> insert_or_assign(key_type&& _Key_val, _OtherMapped&& _Mapped_val)
+        requires is_assignable_v<mapped_type&, _OtherMapped> && is_constructible_v<mapped_type, _OtherMapped>
     {
-        return _Insert_or_assign(_STD move(_Key_val), _STD forward<_MappedTy>(_Mapped_val));
+        return _Insert_or_assign(_STD move(_Key_val), _STD forward<_OtherMapped>(_Mapped_val));
     }
 
-    template <class _OtherKey, class _MappedTy>
-    pair<iterator, bool> insert_or_assign(_OtherKey&& _Key_val, _MappedTy&& _Mapped_val)
+    template <class _OtherKey, class _OtherMapped>
+    pair<iterator, bool> insert_or_assign(_OtherKey&& _Key_val, _OtherMapped&& _Mapped_val)
         requires _Transparent<key_compare> && is_constructible_v<key_type, _OtherKey>
-              && is_assignable_v<mapped_type&, _MappedTy> && is_constructible_v<mapped_type, _MappedTy>
+              && is_assignable_v<mapped_type&, _OtherMapped> && is_constructible_v<mapped_type, _OtherMapped>
     {
-        return _Insert_or_assign(_STD forward<_OtherKey>(_Key_val), _STD forward<_MappedTy>(_Mapped_val));
+        return _Insert_or_assign(_STD forward<_OtherKey>(_Key_val), _STD forward<_OtherMapped>(_Mapped_val));
     }
 
-    template <class _MappedTy>
-    iterator insert_or_assign(const const_iterator _Position, const key_type& _Key_val, _MappedTy&& _Mapped_val)
-        requires is_assignable_v<mapped_type&, _MappedTy> && is_constructible_v<mapped_type, _MappedTy>
+    template <class _OtherMapped>
+    iterator insert_or_assign(const const_iterator _Position, const key_type& _Key_val, _OtherMapped&& _Mapped_val)
+        requires is_assignable_v<mapped_type&, _OtherMapped> && is_constructible_v<mapped_type, _OtherMapped>
     {
-        return this->template _Emplace_hint<true>(_Position, _Key_val, _STD forward<_MappedTy>(_Mapped_val));
+        return this->template _Emplace_hint<true>(_Position, _Key_val, _STD forward<_OtherMapped>(_Mapped_val));
     }
 
-    template <class _MappedTy>
-    iterator insert_or_assign(const const_iterator _Position, key_type&& _Key_val, _MappedTy&& _Mapped_val)
-        requires is_assignable_v<mapped_type&, _MappedTy> && is_constructible_v<mapped_type, _MappedTy>
+    template <class _OtherMapped>
+    iterator insert_or_assign(const const_iterator _Position, key_type&& _Key_val, _OtherMapped&& _Mapped_val)
+        requires is_assignable_v<mapped_type&, _OtherMapped> && is_constructible_v<mapped_type, _OtherMapped>
     {
-        return this->template _Emplace_hint<true>(_Position, _STD move(_Key_val), _STD forward<_MappedTy>(_Mapped_val));
+        return this->template _Emplace_hint<true>(
+            _Position, _STD move(_Key_val), _STD forward<_OtherMapped>(_Mapped_val));
     }
 
-    template <class _OtherKey, class _MappedTy>
-    iterator insert_or_assign(const const_iterator _Position, _OtherKey&& _Key_val, _MappedTy&& _Mapped_val)
+    template <class _OtherKey, class _OtherMapped>
+    iterator insert_or_assign(const const_iterator _Position, _OtherKey&& _Key_val, _OtherMapped&& _Mapped_val)
         requires _Transparent<key_compare> && is_constructible_v<key_type, _OtherKey>
-              && is_assignable_v<mapped_type&, _MappedTy> && is_constructible_v<mapped_type, _MappedTy>
+              && is_assignable_v<mapped_type&, _OtherMapped> && is_constructible_v<mapped_type, _OtherMapped>
     {
         return this->template _Emplace_hint<true>(
-            _Position, _STD forward<_OtherKey>(_Key_val), _STD forward<_MappedTy>(_Mapped_val));
+            _Position, _STD forward<_OtherKey>(_Key_val), _STD forward<_OtherMapped>(_Mapped_val));
     }
 
 private:
@@ -1419,30 +1406,70 @@ private:
         return _Position->second;
     }
 
-    template <class _KeyTy, class _MappedTy>
-    _NODISCARD pair<iterator, bool> _Insert_or_assign(_KeyTy&& _Key_val, _MappedTy&& _Mapped_val) {
-        auto _Res = this->_Try_emplace(_STD forward<_KeyTy>(_Key_val), _STD forward<_MappedTy>(_Mapped_val));
+    template <class _KeyTy, class _OtherMapped>
+    _NODISCARD pair<iterator, bool> _Insert_or_assign(_KeyTy&& _Key_val, _OtherMapped&& _Mapped_val) {
+        auto _Res = this->_Try_emplace(_STD forward<_KeyTy>(_Key_val), _STD forward<_OtherMapped>(_Mapped_val));
         if (!_Res.second) { // Already exists
-            _Res.first->second = _STD forward<_MappedTy>(_Mapped_val);
+            _Res.first->second = _STD forward<_OtherMapped>(_Mapped_val);
         }
         return _Res;
     }
 };
 
+_EXPORT_STD template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer>
+class flat_multimap : public _Flat_map_base<false, _Key, _Mapped, _Compare, _KeyContainer, _MappedContainer> {
+private:
+    using _Mybase = _Flat_map_base<false, _Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>;
+
+public:
+    using typename _Mybase::value_type;
+
+    using _Mybase::_Mybase;
+    flat_multimap(const flat_multimap&) = default;
+    flat_multimap(flat_multimap&&)      = default;
+
+    flat_multimap& operator=(const flat_multimap&) = default;
+    flat_multimap& operator=(flat_multimap&&)      = default;
+
+    flat_multimap& operator=(const initializer_list<value_type> _Ilist) {
+        this->clear();
+        this->insert(_Ilist.begin(), _Ilist.end());
+        return *this;
+    }
+};
+
+_EXPORT_STD template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer,
+    class _Predicate>
+size_t erase_if(flat_map<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>& _Cont, _Predicate _Pred) {
+    return _Cont._Erase_if(_STD _Pass_fn(_Pred));
+}
+_EXPORT_STD template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer,
+    class _Predicate>
+size_t erase_if(flat_multimap<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>& _Cont, _Predicate _Pred) {
+    return _Cont._Erase_if(_STD _Pass_fn(_Pred));
+}
+
+template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer, class _Alloc>
+struct uses_allocator<flat_map<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>, _Alloc>
+    : bool_constant<uses_allocator_v<_KeyContainer, _Alloc> && uses_allocator_v<_MappedContainer, _Alloc>> {};
+
+template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer, class _Alloc>
+struct uses_allocator<flat_multimap<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>, _Alloc>
+    : bool_constant<uses_allocator_v<_KeyContainer, _Alloc> && uses_allocator_v<_MappedContainer, _Alloc>> {};
+
 template <_Not_allocator_for_container _KeyContainer, _Not_allocator_for_container _MappedContainer,
     _Valid_compare_for_container<_KeyContainer> _Compare = less<typename _KeyContainer::value_type>>
 flat_map(_KeyContainer, _MappedContainer, _Compare = _Compare()) -> flat_map<typename _KeyContainer::value_type,
     typename _MappedContainer::value_type, _Compare, _KeyContainer, _MappedContainer>;
 
 template <_Not_allocator_for_container _KeyContainer, _Not_allocator_for_container _MappedContainer,
-    _Usable_allocator_for<_KeyContainer, _MappedContainer> _Allocator>
-flat_map(_KeyContainer, _MappedContainer, _Allocator) -> flat_map<typename _KeyContainer::value_type,
+    _Usable_allocator_for<_KeyContainer, _MappedContainer> _Alloc>
+flat_map(_KeyContainer, _MappedContainer, _Alloc) -> flat_map<typename _KeyContainer::value_type,
     typename _MappedContainer::value_type, less<typename _KeyContainer::value_type>, _KeyContainer, _MappedContainer>;
 
 template <_Not_allocator_for_container _KeyContainer, _Not_allocator_for_container _MappedContainer,
-    _Valid_compare_for_container<_KeyContainer> _Compare,
-    _Usable_allocator_for<_KeyContainer, _MappedContainer> _Allocator>
-flat_map(_KeyContainer, _MappedContainer, _Compare, _Allocator) -> flat_map<typename _KeyContainer::value_type,
+    _Valid_compare_for_container<_KeyContainer> _Compare, _Usable_allocator_for<_KeyContainer, _MappedContainer> _Alloc>
+flat_map(_KeyContainer, _MappedContainer, _Compare, _Alloc) -> flat_map<typename _KeyContainer::value_type,
     typename _MappedContainer::value_type, _Compare, _KeyContainer, _MappedContainer>;
 
 template <_Not_allocator_for_container _KeyContainer, _Not_allocator_for_container _MappedContainer,
@@ -1452,53 +1479,55 @@ flat_map(sorted_unique_t, _KeyContainer, _MappedContainer, _Compare = _Compare()
         _MappedContainer>;
 
 template <_Not_allocator_for_container _KeyContainer, _Not_allocator_for_container _MappedContainer,
-    _Usable_allocator_for<_KeyContainer, _MappedContainer> _Allocator>
-flat_map(sorted_unique_t, _KeyContainer, _MappedContainer, _Allocator) -> flat_map<typename _KeyContainer::value_type,
+    _Usable_allocator_for<_KeyContainer, _MappedContainer> _Alloc>
+flat_map(sorted_unique_t, _KeyContainer, _MappedContainer, _Alloc) -> flat_map<typename _KeyContainer::value_type,
     typename _MappedContainer::value_type, less<typename _KeyContainer::value_type>, _KeyContainer, _MappedContainer>;
 
 template <_Not_allocator_for_container _KeyContainer, _Not_allocator_for_container _MappedContainer,
-    _Valid_compare_for_container<_KeyContainer> _Compare,
-    _Usable_allocator_for<_KeyContainer, _MappedContainer> _Allocator>
-flat_map(sorted_unique_t, _KeyContainer, _MappedContainer, _Compare, _Allocator)
+    _Valid_compare_for_container<_KeyContainer> _Compare, _Usable_allocator_for<_KeyContainer, _MappedContainer> _Alloc>
+flat_map(sorted_unique_t, _KeyContainer, _MappedContainer, _Compare, _Alloc)
     -> flat_map<typename _KeyContainer::value_type, typename _MappedContainer::value_type, _Compare, _KeyContainer,
         _MappedContainer>;
 
-template <_Iterator_for_container _InputIterator,
-    _Not_allocator_for_container _Compare = less<_Guide_key_t<_InputIterator>>>
-flat_map(_InputIterator, _InputIterator, _Compare = _Compare())
-    -> flat_map<_Guide_key_t<_InputIterator>, _Guide_val_t<_InputIterator>, _Compare>;
+#if 1 // TRANSITION, P2582R1 (MSVC, Clang, EDG)
+template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer,
+    _Usable_allocator_for<_KeyContainer, _MappedContainer> _Alloc>
+flat_map(flat_map<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>, _Alloc)
+    -> flat_map<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>;
+#endif // ^^^ workaround ^^^
+
+template <_Iterator_for_container _InIt, _Not_allocator_for_container _Compare = less<_Guide_key_t<_InIt>>>
+flat_map(_InIt, _InIt, _Compare = _Compare()) -> flat_map<_Guide_key_t<_InIt>, _Guide_val_t<_InIt>, _Compare>;
 
-template <_Iterator_for_container _InputIterator,
-    _Not_allocator_for_container _Compare = less<_Guide_key_t<_InputIterator>>>
-flat_map(sorted_unique_t, _InputIterator, _InputIterator, _Compare = _Compare())
-    -> flat_map<_Guide_key_t<_InputIterator>, _Guide_val_t<_InputIterator>, _Compare>;
+template <_Iterator_for_container _InIt, _Not_allocator_for_container _Compare = less<_Guide_key_t<_InIt>>>
+flat_map(sorted_unique_t, _InIt, _InIt, _Compare = _Compare())
+    -> flat_map<_Guide_key_t<_InIt>, _Guide_val_t<_InIt>, _Compare>;
 
 #ifdef __cpp_lib_byte
 // TRANSITION, CWG-2369, should just use constrained template parameters.
 template <_RANGES input_range _Rng, _Not_allocator_for_container _Compare = less<_Range_key_type<_Rng>>,
-    class _Allocator = allocator<byte>, enable_if_t<_Allocator_for_container<_Allocator>, int> = 0>
-flat_map(from_range_t, _Rng&&, _Compare = _Compare(), _Allocator = _Allocator())
-    -> flat_map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, _Compare,
-        vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_key_type<_Rng>>>,
-        vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_mapped_type<_Rng>>>>;
+    class _Alloc = allocator<byte>, enable_if_t<_Allocator_for_container<_Alloc>, int> = 0>
+flat_map(from_range_t, _Rng&&, _Compare = _Compare(), _Alloc = _Alloc()) -> flat_map<_Range_key_type<_Rng>,
+    _Range_mapped_type<_Rng>, _Compare, vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Alloc, _Range_key_type<_Rng>>>,
+    vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Alloc, _Range_mapped_type<_Rng>>>>;
 #else // ^^^ defined(__cpp_lib_byte) / !defined(__cpp_lib_byte) vvv
 template <_RANGES input_range _Rng, _Not_allocator_for_container _Compare = less<_Range_key_type<_Rng>>>
 flat_map(from_range_t, _Rng&&, _Compare = _Compare()) -> flat_map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>,
     _Compare, vector<_Range_key_type<_Rng>>, vector<_Range_mapped_type<_Rng>>>;
 
 // TRANSITION, CWG-2369, should just use constrained template parameters.
-template <_RANGES input_range _Rng, _Not_allocator_for_container _Compare, class _Allocator,
-    enable_if_t<_Allocator_for_container<_Allocator>, int> = 0>
-flat_map(from_range_t, _Rng&&, _Compare, _Allocator) -> flat_map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>,
-    _Compare, vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_key_type<_Rng>>>,
-    vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_mapped_type<_Rng>>>>;
+template <_RANGES input_range _Rng, _Not_allocator_for_container _Compare, class _Alloc,
+    enable_if_t<_Allocator_for_container<_Alloc>, int> = 0>
+flat_map(from_range_t, _Rng&&, _Compare, _Alloc) -> flat_map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, _Compare,
+    vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Alloc, _Range_key_type<_Rng>>>,
+    vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Alloc, _Range_mapped_type<_Rng>>>>;
 #endif // ^^^ !defined(__cpp_lib_byte) ^^^
 
 // TRANSITION, CWG-2369, should just use constrained template parameters.
-template <_RANGES input_range _Rng, class _Allocator, enable_if_t<_Allocator_for_container<_Allocator>, int> = 0>
-flat_map(from_range_t, _Rng&&, _Allocator) -> flat_map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>,
-    less<_Range_key_type<_Rng>>, vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_key_type<_Rng>>>,
-    vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_mapped_type<_Rng>>>>;
+template <_RANGES input_range _Rng, class _Alloc, enable_if_t<_Allocator_for_container<_Alloc>, int> = 0>
+flat_map(from_range_t, _Rng&&, _Alloc) -> flat_map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>,
+    less<_Range_key_type<_Rng>>, vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Alloc, _Range_key_type<_Rng>>>,
+    vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Alloc, _Range_mapped_type<_Rng>>>>;
 
 template <class _Key, class _Mapped, _Not_allocator_for_container _Compare = less<_Key>>
 flat_map(initializer_list<pair<_Key, _Mapped>>, _Compare = _Compare()) -> flat_map<_Key, _Mapped, _Compare>;
@@ -1507,46 +1536,6 @@ template <class _Key, class _Mapped, _Not_allocator_for_container _Compare = les
 flat_map(sorted_unique_t, initializer_list<pair<_Key, _Mapped>>, _Compare = _Compare())
     -> flat_map<_Key, _Mapped, _Compare>;
 
-template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer, class _Allocator>
-struct uses_allocator<flat_map<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>, _Allocator>
-    : bool_constant<uses_allocator_v<_KeyContainer, _Allocator> && uses_allocator_v<_MappedContainer, _Allocator>> {};
-
-_EXPORT_STD template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer,
-    class _Predicate>
-size_t erase_if(flat_map<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>& _Cont, _Predicate _Pred) {
-    return _Cont._Erase_if(_STD _Pass_fn(_Pred));
-}
-
-_EXPORT_STD template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer>
-class flat_multimap : public _Flat_map_base<false, _Key, _Mapped, _Compare, _KeyContainer, _MappedContainer> {
-private:
-    using _Mybase = _Flat_map_base<false, _Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>;
-
-public:
-    using typename _Mybase::value_type;
-
-    using _Mybase::_Mybase;
-    flat_multimap(const flat_multimap&) = default;
-    flat_multimap(flat_multimap&&)      = default;
-
-#if 1 // TRANSITION, P2582R1 (MSVC, Clang, EDG)
-    template <_Usable_allocator_for<_KeyContainer, _MappedContainer> _Allocator>
-    flat_multimap(const flat_multimap& _Other, const _Allocator& _Al) : _Mybase(_Other, _Al) {}
-
-    template <_Usable_allocator_for<_KeyContainer, _MappedContainer> _Allocator>
-    flat_multimap(flat_multimap&& _Other, const _Allocator& _Al) : _Mybase(_STD move(_Other), _Al) {}
-#endif // ^^^ workaround ^^^
-
-    flat_multimap& operator=(const flat_multimap&) = default;
-    flat_multimap& operator=(flat_multimap&&)      = default;
-
-    flat_multimap& operator=(const initializer_list<value_type> _Ilist) {
-        this->clear();
-        this->insert(_Ilist.begin(), _Ilist.end());
-        return *this;
-    }
-};
-
 template <_Not_allocator_for_container _KeyContainer, _Not_allocator_for_container _MappedContainer,
     _Valid_compare_for_container<_KeyContainer> _Compare = less<typename _KeyContainer::value_type>>
 flat_multimap(_KeyContainer, _MappedContainer, _Compare = _Compare())
@@ -1554,16 +1543,14 @@ flat_multimap(_KeyContainer, _MappedContainer, _Compare = _Compare())
         _MappedContainer>;
 
 template <_Not_allocator_for_container _KeyContainer, _Not_allocator_for_container _MappedContainer,
-    _Usable_allocator_for<_KeyContainer, _MappedContainer> _Allocator>
-flat_multimap(_KeyContainer, _MappedContainer, _Allocator) -> flat_multimap<typename _KeyContainer::value_type,
+    _Usable_allocator_for<_KeyContainer, _MappedContainer> _Alloc>
+flat_multimap(_KeyContainer, _MappedContainer, _Alloc) -> flat_multimap<typename _KeyContainer::value_type,
     typename _MappedContainer::value_type, less<typename _KeyContainer::value_type>, _KeyContainer, _MappedContainer>;
 
 template <_Not_allocator_for_container _KeyContainer, _Not_allocator_for_container _MappedContainer,
-    _Valid_compare_for_container<_KeyContainer> _Compare,
-    _Usable_allocator_for<_KeyContainer, _MappedContainer> _Allocator>
-flat_multimap(_KeyContainer, _MappedContainer, _Compare, _Allocator)
-    -> flat_multimap<typename _KeyContainer::value_type, typename _MappedContainer::value_type, _Compare, _KeyContainer,
-        _MappedContainer>;
+    _Valid_compare_for_container<_KeyContainer> _Compare, _Usable_allocator_for<_KeyContainer, _MappedContainer> _Alloc>
+flat_multimap(_KeyContainer, _MappedContainer, _Compare, _Alloc) -> flat_multimap<typename _KeyContainer::value_type,
+    typename _MappedContainer::value_type, _Compare, _KeyContainer, _MappedContainer>;
 
 template <_Not_allocator_for_container _KeyContainer, _Not_allocator_for_container _MappedContainer,
     _Valid_compare_for_container<_KeyContainer> _Compare = less<typename _KeyContainer::value_type>>
@@ -1572,55 +1559,56 @@ flat_multimap(sorted_equivalent_t, _KeyContainer, _MappedContainer, _Compare = _
         _MappedContainer>;
 
 template <_Not_allocator_for_container _KeyContainer, _Not_allocator_for_container _MappedContainer,
-    _Usable_allocator_for<_KeyContainer, _MappedContainer> _Allocator>
-flat_multimap(sorted_equivalent_t, _KeyContainer, _MappedContainer, _Allocator)
+    _Usable_allocator_for<_KeyContainer, _MappedContainer> _Alloc>
+flat_multimap(sorted_equivalent_t, _KeyContainer, _MappedContainer, _Alloc)
     -> flat_multimap<typename _KeyContainer::value_type, typename _MappedContainer::value_type,
         less<typename _KeyContainer::value_type>, _KeyContainer, _MappedContainer>;
 
 template <_Not_allocator_for_container _KeyContainer, _Not_allocator_for_container _MappedContainer,
-    _Valid_compare_for_container<_KeyContainer> _Compare,
-    _Usable_allocator_for<_KeyContainer, _MappedContainer> _Allocator>
-flat_multimap(sorted_equivalent_t, _KeyContainer, _MappedContainer, _Compare, _Allocator)
+    _Valid_compare_for_container<_KeyContainer> _Compare, _Usable_allocator_for<_KeyContainer, _MappedContainer> _Alloc>
+flat_multimap(sorted_equivalent_t, _KeyContainer, _MappedContainer, _Compare, _Alloc)
     -> flat_multimap<typename _KeyContainer::value_type, typename _MappedContainer::value_type, _Compare, _KeyContainer,
         _MappedContainer>;
 
-template <_Iterator_for_container _InputIterator,
-    _Not_allocator_for_container _Compare = less<_Guide_key_t<_InputIterator>>>
-flat_multimap(_InputIterator, _InputIterator, _Compare = _Compare())
-    -> flat_multimap<_Guide_key_t<_InputIterator>, _Guide_val_t<_InputIterator>, _Compare>;
+#if 1 // TRANSITION, P2582R1 (MSVC, Clang, EDG)
+template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer,
+    _Usable_allocator_for<_KeyContainer, _MappedContainer> _Alloc>
+flat_multimap(flat_multimap<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>, _Alloc)
+    -> flat_multimap<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>;
+#endif // ^^^ workaround ^^^
+
+template <_Iterator_for_container _InIt, _Not_allocator_for_container _Compare = less<_Guide_key_t<_InIt>>>
+flat_multimap(_InIt, _InIt, _Compare = _Compare()) -> flat_multimap<_Guide_key_t<_InIt>, _Guide_val_t<_InIt>, _Compare>;
 
-template <_Iterator_for_container _InputIterator,
-    _Not_allocator_for_container _Compare = less<_Guide_key_t<_InputIterator>>>
-flat_multimap(sorted_equivalent_t, _InputIterator, _InputIterator, _Compare = _Compare())
-    -> flat_multimap<_Guide_key_t<_InputIterator>, _Guide_val_t<_InputIterator>, _Compare>;
+template <_Iterator_for_container _InIt, _Not_allocator_for_container _Compare = less<_Guide_key_t<_InIt>>>
+flat_multimap(sorted_equivalent_t, _InIt, _InIt, _Compare = _Compare())
+    -> flat_multimap<_Guide_key_t<_InIt>, _Guide_val_t<_InIt>, _Compare>;
 
 #ifdef __cpp_lib_byte
 // TRANSITION, CWG-2369, should just use constrained template parameters.
 template <_RANGES input_range _Rng, _Not_allocator_for_container _Compare = less<_Range_key_type<_Rng>>,
-    class _Allocator = allocator<byte>, enable_if_t<_Allocator_for_container<_Allocator>, int> = 0>
-flat_multimap(from_range_t, _Rng&&, _Compare = _Compare(), _Allocator = _Allocator())
-    -> flat_multimap<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, _Compare,
-        vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_key_type<_Rng>>>,
-        vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_mapped_type<_Rng>>>>;
+    class _Alloc = allocator<byte>, enable_if_t<_Allocator_for_container<_Alloc>, int> = 0>
+flat_multimap(from_range_t, _Rng&&, _Compare = _Compare(), _Alloc = _Alloc()) -> flat_multimap<_Range_key_type<_Rng>,
+    _Range_mapped_type<_Rng>, _Compare, vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Alloc, _Range_key_type<_Rng>>>,
+    vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Alloc, _Range_mapped_type<_Rng>>>>;
 #else // ^^^ defined(__cpp_lib_byte) / !defined(__cpp_lib_byte) vvv
 template <_RANGES input_range _Rng, _Not_allocator_for_container _Compare = less<_Range_key_type<_Rng>>>
 flat_multimap(from_range_t, _Rng&&, _Compare = _Compare()) -> flat_multimap<_Range_key_type<_Rng>,
     _Range_mapped_type<_Rng>, _Compare, vector<_Range_key_type<_Rng>>, vector<_Range_mapped_type<_Rng>>>;
 
 // TRANSITION, CWG-2369, should just use constrained template parameters.
-template <_RANGES input_range _Rng, _Not_allocator_for_container _Compare, class _Allocator,
-    enable_if_t<_Allocator_for_container<_Allocator>, int> = 0>
-flat_multimap(from_range_t, _Rng&&, _Compare, _Allocator)
-    -> flat_multimap<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, _Compare,
-        vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_key_type<_Rng>>>,
-        vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_mapped_type<_Rng>>>>;
+template <_RANGES input_range _Rng, _Not_allocator_for_container _Compare, class _Alloc,
+    enable_if_t<_Allocator_for_container<_Alloc>, int> = 0>
+flat_multimap(from_range_t, _Rng&&, _Compare, _Alloc) -> flat_multimap<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>,
+    _Compare, vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Alloc, _Range_key_type<_Rng>>>,
+    vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Alloc, _Range_mapped_type<_Rng>>>>;
 #endif // ^^^ !defined(__cpp_lib_byte) ^^^
 
 // TRANSITION, CWG-2369, should just use constrained template parameters.
-template <_RANGES input_range _Rng, class _Allocator, enable_if_t<_Allocator_for_container<_Allocator>, int> = 0>
-flat_multimap(from_range_t, _Rng&&, _Allocator) -> flat_multimap<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>,
-    less<_Range_key_type<_Rng>>, vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_key_type<_Rng>>>,
-    vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Allocator, _Range_mapped_type<_Rng>>>>;
+template <_RANGES input_range _Rng, class _Alloc, enable_if_t<_Allocator_for_container<_Alloc>, int> = 0>
+flat_multimap(from_range_t, _Rng&&, _Alloc) -> flat_multimap<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>,
+    less<_Range_key_type<_Rng>>, vector<_Range_key_type<_Rng>, _Rebind_alloc_t<_Alloc, _Range_key_type<_Rng>>>,
+    vector<_Range_mapped_type<_Rng>, _Rebind_alloc_t<_Alloc, _Range_mapped_type<_Rng>>>>;
 
 template <class _Key, class _Mapped, _Not_allocator_for_container _Compare = less<_Key>>
 flat_multimap(initializer_list<pair<_Key, _Mapped>>, _Compare = _Compare()) -> flat_multimap<_Key, _Mapped, _Compare>;
@@ -1628,16 +1616,6 @@ flat_multimap(initializer_list<pair<_Key, _Mapped>>, _Compare = _Compare()) -> f
 template <class _Key, class _Mapped, _Not_allocator_for_container _Compare = less<_Key>>
 flat_multimap(sorted_equivalent_t, initializer_list<pair<_Key, _Mapped>>, _Compare = _Compare())
     -> flat_multimap<_Key, _Mapped, _Compare>;
-
-template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer, class _Allocator>
-struct uses_allocator<flat_multimap<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>, _Allocator>
-    : bool_constant<uses_allocator_v<_KeyContainer, _Allocator> && uses_allocator_v<_MappedContainer, _Allocator>> {};
-
-_EXPORT_STD template <class _Key, class _Mapped, class _Compare, class _KeyContainer, class _MappedContainer,
-    class _Predicate>
-size_t erase_if(flat_multimap<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>& _Cont, _Predicate _Pred) {
-    return _Cont._Erase_if(_STD _Pass_fn(_Pred));
-}
 _STD_END
 
 // TRANSITION, non-_Ugly attribute tokens
diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index 0c6e51409d0..12a6f90268f 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -57,27 +57,34 @@ struct _NODISCARD _Flat_set_swap_clear_guard<true, _Container> {
     void _Dismiss() noexcept {}
 };
 
-_EXPORT_STD template <class _Kty, class _Keylt = less<_Kty>, class _Container = vector<_Kty>>
+_EXPORT_STD template <class _Key, class _Compare = less<_Key>, class _Container = vector<_Key>>
 class flat_set;
 
-_EXPORT_STD template <class _Kty, class _Keylt = less<_Kty>, class _Container = vector<_Kty>>
+_EXPORT_STD template <class _Key, class _Compare = less<_Key>, class _Container = vector<_Key>>
 class flat_multiset;
 
-template <bool _IsUnique, class _Kty, class _Keylt, class _Container>
+template <bool _IsUnique, class _Key, class _Compare, class _Container>
 class _Flat_set_base {
 private:
     using _Sorted_t = conditional_t<_IsUnique, sorted_unique_t, sorted_equivalent_t>;
     using _Derived =
-        conditional_t<_IsUnique, flat_set<_Kty, _Keylt, _Container>, flat_multiset<_Kty, _Keylt, _Container>>;
+        conditional_t<_IsUnique, flat_set<_Key, _Compare, _Container>, flat_multiset<_Key, _Compare, _Container>>;
 
-    static constexpr const char* _Msg_not_sorted = _IsUnique ? "Input was not sorted-unique!" : "Input was not sorted!";
+    static constexpr const char* _Msg_not_sorted = //
+        _IsUnique ? "Input was not sorted-unique! (N5032 [flat.set.overview]/9)"
+                  : "Input was not sorted! (N5032 [flat.multiset.overview]/9)";
+    static constexpr const char* _Msg_replace_not_sorted =
+        _IsUnique ? "Input was not sorted-unique! (N5032 [flat.set.modifiers]/18)"
+                  : "Input was not sorted! (N5032 [flat.multiset.modifiers]/17)";
+    static constexpr const char* _Msg_heterogeneous_insertion_inconsistent_with_lookup =
+        "The conversion from the heterogeneous key to key_type should be consistent with the heterogeneous lookup!";
 
 public:
     // [flat.set.defn] Types
-    using key_type               = _Kty;
-    using value_type             = _Kty;
-    using key_compare            = _Keylt;
-    using value_compare          = _Keylt;
+    using key_type               = _Key;
+    using value_type             = _Key;
+    using key_compare            = _Compare;
+    using value_compare          = _Compare;
     using reference              = value_type&;
     using const_reference        = const value_type&;
     using size_type              = _Container::size_type;
@@ -99,170 +106,171 @@ public:
         "(N5032 [flat.set.overview]/7, [flat.multiset.overview]/7)");
 
     // [flat.set.cons] Constructors
-    _Flat_set_base() : _Mycont(), _Mycomp() {}
+    _Flat_set_base() : _Data(), _Key_compare() {}
 
     _Flat_set_base(const _Flat_set_base&) = default;
 
     _Flat_set_base(_Flat_set_base&& _Other) noexcept(
         is_nothrow_move_constructible_v<container_type> && is_nothrow_copy_constructible_v<key_compare>) // strengthened
-        : _Mycont(_STD move(_Other).extract()), _Mycomp(_Other._Mycomp) // intentionally copy comparator, see LWG-2227
+        : _Data(_STD move(_Other).extract()),
+          _Key_compare(_Other._Key_compare) // intentionally copy comparator, see LWG-2227
     {}
 
-    explicit _Flat_set_base(const key_compare& _Comp) : _Mycont(), _Mycomp(_Comp) {}
+    explicit _Flat_set_base(const key_compare& _Comp) : _Data(), _Key_compare(_Comp) {}
 
     explicit _Flat_set_base(container_type _Cont, const key_compare& _Comp = key_compare())
-        : _Mycont(_STD move(_Cont)), _Mycomp(_Comp) {
-        _Make_invariants_fulfilled();
+        : _Data(_STD move(_Cont)), _Key_compare(_Comp) {
+        _Establish_invariants();
     }
 
     _Flat_set_base(_Sorted_t, container_type _Cont, const key_compare& _Comp = key_compare())
-        : _Mycont(_STD move(_Cont)), _Mycomp(_Comp) {
+        : _Data(_STD move(_Cont)), _Key_compare(_Comp) {
         _STL_ASSERT(_Is_sorted_and_unique(), _Msg_not_sorted);
     }
 
-    template <_Iterator_for_container _Iter>
-    _Flat_set_base(const _Iter _First, const _Iter _Last, const key_compare& _Comp = key_compare())
-        : _Mycont(_First, _Last), _Mycomp(_Comp) {
-        _Make_invariants_fulfilled();
+    template <_Iterator_for_container _InIt>
+    _Flat_set_base(const _InIt _First, const _InIt _Last, const key_compare& _Comp = key_compare())
+        : _Data(_First, _Last), _Key_compare(_Comp) {
+        _Establish_invariants();
     }
 
-    template <_Iterator_for_container _Iter>
-    _Flat_set_base(_Sorted_t, const _Iter _First, const _Iter _Last, const key_compare& _Comp = key_compare())
-        : _Mycont(_First, _Last), _Mycomp(_Comp) {
+    template <_Iterator_for_container _InIt>
+    _Flat_set_base(_Sorted_t, const _InIt _First, const _InIt _Last, const key_compare& _Comp = key_compare())
+        : _Data(_First, _Last), _Key_compare(_Comp) {
         _STL_ASSERT(_Is_sorted_and_unique(), _Msg_not_sorted);
     }
 
-    template <_Container_compatible_range<_Kty> _Rng>
-    _Flat_set_base(from_range_t, _Rng&& _Range) : _Mycont(from_range, _STD forward<_Rng>(_Range)), _Mycomp() {
-        _Make_invariants_fulfilled();
+    template <_Container_compatible_range<value_type> _Rng>
+    _Flat_set_base(from_range_t, _Rng&& _Range) : _Data(from_range, _STD forward<_Rng>(_Range)), _Key_compare() {
+        _Establish_invariants();
     }
 
-    template <_Container_compatible_range<_Kty> _Rng>
+    template <_Container_compatible_range<value_type> _Rng>
     _Flat_set_base(from_range_t, _Rng&& _Range, const key_compare& _Comp)
-        : _Mycont(from_range, _STD forward<_Rng>(_Range)), _Mycomp(_Comp) {
-        _Make_invariants_fulfilled();
+        : _Data(from_range, _STD forward<_Rng>(_Range)), _Key_compare(_Comp) {
+        _Establish_invariants();
     }
 
-    _Flat_set_base(const initializer_list<_Kty> _Ilist, const key_compare& _Comp = key_compare())
-        : _Mycont(_Ilist.begin(), _Ilist.end()), _Mycomp(_Comp) {
-        _Make_invariants_fulfilled();
+    _Flat_set_base(const initializer_list<value_type> _Ilist, const key_compare& _Comp = key_compare())
+        : _Data(_Ilist.begin(), _Ilist.end()), _Key_compare(_Comp) {
+        _Establish_invariants();
     }
 
-    _Flat_set_base(_Sorted_t, const initializer_list<_Kty> _Ilist, const key_compare& _Comp = key_compare())
-        : _Mycont(_Ilist.begin(), _Ilist.end()), _Mycomp(_Comp) {
+    _Flat_set_base(_Sorted_t, const initializer_list<value_type> _Ilist, const key_compare& _Comp = key_compare())
+        : _Data(_Ilist.begin(), _Ilist.end()), _Key_compare(_Comp) {
         _STL_ASSERT(_Is_sorted_and_unique(), _Msg_not_sorted);
     }
 
     // [flat.set.cons.alloc] Constructors with allocators
     template <_Usable_allocator_for<container_type> _Alloc>
     explicit _Flat_set_base(const _Alloc& _Al)
-        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al)), _Mycomp() {}
+        : _Data(_STD make_obj_using_allocator<container_type>(_Al)), _Key_compare() {}
 
     template <_Usable_allocator_for<container_type> _Alloc>
     _Flat_set_base(const key_compare& _Comp, const _Alloc& _Al)
-        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al)), _Mycomp(_Comp) {}
+        : _Data(_STD make_obj_using_allocator<container_type>(_Al)), _Key_compare(_Comp) {}
 
     template <_Usable_allocator_for<container_type> _Alloc>
     _Flat_set_base(const container_type& _Cont, const _Alloc& _Al)
-        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al, _Cont)), _Mycomp() {
-        _Make_invariants_fulfilled();
+        : _Data(_STD make_obj_using_allocator<container_type>(_Al, _Cont)), _Key_compare() {
+        _Establish_invariants();
     }
 
     template <_Usable_allocator_for<container_type> _Alloc>
     _Flat_set_base(const container_type& _Cont, const key_compare& _Comp, const _Alloc& _Al)
-        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al, _Cont)), _Mycomp(_Comp) {
-        _Make_invariants_fulfilled();
+        : _Data(_STD make_obj_using_allocator<container_type>(_Al, _Cont)), _Key_compare(_Comp) {
+        _Establish_invariants();
     }
 
     template <_Usable_allocator_for<container_type> _Alloc>
     _Flat_set_base(_Sorted_t, const container_type& _Cont, const _Alloc& _Al)
-        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al, _Cont)), _Mycomp() {
+        : _Data(_STD make_obj_using_allocator<container_type>(_Al, _Cont)), _Key_compare() {
         _STL_ASSERT(_Is_sorted_and_unique(), _Msg_not_sorted);
     }
 
     template <_Usable_allocator_for<container_type> _Alloc>
     _Flat_set_base(_Sorted_t, const container_type& _Cont, const key_compare& _Comp, const _Alloc& _Al)
-        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al, _Cont)), _Mycomp(_Comp) {
+        : _Data(_STD make_obj_using_allocator<container_type>(_Al, _Cont)), _Key_compare(_Comp) {
         _STL_ASSERT(_Is_sorted_and_unique(), _Msg_not_sorted);
     }
 
     template <_Usable_allocator_for<container_type> _Alloc>
     _Flat_set_base(const _Flat_set_base& _Other, const _Alloc& _Al)
-        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al, _Other._Mycont)), _Mycomp(_Other._Mycomp) {}
+        : _Data(_STD make_obj_using_allocator<container_type>(_Al, _Other._Data)), _Key_compare(_Other._Key_compare) {}
 
     template <_Usable_allocator_for<container_type> _Alloc>
     _Flat_set_base(_Flat_set_base&& _Other, const _Alloc& _Al)
-        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al, _STD move(_Other).extract())),
-          _Mycomp(_Other._Mycomp) // intentionally copy comparator, see LWG-2227
+        : _Data(_STD make_obj_using_allocator<container_type>(_Al, _STD move(_Other).extract())),
+          _Key_compare(_Other._Key_compare) // intentionally copy comparator, see LWG-2227
     {}
 
-    template <_Iterator_for_container _Iter, _Usable_allocator_for<container_type> _Alloc>
-    _Flat_set_base(const _Iter _First, const _Iter _Last, const _Alloc& _Al)
-        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al, _First, _Last)), _Mycomp() {
-        _Make_invariants_fulfilled();
+    template <_Iterator_for_container _InIt, _Usable_allocator_for<container_type> _Alloc>
+    _Flat_set_base(const _InIt _First, const _InIt _Last, const _Alloc& _Al)
+        : _Data(_STD make_obj_using_allocator<container_type>(_Al, _First, _Last)), _Key_compare() {
+        _Establish_invariants();
     }
 
-    template <_Iterator_for_container _Iter, _Usable_allocator_for<container_type> _Alloc>
-    _Flat_set_base(const _Iter _First, const _Iter _Last, const key_compare& _Comp, const _Alloc& _Al)
-        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al, _First, _Last)), _Mycomp(_Comp) {
-        _Make_invariants_fulfilled();
+    template <_Iterator_for_container _InIt, _Usable_allocator_for<container_type> _Alloc>
+    _Flat_set_base(const _InIt _First, const _InIt _Last, const key_compare& _Comp, const _Alloc& _Al)
+        : _Data(_STD make_obj_using_allocator<container_type>(_Al, _First, _Last)), _Key_compare(_Comp) {
+        _Establish_invariants();
     }
 
-    template <_Iterator_for_container _Iter, _Usable_allocator_for<container_type> _Alloc>
-    _Flat_set_base(_Sorted_t, const _Iter _First, const _Iter _Last, const _Alloc& _Al)
-        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al, _First, _Last)), _Mycomp() {
+    template <_Iterator_for_container _InIt, _Usable_allocator_for<container_type> _Alloc>
+    _Flat_set_base(_Sorted_t, const _InIt _First, const _InIt _Last, const _Alloc& _Al)
+        : _Data(_STD make_obj_using_allocator<container_type>(_Al, _First, _Last)), _Key_compare() {
         _STL_ASSERT(_Is_sorted_and_unique(), _Msg_not_sorted);
     }
 
-    template <_Iterator_for_container _Iter, _Usable_allocator_for<container_type> _Alloc>
-    _Flat_set_base(_Sorted_t, const _Iter _First, const _Iter _Last, const key_compare& _Comp, const _Alloc& _Al)
-        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al, _First, _Last)), _Mycomp(_Comp) {
+    template <_Iterator_for_container _InIt, _Usable_allocator_for<container_type> _Alloc>
+    _Flat_set_base(_Sorted_t, const _InIt _First, const _InIt _Last, const key_compare& _Comp, const _Alloc& _Al)
+        : _Data(_STD make_obj_using_allocator<container_type>(_Al, _First, _Last)), _Key_compare(_Comp) {
         _STL_ASSERT(_Is_sorted_and_unique(), _Msg_not_sorted);
     }
 
-    template <_Container_compatible_range<_Kty> _Rng, _Usable_allocator_for<container_type> _Alloc>
+    template <_Container_compatible_range<value_type> _Rng, _Usable_allocator_for<container_type> _Alloc>
     _Flat_set_base(from_range_t, _Rng&& _Range, const _Alloc& _Al)
-        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al, from_range, _STD forward<_Rng>(_Range))),
-          _Mycomp() {
-        _Make_invariants_fulfilled();
+        : _Data(_STD make_obj_using_allocator<container_type>(_Al, from_range, _STD forward<_Rng>(_Range))),
+          _Key_compare() {
+        _Establish_invariants();
     }
 
-    template <_Container_compatible_range<_Kty> _Rng, _Usable_allocator_for<container_type> _Alloc>
+    template <_Container_compatible_range<value_type> _Rng, _Usable_allocator_for<container_type> _Alloc>
     _Flat_set_base(from_range_t, _Rng&& _Range, const key_compare& _Comp, const _Alloc& _Al)
-        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al, from_range, _STD forward<_Rng>(_Range))),
-          _Mycomp(_Comp) {
-        _Make_invariants_fulfilled();
+        : _Data(_STD make_obj_using_allocator<container_type>(_Al, from_range, _STD forward<_Rng>(_Range))),
+          _Key_compare(_Comp) {
+        _Establish_invariants();
     }
 
     template <_Usable_allocator_for<container_type> _Alloc>
-    _Flat_set_base(const initializer_list<_Kty> _Ilist, const _Alloc& _Al)
-        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al, _Ilist.begin(), _Ilist.end())), _Mycomp() {
-        _Make_invariants_fulfilled();
+    _Flat_set_base(const initializer_list<value_type> _Ilist, const _Alloc& _Al)
+        : _Data(_STD make_obj_using_allocator<container_type>(_Al, _Ilist.begin(), _Ilist.end())), _Key_compare() {
+        _Establish_invariants();
     }
 
     template <_Usable_allocator_for<container_type> _Alloc>
-    _Flat_set_base(const initializer_list<_Kty> _Ilist, const key_compare& _Comp, const _Alloc& _Al)
-        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al, _Ilist.begin(), _Ilist.end())), _Mycomp(_Comp) {
-        _Make_invariants_fulfilled();
+    _Flat_set_base(const initializer_list<value_type> _Ilist, const key_compare& _Comp, const _Alloc& _Al)
+        : _Data(_STD make_obj_using_allocator<container_type>(_Al, _Ilist.begin(), _Ilist.end())), _Key_compare(_Comp) {
+        _Establish_invariants();
     }
 
     template <_Usable_allocator_for<container_type> _Alloc>
-    _Flat_set_base(_Sorted_t, const initializer_list<_Kty> _Ilist, const _Alloc& _Al)
-        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al, _Ilist.begin(), _Ilist.end())), _Mycomp() {
+    _Flat_set_base(_Sorted_t, const initializer_list<value_type> _Ilist, const _Alloc& _Al)
+        : _Data(_STD make_obj_using_allocator<container_type>(_Al, _Ilist.begin(), _Ilist.end())), _Key_compare() {
         _STL_ASSERT(_Is_sorted_and_unique(), _Msg_not_sorted);
     }
 
     template <_Usable_allocator_for<container_type> _Alloc>
-    _Flat_set_base(_Sorted_t, const initializer_list<_Kty> _Ilist, const key_compare& _Comp, const _Alloc& _Al)
-        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al, _Ilist.begin(), _Ilist.end())), _Mycomp(_Comp) {
+    _Flat_set_base(_Sorted_t, const initializer_list<value_type> _Ilist, const key_compare& _Comp, const _Alloc& _Al)
+        : _Data(_STD make_obj_using_allocator<container_type>(_Al, _Ilist.begin(), _Ilist.end())), _Key_compare(_Comp) {
         _STL_ASSERT(_Is_sorted_and_unique(), _Msg_not_sorted);
     }
 
     // Assignment operators
     _Flat_set_base& operator=(const _Flat_set_base& _Other) {
         _Clear_guard _Guard{this};
-        _Mycont        = _Other._Mycont;
-        _Mycomp        = _Other._Mycomp;
+        _Data          = _Other._Data;
+        _Key_compare   = _Other._Key_compare;
         _Guard._Target = nullptr;
         return *this;
     }
@@ -272,8 +280,8 @@ public:
         if (this != _STD addressof(_Other)) {
             _Clear_guard _Guard{this};
             _Clear_guard _Always_clear{_STD addressof(_Other)};
-            _Mycont        = _STD move(_Other._Mycont);
-            _Mycomp        = _Other._Mycomp; // intentionally copy comparator, see LWG-2227
+            _Data          = _STD move(_Other._Data);
+            _Key_compare   = _Other._Key_compare; // intentionally copy comparator, see LWG-2227
             _Guard._Target = nullptr;
         }
         return *this;
@@ -282,115 +290,115 @@ public:
     // Iterators
     // NB: The non-const overloads are intentionally removed for brevity. This will not result in behavioral changes.
     _NODISCARD const_iterator begin() const noexcept {
-        return _Mycont.begin();
+        return _Data.begin();
     }
     _NODISCARD const_iterator end() const noexcept {
-        return _Mycont.end();
+        return _Data.end();
     }
 
     _NODISCARD const_reverse_iterator rbegin() const noexcept {
-        return const_reverse_iterator{_Mycont.end()};
+        return const_reverse_iterator{_Data.end()};
     }
     _NODISCARD const_reverse_iterator rend() const noexcept {
-        return const_reverse_iterator{_Mycont.begin()};
+        return const_reverse_iterator{_Data.begin()};
     }
 
     _NODISCARD const_iterator cbegin() const noexcept {
-        return _Mycont.begin();
+        return _Data.begin();
     }
     _NODISCARD const_iterator cend() const noexcept {
-        return _Mycont.end();
+        return _Data.end();
     }
 
     _NODISCARD const_reverse_iterator crbegin() const noexcept {
-        return const_reverse_iterator{_Mycont.end()};
+        return const_reverse_iterator{_Data.end()};
     }
     _NODISCARD const_reverse_iterator crend() const noexcept {
-        return const_reverse_iterator{_Mycont.begin()};
+        return const_reverse_iterator{_Data.begin()};
     }
 
     // Capacity
     _NODISCARD_EMPTY_MEMBER bool empty() const noexcept {
-        return _Mycont.empty();
+        return _Data.empty();
     }
     _NODISCARD size_type size() const noexcept {
-        return _Mycont.size();
+        return _Data.size();
     }
     _NODISCARD size_type max_size() const noexcept {
-        return _Mycont.max_size();
+        return _Data.max_size();
     }
 
     // [flat.set.modifiers] Modifiers
-    template <class... _Args>
-    auto emplace(_Args&&... _Vals)
-        requires is_constructible_v<value_type, _Args...>
+    template <class... _ArgTypes>
+    auto emplace(_ArgTypes&&... _Args)
+        requires is_constructible_v<value_type, _ArgTypes...>
     {
-        constexpr bool _Is_key_type = _In_place_key_extract_set<_Kty, remove_cvref_t<_Args>...>::_Extractable;
+        constexpr bool _Is_key_type = _In_place_key_extract_set<key_type, remove_cvref_t<_ArgTypes>...>::_Extractable;
         if constexpr (_Is_key_type) {
-            return _Emplace(_STD forward<_Args>(_Vals)...);
+            return _Emplace(_STD forward<_ArgTypes>(_Args)...);
         } else {
-            return _Emplace(_Kty(_STD forward<_Args>(_Vals)...));
+            return _Emplace(key_type(_STD forward<_ArgTypes>(_Args)...));
         }
     }
 
-    template <class... _Args>
-    iterator emplace_hint(const const_iterator _Hint, _Args&&... _Vals)
-        requires is_constructible_v<value_type, _Args...>
+    template <class... _ArgTypes>
+    iterator emplace_hint(const const_iterator _Position, _ArgTypes&&... _Args)
+        requires is_constructible_v<value_type, _ArgTypes...>
     {
-        constexpr bool _Is_key_type = _In_place_key_extract_set<_Kty, remove_cvref_t<_Args>...>::_Extractable;
+        constexpr bool _Is_key_type = _In_place_key_extract_set<key_type, remove_cvref_t<_ArgTypes>...>::_Extractable;
         if constexpr (_Is_key_type) {
-            return _Emplace_hint(_Hint, _STD forward<_Args>(_Vals)...);
+            return _Emplace_hint(_Position, _STD forward<_ArgTypes>(_Args)...);
         } else {
-            return _Emplace_hint(_Hint, _Kty(_STD forward<_Args>(_Vals)...));
+            return _Emplace_hint(_Position, key_type(_STD forward<_ArgTypes>(_Args)...));
         }
     }
 
-    auto insert(const _Kty& _Val) {
+    auto insert(const value_type& _Val) {
         return _Emplace(_Val);
     }
-    auto insert(_Kty&& _Val) {
+    auto insert(value_type&& _Val) {
         return _Emplace(_STD move(_Val));
     }
-    template <_Different_from<_Kty> _Other>
-        requires _IsUnique && _Transparent<key_compare> && is_constructible_v<_Kty, _Other>
+    template <_Different_from<value_type> _Other>
+        requires _IsUnique && _Transparent<key_compare> && is_constructible_v<value_type, _Other>
     auto insert(_Other&& _Val) {
         return _Emplace(_STD forward<_Other>(_Val));
     }
 
-    iterator insert(const const_iterator _Hint, const _Kty& _Val) {
-        return _Emplace_hint(_Hint, _Val);
+    iterator insert(const const_iterator _Position, const value_type& _Val) {
+        return _Emplace_hint(_Position, _Val);
     }
-    iterator insert(const const_iterator _Hint, _Kty&& _Val) {
-        return _Emplace_hint(_Hint, _STD move(_Val));
+    iterator insert(const const_iterator _Position, value_type&& _Val) {
+        return _Emplace_hint(_Position, _STD move(_Val));
     }
-    template <_Different_from<_Kty> _Other>
-        requires _IsUnique && _Transparent<key_compare> && is_constructible_v<_Kty, _Other>
-    iterator insert(const const_iterator _Hint, _Other&& _Val) {
-        return _Emplace_hint(_Hint, _STD forward<_Other>(_Val));
+    template <_Different_from<value_type> _Other>
+        requires _IsUnique && _Transparent<key_compare> && is_constructible_v<value_type, _Other>
+    iterator insert(const const_iterator _Position, _Other&& _Val) {
+        return _Emplace_hint(_Position, _STD forward<_Other>(_Val));
     }
 
-    template <_Iterator_for_container _Iter>
-    void insert(const _Iter _First, const _Iter _Last) {
+    template <_Iterator_for_container _InIt>
+    void insert(const _InIt _First, const _InIt _Last) {
         _Insert_range<true>(_First, _Last);
     }
-    template <_Iterator_for_container _Iter>
-    void insert(_Sorted_t, const _Iter _First, const _Iter _Last) {
+    template <_Iterator_for_container _InIt>
+    void insert(_Sorted_t, const _InIt _First, const _InIt _Last) {
         _Insert_range<false>(_First, _Last);
     }
 
-    template <_Container_compatible_range<_Kty> _Rng>
+    template <_Container_compatible_range<value_type> _Rng>
     void insert_range(_Rng&& _Range) {
         _Insert_range<true>(_STD forward<_Rng>(_Range));
     }
-    template <_Container_compatible_range<_Kty> _Rng>
+    template <_Container_compatible_range<value_type> _Rng>
     void insert_range(_Sorted_t, _Rng&& _Range) {
         _Insert_range<false>(_STD forward<_Rng>(_Range));
     }
 
-    void insert(const initializer_list<_Kty> _Ilist) {
+    void insert(const initializer_list<value_type> _Ilist) {
         _Insert_range<true>(_Ilist.begin(), _Ilist.end());
     }
-    void insert(_Sorted_t, const initializer_list<_Kty> _Ilist) {
+    void insert(_Sorted_t, const initializer_list<value_type> _Ilist) {
         _Insert_range<false>(_Ilist.begin(), _Ilist.end());
     }
 
@@ -398,36 +406,36 @@ public:
         is_nothrow_move_constructible_v<container_type>) /* strengthened */ {
         // always clears the container (N5032 [flat.set.modifiers]/16 and [flat.multiset.modifiers]/15)
         _Clear_guard _Always_clear{this};
-        return _STD move(_Mycont);
+        return _STD move(_Data);
     }
 
     void replace(container_type&& _Cont) {
-        _STL_ASSERT(_Is_sorted_and_unique(_Cont.begin(), _Cont.end()), _Msg_not_sorted);
+        _STL_ASSERT(_Is_sorted_and_unique(_Cont.begin(), _Cont.end()), _Msg_replace_not_sorted);
         _Clear_guard _Guard{this};
-        _Mycont        = _STD move(_Cont);
+        _Data          = _STD move(_Cont);
         _Guard._Target = nullptr;
     }
 
     // NB: `erase(iterator)` is identical to `erase(const_iterator)`
-    iterator erase(const const_iterator _Where) {
+    iterator erase(const const_iterator _Position) {
         _Clear_guard _Guard{this};
-        const auto _Ret = _Mycont.erase(_Where);
+        const auto _Ret = _Data.erase(_Position);
         _Guard._Target  = nullptr;
         return _Ret;
     }
 
-    size_type erase(const _Kty& _Val) {
-        return _Erase(_Val);
+    size_type erase(const key_type& _Val) {
+        return _Erase_key(_Val);
     }
-    template <_Different_from<_Kty> _Other>
+    template <_Different_from<key_type> _Other>
         requires _Transparent<key_compare> && (!is_convertible_v<_Other, const_iterator>)
     size_type erase(_Other&& _Val) {
-        return _Erase(_Val);
+        return _Erase_key(_Val);
     }
 
     iterator erase(const const_iterator _First, const const_iterator _Last) {
         _Clear_guard _Guard{this};
-        const auto _Ret = _Mycont.erase(_First, _Last);
+        const auto _Ret = _Data.erase(_First, _Last);
         _Guard._Target  = nullptr;
         return _Ret;
     }
@@ -436,27 +444,27 @@ public:
         noexcept(is_nothrow_swappable_v<container_type> && is_nothrow_swappable_v<key_compare>) {
         constexpr bool _Is_noexcept = is_nothrow_swappable_v<container_type> && is_nothrow_swappable_v<key_compare>;
         _Flat_set_swap_clear_guard<_Is_noexcept, container_type> _Guard{
-            _STD addressof(_Mycont), _STD addressof(_Other._Mycont)};
-        _RANGES swap(_Mycont, _Other._Mycont);
-        _RANGES swap(_Mycomp, _Other._Mycomp);
+            _STD addressof(_Data), _STD addressof(_Other._Data)};
+        _RANGES swap(_Data, _Other._Data);
+        _RANGES swap(_Key_compare, _Other._Key_compare);
         _Guard._Dismiss();
     }
 
     void clear() noexcept {
-        _Mycont.clear();
+        _Data.clear();
     }
 
     // Observers
     _NODISCARD key_compare key_comp() const {
-        return _Mycomp;
+        return _Key_compare;
     }
     _NODISCARD value_compare value_comp() const {
-        return _Mycomp;
+        return _Key_compare;
     }
 
     // Set operations
     // NB: The non-const overloads are intentionally removed for brevity. This will not result in behavioral changes.
-    _NODISCARD const_iterator find(const _Kty& _Val) const {
+    _NODISCARD const_iterator find(const key_type& _Val) const {
         return _Find(_Val);
     }
     template <class _Other>
@@ -465,7 +473,7 @@ public:
         return _Find(_Val);
     }
 
-    _NODISCARD size_type count(const _Kty& _Val) const {
+    _NODISCARD size_type count(const key_type& _Val) const {
         return _Count(_Val);
     }
     template <class _Other>
@@ -474,7 +482,7 @@ public:
         return _Count(_Val);
     }
 
-    _NODISCARD bool contains(const _Kty& _Val) const {
+    _NODISCARD bool contains(const key_type& _Val) const {
         return _STD binary_search(cbegin(), cend(), _Val, _Pass_comp());
     }
     template <class _Other>
@@ -483,7 +491,7 @@ public:
         return _STD binary_search(cbegin(), cend(), _Val, _Pass_comp());
     }
 
-    _NODISCARD const_iterator lower_bound(const _Kty& _Val) const {
+    _NODISCARD const_iterator lower_bound(const key_type& _Val) const {
         return _STD lower_bound(cbegin(), cend(), _Val, _Pass_comp());
     }
     template <class _Other>
@@ -492,7 +500,7 @@ public:
         return _STD lower_bound(cbegin(), cend(), _Val, _Pass_comp());
     }
 
-    _NODISCARD const_iterator upper_bound(const _Kty& _Val) const {
+    _NODISCARD const_iterator upper_bound(const key_type& _Val) const {
         return _STD upper_bound(cbegin(), cend(), _Val, _Pass_comp());
     }
     template <class _Other>
@@ -501,7 +509,7 @@ public:
         return _STD upper_bound(cbegin(), cend(), _Val, _Pass_comp());
     }
 
-    _NODISCARD pair<const_iterator, const_iterator> equal_range(const _Kty& _Val) const {
+    _NODISCARD pair<const_iterator, const_iterator> equal_range(const key_type& _Val) const {
         return _Equal_range(_Val);
     }
     template <class _Other>
@@ -511,12 +519,12 @@ public:
     }
 
     _NODISCARD friend bool operator==(const _Derived& _Lhs, const _Derived& _Rhs) {
-        return _STD equal(_Lhs._Mycont.begin(), _Lhs._Mycont.end(), _Rhs._Mycont.begin(), _Rhs._Mycont.end());
+        return _STD equal(_Lhs._Data.begin(), _Lhs._Data.end(), _Rhs._Data.begin(), _Rhs._Data.end());
     }
 
     _NODISCARD friend auto operator<=>(const _Derived& _Lhs, const _Derived& _Rhs) {
         return _STD lexicographical_compare_three_way(
-            _Lhs.cbegin(), _Lhs.cend(), _Rhs.cbegin(), _Rhs.cend(), _Synth_three_way{});
+            _Lhs._Data.begin(), _Lhs._Data.end(), _Rhs._Data.begin(), _Rhs._Data.end(), _Synth_three_way{});
     }
 
     friend void swap(_Derived& _Lhs, _Derived& _Rhs) noexcept(noexcept(_Lhs.swap(_Rhs))) {
@@ -529,45 +537,91 @@ public:
 private:
 #endif
     _NODISCARD bool _Is_sorted_and_unique() const {
-        return _Is_sorted_and_unique(_Mycont.begin(), _Mycont.end());
+        return _Is_sorted_and_unique(_Data.begin(), _Data.end());
     }
 
 private:
     _NODISCARD bool _Is_sorted_and_unique(const const_iterator _It, const const_iterator _End) const {
         if constexpr (_IsUnique) {
             // sorted-unique
-            auto _Negated = [this](const key_type& _Lhs, const key_type& _Rhs) { return !_Compare(_Lhs, _Rhs); };
+            auto _Negated = [this](const key_type& _Lhs, const key_type& _Rhs) { return !_Compare_keys(_Lhs, _Rhs); };
             return _STD adjacent_find(_It, _End, _Negated) == _End;
         } else {
             return _STD is_sorted(_It, _End, _Pass_comp());
         }
     }
 
+    _NODISCARD auto _Erase_dupes_if_not_multi_pred() {
+        _STL_INTERNAL_STATIC_ASSERT(_IsUnique);
+        if constexpr (_Equivalence_is_equality<key_compare, key_type>) {
+            return equal_to<>{};
+        } else {
+            return [this](const key_type& _Lhs, const key_type& _Rhs) { return !_Compare_keys(_Lhs, _Rhs); };
+        }
+    }
+
+    template <bool _NeedSorting>
+    void _Restore_invariants(const size_type _Old_size) {
+        // No _Clear_guard needed. This is called only by _Insert_range() (which has a _Clear_guard)
+        // and _Establish_invariants() (which is called only by constructors which don't need guards
+        // and operator=() which has a _Clear_guard).
+
+        const auto _Begin   = _Data.begin();
+        const auto _Old_end = _Begin + static_cast<difference_type>(_Old_size);
+        const auto _End     = _Data.end();
+
+        if constexpr (_NeedSorting) {
+            _STD sort(_Old_end, _End, _Pass_comp());
+        } else {
+            _STL_ASSERT(_Is_sorted_and_unique(_Old_end, _End), _Msg_not_sorted);
+        }
+
+        _STD inplace_merge(_Begin, _Old_end, _End, _Pass_comp());
+
+        if constexpr (_IsUnique) {
+            _Data.erase(_STD unique(_Begin, _End, _Erase_dupes_if_not_multi_pred()), _End);
+        }
+
+        _STL_INTERNAL_CHECK(_Is_sorted_and_unique());
+    }
+
+    void _Establish_invariants() {
+        if (_Data.empty()) {
+            return;
+        }
+
+        const auto _Begin        = _Data.begin();
+        const auto _End          = _Data.end();
+        const auto _Sorted_until = _STD is_sorted_until(_Begin, _End, _Pass_comp()); // O(N) if already sorted.
+        const auto _Sorted_size  = static_cast<size_type>(_Sorted_until - _Begin);
+        _Restore_invariants<true>(_Sorted_size);
+    }
+
     template <class _Ty>
     _NODISCARD bool _Can_insert(const const_iterator _Where, const _Ty& _Val) const {
-        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_Ty, _Kty>); // only accepts _Kty
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_Ty, key_type>); // only accepts key_type
 
         // check that _Val can be inserted before _Where
         if constexpr (_IsUnique) {
             // check that _Where is the lower_bound for _Val, and *_Where is not equivalent to _Val
             // equivalent to checking *(_Where-1) < _Val < *_Where
-            return (_Where == cend() || _Compare(_Val, *_Where))
-                && (_Where == cbegin() || _Compare(*(_Where - 1), _Val));
+            return (_Where == cend() || _Compare_keys(_Val, *_Where))
+                && (_Where == cbegin() || _Compare_keys(*(_Where - 1), _Val));
         } else {
             // check that _Where is the upper_bound for _Val
             // equivalent to checking *(_Where-1) <= _Val < *_Where
-            return (_Where == cend() || _Compare(_Val, *_Where))
-                && (_Where == cbegin() || !_Compare(_Val, *(_Where - 1)));
+            return (_Where == cend() || _Compare_keys(_Val, *_Where))
+                && (_Where == cbegin() || !_Compare_keys(_Val, *(_Where - 1)));
         }
     }
 
     template <class _Ty>
     _NODISCARD iterator _Emplace_with_clear_guard(const const_iterator _Where, _Ty&& _Val) {
         if constexpr (_Has_guaranteed_single_insertion<container_type>) {
-            return _Mycont.emplace(_Where, _STD forward<_Ty>(_Val));
+            return _Data.emplace(_Where, _STD forward<_Ty>(_Val));
         } else {
             _Clear_guard _Guard{this};
-            auto _Iter     = _Mycont.emplace(_Where, _STD forward<_Ty>(_Val));
+            auto _Iter     = _Data.emplace(_Where, _STD forward<_Ty>(_Val));
             _Guard._Target = nullptr;
             return _Iter;
         }
@@ -577,24 +631,22 @@ private:
     _NODISCARD conditional_t<_IsUnique, pair<iterator, bool>, iterator> _Emplace(_Ty&& _Val) {
         if constexpr (_IsUnique) {
             const const_iterator _Where = lower_bound(_Val);
-            if (_Where != cend() && !_Compare(_Val, *_Where)) {
+            if (_Where != cend() && !_Compare_keys(_Val, *_Where)) {
                 return pair{_Where, false};
             }
 
-            if constexpr (is_same_v<remove_cvref_t<_Ty>, _Kty>) {
+            if constexpr (is_same_v<remove_cvref_t<_Ty>, key_type>) {
                 _STL_INTERNAL_CHECK(_Can_insert(_Where, _Val));
                 return pair{_Emplace_with_clear_guard(_Where, _STD forward<_Ty>(_Val)), true};
             } else {
                 // heterogeneous insertion
-                _STL_INTERNAL_STATIC_ASSERT(_Transparent<key_compare> && is_constructible_v<_Kty, _Ty>);
-                _Kty _Keyval(_STD forward<_Ty>(_Val));
-                _STL_ASSERT(_Can_insert(_Where, _Keyval),
-                    "The conversion from the heterogeneous key to key_type should "
-                    "be consistent with the heterogeneous lookup!");
+                _STL_INTERNAL_STATIC_ASSERT(_Transparent<key_compare> && is_constructible_v<key_type, _Ty>);
+                key_type _Keyval(_STD forward<_Ty>(_Val));
+                _STL_ASSERT(_Can_insert(_Where, _Keyval), _Msg_heterogeneous_insertion_inconsistent_with_lookup);
                 return pair{_Emplace_with_clear_guard(_Where, _STD move(_Keyval)), true};
             }
         } else {
-            _STL_INTERNAL_STATIC_ASSERT(is_same_v<remove_cvref_t<_Ty>, _Kty>);
+            _STL_INTERNAL_STATIC_ASSERT(is_same_v<remove_cvref_t<_Ty>, key_type>);
             return _Emplace_with_clear_guard(upper_bound(_Val), _STD forward<_Ty>(_Val));
         }
     }
@@ -606,9 +658,9 @@ private:
 
         if constexpr (_IsUnique) {
             // look for lower_bound(_Val)
-            if (_Where == _End || !_Compare(*_Where, _Val)) {
+            if (_Where == _End || !_Compare_keys(*_Where, _Val)) {
                 // _Val <= *_Where
-                if (_Where == _Begin || _Compare(*(_Where - 1), _Val)) {
+                if (_Where == _Begin || _Compare_keys(*(_Where - 1), _Val)) {
                     // _Val > *(_Where-1) ~ lower_bound is _Where
                 } else {
                     // _Val <= *(_Where-1) ~ lower_bound is in [_Begin,_Where-1]
@@ -619,29 +671,27 @@ private:
                 _Where = _STD lower_bound(_Where + 1, _End, _Val, _Pass_comp());
             }
 
-            if (_Where != _End && !_Compare(_Val, *_Where)) {
+            if (_Where != _End && !_Compare_keys(_Val, *_Where)) {
                 return _Where;
             }
 
-            if constexpr (is_same_v<remove_cvref_t<_Ty>, _Kty>) {
+            if constexpr (is_same_v<remove_cvref_t<_Ty>, key_type>) {
                 _STL_INTERNAL_CHECK(_Can_insert(_Where, _Val));
                 return _Emplace_with_clear_guard(_Where, _STD forward<_Ty>(_Val));
             } else {
                 // heterogeneous insertion
-                _STL_INTERNAL_STATIC_ASSERT(_Transparent<key_compare> && is_constructible_v<_Kty, _Ty>);
-                _Kty _Keyval(_STD forward<_Ty>(_Val));
-                _STL_ASSERT(_Can_insert(_Where, _Keyval),
-                    "The conversion from the heterogeneous key to key_type should "
-                    "be consistent with the heterogeneous lookup!");
+                _STL_INTERNAL_STATIC_ASSERT(_Transparent<key_compare> && is_constructible_v<key_type, _Ty>);
+                key_type _Keyval(_STD forward<_Ty>(_Val));
+                _STL_ASSERT(_Can_insert(_Where, _Keyval), _Msg_heterogeneous_insertion_inconsistent_with_lookup);
                 return _Emplace_with_clear_guard(_Where, _STD move(_Keyval));
             }
         } else {
-            _STL_INTERNAL_STATIC_ASSERT(is_same_v<remove_cvref_t<_Ty>, _Kty>);
+            _STL_INTERNAL_STATIC_ASSERT(is_same_v<remove_cvref_t<_Ty>, key_type>);
 
             // look for closest position just prior to _Where, respecting ordering
-            if (_Where == _End || _Compare(_Val, *_Where)) {
+            if (_Where == _End || _Compare_keys(_Val, *_Where)) {
                 // _Val < *_Where
-                if (_Where == _Begin || !_Compare(_Val, *(_Where - 1))) {
+                if (_Where == _Begin || !_Compare_keys(_Val, *(_Where - 1))) {
                     // _Val >= *(_Where-1) ~ closest valid position is _Where
                 } else {
                     // _Val < *(_Where-1) ~ closest valid position is upper_bound(_Val) located in [_Begin,_Where-1]
@@ -658,74 +708,74 @@ private:
         }
     }
 
-    template <bool _NeedSorting, class _Iter>
-    void _Insert_range(const _Iter _First, const _Iter _Last) {
+    template <bool _NeedSorting, class _InIt>
+    void _Insert_range(const _InIt _First, const _InIt _Last) {
         const size_type _Old_size = size();
         _Clear_guard _Guard{this};
-        _Mycont.insert(_Mycont.end(), _First, _Last);
-        _Restore_invariants_after_insert<_NeedSorting>(_Old_size);
+        _Data.insert(_Data.end(), _First, _Last);
+        _Restore_invariants<_NeedSorting>(_Old_size);
         _Guard._Target = nullptr;
     }
 
-    template <bool _NeedSorting, _Container_compatible_range<_Kty> _Rng>
+    template <bool _NeedSorting, _Container_compatible_range<value_type> _Rng>
     void _Insert_range(_Rng&& _Range) {
         const size_type _Old_size = size();
         _Clear_guard _Guard{this};
         if constexpr (_Has_guaranteed_append_range<container_type>) {
-            _Mycont.append_range(_STD forward<_Rng>(_Range));
+            _Data.append_range(_STD forward<_Rng>(_Range));
         } else {
-            _Mycont.insert_range(_Mycont.end(), _STD forward<_Rng>(_Range));
+            _Data.insert_range(_Data.end(), _STD forward<_Rng>(_Range));
         }
-        _Restore_invariants_after_insert<_NeedSorting>(_Old_size);
+        _Restore_invariants<_NeedSorting>(_Old_size);
         _Guard._Target = nullptr;
     }
 
-    template <class _Ty>
-    _NODISCARD size_type _Erase(const _Ty& _Val) {
-        _STL_INTERNAL_STATIC_ASSERT(_Transparent<key_compare> || is_same_v<_Ty, _Kty>);
+    template <class _KeyTy>
+    _NODISCARD size_type _Erase_key(const _KeyTy& _Key_val) {
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
 
-        if constexpr (_IsUnique && is_same_v<_Ty, key_type>) { // Optimization restricted due to GH-5992
-            const const_iterator _Where = lower_bound(_Val);
-            if (_Where != cend() && !_Compare(_Val, *_Where)) {
+        if constexpr (_IsUnique && is_same_v<_KeyTy, key_type>) { // Optimization restricted due to GH-5992
+            const const_iterator _Where = lower_bound(_Key_val);
+            if (_Where != cend() && !_Compare_keys(_Key_val, *_Where)) {
                 _Clear_guard _Guard{this};
-                _Mycont.erase(_Where);
+                _Data.erase(_Where);
                 _Guard._Target = nullptr;
                 return 1;
             }
             return 0;
         } else {
-            const auto [_First, _Last] = equal_range(_Val);
+            const auto [_First, _Last] = equal_range(_Key_val);
 
             const auto _Removed = static_cast<size_type>(_Last - _First);
             _Clear_guard _Guard{this};
-            _Mycont.erase(_First, _Last);
+            _Data.erase(_First, _Last);
             _Guard._Target = nullptr;
             return _Removed;
         }
     }
 
     // typename is a workaround for VSO-2680018 (EDG)
-    template <class _Kty2, class _Keylt2, class _Container2, class _Pred2>
-    friend typename _Container2::size_type erase_if(flat_set<_Kty2, _Keylt2, _Container2>&, _Pred2);
-    template <class _Kty2, class _Keylt2, class _Container2, class _Pred2>
-    friend typename _Container2::size_type erase_if(flat_multiset<_Kty2, _Keylt2, _Container2>&, _Pred2);
+    template <class _Key2, class _Compare2, class _Container2, class _Predicate2>
+    friend typename _Container2::size_type erase_if(flat_set<_Key2, _Compare2, _Container2>&, _Predicate2);
+    template <class _Key2, class _Compare2, class _Container2, class _Predicate2>
+    friend typename _Container2::size_type erase_if(flat_multiset<_Key2, _Compare2, _Container2>&, _Predicate2);
 
-    template <class _Pred>
-    _NODISCARD size_type _Erase_if(_Pred _Predicate) {
+    template <class _Predicate>
+    _NODISCARD size_type _Erase_if(_Predicate _Pred) {
         // Maintain invariants when an exception is thrown (N5032 [flat.set.erasure]/5, [flat.multiset.erasure]/5)
         _Clear_guard _Guard{this};
-        const auto _Erased_count = _STD _Erase_remove_if(_Mycont, _Predicate);
+        const auto _Erased_count = _STD _Erase_remove_if(_Data, _Pred);
         _Guard._Target           = nullptr;
         return _Erased_count;
     }
 
-    template <class _Ty>
-    _NODISCARD const_iterator _Find(const _Ty& _Val) const {
-        _STL_INTERNAL_STATIC_ASSERT(_Transparent<key_compare> || is_same_v<_Ty, _Kty>);
+    template <class _KeyTy>
+    _NODISCARD const_iterator _Find(const _KeyTy& _Key_val) const {
+        _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
 
         const const_iterator _End   = cend();
-        const const_iterator _Where = lower_bound(_Val);
-        if (_Where != _End && !_Compare(_Val, *_Where)) {
+        const const_iterator _Where = lower_bound(_Key_val);
+        if (_Where != _End && !_Compare_keys(_Key_val, *_Where)) {
             return _Where;
         } else {
             return _End;
@@ -748,156 +798,86 @@ private:
         _STL_INTERNAL_STATIC_ASSERT(is_same_v<_KeyTy, key_type> || _Transparent<key_compare>);
         if constexpr (_IsUnique && is_same_v<_KeyTy, key_type>) { // Optimization restricted due to GH-5992
             // In a non-multi container, equal_range can have size at most 1
-            const auto _First   = _STD lower_bound(_Mycont.begin(), _Mycont.end(), _Key_val, _Pass_comp());
-            const bool _Missing = _First == _Mycont.end() || _Compare(_Key_val, *_First);
+            const auto _First   = _STD lower_bound(_Data.begin(), _Data.end(), _Key_val, _Pass_comp());
+            const bool _Missing = _First == _Data.end() || _Compare_keys(_Key_val, *_First);
             return pair{_First, _Missing ? _First : _First + 1};
         } else {
             return _STD equal_range(begin(), end(), _Key_val, _Pass_comp());
         }
     }
 
-    auto _Erase_dupes_if_not_multi_pred() {
-        _STL_INTERNAL_STATIC_ASSERT(_IsUnique);
-        if constexpr (_Equivalence_is_equality<_Keylt, _Kty>) {
-            return equal_to<>{};
-        } else {
-            return [this](const _Kty& _Lhs, const _Kty& _Rhs) { return !_Compare(_Lhs, _Rhs); };
-        }
-    }
-
-    void _Erase_dupes_if_not_multi() {
-        if constexpr (_IsUnique) {
-            // No _Clear_guard needed. The only callers are _Restore_invariants_after_insert() (which is called
-            // only by _Insert_range() which has a _Clear_guard) and _Make_invariants_fulfilled() (which is called
-            // only by constructors which don't need guards and operator=() which has a _Clear_guard).
-            const auto _End = _Mycont.end();
-            _Mycont.erase(_STD unique(_Mycont.begin(), _End, _Erase_dupes_if_not_multi_pred()), _End);
-        }
-    }
-
-    template <bool _NeedSorting>
-    void _Restore_invariants_after_insert(const size_type _Old_size) {
-        const auto _Begin   = _Mycont.begin();
-        const auto _Old_end = _Begin + static_cast<difference_type>(_Old_size);
-        const auto _End     = _Mycont.end();
-
-        if constexpr (_NeedSorting) {
-            _STD sort(_Old_end, _End, _Pass_comp());
-        } else {
-            _STL_ASSERT(_Is_sorted_and_unique(_Old_end, _End), _Msg_not_sorted);
-        }
-
-        _STD inplace_merge(_Begin, _Old_end, _End, _Pass_comp());
-        _Erase_dupes_if_not_multi();
-
-        _STL_INTERNAL_CHECK(_Is_sorted_and_unique());
-    }
-
-    void _Make_invariants_fulfilled() {
-        const auto _Begin = _Mycont.begin();
-        const auto _End   = _Mycont.end();
-
-        if (_Begin == _End) {
-            return;
-        }
-
-        // O(N) if already sorted.
-        const auto _Begin_unsorted = _STD is_sorted_until(_Begin, _End, _Pass_comp());
-
-        _STD sort(_Begin_unsorted, _End, _Pass_comp());
-        _STD inplace_merge(_Begin, _Begin_unsorted, _End, _Pass_comp());
-        _Erase_dupes_if_not_multi();
-
-        _STL_INTERNAL_CHECK(_Is_sorted_and_unique());
-    }
-
     template <class _Lty, class _Rty>
-    _NODISCARD bool _Compare(const _Lty& _Lhs, const _Rty& _Rhs) const
-        noexcept(noexcept(_DEBUG_LT_PRED(_Mycomp, _Lhs, _Rhs))) {
-        _STL_INTERNAL_STATIC_ASSERT(_Transparent<key_compare> || (is_same_v<_Kty, _Lty> && is_same_v<_Kty, _Rty>) );
+    _NODISCARD bool _Compare_keys(const _Lty& _Lhs, const _Rty& _Rhs) const
+        noexcept(noexcept(_DEBUG_LT_PRED(_Key_compare, _Lhs, _Rhs))) {
+        _STL_INTERNAL_STATIC_ASSERT(
+            (is_same_v<_Lty, key_type> && is_same_v<_Rty, key_type>) || _Transparent<key_compare>);
 
-        return _DEBUG_LT_PRED(_Mycomp, _Lhs, _Rhs);
+        return _DEBUG_LT_PRED(_Key_compare, _Lhs, _Rhs);
     }
 
     _NODISCARD auto _Pass_comp() const noexcept {
-        return _STD _Pass_fn(_Mycomp);
+        return _STD _Pass_fn(_Key_compare);
     }
 
-    container_type _Mycont;
-    _MSVC_NO_UNIQUE_ADDRESS key_compare _Mycomp;
+    container_type _Data;
+    _MSVC_NO_UNIQUE_ADDRESS key_compare _Key_compare;
 };
 
-_EXPORT_STD template <class _Kty, class _Keylt, class _Container>
-class flat_set : public _Flat_set_base<true, _Kty, _Keylt, _Container> {
+_EXPORT_STD template <class _Key, class _Compare, class _Container>
+class flat_set : public _Flat_set_base<true, _Key, _Compare, _Container> {
 private:
-    using _Mybase = _Flat_set_base<true, _Kty, _Keylt, _Container>;
+    using _Mybase = _Flat_set_base<true, _Key, _Compare, _Container>;
 
 public:
     using _Mybase::_Mybase;
     flat_set(const flat_set&) = default;
     flat_set(flat_set&&)      = default;
 
-#if 1 // TRANSITION, P2582R1 (MSVC, Clang, EDG)
-    template <_Usable_allocator_for<_Container> _Allocator>
-    flat_set(const flat_set& _Other, const _Allocator& _Al) : _Mybase(_Other, _Al) {}
-
-    template <_Usable_allocator_for<_Container> _Allocator>
-    flat_set(flat_set&& _Other, const _Allocator& _Al) : _Mybase(_STD move(_Other), _Al) {}
-#endif // ^^^ workaround ^^^
-
     flat_set& operator=(const flat_set&) = default;
     flat_set& operator=(flat_set&&)      = default;
 
-    flat_set& operator=(const initializer_list<_Kty> _Ilist) {
+    flat_set& operator=(const initializer_list<_Key> _Ilist) {
         this->clear();
         this->insert(_Ilist.begin(), _Ilist.end());
         return *this;
     }
 };
 
-_EXPORT_STD template <class _Kty, class _Keylt, class _Container>
-class flat_multiset : public _Flat_set_base<false, _Kty, _Keylt, _Container> {
+_EXPORT_STD template <class _Key, class _Compare, class _Container>
+class flat_multiset : public _Flat_set_base<false, _Key, _Compare, _Container> {
 private:
-    using _Mybase = _Flat_set_base<false, _Kty, _Keylt, _Container>;
+    using _Mybase = _Flat_set_base<false, _Key, _Compare, _Container>;
 
 public:
     using _Mybase::_Mybase;
     flat_multiset(const flat_multiset&) = default;
     flat_multiset(flat_multiset&&)      = default;
 
-#if 1 // TRANSITION, P2582R1 (MSVC, Clang, EDG)
-    template <_Usable_allocator_for<_Container> _Allocator>
-    flat_multiset(const flat_multiset& _Other, const _Allocator& _Al) : _Mybase(_Other, _Al) {}
-
-    template <_Usable_allocator_for<_Container> _Allocator>
-    flat_multiset(flat_multiset&& _Other, const _Allocator& _Al) : _Mybase(_STD move(_Other), _Al) {}
-#endif // ^^^ workaround ^^^
-
     flat_multiset& operator=(const flat_multiset&) = default;
     flat_multiset& operator=(flat_multiset&&)      = default;
 
-    flat_multiset& operator=(const initializer_list<_Kty> _Ilist) {
+    flat_multiset& operator=(const initializer_list<_Key> _Ilist) {
         this->clear();
         this->insert(_Ilist.begin(), _Ilist.end());
         return *this;
     }
 };
 
-_EXPORT_STD template <class _Kty, class _Keylt, class _Container, class _Pred>
-_Container::size_type erase_if(flat_set<_Kty, _Keylt, _Container>& _Val, _Pred _Predicate) {
-    return _Val._Erase_if(_STD _Pass_fn(_Predicate));
+_EXPORT_STD template <class _Key, class _Compare, class _Container, class _Predicate>
+_Container::size_type erase_if(flat_set<_Key, _Compare, _Container>& _Cont, _Predicate _Pred) {
+    return _Cont._Erase_if(_STD _Pass_fn(_Pred));
 }
-_EXPORT_STD template <class _Kty, class _Keylt, class _Container, class _Pred>
-_Container::size_type erase_if(flat_multiset<_Kty, _Keylt, _Container>& _Val, _Pred _Predicate) {
-    return _Val._Erase_if(_STD _Pass_fn(_Predicate));
+_EXPORT_STD template <class _Key, class _Compare, class _Container, class _Predicate>
+_Container::size_type erase_if(flat_multiset<_Key, _Compare, _Container>& _Cont, _Predicate _Pred) {
+    return _Cont._Erase_if(_STD _Pass_fn(_Pred));
 }
 
-template <class _Kty, class _Keylt, class _Container, class _Alloc>
-struct uses_allocator<flat_set<_Kty, _Keylt, _Container>, _Alloc>
+template <class _Key, class _Compare, class _Container, class _Alloc>
+struct uses_allocator<flat_set<_Key, _Compare, _Container>, _Alloc>
     : bool_constant<uses_allocator_v<_Container, _Alloc>> {};
 
-template <class _Kty, class _Keylt, class _Container, class _Alloc>
-struct uses_allocator<flat_multiset<_Kty, _Keylt, _Container>, _Alloc>
+template <class _Key, class _Compare, class _Container, class _Alloc>
+struct uses_allocator<flat_multiset<_Key, _Compare, _Container>, _Alloc>
     : bool_constant<uses_allocator_v<_Container, _Alloc>> {};
 
 template <_Not_allocator_for_container _Container,
@@ -922,10 +902,15 @@ template <_Not_allocator_for_container _Container, _Valid_compare_for_container<
 flat_set(sorted_unique_t, _Container, _Compare, _Alloc)
     -> flat_set<typename _Container::value_type, _Compare, _Container>;
 
-template <_Iterator_for_container _Iter, _Not_allocator_for_container _Compare = less<iter_value_t<_Iter>>>
-flat_set(_Iter, _Iter, _Compare = _Compare()) -> flat_set<iter_value_t<_Iter>, _Compare>;
-template <_Iterator_for_container _Iter, _Not_allocator_for_container _Compare = less<iter_value_t<_Iter>>>
-flat_set(sorted_unique_t, _Iter, _Iter, _Compare = _Compare()) -> flat_set<iter_value_t<_Iter>, _Compare>;
+#if 1 // TRANSITION, P2582R1 (MSVC, Clang, EDG)
+template <class _Key, class _Compare, class _Container, _Usable_allocator_for<_Container> _Alloc>
+flat_set(flat_set<_Key, _Compare, _Container>, _Alloc) -> flat_set<_Key, _Compare, _Container>;
+#endif // ^^^ workaround ^^^
+
+template <_Iterator_for_container _InIt, _Not_allocator_for_container _Compare = less<iter_value_t<_InIt>>>
+flat_set(_InIt, _InIt, _Compare = _Compare()) -> flat_set<iter_value_t<_InIt>, _Compare>;
+template <_Iterator_for_container _InIt, _Not_allocator_for_container _Compare = less<iter_value_t<_InIt>>>
+flat_set(sorted_unique_t, _InIt, _InIt, _Compare = _Compare()) -> flat_set<iter_value_t<_InIt>, _Compare>;
 
 // TRANSITION, CWG-2369, should just use constrained template parameters.
 template <_RANGES input_range _Range, _Not_allocator_for_container _Compare = less<_RANGES range_value_t<_Range>>,
@@ -938,10 +923,10 @@ template <_RANGES input_range _Range, class _Alloc, enable_if_t<_Allocator_for_c
 flat_set(from_range_t, _Range&&, _Alloc) -> flat_set<_RANGES range_value_t<_Range>, less<_RANGES range_value_t<_Range>>,
     vector<_RANGES range_value_t<_Range>, _Rebind_alloc_t<_Alloc, _RANGES range_value_t<_Range>>>>;
 
-template <class _Kty, _Not_allocator_for_container _Compare = less<_Kty>>
-flat_set(initializer_list<_Kty>, _Compare = _Compare()) -> flat_set<_Kty, _Compare>;
-template <class _Kty, _Not_allocator_for_container _Compare = less<_Kty>>
-flat_set(sorted_unique_t, initializer_list<_Kty>, _Compare = _Compare()) -> flat_set<_Kty, _Compare>;
+template <class _Key, _Not_allocator_for_container _Compare = less<_Key>>
+flat_set(initializer_list<_Key>, _Compare = _Compare()) -> flat_set<_Key, _Compare>;
+template <class _Key, _Not_allocator_for_container _Compare = less<_Key>>
+flat_set(sorted_unique_t, initializer_list<_Key>, _Compare = _Compare()) -> flat_set<_Key, _Compare>;
 
 template <_Not_allocator_for_container _Container,
     _Valid_compare_for_container<_Container> _Compare = less<typename _Container::value_type>>
@@ -966,10 +951,15 @@ template <_Not_allocator_for_container _Container, _Valid_compare_for_container<
 flat_multiset(sorted_equivalent_t, _Container, _Compare, _Alloc)
     -> flat_multiset<typename _Container::value_type, _Compare, _Container>;
 
-template <_Iterator_for_container _Iter, _Not_allocator_for_container _Compare = less<iter_value_t<_Iter>>>
-flat_multiset(_Iter, _Iter, _Compare = _Compare()) -> flat_multiset<iter_value_t<_Iter>, _Compare>;
-template <_Iterator_for_container _Iter, _Not_allocator_for_container _Compare = less<iter_value_t<_Iter>>>
-flat_multiset(sorted_equivalent_t, _Iter, _Iter, _Compare = _Compare()) -> flat_multiset<iter_value_t<_Iter>, _Compare>;
+#if 1 // TRANSITION, P2582R1 (MSVC, Clang, EDG)
+template <class _Key, class _Compare, class _Container, _Usable_allocator_for<_Container> _Alloc>
+flat_multiset(flat_multiset<_Key, _Compare, _Container>, _Alloc) -> flat_multiset<_Key, _Compare, _Container>;
+#endif // ^^^ workaround ^^^
+
+template <_Iterator_for_container _InIt, _Not_allocator_for_container _Compare = less<iter_value_t<_InIt>>>
+flat_multiset(_InIt, _InIt, _Compare = _Compare()) -> flat_multiset<iter_value_t<_InIt>, _Compare>;
+template <_Iterator_for_container _InIt, _Not_allocator_for_container _Compare = less<iter_value_t<_InIt>>>
+flat_multiset(sorted_equivalent_t, _InIt, _InIt, _Compare = _Compare()) -> flat_multiset<iter_value_t<_InIt>, _Compare>;
 
 // TRANSITION, CWG-2369, should just use constrained template parameters.
 template <_RANGES input_range _Range, _Not_allocator_for_container _Compare = less<_RANGES range_value_t<_Range>>,
@@ -984,10 +974,10 @@ flat_multiset(from_range_t, _Range&&, _Alloc)
     -> flat_multiset<_RANGES range_value_t<_Range>, less<_RANGES range_value_t<_Range>>,
         vector<_RANGES range_value_t<_Range>, _Rebind_alloc_t<_Alloc, _RANGES range_value_t<_Range>>>>;
 
-template <class _Kty, _Not_allocator_for_container _Compare = less<_Kty>>
-flat_multiset(initializer_list<_Kty>, _Compare = _Compare()) -> flat_multiset<_Kty, _Compare>;
-template <class _Kty, _Not_allocator_for_container _Compare = less<_Kty>>
-flat_multiset(sorted_equivalent_t, initializer_list<_Kty>, _Compare = _Compare()) -> flat_multiset<_Kty, _Compare>;
+template <class _Key, _Not_allocator_for_container _Compare = less<_Key>>
+flat_multiset(initializer_list<_Key>, _Compare = _Compare()) -> flat_multiset<_Key, _Compare>;
+template <class _Key, _Not_allocator_for_container _Compare = less<_Key>>
+flat_multiset(sorted_equivalent_t, initializer_list<_Key>, _Compare = _Compare()) -> flat_multiset<_Key, _Compare>;
 
 _STD_END
 
diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index 54ac624422c..ca4a2989ef7 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -383,9 +383,9 @@ void test_construction() {
             MyAllocatorCounter allocation_counter;
             flat_map fmap(keys, vals, MyAllocator<int>{});
             assert(allocation_counter.check_then_reset());
-            flat_map fmap1(fmap);
+            flat_map fmap1(fmap, MyAllocator<int>{});
             assert(allocation_counter.check_then_reset());
-            flat_map fmap2(move(fmap));
+            flat_map fmap2(move(fmap), MyAllocator<int>{});
             assert(!allocation_counter.check_then_reset());
 
             assert(check_key_content(fmap1, {0, 1, 2, 3, 4}));
@@ -396,9 +396,9 @@ void test_construction() {
             MyAllocatorCounter allocation_counter;
             flat_multimap fmmap(keys, vals, MyAllocator<int>{});
             assert(allocation_counter.check_then_reset());
-            flat_multimap fmmap1(fmmap);
+            flat_multimap fmmap1(fmmap, MyAllocator<int>{});
             assert(allocation_counter.check_then_reset());
-            flat_multimap fmmap2(move(fmmap));
+            flat_multimap fmmap2(move(fmmap), MyAllocator<int>{});
             assert(!allocation_counter.check_then_reset());
 
             assert(check_key_content(fmmap1, {0, 1, 2, 2, 3, 4}));
diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index bc47cbae256..ac673797ca3 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -205,12 +205,11 @@ void test_constructors() {
     const int arr[] = {2, 7, 18, 28, 18, 28, 45, 90, 45, 23};
 
     // Test flat_set(InIt, InIt, const key_compare& = key_compare())
-    assert_all_requirements_and_equals(flat_set<int, lt, C>(begin(arr), end(arr)), {2, 7, 18, 23, 28, 45, 90});
+    assert_all_requirements_and_equals(flat_set(begin(arr), end(arr)), {2, 7, 18, 23, 28, 45, 90});
+    assert_all_requirements_and_equals(flat_multiset(begin(arr), end(arr)), {2, 7, 18, 18, 23, 28, 28, 45, 45, 90});
+    assert_all_requirements_and_equals(flat_set(begin(arr), end(arr), gt{}), {90, 45, 28, 23, 18, 7, 2});
     assert_all_requirements_and_equals(
-        flat_multiset<int, lt, C>(begin(arr), end(arr)), {2, 7, 18, 18, 23, 28, 28, 45, 45, 90});
-    assert_all_requirements_and_equals(flat_set<int, gt, C>(begin(arr), end(arr), gt{}), {90, 45, 28, 23, 18, 7, 2});
-    assert_all_requirements_and_equals(
-        flat_multiset<int, gt, C>(begin(arr), end(arr), gt{}), {90, 45, 45, 28, 28, 23, 18, 18, 7, 2});
+        flat_multiset(begin(arr), end(arr), gt{}), {90, 45, 45, 28, 28, 23, 18, 18, 7, 2});
 
     {
         // Test flat_set(sorted_unique_t, InIt, InIt, const key_compare& = key_compare())
@@ -218,32 +217,30 @@ void test_constructors() {
         const int ea[] = {40, 50, 50, 60, 60, 60}; // equivalent ascending
         const int ud[] = {66, 55, 44}; // unique descending
         const int ed[] = {33, 22, 22, 11, 11, 11}; // equivalent descending
-        assert_all_requirements_and_equals(flat_set<int, lt, C>(sorted_unique, begin(ua), end(ua)), ua);
-        assert_all_requirements_and_equals(flat_multiset<int, lt, C>(sorted_equivalent, begin(ea), end(ea)), ea);
-        assert_all_requirements_and_equals(flat_set<int, gt, C>(sorted_unique, begin(ud), end(ud), gt{}), ud);
-        assert_all_requirements_and_equals(flat_multiset<int, gt, C>(sorted_equivalent, begin(ed), end(ed), gt{}), ed);
+        assert_all_requirements_and_equals(flat_set(sorted_unique, begin(ua), end(ua)), ua);
+        assert_all_requirements_and_equals(flat_multiset(sorted_equivalent, begin(ea), end(ea)), ea);
+        assert_all_requirements_and_equals(flat_set(sorted_unique, begin(ud), end(ud), gt{}), ud);
+        assert_all_requirements_and_equals(flat_multiset(sorted_equivalent, begin(ed), end(ed), gt{}), ed);
     }
 
     // Test flat_set(from_range_t, R&&)
     // and  flat_set(from_range_t, R&&, const key_compare&)
-    assert_all_requirements_and_equals(flat_set<int, lt, C>(from_range, arr), {2, 7, 18, 23, 28, 45, 90});
-    assert_all_requirements_and_equals(
-        flat_multiset<int, lt, C>(from_range, arr), {2, 7, 18, 18, 23, 28, 28, 45, 45, 90});
-    assert_all_requirements_and_equals(flat_set<int, gt, C>(from_range, arr, gt{}), {90, 45, 28, 23, 18, 7, 2});
-    assert_all_requirements_and_equals(
-        flat_multiset<int, gt, C>(from_range, arr, gt{}), {90, 45, 45, 28, 28, 23, 18, 18, 7, 2});
+    assert_all_requirements_and_equals(flat_set(from_range, arr), {2, 7, 18, 23, 28, 45, 90});
+    assert_all_requirements_and_equals(flat_multiset(from_range, arr), {2, 7, 18, 18, 23, 28, 28, 45, 45, 90});
+    assert_all_requirements_and_equals(flat_set(from_range, arr, gt{}), {90, 45, 28, 23, 18, 7, 2});
+    assert_all_requirements_and_equals(flat_multiset(from_range, arr, gt{}), {90, 45, 45, 28, 28, 23, 18, 18, 7, 2});
 
     // Test flat_set(initializer_list<value_type>, const key_compare& = key_compare())
-    assert_all_requirements_and_equals(flat_set<int, lt, C>({3, 7, 1, 85, 222, 1}), {1, 3, 7, 85, 222});
-    assert_all_requirements_and_equals(flat_multiset<int, lt, C>({3, 7, 1, 85, 7, 222, 1}), {1, 1, 3, 7, 7, 85, 222});
-    assert_all_requirements_and_equals(flat_set<int, gt, C>({1, 2, 3, 3}, gt{}), {3, 2, 1});
-    assert_all_requirements_and_equals(flat_multiset<int, gt, C>({1, 1, 2, 3}, gt{}), {3, 2, 1, 1});
+    assert_all_requirements_and_equals(flat_set({3, 7, 1, 85, 222, 1}), {1, 3, 7, 85, 222});
+    assert_all_requirements_and_equals(flat_multiset({3, 7, 1, 85, 7, 222, 1}), {1, 1, 3, 7, 7, 85, 222});
+    assert_all_requirements_and_equals(flat_set({1, 2, 3, 3}, gt{}), {3, 2, 1});
+    assert_all_requirements_and_equals(flat_multiset({1, 1, 2, 3}, gt{}), {3, 2, 1, 1});
 
     // Test flat_set(sorted_unique_t, initializer_list<value_type>, const key_compare& = key_compare())
-    assert_all_requirements_and_equals(flat_set<int, lt, C>(sorted_unique, {1, 200, 30000}), {1, 200, 30000});
-    assert_all_requirements_and_equals(flat_multiset<int, lt, C>(sorted_equivalent, {-1, 3, 3}), {-1, 3, 3});
-    assert_all_requirements_and_equals(flat_set<int, gt, C>(sorted_unique, {30000, 200, 1}, gt{}), {30000, 200, 1});
-    assert_all_requirements_and_equals(flat_multiset<int, gt, C>(sorted_equivalent, {3, 3, -1}, gt{}), {3, 3, -1});
+    assert_all_requirements_and_equals(flat_set(sorted_unique, {1, 200, 30000}), {1, 200, 30000});
+    assert_all_requirements_and_equals(flat_multiset(sorted_equivalent, {-1, 3, 3}), {-1, 3, 3});
+    assert_all_requirements_and_equals(flat_set(sorted_unique, {30000, 200, 1}, gt{}), {30000, 200, 1});
+    assert_all_requirements_and_equals(flat_multiset(sorted_equivalent, {3, 3, -1}, gt{}), {3, 3, -1});
 }
 
 template <iterator_pair_construction Choice>
@@ -256,29 +253,30 @@ void test_allocator_extended_constructors() {
 
         fs s{3, 7, 1, 85, 222, 1};
         fs s_expected{1, 3, 7, 85, 222};
+        flat_set<int> s_expected_plain{1, 3, 7, 85, 222};
         vec v_raw{3, 7, 1, 85, 222, 1};
         vec v_sorted_unique{1, 3, 7, 85, 222};
 
         TEST_ASSERT(fs{ator} == fs{});
         TEST_ASSERT(fs{comp, ator} == fs{});
 
-        TEST_ASSERT(fs{s, ator} == s_expected);
-        TEST_ASSERT(fs{s_expected, ator} == s_expected);
-        TEST_ASSERT(fs{move(s), ator} == s_expected);
-        TEST_ASSERT(fs{fs{s_expected}, ator} == s_expected);
+        TEST_ASSERT(flat_set{s, ator} == s_expected);
+        TEST_ASSERT(flat_set{s_expected, ator} == s_expected);
+        TEST_ASSERT(flat_set{move(s), ator} == s_expected);
+        TEST_ASSERT(flat_set{fs{s_expected}, ator} == s_expected);
 
-        TEST_ASSERT(fs{v_raw, ator} == s_expected);
+        TEST_ASSERT(flat_set{v_raw, ator} == s_expected);
         TEST_ASSERT(fs{{3, 7, 1, 85, 222, 1}, ator} == s_expected);
         TEST_ASSERT(fs{v_raw.begin(), v_raw.end(), ator} == s_expected);
-        TEST_ASSERT(fs{from_range, v_raw, ator} == s_expected);
+        TEST_ASSERT(flat_set{from_range, v_raw, ator} == s_expected_plain);
 
-        TEST_ASSERT(fs{v_raw, comp, ator} == s_expected);
+        TEST_ASSERT(flat_set{v_raw, comp, ator} == s_expected);
         TEST_ASSERT(fs{{3, 7, 1, 85, 222, 1}, comp, ator} == s_expected);
         TEST_ASSERT(fs{v_raw.begin(), v_raw.end(), comp, ator} == s_expected);
-        TEST_ASSERT(fs{from_range, v_raw, comp, ator} == s_expected);
+        TEST_ASSERT(flat_set{from_range, v_raw, comp, ator} == s_expected_plain);
 
-        TEST_ASSERT(fs{sorted_unique, v_sorted_unique, ator} == s_expected);
-        TEST_ASSERT(fs{sorted_unique, v_sorted_unique, comp, ator} == s_expected);
+        TEST_ASSERT(flat_set{sorted_unique, v_sorted_unique, ator} == s_expected);
+        TEST_ASSERT(flat_set{sorted_unique, v_sorted_unique, comp, ator} == s_expected);
 
         TEST_ASSERT(fs{sorted_unique, {1, 3, 7, 85, 222}, ator} == s_expected);
         TEST_ASSERT(fs{sorted_unique, {1, 3, 7, 85, 222}, comp, ator} == s_expected);
@@ -291,29 +289,30 @@ void test_allocator_extended_constructors() {
 
         fms s{3, 7, 1, 85, 222, 1};
         fms s_expected{1, 1, 3, 7, 85, 222};
+        flat_multiset<int> s_expected_plain{1, 1, 3, 7, 85, 222};
         vec v_raw{3, 7, 1, 85, 222, 1};
         vec v_sorted_eq{1, 1, 3, 7, 85, 222};
 
         TEST_ASSERT(fms{ator} == fms{});
         TEST_ASSERT(fms{comp, ator} == fms{});
 
-        TEST_ASSERT(fms{s, ator} == s_expected);
-        TEST_ASSERT(fms{s_expected, ator} == s_expected);
-        TEST_ASSERT(fms{move(s), ator} == s_expected);
-        TEST_ASSERT(fms{fms{s_expected}, ator} == s_expected);
+        TEST_ASSERT(flat_multiset{s, ator} == s_expected);
+        TEST_ASSERT(flat_multiset{s_expected, ator} == s_expected);
+        TEST_ASSERT(flat_multiset{move(s), ator} == s_expected);
+        TEST_ASSERT(flat_multiset{fms{s_expected}, ator} == s_expected);
 
-        TEST_ASSERT(fms{v_raw, ator} == s_expected);
+        TEST_ASSERT(flat_multiset{v_raw, ator} == s_expected);
         TEST_ASSERT(fms{{3, 7, 1, 85, 222, 1}, ator} == s_expected);
         TEST_ASSERT(fms{v_raw.begin(), v_raw.end(), ator} == s_expected);
-        TEST_ASSERT(fms{from_range, v_raw, ator} == s_expected);
+        TEST_ASSERT(flat_multiset{from_range, v_raw, ator} == s_expected_plain);
 
-        TEST_ASSERT(fms{v_raw, comp, ator} == s_expected);
+        TEST_ASSERT(flat_multiset{v_raw, comp, ator} == s_expected);
         TEST_ASSERT(fms{{3, 7, 1, 85, 222, 1}, comp, ator} == s_expected);
         TEST_ASSERT(fms{v_raw.begin(), v_raw.end(), comp, ator} == s_expected);
-        TEST_ASSERT(fms{from_range, v_raw, comp, ator} == s_expected);
+        TEST_ASSERT(flat_multiset{from_range, v_raw, comp, ator} == s_expected_plain);
 
-        TEST_ASSERT(fms{sorted_equivalent, v_sorted_eq, ator} == s_expected);
-        TEST_ASSERT(fms{sorted_equivalent, v_sorted_eq, comp, ator} == s_expected);
+        TEST_ASSERT(flat_multiset{sorted_equivalent, v_sorted_eq, ator} == s_expected);
+        TEST_ASSERT(flat_multiset{sorted_equivalent, v_sorted_eq, comp, ator} == s_expected);
 
         TEST_ASSERT(fms{sorted_equivalent, {1, 1, 3, 7, 85, 222}, ator} == s_expected);
         TEST_ASSERT(fms{sorted_equivalent, {1, 1, 3, 7, 85, 222}, comp, ator} == s_expected);

From 9cb3a5c0bb115eb054866eda65f25c5ea338d66b Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Wed, 4 Feb 2026 08:17:13 -0800
Subject: [PATCH 124/134] `<flat_map>`, `<flat_set>`: Final fixes (#6070)

---
 stl/inc/flat_map | 98 ++++++++++++++++++++----------------------------
 stl/inc/flat_set | 11 +++---
 2 files changed, 45 insertions(+), 64 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index 7ab9517882c..4e7011d06fd 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -43,10 +43,6 @@ template <class _KeyIter, class _MappedIter, class _MappedConvIter>
 concept _Can_unwrap_pairing_iterator =
     !conjunction_v<is_same<_Unwrapped_t<_KeyIter>, _KeyIter>, is_same<_Unwrapped_t<_MappedIter>, _MappedIter>>;
 
-template <class _KeyIter, class _MappedIter, class _MappedConvIter>
-using _Unwrapped_pairing_iterator = _Pairing_iterator_provider<_Unwrapped_t<_KeyIter>, _Unwrapped_t<_MappedIter>,
-    _Unwrapped_t<_MappedConvIter>>::_Iterator;
-
 template <class _KeyIter, class _MappedIter, class _MappedConvIter>
 struct _Pairing_iterator_provider {
     class _Iterator {
@@ -66,22 +62,25 @@ struct _Pairing_iterator_provider {
         template <class _KeyIter2, class _MappedIter2, class _MappedConvIter2>
         friend struct _Pairing_iterator_provider;
 
-        _Iterator(_KeyIter _Key_iter, _MappedIter _Mapped_iter)
+        explicit _Iterator(_KeyIter _Key_iter, _MappedIter _Mapped_iter)
             noexcept(is_nothrow_move_constructible_v<_KeyIter> && is_nothrow_move_constructible_v<_MappedIter>)
             : _Key_it(_STD move(_Key_iter)), _Mapped_it(_STD move(_Mapped_iter)) {}
 
         using _Const_iterator     = _Pairing_iterator_provider<_KeyIter, _MappedConvIter, _MappedConvIter>::_Iterator;
-        using _Unwrapped_iterator = _Unwrapped_pairing_iterator<_KeyIter, _MappedIter, _MappedConvIter>;
+        using _Unwrapped_iterator = _Pairing_iterator_provider<_Unwrapped_t<_KeyIter>, _Unwrapped_t<_MappedIter>,
+            _Unwrapped_t<_MappedConvIter>>::_Iterator;
 
         class _Arrow_proxy {
         public:
-            explicit _Arrow_proxy(const reference& _Rx) noexcept : _Ref{_Rx} {}
-
             _NODISCARD const reference* operator->() const noexcept {
                 return _STD addressof(_Ref);
             }
 
         private:
+            friend _Iterator;
+
+            explicit _Arrow_proxy(const _Iterator& _Iter) : _Ref{*_Iter} {}
+
             reference _Ref;
         };
 
@@ -98,7 +97,7 @@ struct _Pairing_iterator_provider {
         }
 
         _NODISCARD pointer operator->() const {
-            return pointer{**this};
+            return pointer{*this};
         }
 
         _Iterator& operator++() {
@@ -148,15 +147,15 @@ struct _Pairing_iterator_provider {
         }
 
         _NODISCARD _Iterator operator+(const difference_type _Off) const {
-            auto _Old = *this;
-            _Old += _Off;
-            return _Old;
+            auto _Tmp = *this;
+            _Tmp += _Off;
+            return _Tmp;
         }
 
         _NODISCARD _Iterator operator-(const difference_type _Off) const {
-            auto _Old = *this;
-            _Old -= _Off;
-            return _Old;
+            auto _Tmp = *this;
+            _Tmp -= _Off;
+            return _Tmp;
         }
 
         _NODISCARD reference operator[](const difference_type _Off) const {
@@ -204,14 +203,10 @@ struct _Pairing_iterator_provider {
         void _Verify_offset(const difference_type _Off) const noexcept {
             if constexpr (_Offset_verifiable_v<_KeyIter>) {
                 _Key_it._Verify_offset(_Off);
-            } else {
-                _STL_VERIFY(_Off == 0 || _Key_it != _KeyIter(), "cannot seek value-initialized iterator");
             }
 
             if constexpr (_Offset_verifiable_v<_MappedIter>) {
                 _Mapped_it._Verify_offset(_Off);
-            } else {
-                _STL_VERIFY(_Off == 0 || _Mapped_it != _MappedIter(), "cannot seek value-initialized iterator");
             }
         }
 
@@ -351,7 +346,7 @@ public:
     private:
         friend _Flat_map_base;
 
-        value_compare(const key_compare& _Comp) : _Key_comparator(_Comp) {}
+        explicit value_compare(const key_compare& _Comp) : _Key_comparator(_Comp) {}
 
         key_compare _Key_comparator;
     };
@@ -366,9 +361,9 @@ public:
 
     _Flat_map_base(const _Flat_map_base&) = default;
 
-    _Flat_map_base(_Flat_map_base&& _Other)
-        noexcept(is_nothrow_copy_constructible_v<key_compare> && is_nothrow_move_constructible_v<key_container_type>
-                 && is_nothrow_move_constructible_v<mapped_container_type>) // strengthened
+    _Flat_map_base(_Flat_map_base&& _Other) noexcept(is_nothrow_move_constructible_v<key_container_type>
+                                                     && is_nothrow_move_constructible_v<mapped_container_type>
+                                                     && is_nothrow_copy_constructible_v<key_compare>) // strengthened
         : _Data(_STD move(_Other).extract()),
           _Key_compare(_Other._Key_compare) // intentionally copy comparator, see LWG-2227
     {}
@@ -552,8 +547,8 @@ public:
     }
 
     _Flat_map_base& operator=(_Flat_map_base&& _Other)
-        noexcept(is_nothrow_copy_assignable_v<key_compare> && is_nothrow_move_assignable_v<key_container_type>
-                 && is_nothrow_move_assignable_v<mapped_container_type>) /* strengthened */ {
+        noexcept(is_nothrow_move_assignable_v<key_container_type> && is_nothrow_move_assignable_v<mapped_container_type>
+                 && is_nothrow_copy_assignable_v<key_compare>) /* strengthened */ {
         if (this != _STD addressof(_Other)) {
             _Clear_guard _Guard{this};
             _Clear_guard _Always_clear{_STD addressof(_Other)};
@@ -745,12 +740,11 @@ public:
         constexpr bool _Is_noexcept = is_nothrow_swappable_v<key_container_type>
                                    && is_nothrow_swappable_v<mapped_container_type>
                                    && is_nothrow_swappable_v<key_compare>;
-        auto& _Other_base = static_cast<_Flat_map_base&>(_Other);
         _Flat_map_swap_clear_guard<_Is_noexcept, containers> _Guard{
-            _STD addressof(_Data), _STD addressof(_Other_base._Data)};
-        _RANGES swap(_Data.keys, _Other_base._Data.keys);
-        _RANGES swap(_Data.values, _Other_base._Data.values);
-        _RANGES swap(_Key_compare, _Other_base._Key_compare);
+            _STD addressof(_Data), _STD addressof(_Other._Data)};
+        _RANGES swap(_Data.keys, _Other._Data.keys);
+        _RANGES swap(_Data.values, _Other._Data.values);
+        _RANGES swap(_Key_compare, _Other._Key_compare);
         _Guard._Dismiss();
     }
 
@@ -904,9 +898,8 @@ protected:
         }
 
         // Need to insert
-        key_type _Key_to_insert(_STD forward<_OtherKey>(_Key_val));
-        mapped_type _Mapped_to_insert(_STD forward<_MappedArgTypes>(_Mapped_args)...);
-        _Insert_exact(cbegin() + _Index, _STD move(_Key_to_insert), _STD move(_Mapped_to_insert));
+        _Emplace_exact(
+            cbegin() + _Index, _STD forward<_OtherKey>(_Key_val), _STD forward<_MappedArgTypes>(_Mapped_args)...);
 
         if constexpr (_IsUnique) {
             return {begin() + _Index, true};
@@ -917,7 +910,7 @@ protected:
 
     template <bool _OverwriteIfExists, class _OtherKey, class... _MappedArgTypes>
     _NODISCARD iterator _Emplace_hint(
-        const const_iterator _Position, _OtherKey&& _Key_val, _MappedArgTypes&&... _Args) {
+        const const_iterator _Position, _OtherKey&& _Key_val, _MappedArgTypes&&... _Mapped_args) {
         _STL_INTERNAL_STATIC_ASSERT(is_constructible_v<mapped_type, _MappedArgTypes...>);
         _STL_INTERNAL_STATIC_ASSERT(is_same_v<remove_cvref_t<_OtherKey>, key_type>
                                     || (is_constructible_v<key_type, _OtherKey> && _Transparent<key_compare>) );
@@ -949,18 +942,9 @@ protected:
             return weak_ordering::less;
         }();
 
-        if (_Hint_order == weak_ordering::equivalent) {
-            const auto _Dist = _Position._Key_it - _Begin._Key_it;
-            {
-                key_type _Key_to_insert(_STD forward<_OtherKey>(_Key_val));
-                mapped_type _Mapped_to_insert(_STD forward<_MappedArgTypes>(_Args)...);
-                _Insert_exact(_Position, _STD move(_Key_to_insert), _STD move(_Mapped_to_insert));
-            }
-            return begin() + _Dist;
-        }
-
         const auto _New_position = _Iterator_from_key_iterator(
-            _Hint_order == weak_ordering::less
+            _Hint_order == weak_ordering::equivalent ? _Position._Key_it
+            : _Hint_order == weak_ordering::less
                 ? _STD lower_bound(_Position._Key_it, _Data.keys.cend(), _Key_val, _Pass_key_comp())
                 : _STD upper_bound(_Data.keys.cbegin(), _Position._Key_it, _Key_val, _Pass_key_comp()));
 
@@ -968,15 +952,15 @@ protected:
             if (_Hint_order == weak_ordering::less) {
                 if (_New_position != _End && !_Compare_keys(_Key_val, *_New_position._Key_it)) {
                     if constexpr (_OverwriteIfExists) {
-                        *_New_position._Mapped_it = mapped_type(_STD forward<_MappedArgTypes>(_Args)...);
+                        *_New_position._Mapped_it = mapped_type(_STD forward<_MappedArgTypes>(_Mapped_args)...);
                     }
                     return _New_position;
                 }
-            } else {
+            } else if (_Hint_order == weak_ordering::greater) {
                 if (_New_position != _Begin && !_Compare_keys(*(_New_position._Key_it - 1), _Key_val)) {
                     const auto _It = _New_position - 1;
                     if constexpr (_OverwriteIfExists) {
-                        *_It._Mapped_it = mapped_type(_STD forward<_MappedArgTypes>(_Args)...);
+                        *_It._Mapped_it = mapped_type(_STD forward<_MappedArgTypes>(_Mapped_args)...);
                     }
                     return _It;
                 }
@@ -984,11 +968,8 @@ protected:
         }
 
         const auto _Dist = _New_position - begin();
-        {
-            key_type _Key_to_insert(_STD forward<_OtherKey>(_Key_val));
-            mapped_type _Mapped_to_insert(_STD forward<_MappedArgTypes>(_Args)...);
-            _Insert_exact(_New_position, _STD move(_Key_to_insert), _STD move(_Mapped_to_insert));
-        }
+        _Emplace_exact(
+            _New_position, _STD forward<_OtherKey>(_Key_val), _STD forward<_MappedArgTypes>(_Mapped_args)...);
         return begin() + _Dist;
     }
 
@@ -1089,19 +1070,20 @@ private:
         _Restore_invariants<true>(_Sorted_size);
     }
 
-    void _Insert_exact(const const_iterator _Position, key_type&& _Key_val, mapped_type&& _Mapped_val) {
+    template <class _OtherKey, class... _MappedArgTypes>
+    void _Emplace_exact(const const_iterator _Position, _OtherKey&& _Key_val, _MappedArgTypes&&... _Mapped_args) {
         _Clear_guard _Guard{this};
-        _Data.keys.insert(_Position._Key_it, _STD move(_Key_val));
-        _Data.values.insert(_Position._Mapped_it, _STD move(_Mapped_val));
+        _Data.keys.emplace(_Position._Key_it, _STD forward<_OtherKey>(_Key_val));
+        _Data.values.emplace(_Position._Mapped_it, _STD forward<_MappedArgTypes>(_Mapped_args)...);
         _Guard._Target = nullptr;
     }
 
     template <bool _NeedSorting, class _InIt, class _Sentinel>
     void _Insert_range(_InIt _First, const _Sentinel _Last) {
-        const size_type _Old_size = size();
-
         _Clear_guard _Guard{this};
 
+        const size_type _Old_size = size();
+
         // Insert the new elements at the end
         for (; _First != _Last; ++_First) {
             value_type _Val = *_First;
diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index 12a6f90268f..d0f59f48c1f 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -333,7 +333,7 @@ public:
     auto emplace(_ArgTypes&&... _Args)
         requires is_constructible_v<value_type, _ArgTypes...>
     {
-        constexpr bool _Is_key_type = _In_place_key_extract_set<key_type, remove_cvref_t<_ArgTypes>...>::_Extractable;
+        constexpr bool _Is_key_type = _In_place_key_extract_set<key_type, _ArgTypes...>::_Extractable;
         if constexpr (_Is_key_type) {
             return _Emplace(_STD forward<_ArgTypes>(_Args)...);
         } else {
@@ -345,7 +345,7 @@ public:
     iterator emplace_hint(const const_iterator _Position, _ArgTypes&&... _Args)
         requires is_constructible_v<value_type, _ArgTypes...>
     {
-        constexpr bool _Is_key_type = _In_place_key_extract_set<key_type, remove_cvref_t<_ArgTypes>...>::_Extractable;
+        constexpr bool _Is_key_type = _In_place_key_extract_set<key_type, _ArgTypes...>::_Extractable;
         if constexpr (_Is_key_type) {
             return _Emplace_hint(_Position, _STD forward<_ArgTypes>(_Args)...);
         } else {
@@ -563,8 +563,7 @@ private:
     template <bool _NeedSorting>
     void _Restore_invariants(const size_type _Old_size) {
         // No _Clear_guard needed. This is called only by _Insert_range() (which has a _Clear_guard)
-        // and _Establish_invariants() (which is called only by constructors which don't need guards
-        // and operator=() which has a _Clear_guard).
+        // and _Establish_invariants() (which is called only by constructors which don't need guards).
 
         const auto _Begin   = _Data.begin();
         const auto _Old_end = _Begin + static_cast<difference_type>(_Old_size);
@@ -710,8 +709,8 @@ private:
 
     template <bool _NeedSorting, class _InIt>
     void _Insert_range(const _InIt _First, const _InIt _Last) {
-        const size_type _Old_size = size();
         _Clear_guard _Guard{this};
+        const size_type _Old_size = size();
         _Data.insert(_Data.end(), _First, _Last);
         _Restore_invariants<_NeedSorting>(_Old_size);
         _Guard._Target = nullptr;
@@ -719,8 +718,8 @@ private:
 
     template <bool _NeedSorting, _Container_compatible_range<value_type> _Rng>
     void _Insert_range(_Rng&& _Range) {
-        const size_type _Old_size = size();
         _Clear_guard _Guard{this};
+        const size_type _Old_size = size();
         if constexpr (_Has_guaranteed_append_range<container_type>) {
             _Data.append_range(_STD forward<_Rng>(_Range));
         } else {

From c4f7dea708bb16d15b3c719f79b4f41de17e55fe Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Mon, 9 Feb 2026 09:41:56 -0800
Subject: [PATCH 125/134] `_Is_sorted_and_unique` => `_Is_sorted_maybe_unique`

---
 stl/inc/flat_map                              | 16 +++++-----
 stl/inc/flat_set                              | 30 +++++++++----------
 .../include/test_container_requirements.hpp   |  2 +-
 3 files changed, 24 insertions(+), 24 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index 4e7011d06fd..94f88618c29 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -381,7 +381,7 @@ public:
         const key_compare& _Comp = key_compare())
         : _Data{.keys = _STD move(_Key_cont), .values = _STD move(_Mapped_cont)}, _Key_compare(_Comp) {
         _STL_ASSERT(_Data.keys.size() == _Data.values.size(), _Msg_different_sizes);
-        _STL_ASSERT(_Is_sorted_and_unique(), _Msg_not_sorted);
+        _STL_ASSERT(_Is_sorted_maybe_unique(), _Msg_not_sorted);
     }
 
     template <_Iterator_for_container _InIt>
@@ -455,7 +455,7 @@ public:
               .values = _STD make_obj_using_allocator<mapped_container_type>(_Al, _Mapped_cont)},
           _Key_compare(_Comp) {
         _STL_ASSERT(_Data.keys.size() == _Data.values.size(), _Msg_different_sizes);
-        _STL_ASSERT(_Is_sorted_and_unique(), _Msg_not_sorted);
+        _STL_ASSERT(_Is_sorted_maybe_unique(), _Msg_not_sorted);
     }
 
     template <_Usable_allocator_for<key_container_type, mapped_container_type> _Alloc>
@@ -696,7 +696,7 @@ public:
 
     void replace(key_container_type&& _Key_cont, mapped_container_type&& _Mapped_cont) {
         _STL_ASSERT(_Key_cont.size() == _Mapped_cont.size(), _Msg_replace_different_sizes);
-        _STL_ASSERT(_Is_sorted_and_unique(_Key_cont.begin(), _Key_cont.end()), _Msg_replace_not_sorted);
+        _STL_ASSERT(_Is_sorted_maybe_unique(_Key_cont.begin(), _Key_cont.end()), _Msg_replace_not_sorted);
         _Clear_guard _Guard{this};
         _Data.keys     = _STD move(_Key_cont);
         _Data.values   = _STD move(_Mapped_cont);
@@ -978,12 +978,12 @@ public:
 #else
 private:
 #endif
-    _NODISCARD bool _Is_sorted_and_unique() const {
-        return _Is_sorted_and_unique(_Data.keys.begin(), _Data.keys.end());
+    _NODISCARD bool _Is_sorted_maybe_unique() const {
+        return _Is_sorted_maybe_unique(_Data.keys.begin(), _Data.keys.end());
     }
 
 private:
-    _NODISCARD bool _Is_sorted_and_unique(
+    _NODISCARD bool _Is_sorted_maybe_unique(
         const key_container_type::const_iterator _It, const key_container_type::const_iterator _End) const {
         if constexpr (_IsUnique) {
             // sorted-unique
@@ -1044,7 +1044,7 @@ private:
             _RANGES sort(_Old_end, _End, _Value_compare_to_pass{_Key_compare});
         } else {
             [[maybe_unused]] const auto _Diff = static_cast<key_container_type::difference_type>(_Old_size);
-            _STL_ASSERT(_Is_sorted_and_unique(_Data.keys.begin() + _Diff, _Data.keys.end()), _Msg_not_sorted);
+            _STL_ASSERT(_Is_sorted_maybe_unique(_Data.keys.begin() + _Diff, _Data.keys.end()), _Msg_not_sorted);
         }
 
         _RANGES inplace_merge(_View, _Old_end, _Value_compare_to_pass{_Key_compare});
@@ -1055,7 +1055,7 @@ private:
             _Data.values.erase(_New_last._Mapped_it, _Data.values.end());
         }
 
-        _STL_INTERNAL_CHECK(_Is_sorted_and_unique());
+        _STL_INTERNAL_CHECK(_Is_sorted_maybe_unique());
     }
 
     void _Establish_invariants() {
diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index d0f59f48c1f..9fa2fa4d180 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -125,7 +125,7 @@ public:
 
     _Flat_set_base(_Sorted_t, container_type _Cont, const key_compare& _Comp = key_compare())
         : _Data(_STD move(_Cont)), _Key_compare(_Comp) {
-        _STL_ASSERT(_Is_sorted_and_unique(), _Msg_not_sorted);
+        _STL_ASSERT(_Is_sorted_maybe_unique(), _Msg_not_sorted);
     }
 
     template <_Iterator_for_container _InIt>
@@ -137,7 +137,7 @@ public:
     template <_Iterator_for_container _InIt>
     _Flat_set_base(_Sorted_t, const _InIt _First, const _InIt _Last, const key_compare& _Comp = key_compare())
         : _Data(_First, _Last), _Key_compare(_Comp) {
-        _STL_ASSERT(_Is_sorted_and_unique(), _Msg_not_sorted);
+        _STL_ASSERT(_Is_sorted_maybe_unique(), _Msg_not_sorted);
     }
 
     template <_Container_compatible_range<value_type> _Rng>
@@ -158,7 +158,7 @@ public:
 
     _Flat_set_base(_Sorted_t, const initializer_list<value_type> _Ilist, const key_compare& _Comp = key_compare())
         : _Data(_Ilist.begin(), _Ilist.end()), _Key_compare(_Comp) {
-        _STL_ASSERT(_Is_sorted_and_unique(), _Msg_not_sorted);
+        _STL_ASSERT(_Is_sorted_maybe_unique(), _Msg_not_sorted);
     }
 
     // [flat.set.cons.alloc] Constructors with allocators
@@ -185,13 +185,13 @@ public:
     template <_Usable_allocator_for<container_type> _Alloc>
     _Flat_set_base(_Sorted_t, const container_type& _Cont, const _Alloc& _Al)
         : _Data(_STD make_obj_using_allocator<container_type>(_Al, _Cont)), _Key_compare() {
-        _STL_ASSERT(_Is_sorted_and_unique(), _Msg_not_sorted);
+        _STL_ASSERT(_Is_sorted_maybe_unique(), _Msg_not_sorted);
     }
 
     template <_Usable_allocator_for<container_type> _Alloc>
     _Flat_set_base(_Sorted_t, const container_type& _Cont, const key_compare& _Comp, const _Alloc& _Al)
         : _Data(_STD make_obj_using_allocator<container_type>(_Al, _Cont)), _Key_compare(_Comp) {
-        _STL_ASSERT(_Is_sorted_and_unique(), _Msg_not_sorted);
+        _STL_ASSERT(_Is_sorted_maybe_unique(), _Msg_not_sorted);
     }
 
     template <_Usable_allocator_for<container_type> _Alloc>
@@ -219,13 +219,13 @@ public:
     template <_Iterator_for_container _InIt, _Usable_allocator_for<container_type> _Alloc>
     _Flat_set_base(_Sorted_t, const _InIt _First, const _InIt _Last, const _Alloc& _Al)
         : _Data(_STD make_obj_using_allocator<container_type>(_Al, _First, _Last)), _Key_compare() {
-        _STL_ASSERT(_Is_sorted_and_unique(), _Msg_not_sorted);
+        _STL_ASSERT(_Is_sorted_maybe_unique(), _Msg_not_sorted);
     }
 
     template <_Iterator_for_container _InIt, _Usable_allocator_for<container_type> _Alloc>
     _Flat_set_base(_Sorted_t, const _InIt _First, const _InIt _Last, const key_compare& _Comp, const _Alloc& _Al)
         : _Data(_STD make_obj_using_allocator<container_type>(_Al, _First, _Last)), _Key_compare(_Comp) {
-        _STL_ASSERT(_Is_sorted_and_unique(), _Msg_not_sorted);
+        _STL_ASSERT(_Is_sorted_maybe_unique(), _Msg_not_sorted);
     }
 
     template <_Container_compatible_range<value_type> _Rng, _Usable_allocator_for<container_type> _Alloc>
@@ -257,13 +257,13 @@ public:
     template <_Usable_allocator_for<container_type> _Alloc>
     _Flat_set_base(_Sorted_t, const initializer_list<value_type> _Ilist, const _Alloc& _Al)
         : _Data(_STD make_obj_using_allocator<container_type>(_Al, _Ilist.begin(), _Ilist.end())), _Key_compare() {
-        _STL_ASSERT(_Is_sorted_and_unique(), _Msg_not_sorted);
+        _STL_ASSERT(_Is_sorted_maybe_unique(), _Msg_not_sorted);
     }
 
     template <_Usable_allocator_for<container_type> _Alloc>
     _Flat_set_base(_Sorted_t, const initializer_list<value_type> _Ilist, const key_compare& _Comp, const _Alloc& _Al)
         : _Data(_STD make_obj_using_allocator<container_type>(_Al, _Ilist.begin(), _Ilist.end())), _Key_compare(_Comp) {
-        _STL_ASSERT(_Is_sorted_and_unique(), _Msg_not_sorted);
+        _STL_ASSERT(_Is_sorted_maybe_unique(), _Msg_not_sorted);
     }
 
     // Assignment operators
@@ -410,7 +410,7 @@ public:
     }
 
     void replace(container_type&& _Cont) {
-        _STL_ASSERT(_Is_sorted_and_unique(_Cont.begin(), _Cont.end()), _Msg_replace_not_sorted);
+        _STL_ASSERT(_Is_sorted_maybe_unique(_Cont.begin(), _Cont.end()), _Msg_replace_not_sorted);
         _Clear_guard _Guard{this};
         _Data          = _STD move(_Cont);
         _Guard._Target = nullptr;
@@ -536,12 +536,12 @@ public:
 #else
 private:
 #endif
-    _NODISCARD bool _Is_sorted_and_unique() const {
-        return _Is_sorted_and_unique(_Data.begin(), _Data.end());
+    _NODISCARD bool _Is_sorted_maybe_unique() const {
+        return _Is_sorted_maybe_unique(_Data.begin(), _Data.end());
     }
 
 private:
-    _NODISCARD bool _Is_sorted_and_unique(const const_iterator _It, const const_iterator _End) const {
+    _NODISCARD bool _Is_sorted_maybe_unique(const const_iterator _It, const const_iterator _End) const {
         if constexpr (_IsUnique) {
             // sorted-unique
             auto _Negated = [this](const key_type& _Lhs, const key_type& _Rhs) { return !_Compare_keys(_Lhs, _Rhs); };
@@ -572,7 +572,7 @@ private:
         if constexpr (_NeedSorting) {
             _STD sort(_Old_end, _End, _Pass_comp());
         } else {
-            _STL_ASSERT(_Is_sorted_and_unique(_Old_end, _End), _Msg_not_sorted);
+            _STL_ASSERT(_Is_sorted_maybe_unique(_Old_end, _End), _Msg_not_sorted);
         }
 
         _STD inplace_merge(_Begin, _Old_end, _End, _Pass_comp());
@@ -581,7 +581,7 @@ private:
             _Data.erase(_STD unique(_Begin, _End, _Erase_dupes_if_not_multi_pred()), _End);
         }
 
-        _STL_INTERNAL_CHECK(_Is_sorted_and_unique());
+        _STL_INTERNAL_CHECK(_Is_sorted_maybe_unique());
     }
 
     void _Establish_invariants() {
diff --git a/tests/std/include/test_container_requirements.hpp b/tests/std/include/test_container_requirements.hpp
index be234339777..43f18fc1eb3 100644
--- a/tests/std/include/test_container_requirements.hpp
+++ b/tests/std/include/test_container_requirements.hpp
@@ -127,7 +127,7 @@ void assert_is_sorted_maybe_unique(const T& s) {
     const auto end_it   = s.cend();
 
     // internal check by the container itself
-    assert(s._Is_sorted_and_unique());
+    assert(s._Is_sorted_maybe_unique());
 
     // external check observable by the user
     assert(std::is_sorted(begin_it, end_it, val_comp));

From d587c3ba1e58f97fd3abda886881cc48b171b7c8 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Mon, 9 Feb 2026 09:45:20 -0800
Subject: [PATCH 126/134] `_Msg_not_sorted` => `_Msg_not_sorted_maybe_unique`

---
 stl/inc/flat_map |  9 +++++----
 stl/inc/flat_set | 22 +++++++++++-----------
 2 files changed, 16 insertions(+), 15 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index 94f88618c29..2c980260a81 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -283,7 +283,7 @@ private:
     using _Derived  = conditional_t<_IsUnique, flat_map<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>,
          flat_multimap<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>>;
 
-    static constexpr const char* _Msg_not_sorted = //
+    static constexpr const char* _Msg_not_sorted_maybe_unique = //
         _IsUnique ? "Keys were not sorted-unique! (N5032 [flat.map.overview]/10)"
                   : "Keys were not sorted! (N5032 [flat.multimap.overview]/10)";
     static constexpr const char* _Msg_replace_not_sorted =
@@ -381,7 +381,7 @@ public:
         const key_compare& _Comp = key_compare())
         : _Data{.keys = _STD move(_Key_cont), .values = _STD move(_Mapped_cont)}, _Key_compare(_Comp) {
         _STL_ASSERT(_Data.keys.size() == _Data.values.size(), _Msg_different_sizes);
-        _STL_ASSERT(_Is_sorted_maybe_unique(), _Msg_not_sorted);
+        _STL_ASSERT(_Is_sorted_maybe_unique(), _Msg_not_sorted_maybe_unique);
     }
 
     template <_Iterator_for_container _InIt>
@@ -455,7 +455,7 @@ public:
               .values = _STD make_obj_using_allocator<mapped_container_type>(_Al, _Mapped_cont)},
           _Key_compare(_Comp) {
         _STL_ASSERT(_Data.keys.size() == _Data.values.size(), _Msg_different_sizes);
-        _STL_ASSERT(_Is_sorted_maybe_unique(), _Msg_not_sorted);
+        _STL_ASSERT(_Is_sorted_maybe_unique(), _Msg_not_sorted_maybe_unique);
     }
 
     template <_Usable_allocator_for<key_container_type, mapped_container_type> _Alloc>
@@ -1044,7 +1044,8 @@ private:
             _RANGES sort(_Old_end, _End, _Value_compare_to_pass{_Key_compare});
         } else {
             [[maybe_unused]] const auto _Diff = static_cast<key_container_type::difference_type>(_Old_size);
-            _STL_ASSERT(_Is_sorted_maybe_unique(_Data.keys.begin() + _Diff, _Data.keys.end()), _Msg_not_sorted);
+            _STL_ASSERT(
+                _Is_sorted_maybe_unique(_Data.keys.begin() + _Diff, _Data.keys.end()), _Msg_not_sorted_maybe_unique);
         }
 
         _RANGES inplace_merge(_View, _Old_end, _Value_compare_to_pass{_Key_compare});
diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index 9fa2fa4d180..19d6b0f17e2 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -70,7 +70,7 @@ private:
     using _Derived =
         conditional_t<_IsUnique, flat_set<_Key, _Compare, _Container>, flat_multiset<_Key, _Compare, _Container>>;
 
-    static constexpr const char* _Msg_not_sorted = //
+    static constexpr const char* _Msg_not_sorted_maybe_unique = //
         _IsUnique ? "Input was not sorted-unique! (N5032 [flat.set.overview]/9)"
                   : "Input was not sorted! (N5032 [flat.multiset.overview]/9)";
     static constexpr const char* _Msg_replace_not_sorted =
@@ -125,7 +125,7 @@ public:
 
     _Flat_set_base(_Sorted_t, container_type _Cont, const key_compare& _Comp = key_compare())
         : _Data(_STD move(_Cont)), _Key_compare(_Comp) {
-        _STL_ASSERT(_Is_sorted_maybe_unique(), _Msg_not_sorted);
+        _STL_ASSERT(_Is_sorted_maybe_unique(), _Msg_not_sorted_maybe_unique);
     }
 
     template <_Iterator_for_container _InIt>
@@ -137,7 +137,7 @@ public:
     template <_Iterator_for_container _InIt>
     _Flat_set_base(_Sorted_t, const _InIt _First, const _InIt _Last, const key_compare& _Comp = key_compare())
         : _Data(_First, _Last), _Key_compare(_Comp) {
-        _STL_ASSERT(_Is_sorted_maybe_unique(), _Msg_not_sorted);
+        _STL_ASSERT(_Is_sorted_maybe_unique(), _Msg_not_sorted_maybe_unique);
     }
 
     template <_Container_compatible_range<value_type> _Rng>
@@ -158,7 +158,7 @@ public:
 
     _Flat_set_base(_Sorted_t, const initializer_list<value_type> _Ilist, const key_compare& _Comp = key_compare())
         : _Data(_Ilist.begin(), _Ilist.end()), _Key_compare(_Comp) {
-        _STL_ASSERT(_Is_sorted_maybe_unique(), _Msg_not_sorted);
+        _STL_ASSERT(_Is_sorted_maybe_unique(), _Msg_not_sorted_maybe_unique);
     }
 
     // [flat.set.cons.alloc] Constructors with allocators
@@ -185,13 +185,13 @@ public:
     template <_Usable_allocator_for<container_type> _Alloc>
     _Flat_set_base(_Sorted_t, const container_type& _Cont, const _Alloc& _Al)
         : _Data(_STD make_obj_using_allocator<container_type>(_Al, _Cont)), _Key_compare() {
-        _STL_ASSERT(_Is_sorted_maybe_unique(), _Msg_not_sorted);
+        _STL_ASSERT(_Is_sorted_maybe_unique(), _Msg_not_sorted_maybe_unique);
     }
 
     template <_Usable_allocator_for<container_type> _Alloc>
     _Flat_set_base(_Sorted_t, const container_type& _Cont, const key_compare& _Comp, const _Alloc& _Al)
         : _Data(_STD make_obj_using_allocator<container_type>(_Al, _Cont)), _Key_compare(_Comp) {
-        _STL_ASSERT(_Is_sorted_maybe_unique(), _Msg_not_sorted);
+        _STL_ASSERT(_Is_sorted_maybe_unique(), _Msg_not_sorted_maybe_unique);
     }
 
     template <_Usable_allocator_for<container_type> _Alloc>
@@ -219,13 +219,13 @@ public:
     template <_Iterator_for_container _InIt, _Usable_allocator_for<container_type> _Alloc>
     _Flat_set_base(_Sorted_t, const _InIt _First, const _InIt _Last, const _Alloc& _Al)
         : _Data(_STD make_obj_using_allocator<container_type>(_Al, _First, _Last)), _Key_compare() {
-        _STL_ASSERT(_Is_sorted_maybe_unique(), _Msg_not_sorted);
+        _STL_ASSERT(_Is_sorted_maybe_unique(), _Msg_not_sorted_maybe_unique);
     }
 
     template <_Iterator_for_container _InIt, _Usable_allocator_for<container_type> _Alloc>
     _Flat_set_base(_Sorted_t, const _InIt _First, const _InIt _Last, const key_compare& _Comp, const _Alloc& _Al)
         : _Data(_STD make_obj_using_allocator<container_type>(_Al, _First, _Last)), _Key_compare(_Comp) {
-        _STL_ASSERT(_Is_sorted_maybe_unique(), _Msg_not_sorted);
+        _STL_ASSERT(_Is_sorted_maybe_unique(), _Msg_not_sorted_maybe_unique);
     }
 
     template <_Container_compatible_range<value_type> _Rng, _Usable_allocator_for<container_type> _Alloc>
@@ -257,13 +257,13 @@ public:
     template <_Usable_allocator_for<container_type> _Alloc>
     _Flat_set_base(_Sorted_t, const initializer_list<value_type> _Ilist, const _Alloc& _Al)
         : _Data(_STD make_obj_using_allocator<container_type>(_Al, _Ilist.begin(), _Ilist.end())), _Key_compare() {
-        _STL_ASSERT(_Is_sorted_maybe_unique(), _Msg_not_sorted);
+        _STL_ASSERT(_Is_sorted_maybe_unique(), _Msg_not_sorted_maybe_unique);
     }
 
     template <_Usable_allocator_for<container_type> _Alloc>
     _Flat_set_base(_Sorted_t, const initializer_list<value_type> _Ilist, const key_compare& _Comp, const _Alloc& _Al)
         : _Data(_STD make_obj_using_allocator<container_type>(_Al, _Ilist.begin(), _Ilist.end())), _Key_compare(_Comp) {
-        _STL_ASSERT(_Is_sorted_maybe_unique(), _Msg_not_sorted);
+        _STL_ASSERT(_Is_sorted_maybe_unique(), _Msg_not_sorted_maybe_unique);
     }
 
     // Assignment operators
@@ -572,7 +572,7 @@ private:
         if constexpr (_NeedSorting) {
             _STD sort(_Old_end, _End, _Pass_comp());
         } else {
-            _STL_ASSERT(_Is_sorted_maybe_unique(_Old_end, _End), _Msg_not_sorted);
+            _STL_ASSERT(_Is_sorted_maybe_unique(_Old_end, _End), _Msg_not_sorted_maybe_unique);
         }
 
         _STD inplace_merge(_Begin, _Old_end, _End, _Pass_comp());

From 89f3b57f924b3e095094be14e83ff20e975a323b Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Mon, 9 Feb 2026 09:45:50 -0800
Subject: [PATCH 127/134] `_Msg_replace_not_sorted` =>
 `_Msg_replace_not_sorted_maybe_unique`

---
 stl/inc/flat_map | 4 ++--
 stl/inc/flat_set | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index 2c980260a81..5966a406730 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -286,7 +286,7 @@ private:
     static constexpr const char* _Msg_not_sorted_maybe_unique = //
         _IsUnique ? "Keys were not sorted-unique! (N5032 [flat.map.overview]/10)"
                   : "Keys were not sorted! (N5032 [flat.multimap.overview]/10)";
-    static constexpr const char* _Msg_replace_not_sorted =
+    static constexpr const char* _Msg_replace_not_sorted_maybe_unique =
         _IsUnique ? "Keys were not sorted-unique! (N5032 [flat.map.modifiers]/37)"
                   : "Keys were not sorted! (N5032 [flat.map.modifiers]/37, [flat.multimap.overview]/4)";
     static constexpr const char* _Msg_different_sizes =
@@ -696,7 +696,7 @@ public:
 
     void replace(key_container_type&& _Key_cont, mapped_container_type&& _Mapped_cont) {
         _STL_ASSERT(_Key_cont.size() == _Mapped_cont.size(), _Msg_replace_different_sizes);
-        _STL_ASSERT(_Is_sorted_maybe_unique(_Key_cont.begin(), _Key_cont.end()), _Msg_replace_not_sorted);
+        _STL_ASSERT(_Is_sorted_maybe_unique(_Key_cont.begin(), _Key_cont.end()), _Msg_replace_not_sorted_maybe_unique);
         _Clear_guard _Guard{this};
         _Data.keys     = _STD move(_Key_cont);
         _Data.values   = _STD move(_Mapped_cont);
diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index 19d6b0f17e2..62f8c420f93 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -73,7 +73,7 @@ private:
     static constexpr const char* _Msg_not_sorted_maybe_unique = //
         _IsUnique ? "Input was not sorted-unique! (N5032 [flat.set.overview]/9)"
                   : "Input was not sorted! (N5032 [flat.multiset.overview]/9)";
-    static constexpr const char* _Msg_replace_not_sorted =
+    static constexpr const char* _Msg_replace_not_sorted_maybe_unique =
         _IsUnique ? "Input was not sorted-unique! (N5032 [flat.set.modifiers]/18)"
                   : "Input was not sorted! (N5032 [flat.multiset.modifiers]/17)";
     static constexpr const char* _Msg_heterogeneous_insertion_inconsistent_with_lookup =
@@ -410,7 +410,7 @@ public:
     }
 
     void replace(container_type&& _Cont) {
-        _STL_ASSERT(_Is_sorted_maybe_unique(_Cont.begin(), _Cont.end()), _Msg_replace_not_sorted);
+        _STL_ASSERT(_Is_sorted_maybe_unique(_Cont.begin(), _Cont.end()), _Msg_replace_not_sorted_maybe_unique);
         _Clear_guard _Guard{this};
         _Data          = _STD move(_Cont);
         _Guard._Target = nullptr;

From f71e08f8f6d5d157737dc3874b41fde342bba7f8 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Mon, 9 Feb 2026 09:47:06 -0800
Subject: [PATCH 128/134] Manual wrapping for clang-format is no longer
 necessary.

---
 stl/inc/flat_map | 2 +-
 stl/inc/flat_set | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index 5966a406730..92f6f92e801 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -283,7 +283,7 @@ private:
     using _Derived  = conditional_t<_IsUnique, flat_map<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>,
          flat_multimap<_Key, _Mapped, _Compare, _KeyContainer, _MappedContainer>>;
 
-    static constexpr const char* _Msg_not_sorted_maybe_unique = //
+    static constexpr const char* _Msg_not_sorted_maybe_unique =
         _IsUnique ? "Keys were not sorted-unique! (N5032 [flat.map.overview]/10)"
                   : "Keys were not sorted! (N5032 [flat.multimap.overview]/10)";
     static constexpr const char* _Msg_replace_not_sorted_maybe_unique =
diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index 62f8c420f93..52494d36d52 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -70,7 +70,7 @@ private:
     using _Derived =
         conditional_t<_IsUnique, flat_set<_Key, _Compare, _Container>, flat_multiset<_Key, _Compare, _Container>>;
 
-    static constexpr const char* _Msg_not_sorted_maybe_unique = //
+    static constexpr const char* _Msg_not_sorted_maybe_unique =
         _IsUnique ? "Input was not sorted-unique! (N5032 [flat.set.overview]/9)"
                   : "Input was not sorted! (N5032 [flat.multiset.overview]/9)";
     static constexpr const char* _Msg_replace_not_sorted_maybe_unique =

From 0d27c5fa7f98ce461a0f581e9c901eedc37debf0 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Mon, 9 Feb 2026 09:56:27 -0800
Subject: [PATCH 129/134] Drop `forward` when calling `_Compare_keys`.

---
 stl/inc/flat_map | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index 92f6f92e801..ad8b6aa4dbc 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -891,7 +891,7 @@ protected:
         const auto _Key_it = _STD upper_bound(_Data.keys.begin(), _Data.keys.end(), _Key_val, _Pass_key_comp());
         const auto _Index  = _Key_it - _Data.keys.begin();
         if constexpr (_IsUnique) {
-            if (_Key_it != _Data.keys.begin() && !_Compare_keys(*(_Key_it - 1), _STD forward<_OtherKey>(_Key_val))) {
+            if (_Key_it != _Data.keys.begin() && !_Compare_keys(*(_Key_it - 1), _Key_val)) {
                 // Previous element is equivalent to key, no insert needed
                 return {begin() + (_Index - 1), false};
             }

From 95cb9999b6055c0169744cc26ad167e9488d0d57 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Mon, 9 Feb 2026 10:12:44 -0800
Subject: [PATCH 130/134] benchmark: Extract `initializer_list` construction.

---
 benchmarks/src/flat_meow_assign.cpp | 25 ++++++++++++++++++-------
 1 file changed, 18 insertions(+), 7 deletions(-)

diff --git a/benchmarks/src/flat_meow_assign.cpp b/benchmarks/src/flat_meow_assign.cpp
index 07b718695f5..980da7521ed 100644
--- a/benchmarks/src/flat_meow_assign.cpp
+++ b/benchmarks/src/flat_meow_assign.cpp
@@ -5,28 +5,39 @@
 #include <flat_map>
 #include <flat_set>
 #include <string>
+#include <utility>
 
 using namespace std;
 
-void flat_map_strings(benchmark::State& state) {
+void flat_map_strings_impl(benchmark::State& state, initializer_list<pair<string, int>> il) {
     flat_map<string, int> pieces;
     for (auto _ : state) {
-        pieces = {{"soldier"s, 1}, {"soldier"s, 2}, {"soldier"s, 3}, {"soldier"s, 4}, {"soldier"s, 5}, {"soldier"s, 6},
-            {"soldier"s, 7}, {"soldier"s, 8}, {"tower"s, 9}, {"horse"s, 10}, {"elephant"s, 11}, {"vizier"s, 12},
-            {"king"s, 13}, {"elephant"s, 14}, {"horse"s, 15}, {"tower"s, 16}};
+        pieces = il;
         benchmark::DoNotOptimize(pieces);
     }
 }
 
-void flat_set_strings(benchmark::State& state) {
+void flat_map_strings(benchmark::State& state) {
+    flat_map_strings_impl(
+        state, {{"soldier"s, 1}, {"soldier"s, 2}, {"soldier"s, 3}, {"soldier"s, 4}, {"soldier"s, 5}, {"soldier"s, 6},
+                   {"soldier"s, 7}, {"soldier"s, 8}, {"tower"s, 9}, {"horse"s, 10}, {"elephant"s, 11}, {"vizier"s, 12},
+                   {"king"s, 13}, {"elephant"s, 14}, {"horse"s, 15}, {"tower"s, 16}});
+}
+
+void flat_set_strings_impl(benchmark::State& state, initializer_list<string> il) {
     flat_set<string> pieces;
     for (auto _ : state) {
-        pieces = {"soldier"s, "soldier"s, "soldier"s, "soldier"s, "soldier"s, "soldier"s, "soldier"s, "soldier"s,
-            "tower"s, "horse"s, "elephant"s, "vizier"s, "king"s, "elephant"s, "horse"s, "tower"s};
+        pieces = il;
         benchmark::DoNotOptimize(pieces);
     }
 }
 
+void flat_set_strings(benchmark::State& state) {
+    flat_set_strings_impl(
+        state, {"soldier"s, "soldier"s, "soldier"s, "soldier"s, "soldier"s, "soldier"s, "soldier"s, "soldier"s,
+                   "tower"s, "horse"s, "elephant"s, "vizier"s, "king"s, "elephant"s, "horse"s, "tower"s});
+}
+
 void flat_map_integers(benchmark::State& state) {
     flat_map<int, int> pieces;
     for (auto _ : state) {

From 1945ad0efa98c3621e1059c9be799e802bb992d9 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Mon, 9 Feb 2026 10:22:59 -0800
Subject: [PATCH 131/134] flat_map: const overloads of begin()/end() can call
 values.cbegin()/cend() for clarity.

This makes them exactly match flat_map::cbegin()/cend().
---
 stl/inc/flat_map | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/stl/inc/flat_map b/stl/inc/flat_map
index ad8b6aa4dbc..79581d333b3 100644
--- a/stl/inc/flat_map
+++ b/stl/inc/flat_map
@@ -567,13 +567,13 @@ public:
     _NODISCARD const_iterator begin() const noexcept {
         _STL_INTERNAL_STATIC_ASSERT(random_access_iterator<const_iterator>);
         _STL_INTERNAL_STATIC_ASSERT(convertible_to<iterator, const_iterator>);
-        return const_iterator{_Data.keys.cbegin(), _Data.values.begin()};
+        return const_iterator{_Data.keys.cbegin(), _Data.values.cbegin()};
     }
     _NODISCARD iterator end() noexcept {
         return iterator{_Data.keys.cend(), _Data.values.end()};
     }
     _NODISCARD const_iterator end() const noexcept {
-        return const_iterator{_Data.keys.cend(), _Data.values.end()};
+        return const_iterator{_Data.keys.cend(), _Data.values.cend()};
     }
 
     _NODISCARD reverse_iterator rbegin() noexcept {

From d6b947f3acbe7f769be771a6bd2d9f4715ed4a8b Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Mon, 9 Feb 2026 14:26:44 -0800
Subject: [PATCH 132/134] Use `_Not_allocator_for_container` in existing code.

---
 stl/inc/map           |  6 ++----
 stl/inc/set           |  6 ++----
 stl/inc/unordered_map | 10 ++++------
 stl/inc/unordered_set | 10 ++++------
 stl/inc/xhash         |  2 +-
 5 files changed, 13 insertions(+), 21 deletions(-)

diff --git a/stl/inc/map b/stl/inc/map
index 1e7c30bc404..860d463ded8 100644
--- a/stl/inc/map
+++ b/stl/inc/map
@@ -384,9 +384,8 @@ template <class _Kty, class _Ty, class _Alloc, enable_if_t<_Is_allocator<_Alloc>
 map(initializer_list<pair<_Kty, _Ty>>, _Alloc) -> map<_Kty, _Ty, less<_Kty>, _Alloc>;
 
 #if _HAS_CXX23
-template <_RANGES input_range _Rng, class _Pr = less<_Range_key_type<_Rng>>,
+template <_RANGES input_range _Rng, _Not_allocator_for_container _Pr = less<_Range_key_type<_Rng>>,
     _Allocator_for_container _Alloc = allocator<_Range_to_alloc_type<_Rng>>>
-    requires (!_Allocator_for_container<_Pr>)
 map(from_range_t, _Rng&&, _Pr = _Pr(), _Alloc = _Alloc())
     -> map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, _Pr, _Alloc>;
 
@@ -615,9 +614,8 @@ template <class _Kty, class _Ty, class _Alloc, enable_if_t<_Is_allocator<_Alloc>
 multimap(initializer_list<pair<_Kty, _Ty>>, _Alloc) -> multimap<_Kty, _Ty, less<_Kty>, _Alloc>;
 
 #if _HAS_CXX23
-template <_RANGES input_range _Rng, class _Pr = less<_Range_key_type<_Rng>>,
+template <_RANGES input_range _Rng, _Not_allocator_for_container _Pr = less<_Range_key_type<_Rng>>,
     _Allocator_for_container _Alloc = allocator<_Range_to_alloc_type<_Rng>>>
-    requires (!_Allocator_for_container<_Pr>)
 multimap(from_range_t, _Rng&&, _Pr = _Pr(), _Alloc = _Alloc())
     -> multimap<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, _Pr, _Alloc>;
 
diff --git a/stl/inc/set b/stl/inc/set
index d78a0b88cfb..9d69548a259 100644
--- a/stl/inc/set
+++ b/stl/inc/set
@@ -195,9 +195,8 @@ template <class _Kty, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, in
 set(initializer_list<_Kty>, _Alloc) -> set<_Kty, less<_Kty>, _Alloc>;
 
 #if _HAS_CXX23
-template <_RANGES input_range _Rng, class _Pr = less<_RANGES range_value_t<_Rng>>,
+template <_RANGES input_range _Rng, _Not_allocator_for_container _Pr = less<_RANGES range_value_t<_Rng>>,
     _Allocator_for_container _Alloc = allocator<_RANGES range_value_t<_Rng>>>
-    requires (!_Allocator_for_container<_Pr>)
 set(from_range_t, _Rng&&, _Pr = _Pr(), _Alloc = _Alloc()) -> set<_RANGES range_value_t<_Rng>, _Pr, _Alloc>;
 
 template <_RANGES input_range _Rng, _Allocator_for_container _Alloc>
@@ -409,9 +408,8 @@ template <class _Kty, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, in
 multiset(initializer_list<_Kty>, _Alloc) -> multiset<_Kty, less<_Kty>, _Alloc>;
 
 #if _HAS_CXX23
-template <_RANGES input_range _Rng, class _Pr = less<_RANGES range_value_t<_Rng>>,
+template <_RANGES input_range _Rng, _Not_allocator_for_container _Pr = less<_RANGES range_value_t<_Rng>>,
     _Allocator_for_container _Alloc = allocator<_RANGES range_value_t<_Rng>>>
-    requires (!_Allocator_for_container<_Pr>)
 multiset(from_range_t, _Rng&&, _Pr = _Pr(), _Alloc = _Alloc()) -> multiset<_RANGES range_value_t<_Rng>, _Pr, _Alloc>;
 
 template <_RANGES input_range _Rng, _Allocator_for_container _Alloc>
diff --git a/stl/inc/unordered_map b/stl/inc/unordered_map
index 2292fb3dc64..3bc38508676 100644
--- a/stl/inc/unordered_map
+++ b/stl/inc/unordered_map
@@ -495,9 +495,8 @@ unordered_map(initializer_list<pair<_Kty, _Ty>>, _Guide_size_type_t<_Alloc>, _Ha
 
 #if _HAS_CXX23
 template <_RANGES input_range _Rng, _Hasher_for_container _Hasher = hash<_Range_key_type<_Rng>>,
-    class _Keyeq                    = equal_to<_Range_key_type<_Rng>>,
-    _Allocator_for_container _Alloc = allocator<_Range_to_alloc_type<_Rng>>>
-    requires (!_Allocator_for_container<_Keyeq>)
+    _Not_allocator_for_container _Keyeq = equal_to<_Range_key_type<_Rng>>,
+    _Allocator_for_container _Alloc     = allocator<_Range_to_alloc_type<_Rng>>>
 unordered_map(from_range_t, _Rng&&, _Guide_size_type_t<_Alloc> = 0, _Hasher = _Hasher(), _Keyeq = _Keyeq(),
     _Alloc = _Alloc()) -> unordered_map<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, _Hasher, _Keyeq, _Alloc>;
 
@@ -865,9 +864,8 @@ unordered_multimap(initializer_list<pair<_Kty, _Ty>>, _Guide_size_type_t<_Alloc>
 
 #if _HAS_CXX23
 template <_RANGES input_range _Rng, _Hasher_for_container _Hasher = hash<_Range_key_type<_Rng>>,
-    class _Keyeq                    = equal_to<_Range_key_type<_Rng>>,
-    _Allocator_for_container _Alloc = allocator<_Range_to_alloc_type<_Rng>>>
-    requires (!_Allocator_for_container<_Keyeq>)
+    _Not_allocator_for_container _Keyeq = equal_to<_Range_key_type<_Rng>>,
+    _Allocator_for_container _Alloc     = allocator<_Range_to_alloc_type<_Rng>>>
 unordered_multimap(from_range_t, _Rng&&, _Guide_size_type_t<_Alloc> = 0, _Hasher = _Hasher(), _Keyeq = _Keyeq(),
     _Alloc = _Alloc()) -> unordered_multimap<_Range_key_type<_Rng>, _Range_mapped_type<_Rng>, _Hasher, _Keyeq, _Alloc>;
 
diff --git a/stl/inc/unordered_set b/stl/inc/unordered_set
index 8b33a274f02..89c33f977cb 100644
--- a/stl/inc/unordered_set
+++ b/stl/inc/unordered_set
@@ -351,9 +351,8 @@ unordered_set(initializer_list<_Kty>, _Guide_size_type_t<_Alloc>, _Hasher, _Allo
 
 #if _HAS_CXX23
 template <_RANGES input_range _Rng, _Hasher_for_container _Hasher = hash<_RANGES range_value_t<_Rng>>,
-    class _Keyeq                    = equal_to<_RANGES range_value_t<_Rng>>,
-    _Allocator_for_container _Alloc = allocator<_RANGES range_value_t<_Rng>>>
-    requires (!_Allocator_for_container<_Keyeq>)
+    _Not_allocator_for_container _Keyeq = equal_to<_RANGES range_value_t<_Rng>>,
+    _Allocator_for_container _Alloc     = allocator<_RANGES range_value_t<_Rng>>>
 unordered_set(from_range_t, _Rng&&, _Guide_size_type_t<_Alloc> = 0, _Hasher = _Hasher(), _Keyeq = _Keyeq(),
     _Alloc = _Alloc()) -> unordered_set<_RANGES range_value_t<_Rng>, _Hasher, _Keyeq, _Alloc>;
 
@@ -694,9 +693,8 @@ unordered_multiset(initializer_list<_Kty>, _Guide_size_type_t<_Alloc>, _Hasher,
 
 #if _HAS_CXX23
 template <_RANGES input_range _Rng, _Hasher_for_container _Hasher = hash<_RANGES range_value_t<_Rng>>,
-    class _Keyeq                    = equal_to<_RANGES range_value_t<_Rng>>,
-    _Allocator_for_container _Alloc = allocator<_RANGES range_value_t<_Rng>>>
-    requires (!_Allocator_for_container<_Keyeq>)
+    _Not_allocator_for_container _Keyeq = equal_to<_RANGES range_value_t<_Rng>>,
+    _Allocator_for_container _Alloc     = allocator<_RANGES range_value_t<_Rng>>>
 unordered_multiset(from_range_t, _Rng&&, _Guide_size_type_t<_Alloc> = 0, _Hasher = _Hasher(), _Keyeq = _Keyeq(),
     _Alloc = _Alloc()) -> unordered_multiset<_RANGES range_value_t<_Rng>, _Hasher, _Keyeq, _Alloc>;
 
diff --git a/stl/inc/xhash b/stl/inc/xhash
index 52c82bcd216..1cfd0d21afb 100644
--- a/stl/inc/xhash
+++ b/stl/inc/xhash
@@ -1883,7 +1883,7 @@ protected:
 // For constraining deduction guides (N4981 [unord.req.general]/248.3)
 #if _HAS_CXX23
 template <class _Hasher>
-concept _Hasher_for_container = !integral<_Hasher> && !_Allocator_for_container<_Hasher>;
+concept _Hasher_for_container = !integral<_Hasher> && _Not_allocator_for_container<_Hasher>;
 
 template <class _Hasher>
 using _Is_hasher = bool_constant<_Hasher_for_container<_Hasher>>;

From de5086a39f2d9929d3afa2e8bb1b4cddae1f6e25 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Mon, 9 Feb 2026 14:33:01 -0800
Subject: [PATCH 133/134] Add a comment explaining SCARY iterators with
 citations.

---
 stl/inc/xmemory | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/stl/inc/xmemory b/stl/inc/xmemory
index 16be444efaf..4bdb8fed77a 100644
--- a/stl/inc/xmemory
+++ b/stl/inc/xmemory
@@ -792,6 +792,9 @@ constexpr bool _Is_simple_alloc_v =
     && is_same_v<typename allocator_traits<_Alloc>::pointer, typename _Alloc::value_type*>
     && is_same_v<typename allocator_traits<_Alloc>::const_pointer, const typename _Alloc::value_type*>;
 
+// SCARY iterators are permitted but not required by the Standard. See:
+// N2911 Minimizing Dependencies Within Generic Classes For Faster And Smaller Programs
+// N2980 SCARY Iterator Assignment And Initialization
 template <class _Value_type>
 struct _Simple_types { // wraps types from allocators with simple addressing for use in iterators
                        // and other SCARY machinery

From c7dfdb7a0a0757a2b1e93f0f32a7a2765c80a6dc Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Tue, 10 Feb 2026 02:01:37 -0800
Subject: [PATCH 134/134] Add compiler bug workarounds.

---
 tests/std/tests/P0429R9_flat_map/test.cpp | 10 +++++++++-
 tests/std/tests/P1222R4_flat_set/test.cpp | 14 ++++++++++----
 2 files changed, 19 insertions(+), 5 deletions(-)

diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index ca4a2989ef7..b2e8adea29b 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -18,6 +18,7 @@
 #include <utility>
 #include <vector>
 
+#include <is_permissive.hpp>
 #include <test_container_requirements.hpp>
 #include <test_death.hpp>
 using namespace std;
@@ -957,6 +958,7 @@ void test_insert() {
 }
 
 void test_insert_range() {
+#ifndef _PREFAST_ // TRANSITION, VSO-2714798
     {
         flat_map<int, char> fm{{1, 'p'}, {4, 'q'}, {9, 'r'}};
         using char_type_array = flat_map<int, char>::value_type[];
@@ -981,6 +983,7 @@ void test_insert_range() {
         assert(check_key_content(fmm, {1, 4, 4, 9, 9, 9, 16, 16, 25}));
         assert(check_value_content(fmm, {'p', 'q', 'z', 'r', 'y', 'a', 'x', 'b', 'c'}));
     }
+#endif // ^^^ no workaround ^^^
 }
 
 // GH-4344 <flat_map> Fix compile errors
@@ -1344,7 +1347,12 @@ void test_insert_hint_is_respected() {
 
 template <template <class...> class KeyCont, template <class...> class MappedCont>
 void test_key_mapped_cont_combinations() {
-    test_construction<KeyCont, MappedCont>();
+#if !defined(__clang__) && !defined(__EDG__) // TRANSITION, VSO-2714784
+    if constexpr (!is_permissive)
+#endif // ^^^ workaround ^^^
+    {
+        test_construction<KeyCont, MappedCont>();
+    }
     test_insert_hint_is_respected<KeyCont, MappedCont>();
     test_throwing_compare_swap_single<flat_map, KeyCont, MappedCont>();
     test_throwing_compare_swap_single<flat_multimap, KeyCont, MappedCont>();
diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index ac673797ca3..5648dc47464 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -18,6 +18,7 @@
 #include <utility>
 #include <vector>
 
+#include <is_permissive.hpp>
 #include <test_container_requirements.hpp>
 #include <test_death.hpp>
 #define TEST_ASSERT(...) assert((__VA_ARGS__))
@@ -1351,10 +1352,15 @@ void test_non_strict_weak_order_compare() {
 void run_normal_tests() {
     mt19937_64 eng(42);
 
-    test_constructors<vector<int>>();
-    test_constructors<deque<int>>();
-    test_allocator_extended_constructors<iterator_pair_construction::allocator_first>();
-    test_allocator_extended_constructors<iterator_pair_construction::allocator_last>();
+#if !defined(__clang__) && !defined(__EDG__) // TRANSITION, VSO-2714784
+    if constexpr (!is_permissive)
+#endif // ^^^ workaround ^^^
+    {
+        test_constructors<vector<int>>();
+        test_constructors<deque<int>>();
+        test_allocator_extended_constructors<iterator_pair_construction::allocator_first>();
+        test_allocator_extended_constructors<iterator_pair_construction::allocator_last>();
+    }
 
     test_iterators_and_capacity<flat_set<int>>();
     test_iterators_and_capacity<flat_multiset<int>>();