[container.adaptors] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpolrii7h9/{from.md → to.md} +1214 -1145

tmp/tmpolrii7h9/{from.md → to.md} RENAMED Viewed

@@ -1,8 +1,8 @@
 ## Container adaptors <a id="container.adaptors">[[container.adaptors]]</a>
-### In general <a id="container.adaptors.general">[[container.adaptors.general]]</a>
 The headers `<queue>`, `<stack>`, `<flat_map>`, and `<flat_set>` define
 the container adaptors `queue` and `priority_queue`, `stack`, `flat_map`
 and `flat_multimap`, and `flat_set` and `flat_multiset`, respectively.
@@ -73,12 +73,11 @@ deduction guides for container adaptors.
 The following exposition-only alias template may appear in deduction
 guides for container adaptors:
 ``` cpp
 template<class Allocator, class T>
-  using alloc-rebind = // exposition only
-    typename allocator_traits<Allocator>::template rebind_alloc<T>;
 ```
 ### Header `<queue>` synopsis <a id="queue.syn">[[queue.syn]]</a>
 ``` cpp
@@ -88,159 +87,49 @@ template<class Allocator, class T>
 namespace std {
   // [queue], class template queue
   template<class T, class Container = deque<T>> class queue;
   template<class T, class Container>
-    bool operator==(const queue<T, Container>& x, const queue<T, Container>& y);
   template<class T, class Container>
-    bool operator!=(const queue<T, Container>& x, const queue<T, Container>& y);
   template<class T, class Container>
-    bool operator< (const queue<T, Container>& x, const queue<T, Container>& y);
   template<class T, class Container>
-    bool operator> (const queue<T, Container>& x, const queue<T, Container>& y);
   template<class T, class Container>
-    bool operator<=(const queue<T, Container>& x, const queue<T, Container>& y);
   template<class T, class Container>
-    bool operator>=(const queue<T, Container>& x, const queue<T, Container>& y);
   template<class T, three_way_comparable Container>
-    compare_three_way_result_t<Container>
       operator<=>(const queue<T, Container>& x, const queue<T, Container>& y);
   template<class T, class Container>
-    void swap(queue<T, Container>& x, queue<T, Container>& y) noexcept(noexcept(x.swap(y)));
   template<class T, class Container, class Alloc>
     struct uses_allocator<queue<T, Container>, Alloc>;
   // [priority.queue], class template priority_queue
   template<class T, class Container = vector<T>,
            class Compare = less<typename Container::value_type>>
     class priority_queue;
   template<class T, class Container, class Compare>
-    void swap(priority_queue<T, Container, Compare>& x,
                         priority_queue<T, Container, Compare>& y) noexcept(noexcept(x.swap(y)));
   template<class T, class Container, class Compare, class Alloc>
     struct uses_allocator<priority_queue<T, Container, Compare>, Alloc>;
-}
-```
-### Header `<stack>` synopsis <a id="stack.syn">[[stack.syn]]</a>
-``` cpp
-#include <compare>              // see [compare.syn]
-#include <initializer_list>     // see [initializer.list.syn]
-namespace std {
-  // [stack], class template stack
-  template<class T, class Container = deque<T>> class stack;
-  template<class T, class Container>
-    bool operator==(const stack<T, Container>& x, const stack<T, Container>& y);
-  template<class T, class Container>
-    bool operator!=(const stack<T, Container>& x, const stack<T, Container>& y);
-  template<class T, class Container>
-    bool operator< (const stack<T, Container>& x, const stack<T, Container>& y);
-  template<class T, class Container>
-    bool operator> (const stack<T, Container>& x, const stack<T, Container>& y);
-  template<class T, class Container>
-    bool operator<=(const stack<T, Container>& x, const stack<T, Container>& y);
-  template<class T, class Container>
-    bool operator>=(const stack<T, Container>& x, const stack<T, Container>& y);
-  template<class T, three_way_comparable Container>
-    compare_three_way_result_t<Container>
-      operator<=>(const stack<T, Container>& x, const stack<T, Container>& y);
-  template<class T, class Container>
-    void swap(stack<T, Container>& x, stack<T, Container>& y) noexcept(noexcept(x.swap(y)));
-  template<class T, class Container, class Alloc>
-    struct uses_allocator<stack<T, Container>, Alloc>;
-}
-```
-### Header `<flat_map>` synopsis <a id="flat.map.syn">[[flat.map.syn]]</a>
-``` cpp
-#include <compare>              // see [compare.syn]
-#include <initializer_list>     // see [initializer.list.syn]
-namespace std {
-  // [flat.map], class template flat_map
-  template<class Key, class T, class Compare = less<Key>,
-           class KeyContainer = vector<Key>, class MappedContainer = vector<T>>
-    class flat_map;
-  struct sorted_unique_t { explicit sorted_unique_t() = default; };
-  inline constexpr sorted_unique_t sorted_unique{};
-  template<class Key, class T, class Compare, class KeyContainer, class MappedContainer,
-           class Allocator>
-    struct uses_allocator<flat_map<Key, T, Compare, KeyContainer, MappedContainer>,
-                          Allocator>;
-  // [flat.map.erasure], erasure for flat_map
-  template<class Key, class T, class Compare, class KeyContainer, class MappedContainer,
-           class Predicate>
-    typename flat_map<Key, T, Compare, KeyContainer, MappedContainer>::size_type
-      erase_if(flat_map<Key, T, Compare, KeyContainer, MappedContainer>& c, Predicate pred);
-  // [flat.multimap], class template flat_multimap
-  template<class Key, class T, class Compare = less<Key>,
-           class KeyContainer = vector<Key>, class MappedContainer = vector<T>>
-    class flat_multimap;
-  struct sorted_equivalent_t { explicit sorted_equivalent_t() = default; };
-  inline constexpr sorted_equivalent_t sorted_equivalent{};
-  template<class Key, class T, class Compare, class KeyContainer, class MappedContainer,
-           class Allocator>
-    struct uses_allocator<flat_multimap<Key, T, Compare, KeyContainer, MappedContainer>,
-                          Allocator>;
-  // [flat.multimap.erasure], erasure for flat_multimap
-  template<class Key, class T, class Compare, class KeyContainer, class MappedContainer,
-           class Predicate>
-    typename flat_multimap<Key, T, Compare, KeyContainer, MappedContainer>::size_type
-      erase_if(flat_multimap<Key, T, Compare, KeyContainer, MappedContainer>& c, Predicate pred);
-}
-```
-### Header `<flat_set>` synopsis <a id="flat.set.syn">[[flat.set.syn]]</a>
-``` cpp
-#include <compare>              // see [compare.syn]
-#include <initializer_list>     // see [initializer.list.syn]
-namespace std {
-  // [flat.set], class template flat_set
-  template<class Key, class Compare = less<Key>, class KeyContainer = vector<Key>>
-    class flat_set;
-  struct sorted_unique_t { explicit sorted_unique_t() = default; };
-  inline constexpr sorted_unique_t sorted_unique{};
-  template<class Key, class Compare, class KeyContainer, class Allocator>
-    struct uses_allocator<flat_set<Key, Compare, KeyContainer>, Allocator>;
-  // [flat.set.erasure], erasure for flat_set
-  template<class Key, class Compare, class KeyContainer, class Predicate>
-    typename flat_set<Key, Compare, KeyContainer>::size_type
-      erase_if(flat_set<Key, Compare, KeyContainer>& c, Predicate pred);
-  // [flat.multiset], class template flat_multiset
-  template<class Key, class Compare = less<Key>, class KeyContainer = vector<Key>>
-    class flat_multiset;
-  struct sorted_equivalent_t { explicit sorted_equivalent_t() = default; };
-  inline constexpr sorted_equivalent_t sorted_equivalent{};
-  template<class Key, class Compare, class KeyContainer, class Allocator>
-    struct uses_allocator<flat_multiset<Key, Compare, KeyContainer>, Allocator>;
-  // [flat.multiset.erasure], erasure for flat_multiset
-  template<class Key, class Compare, class KeyContainer, class Predicate>
-    typename flat_multiset<Key, Compare, KeyContainer>::size_type
-      erase_if(flat_multiset<Key, Compare, KeyContainer>& c, Predicate pred);
 }
 ```
 ### Class template `queue` <a id="queue">[[queue]]</a>
@@ -253,49 +142,49 @@ particular, `list` [[list]] and `deque` [[deque]] can be used.
 ``` cpp
 namespace std {
   template<class T, class Container = deque<T>>
   class queue {
   public:
-    using value_type      = typename Container::value_type;
-    using reference       = typename Container::reference;
-    using const_reference = typename Container::const_reference;
-    using size_type       = typename Container::size_type;
     using container_type  = Container;
   protected:
     Container c;
   public:
-    queue() : queue(Container()) {}
-    explicit queue(const Container&);
-    explicit queue(Container&&);
-    template<class InputIterator> queue(InputIterator first, InputIterator last);
-    template<container-compatible-range<T> R> queue(from_range_t, R&& rg);
-    template<class Alloc> explicit queue(const Alloc&);
-    template<class Alloc> queue(const Container&, const Alloc&);
-    template<class Alloc> queue(Container&&, const Alloc&);
-    template<class Alloc> queue(const queue&, const Alloc&);
-    template<class Alloc> queue(queue&&, const Alloc&);
     template<class InputIterator, class Alloc>
-      queue(InputIterator first, InputIterator last, const Alloc&);
     template<container-compatible-range<T> R, class Alloc>
-      queue(from_range_t, R&& rg, const Alloc&);
- [[nodiscard]] bool empty() const { return c.empty(); }
-    size_type         size()  const     { return c.size(); }
-    reference         front()           { return c.front(); }
-    const_reference   front() const     { return c.front(); }
-    reference         back()            { return c.back(); }
-    const_reference   back() const      { return c.back(); }
-    void push(const value_type& x)      { c.push_back(x); }
-    void push(value_type&& x)           { c.push_back(std::move(x)); }
-    template<container-compatible-range<T> R> void push_range(R&& rg);
     template<class... Args>
-      decltype(auto) emplace(Args&&... args)
         { return c.emplace_back(std::forward<Args>(args)...); }
-    void pop()                          { c.pop_front(); }
-    void swap(queue& q) noexcept(is_nothrow_swappable_v<Container>)
       { using std::swap; swap(c, q.c); }
   };
   template<class Container>
     queue(Container) -> queue<typename Container::value_type, Container>;
@@ -325,32 +214,32 @@ namespace std {
 ```
 #### Constructors <a id="queue.cons">[[queue.cons]]</a>
 ``` cpp
-explicit queue(const Container& cont);
 ```
 *Effects:* Initializes `c` with `cont`.
 ``` cpp
-explicit queue(Container&& cont);
 ```
 *Effects:* Initializes `c` with `std::move(cont)`.
 ``` cpp
 template<class InputIterator>
-  queue(InputIterator first, InputIterator last);
 ```
 *Effects:* Initializes `c` with `first` as the first argument and `last`
 as the second argument.
 ``` cpp
 template<container-compatible-range<T> R>
-  queue(from_range_t, R&& rg);
 ```
 *Effects:* Initializes `c` with
 `ranges::to<Container>(std::forward<R>(rg))`.
@@ -358,127 +247,127 @@ template<container-compatible-range<T> R>
 If `uses_allocator_v<container_type, Alloc>` is `false` the constructors
 in this subclause shall not participate in overload resolution.
 ``` cpp
-template<class Alloc> explicit queue(const Alloc& a);
 ```
 *Effects:* Initializes `c` with `a`.
 ``` cpp
-template<class Alloc> queue(const container_type& cont, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `cont` as the first argument and `a` as
 the second argument.
 ``` cpp
-template<class Alloc> queue(container_type&& cont, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `std::move(cont)` as the first argument
 and `a` as the second argument.
 ``` cpp
-template<class Alloc> queue(const queue& q, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `q.c` as the first argument and `a` as
 the second argument.
 ``` cpp
-template<class Alloc> queue(queue&& q, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `std::move(q.c)` as the first argument
 and `a` as the second argument.
 ``` cpp
 template<class InputIterator, class Alloc>
-  queue(InputIterator first, InputIterator last, const Alloc& alloc);
 ```
 *Effects:* Initializes `c` with `first` as the first argument, `last` as
 the second argument, and `alloc` as the third argument.
 ``` cpp
 template<container-compatible-range<T> R, class Alloc>
-  queue(from_range_t, R&& rg, const Alloc& a);
 ```
 *Effects:* Initializes `c` with
 `ranges::to<Container>(std::forward<R>(rg), a)`.
 #### Modifiers <a id="queue.mod">[[queue.mod]]</a>
 ``` cpp
 template<container-compatible-range<T> R>
-  void push_range(R&& rg);
 ```
 *Effects:* Equivalent to `c.append_range(std::forward<R>(rg))` if that
 is a valid expression, otherwise `ranges::copy(rg, back_inserter(c))`.
 #### Operators <a id="queue.ops">[[queue.ops]]</a>
 ``` cpp
 template<class T, class Container>
-  bool operator==(const queue<T, Container>& x, const queue<T, Container>& y);
 ```
 *Returns:* `x.c == y.c`.
 ``` cpp
 template<class T, class Container>
-  bool operator!=(const queue<T, Container>& x,  const queue<T, Container>& y);
 ```
 *Returns:* `x.c != y.c`.
 ``` cpp
 template<class T, class Container>
-  bool operator< (const queue<T, Container>& x, const queue<T, Container>& y);
 ```
 *Returns:* `x.c < y.c`.
 ``` cpp
 template<class T, class Container>
-  bool operator> (const queue<T, Container>& x, const queue<T, Container>& y);
 ```
 *Returns:* `x.c > y.c`.
 ``` cpp
 template<class T, class Container>
-  bool operator<=(const queue<T, Container>& x, const queue<T, Container>& y);
 ```
 *Returns:* `x.c <= y.c`.
 ``` cpp
 template<class T, class Container>
- bool operator>=(const queue<T, Container>& x,
-                    const queue<T, Container>& y);
 ```
 *Returns:* `x.c >= y.c`.
 ``` cpp
 template<class T, three_way_comparable Container>
-  compare_three_way_result_t<Container>
     operator<=>(const queue<T, Container>& x, const queue<T, Container>& y);
 ```
 *Returns:* `x.c <=> y.c`.
 #### Specialized algorithms <a id="queue.special">[[queue.special]]</a>
 ``` cpp
 template<class T, class Container>
-  void swap(queue<T, Container>& x, queue<T, Container>& y) noexcept(noexcept(x.swap(y)));
 ```
 *Constraints:* `is_swappable_v<Container>` is `true`.
 *Effects:* As if by `x.swap(y)`.
@@ -499,67 +388,70 @@ defines a strict weak ordering [[alg.sorting]].
 namespace std {
   template<class T, class Container = vector<T>,
            class Compare = less<typename Container::value_type>>
   class priority_queue {
   public:
-    using value_type      = typename Container::value_type;
-    using reference       = typename Container::reference;
-    using const_reference = typename Container::const_reference;
-    using size_type       = typename Container::size_type;
     using container_type  = Container;
     using value_compare   = Compare;
   protected:
     Container c;
     Compare comp;
   public:
-    priority_queue() : priority_queue(Compare()) {}
-    explicit priority_queue(const Compare& x) : priority_queue(x, Container()) {}
-    priority_queue(const Compare& x, const Container&);
-    priority_queue(const Compare& x, Container&&);
     template<class InputIterator>
-      priority_queue(InputIterator first, InputIterator last, const Compare& x = Compare());
     template<class InputIterator>
-      priority_queue(InputIterator first, InputIterator last, const Compare& x,
                                const Container&);
     template<class InputIterator>
-      priority_queue(InputIterator first, InputIterator last, const Compare& x,
                                Container&&);
     template<container-compatible-range<T> R>
-      priority_queue(from_range_t, R&& rg, const Compare& x = Compare());
-    template<class Alloc> explicit priority_queue(const Alloc&);
-    template<class Alloc> priority_queue(const Compare&, const Alloc&);
-    template<class Alloc> priority_queue(const Compare&, const Container&, const Alloc&);
-    template<class Alloc> priority_queue(const Compare&, Container&&, const Alloc&);
-    template<class Alloc> priority_queue(const priority_queue&, const Alloc&);
-    template<class Alloc> priority_queue(priority_queue&&, const Alloc&);
     template<class InputIterator, class Alloc>
-      priority_queue(InputIterator, InputIterator, const Alloc&);
     template<class InputIterator, class Alloc>
-      priority_queue(InputIterator, InputIterator, const Compare&, const Alloc&);
     template<class InputIterator, class Alloc>
-      priority_queue(InputIterator, InputIterator, const Compare&, const Container&,
                                const Alloc&);
     template<class InputIterator, class Alloc>
-      priority_queue(InputIterator, InputIterator, const Compare&, Container&&, const Alloc&);
     template<container-compatible-range<T> R, class Alloc>
-      priority_queue(from_range_t, R&& rg, const Compare&, const Alloc&);
     template<container-compatible-range<T> R, class Alloc>
-      priority_queue(from_range_t, R&& rg, const Alloc&);
- [[nodiscard]] bool empty() const { return c.empty(); }
- size_type size()  const { return c.size(); }
-    const_reference top() const { return c.front(); }
-    void push(const value_type& x);
-    void push(value_type&& x);
     template<container-compatible-range<T> R>
-      void push_range(R&& rg);
-    template<class... Args> void emplace(Args&&... args);
-    void pop();
-    void swap(priority_queue& q) noexcept(is_nothrow_swappable_v<Container> &&
- is_nothrow_swappable_v<Compare>)
       { using std::swap; swap(c, q.c); swap(comp, q.comp); }
   };
   template<class Compare, class Container>
     priority_queue(Compare, Container)
@@ -612,36 +504,38 @@ namespace std {
 ```
 #### Constructors <a id="priqueue.cons">[[priqueue.cons]]</a>
 ``` cpp
-priority_queue(const Compare& x, const Container& y);
-priority_queue(const Compare& x, Container&& y);
 ```
 *Preconditions:* `x` defines a strict weak ordering [[alg.sorting]].
 *Effects:* Initializes `comp` with `x` and `c` with `y` (copy
 constructing or move constructing as appropriate); calls
 `make_heap(c.begin(), c.end(), comp)`.
 ``` cpp
 template<class InputIterator>
-  priority_queue(InputIterator first, InputIterator last, const Compare& x = Compare());
 ```
 *Preconditions:* `x` defines a strict weak ordering [[alg.sorting]].
 *Effects:* Initializes `c` with `first` as the first argument and `last`
 as the second argument, and initializes `comp` with `x`; then calls
 `make_heap(c.begin(), c.end(), comp)`.
 ``` cpp
 template<class InputIterator>
-  priority_queue(InputIterator first, InputIterator last, const Compare& x, const Container& y);
 template<class InputIterator>
-  priority_queue(InputIterator first, InputIterator last, const Compare& x, Container&& y);
 ```
 *Preconditions:* `x` defines a strict weak ordering [[alg.sorting]].
 *Effects:* Initializes `comp` with `x` and `c` with `y` (copy
@@ -649,11 +543,11 @@ constructing or move constructing as appropriate); calls
 `c.insert(c.end(), first, last)`; and finally calls
 `make_heap(c.begin(), c.end(), comp)`.
 ``` cpp
 template<container-compatible-range<T> R>
-  priority_queue(from_range_t, R&& rg, const Compare& x = Compare());
 ```
 *Preconditions:* `x` defines a strict weak ordering [[alg.sorting]].
 *Effects:* Initializes `comp` with `x` and `c` with
@@ -664,128 +558,129 @@ template<container-compatible-range<T> R>
 If `uses_allocator_v<container_type, Alloc>` is `false` the constructors
 in this subclause shall not participate in overload resolution.
 ``` cpp
-template<class Alloc> explicit priority_queue(const Alloc& a);
 ```
 *Effects:* Initializes `c` with `a` and value-initializes `comp`.
 ``` cpp
-template<class Alloc> priority_queue(const Compare& compare, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `a` and initializes `comp` with
 `compare`.
 ``` cpp
 template<class Alloc>
-  priority_queue(const Compare& compare, const Container& cont, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `cont` as the first argument and `a` as
 the second argument, and initializes `comp` with `compare`; calls
 `make_heap(c.begin(), c.end(), comp)`.
 ``` cpp
 template<class Alloc>
-  priority_queue(const Compare& compare, Container&& cont, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `std::move(cont)` as the first argument
 and `a` as the second argument, and initializes `comp` with `compare`;
 calls `make_heap(c.begin(), c.end(), comp)`.
 ``` cpp
-template<class Alloc> priority_queue(const priority_queue& q, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `q.c` as the first argument and `a` as
 the second argument, and initializes `comp` with `q.comp`.
 ``` cpp
-template<class Alloc> priority_queue(priority_queue&& q, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `std::move(q.c)` as the first argument
 and `a` as the second argument, and initializes `comp` with
 `std::move(q.comp)`.
 ``` cpp
 template<class InputIterator, class Alloc>
-  priority_queue(InputIterator first, InputIterator last, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `first` as the first argument, `last` as
 the second argument, and `a` as the third argument, and
 value-initializes `comp`; calls `make_heap(c.begin(), c.end(), comp)`.
 ``` cpp
 template<class InputIterator, class Alloc>
-  priority_queue(InputIterator first, InputIterator last, const Compare& compare, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `first` as the first argument, `last` as
 the second argument, and `a` as the third argument, and initializes
 `comp` with `compare`; calls `make_heap(c.begin(), c.end(), comp)`.
 ``` cpp
 template<class InputIterator, class Alloc>
-  priority_queue(InputIterator first, InputIterator last, const Compare& compare,
                            const Container& cont, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `cont` as the first argument and `a` as
 the second argument, and initializes `comp` with `compare`; calls
 `c.insert(c.end(), first, last)`; and finally calls
 `make_heap(c.begin(), c.end(), comp)`.
 ``` cpp
 template<class InputIterator, class Alloc>
-  priority_queue(InputIterator first, InputIterator last, const Compare& compare, Container&& cont,
- const Alloc& a);
 ```
 *Effects:* Initializes `c` with `std::move(cont)` as the first argument
 and `a` as the second argument, and initializes `comp` with `compare`;
 calls `c.insert(c.end(), first, last)`; and finally calls
 `make_heap(c.begin(), c.end(), comp)`.
 ``` cpp
 template<container-compatible-range<T> R, class Alloc>
-  priority_queue(from_range_t, R&& rg, const Compare& compare, const Alloc& a);
 ```
 *Effects:* Initializes `comp` with `compare` and `c` with
 `ranges::to<Container>(std::forward<R>(rg), a)`; calls
 `make_heap(c.begin(), c.end(), comp)`.
 ``` cpp
 template<container-compatible-range<T> R, class Alloc>
-  priority_queue(from_range_t, R&& rg, const Alloc& a);
 ```
 *Effects:* Initializes `c` with
-`ranges::to<Container>(std::forward<R>(rg), a)`; calls
-`make_heap(c.begin(), c.end(), comp)`.
 #### Members <a id="priqueue.members">[[priqueue.members]]</a>
 ``` cpp
-void push(const value_type& x);
 ```
 *Effects:* As if by:
 ``` cpp
 c.push_back(x);
 push_heap(c.begin(), c.end(), comp);
 ```
 ``` cpp
-void push(value_type&& x);
 ```
 *Effects:* As if by:
 ``` cpp
@@ -793,33 +688,33 @@ c.push_back(std::move(x));
 push_heap(c.begin(), c.end(), comp);
 ```
 ``` cpp
 template<container-compatible-range<T> R>
-  void push_range(R&& rg);
 ```
 *Effects:* Inserts all elements of `rg` in `c` via
 `c.append_range(std::forward<R>(rg))` if that is a valid expression, or
 `ranges::copy(rg, back_inserter(c))` otherwise. Then restores the heap
 property as if by `make_heap(c.begin(), c.end(), comp)`.
 *Ensures:* `is_heap(c.begin(), c.end(), comp)` is `true`.
 ``` cpp
-template<class... Args> void emplace(Args&&... args);
 ```
 *Effects:* As if by:
 ``` cpp
 c.emplace_back(std::forward<Args>(args)...);
 push_heap(c.begin(), c.end(), comp);
 ```
 ``` cpp
-void pop();
 ```
 *Effects:* As if by:
 ``` cpp
@@ -829,19 +724,57 @@ c.pop_back();
 #### Specialized algorithms <a id="priqueue.special">[[priqueue.special]]</a>
 ``` cpp
 template<class T, class Container, class Compare>
-  void swap(priority_queue<T, Container, Compare>& x,
                       priority_queue<T, Container, Compare>& y) noexcept(noexcept(x.swap(y)));
 ```
 *Constraints:* `is_swappable_v<Container>` is `true` and
 `is_swappable_v<Compare>` is `true`.
 *Effects:* As if by `x.swap(y)`.
 ### Class template `stack` <a id="stack">[[stack]]</a>
 #### General <a id="stack.general">[[stack.general]]</a>
 Any sequence container supporting operations `back()`, `push_back()` and
@@ -853,48 +786,49 @@ Any sequence container supporting operations `back()`, `push_back()` and
 ``` cpp
 namespace std {
   template<class T, class Container = deque<T>>
   class stack {
   public:
-    using value_type      = typename Container::value_type;
-    using reference       = typename Container::reference;
-    using const_reference = typename Container::const_reference;
-    using size_type       = typename Container::size_type;
     using container_type  = Container;
   protected:
     Container c;
   public:
-    stack() : stack(Container()) {}
-    explicit stack(const Container&);
-    explicit stack(Container&&);
-    template<class InputIterator> stack(InputIterator first, InputIterator last);
-    template<container-compatible-range<T> R> stack(from_range_t, R&& rg);
-    template<class Alloc> explicit stack(const Alloc&);
-    template<class Alloc> stack(const Container&, const Alloc&);
-    template<class Alloc> stack(Container&&, const Alloc&);
-    template<class Alloc> stack(const stack&, const Alloc&);
-    template<class Alloc> stack(stack&&, const Alloc&);
     template<class InputIterator, class Alloc>
-      stack(InputIterator first, InputIterator last, const Alloc&);
     template<container-compatible-range<T> R, class Alloc>
-      stack(from_range_t, R&& rg, const Alloc&);
- [[nodiscard]] bool empty() const { return c.empty(); }
- size_type size()  const { return c.size(); }
-    reference         top()             { return c.back(); }
-    const_reference   top() const { return c.back(); }
-    void push(const value_type& x)      { c.push_back(x); }
-    void push(value_type&& x)           { c.push_back(std::move(x)); }
     template<container-compatible-range<T> R>
-      void push_range(R&& rg);
     template<class... Args>
-      decltype(auto) emplace(Args&&... args)
         { return c.emplace_back(std::forward<Args>(args)...); }
-    void pop()                          { c.pop_back(); }
-    void swap(stack& s) noexcept(is_nothrow_swappable_v<Container>)
       { using std::swap; swap(c, s.c); }
   };
   template<class Container>
     stack(Container) -> stack<typename Container::value_type, Container>;
@@ -924,32 +858,32 @@ namespace std {
 ```
 #### Constructors <a id="stack.cons">[[stack.cons]]</a>
 ``` cpp
-explicit stack(const Container& cont);
 ```
 *Effects:* Initializes `c` with `cont`.
 ``` cpp
-explicit stack(Container&& cont);
 ```
 *Effects:* Initializes `c` with `std::move(cont)`.
 ``` cpp
 template<class InputIterator>
-  stack(InputIterator first, InputIterator last);
 ```
 *Effects:* Initializes `c` with `first` as the first argument and `last`
 as the second argument.
 ``` cpp
 template<container-compatible-range<T> R>
-  stack(from_range_t, R&& rg);
 ```
 *Effects:* Initializes `c` with
 `ranges::to<Container>(std::forward<R>(rg))`.
@@ -957,132 +891,180 @@ template<container-compatible-range<T> R>
 If `uses_allocator_v<container_type, Alloc>` is `false` the constructors
 in this subclause shall not participate in overload resolution.
 ``` cpp
-template<class Alloc> explicit stack(const Alloc& a);
 ```
 *Effects:* Initializes `c` with `a`.
 ``` cpp
-template<class Alloc> stack(const container_type& cont, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `cont` as the first argument and `a` as
 the second argument.
 ``` cpp
-template<class Alloc> stack(container_type&& cont, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `std::move(cont)` as the first argument
 and `a` as the second argument.
 ``` cpp
-template<class Alloc> stack(const stack& s, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `s.c` as the first argument and `a` as
 the second argument.
 ``` cpp
-template<class Alloc> stack(stack&& s, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `std::move(s.c)` as the first argument
 and `a` as the second argument.
 ``` cpp
 template<class InputIterator, class Alloc>
-  stack(InputIterator first, InputIterator last, const Alloc& alloc);
 ```
 *Effects:* Initializes `c` with `first` as the first argument, `last` as
 the second argument, and `alloc` as the third argument.
 ``` cpp
 template<container-compatible-range<T> R, class Alloc>
-  stack(from_range_t, R&& rg, const Alloc& a);
 ```
 *Effects:* Initializes `c` with
 `ranges::to<Container>(std::forward<R>(rg), a)`.
 #### Modifiers <a id="stack.mod">[[stack.mod]]</a>
 ``` cpp
 template<container-compatible-range<T> R>
-  void push_range(R&& rg);
 ```
 *Effects:* Equivalent to `c.append_range(std::forward<R>(rg))` if that
 is a valid expression, otherwise `ranges::copy(rg, back_inserter(c))`.
 #### Operators <a id="stack.ops">[[stack.ops]]</a>
 ``` cpp
 template<class T, class Container>
-  bool operator==(const stack<T, Container>& x, const stack<T, Container>& y);
 ```
 *Returns:* `x.c == y.c`.
 ``` cpp
 template<class T, class Container>
-  bool operator!=(const stack<T, Container>& x, const stack<T, Container>& y);
 ```
 *Returns:* `x.c != y.c`.
 ``` cpp
 template<class T, class Container>
-  bool operator< (const stack<T, Container>& x, const stack<T, Container>& y);
 ```
 *Returns:* `x.c < y.c`.
 ``` cpp
 template<class T, class Container>
-  bool operator> (const stack<T, Container>& x, const stack<T, Container>& y);
 ```
 *Returns:* `x.c > y.c`.
 ``` cpp
 template<class T, class Container>
-  bool operator<=(const stack<T, Container>& x, const stack<T, Container>& y);
 ```
 *Returns:* `x.c <= y.c`.
 ``` cpp
 template<class T, class Container>
-  bool operator>=(const stack<T, Container>& x, const stack<T, Container>& y);
 ```
 *Returns:* `x.c >= y.c`.
 ``` cpp
 template<class T, three_way_comparable Container>
-  compare_three_way_result_t<Container>
     operator<=>(const stack<T, Container>& x, const stack<T, Container>& y);
 ```
 *Returns:* `x.c <=> y.c`.
 #### Specialized algorithms <a id="stack.special">[[stack.special]]</a>
 ``` cpp
 template<class T, class Container>
-  void swap(stack<T, Container>& x, stack<T, Container>& y) noexcept(noexcept(x.swap(y)));
 ```
 *Constraints:* `is_swappable_v<Container>` is `true`.
 *Effects:* As if by `x.swap(y)`.
 ### Class template `flat_map` <a id="flat.map">[[flat.map]]</a>
 #### Overview <a id="flat.map.overview">[[flat.map.overview]]</a>
 A `flat_map` is a container adaptor that provides an associative
@@ -1147,14 +1129,16 @@ The program is ill-formed if `Key` is not the same type as
 The effect of calling a constructor that takes both `key_container_type`
 and `mapped_container_type` arguments with containers of different sizes
 is undefined.
-The effect of calling a constructor or member function that takes a
-`sorted_unique_t` argument with a container, containers, or range that
-is not sorted with respect to `key_comp()`, or that contains equal
-elements, is undefined.
 #### Definition <a id="flat.map.defn">[[flat.map.defn]]</a>
 ``` cpp
 namespace std {
@@ -1179,245 +1163,259 @@ namespace std {
     using mapped_container_type  = MappedContainer;
     class value_compare {
     private:
       key_compare comp;                                         // exposition only
-      value_compare(key_compare c) : comp(c) { } // exposition only
     public:
-      bool operator()(const_reference x, const_reference y) const {
         return comp(x.first, y.first);
       }
     };
     struct containers {
       key_container_type keys;
       mapped_container_type values;
     };
-    // [flat.map.cons], construct/copy/destroy
-    flat_map() : flat_map(key_compare()) { }
-    flat_map(key_container_type key_cont, mapped_container_type mapped_cont,
-             const key_compare& comp = key_compare());
-    template<class Allocator>
-      flat_map(const key_container_type& key_cont, const mapped_container_type& mapped_cont,
-               const Allocator& a);
-    template<class Allocator>
-      flat_map(const key_container_type& key_cont, const mapped_container_type& mapped_cont,
-               const key_compare& comp, const Allocator& a);
-    flat_map(sorted_unique_t, key_container_type key_cont, mapped_container_type mapped_cont,
-             const key_compare& comp = key_compare());
-    template<class Allocator>
-      flat_map(sorted_unique_t, const key_container_type& key_cont,
-               const mapped_container_type& mapped_cont, const Allocator& a);
-    template<class Allocator>
-      flat_map(sorted_unique_t, const key_container_type& key_cont,
-               const mapped_container_type& mapped_cont,
-               const key_compare& comp, const Allocator& a);
-    explicit flat_map(const key_compare& comp)
       : c(), compare(comp) { }
-    template<class Allocator>
- flat_map(const key_compare& comp, const Allocator& a);
-    template<class Allocator>
-      explicit flat_map(const Allocator& a);
     template<class InputIterator>
-      flat_map(InputIterator first, InputIterator last, const key_compare& comp = key_compare())
         : c(), compare(comp) { insert(first, last); }
-    template<class InputIterator, class Allocator>
-      flat_map(InputIterator first, InputIterator last,
-               const key_compare& comp, const Allocator& a);
-    template<class InputIterator, class Allocator>
-      flat_map(InputIterator first, InputIterator last, const Allocator& a);
     template<container-compatible-range<value_type> R>
-      flat_map(from_range_t fr, R&& rg)
-        : flat_map(fr, std::forward<R>(rg), key_compare()) { }
-    template<container-compatible-range<value_type> R, class Allocator>
-      flat_map(from_range_t, R&& rg, const Allocator& a);
     template<container-compatible-range<value_type> R>
-      flat_map(from_range_t, R&& rg, const key_compare& comp)
         : flat_map(comp) { insert_range(std::forward<R>(rg)); }
-    template<container-compatible-range<value_type> R, class Allocator>
-      flat_map(from_range_t, R&& rg, const key_compare& comp, const Allocator& a);
- template<class InputIterator>
-      flat_map(sorted_unique_t s, InputIterator first, InputIterator last,
-               const key_compare& comp = key_compare())
-        : c(), compare(comp) { insert(s, first, last); }
-    template<class InputIterator, class Allocator>
-      flat_map(sorted_unique_t, InputIterator first, InputIterator last,
-               const key_compare& comp, const Allocator& a);
-    template<class InputIterator, class Allocator>
-      flat_map(sorted_unique_t, InputIterator first, InputIterator last, const Allocator& a);
-    flat_map(initializer_list<value_type> il, const key_compare& comp = key_compare())
         : flat_map(il.begin(), il.end(), comp) { }
-    template<class Allocator>
-      flat_map(initializer_list<value_type> il, const key_compare& comp, const Allocator& a);
-    template<class Allocator>
-      flat_map(initializer_list<value_type> il, const Allocator& a);
-    flat_map(sorted_unique_t s, initializer_list<value_type> il,
                        const key_compare& comp = key_compare())
-        : flat_map(s, il.begin(), il.end(), comp) { }
-    template<class Allocator>
-      flat_map(sorted_unique_t, initializer_list<value_type> il,
-               const key_compare& comp, const Allocator& a);
-    template<class Allocator>
-      flat_map(sorted_unique_t, initializer_list<value_type> il, const Allocator& a);
- flat_map& operator=(initializer_list<value_type> il);
     // iterators
-    iterator               begin() noexcept;
-    const_iterator         begin() const noexcept;
-    iterator               end() noexcept;
-    const_iterator         end() const noexcept;
-    reverse_iterator       rbegin() noexcept;
-    const_reverse_iterator rbegin() const noexcept;
-    reverse_iterator       rend() noexcept;
-    const_reverse_iterator rend() const noexcept;
-    const_iterator         cbegin() const noexcept;
-    const_iterator         cend() const noexcept;
-    const_reverse_iterator crbegin() const noexcept;
-    const_reverse_iterator crend() const noexcept;
     // [flat.map.capacity], capacity
- [[nodiscard]] bool empty() const noexcept;
-    size_type size() const noexcept;
-    size_type max_size() const noexcept;
     // [flat.map.access], element access
-    mapped_type& operator[](const key_type& x);
-    mapped_type& operator[](key_type&& x);
-    template<class K> mapped_type& operator[](K&& x);
-    mapped_type& at(const key_type& x);
-    const mapped_type& at(const key_type& x) const;
-    template<class K> mapped_type& at(const K& x);
-    template<class K> const mapped_type& at(const K& x) const;
     // [flat.map.modifiers], modifiers
-    template<class... Args> pair<iterator, bool> emplace(Args&&... args);
     template<class... Args>
-      iterator emplace_hint(const_iterator position, Args&&... args);
-    pair<iterator, bool> insert(const value_type& x)
       { return emplace(x); }
-    pair<iterator, bool> insert(value_type&& x)
       { return emplace(std::move(x)); }
-    iterator insert(const_iterator position, const value_type& x)
       { return emplace_hint(position, x); }
-    iterator insert(const_iterator position, value_type&& x)
       { return emplace_hint(position, std::move(x)); }
-    template<class P> pair<iterator, bool> insert(P&& x);
     template<class P>
-      iterator insert(const_iterator position, P&&);
     template<class InputIterator>
-      void insert(InputIterator first, InputIterator last);
     template<class InputIterator>
-      void insert(sorted_unique_t, InputIterator first, InputIterator last);
     template<container-compatible-range<value_type> R>
-      void insert_range(R&& rg);
-    void insert(initializer_list<value_type> il)
       { insert(il.begin(), il.end()); }
-    void insert(sorted_unique_t s, initializer_list<value_type> il)
-      { insert(s, il.begin(), il.end()); }
-    containers extract() &&;
-    void replace(key_container_type&& key_cont, mapped_container_type&& mapped_cont);
     template<class... Args>
-      pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
     template<class... Args>
-      pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
     template<class K, class... Args>
-      pair<iterator, bool> try_emplace(K&& k, Args&&... args);
     template<class... Args>
-      iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args);
     template<class... Args>
-      iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);
     template<class K, class... Args>
-      iterator try_emplace(const_iterator hint, K&& k, Args&&... args);
     template<class M>
-      pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);
     template<class M>
-      pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj);
     template<class K, class M>
-      pair<iterator, bool> insert_or_assign(K&& k, M&& obj);
     template<class M>
-      iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);
     template<class M>
-      iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj);
     template<class K, class M>
-      iterator insert_or_assign(const_iterator hint, K&& k, M&& obj);
-    iterator erase(iterator position);
-    iterator erase(const_iterator position);
-    size_type erase(const key_type& x);
-    template<class K> size_type erase(K&& x);
-    iterator erase(const_iterator first, const_iterator last);
-    void swap(flat_map& y) noexcept;
-    void clear() noexcept;
     // observers
-    key_compare key_comp() const;
-    value_compare value_comp() const;
-    const key_container_type& keys() const noexcept      { return c.keys; }
-    const mapped_container_type& values() const noexcept { return c.values; }
     // map operations
-    iterator find(const key_type& x);
-    const_iterator find(const key_type& x) const;
-    template<class K> iterator find(const K& x);
-    template<class K> const_iterator find(const K& x) const;
-    size_type count(const key_type& x) const;
-    template<class K> size_type count(const K& x) const;
-    bool contains(const key_type& x) const;
-    template<class K> bool contains(const K& x) const;
-    iterator lower_bound(const key_type& x);
-    const_iterator lower_bound(const key_type& x) const;
-    template<class K> iterator lower_bound(const K& x);
-    template<class K> const_iterator lower_bound(const K& x) const;
-    iterator upper_bound(const key_type& x);
-    const_iterator upper_bound(const key_type& x) const;
-    template<class K> iterator upper_bound(const K& x);
-    template<class K> const_iterator upper_bound(const K& x) const;
-    pair<iterator, iterator> equal_range(const key_type& x);
-    pair<const_iterator, const_iterator> equal_range(const key_type& x) const;
-    template<class K> pair<iterator, iterator> equal_range(const K& x);
-    template<class K> pair<const_iterator, const_iterator> equal_range(const K& x) const;
-    friend bool operator==(const flat_map& x, const flat_map& y);
-    friend synth-three-way-result<value_type>
       operator<=>(const flat_map& x, const flat_map& y);
-    friend void swap(flat_map& x, flat_map& y) noexcept
       { x.swap(y); }
   private:
     containers c;               // exposition only
     key_compare compare;        // exposition only
-    struct key_equiv {  // exposition only
- key_equiv(key_compare c) : comp(c) { }
-      bool operator()(const_reference x, const_reference y) const {
         return !comp(x.first, y.first) && !comp(y.first, x.first);
       }
       key_compare comp;
     };
   };
@@ -1494,162 +1492,163 @@ specified above. It has no base classes or members other than those
 specified.
 #### Constructors <a id="flat.map.cons">[[flat.map.cons]]</a>
 ``` cpp
-flat_map(key_container_type key_cont, mapped_container_type mapped_cont,
                    const key_compare& comp = key_compare());
 ```
-*Effects:* Initializes `c.keys` with `std::move(key_cont)`, `c.values`
-with `std::move(mapped_cont)`, and `compare` with `comp`; sorts the
-range \[`begin()`, `end()`) with respect to `value_comp()`; and finally
-erases the duplicate elements as if by:
 ``` cpp
-auto zv = ranges::zip_view(c.keys, c.values);
-auto it = ranges::unique(zv, key_equiv(compare)).begin();
 auto dist = distance(zv.begin(), it);
 c.keys.erase(c.keys.begin() + dist, c.keys.end());
 c.values.erase(c.values.begin() + dist, c.values.end());
 ```
 *Complexity:* Linear in N if the container arguments are already sorted
 with respect to `value_comp()` and otherwise N log N, where N is the
 value of `key_cont.size()` before this call.
 ``` cpp
-template<class Allocator>
-  flat_map(const key_container_type& key_cont, const mapped_container_type& mapped_cont,
-           const Allocator& a);
-template<class Allocator>
-  flat_map(const key_container_type& key_cont, const mapped_container_type& mapped_cont,
-           const key_compare& comp, const Allocator& a);
 ```
-*Constraints:* `uses_allocator_v<key_container_type, Allocator>` is
-`true` and `uses_allocator_v<mapped_container_type, Allocator>` is
-`true`.
 *Effects:* Equivalent to `flat_map(key_cont, mapped_cont)` and
 `flat_map(key_cont, mapped_cont, comp)`, respectively, except that
-`c.keys` and `c.values` are constructed with uses-allocator
 construction [[allocator.uses.construction]].
 *Complexity:* Same as `flat_map(key_cont, mapped_cont)` and
 `flat_map(key_cont, mapped_cont, comp)`, respectively.
 ``` cpp
-flat_map(sorted_unique_t, key_container_type key_cont, mapped_container_type mapped_cont,
- const key_compare& comp = key_compare());
-```
-*Effects:* Initializes `c.keys` with `std::move(key_cont)`, `c.values`
-with `std::move(mapped_cont)`, and `compare` with `comp`.
-*Complexity:* Constant.
-``` cpp
-template<class Allocator>
-  flat_map(sorted_unique_t s, const key_container_type& key_cont,
-           const mapped_container_type& mapped_cont, const Allocator& a);
-template<class Allocator>
-  flat_map(sorted_unique_t s, const key_container_type& key_cont,
                      const mapped_container_type& mapped_cont, const key_compare& comp,
- const Allocator& a);
 ```
-*Constraints:* `uses_allocator_v<key_container_type, Allocator>` is
-`true` and `uses_allocator_v<mapped_container_type, Allocator>` is
-`true`.
-*Effects:* Equivalent to `flat_map(s, key_cont, mapped_cont)` and
-`flat_map(s, key_cont, mapped_cont, comp)`, respectively, except that
-`c.keys` and `c.values` are constructed with uses-allocator
-construction [[allocator.uses.construction]].
 *Complexity:* Linear.
 ``` cpp
-template<class Allocator>
-  flat_map(const key_compare& comp, const Allocator& a);
-template<class Allocator>
- explicit flat_map(const Allocator& a);
-template<class InputIterator, class Allocator>
-  flat_map(InputIterator first, InputIterator last, const key_compare& comp, const Allocator& a);
-template<class InputIterator, class Allocator>
-  flat_map(InputIterator first, InputIterator last, const Allocator& a);
-template<container-compatible-range<value_type> R, class Allocator>
-  flat_map(from_range_t, R&& rg, const Allocator& a);
-template<container-compatible-range<value_type> R, class Allocator>
-  flat_map(from_range_t, R&& rg, const key_compare& comp, const Allocator& a);
-template<class InputIterator, class Allocator>
-  flat_map(sorted_unique_t, InputIterator first, InputIterator last,
-           const key_compare& comp, const Allocator& a);
-template<class InputIterator, class Allocator>
-  flat_map(sorted_unique_t, InputIterator first, InputIterator last, const Allocator& a);
-template<class Allocator>
-  flat_map(initializer_list<value_type> il, const key_compare& comp, const Allocator& a);
-template<class Allocator>
-  flat_map(initializer_list<value_type> il, const Allocator& a);
-template<class Allocator>
-  flat_map(sorted_unique_t, initializer_list<value_type> il,
-           const key_compare& comp, const Allocator& a);
-template<class Allocator>
-  flat_map(sorted_unique_t, initializer_list<value_type> il, const Allocator& a);
 ```
-*Constraints:* `uses_allocator_v<key_container_type, Allocator>` is
-`true` and `uses_allocator_v<mapped_container_type, Allocator>` is
-`true`.
 *Effects:* Equivalent to the corresponding non-allocator constructors
-except that `c.keys` and `c.values` are constructed with uses-allocator
-construction [[allocator.uses.construction]].
 #### Capacity <a id="flat.map.capacity">[[flat.map.capacity]]</a>
 ``` cpp
-size_type size() const noexcept;
 ```
-*Returns:* `c.keys.size()`.
 ``` cpp
-size_type max_size() const noexcept;
 ```
-*Returns:* `min<size_type>(c.keys.max_size(), c.values.max_size())`.
 #### Access <a id="flat.map.access">[[flat.map.access]]</a>
 ``` cpp
-mapped_type& operator[](const key_type& x);
 ```
 *Effects:* Equivalent to: `return try_emplace(x).first->second;`
 ``` cpp
-mapped_type& operator[](key_type&& x);
 ```
 *Effects:* Equivalent to:
 `return try_emplace(std::move(x)).first->second;`
 ``` cpp
-template<class K> mapped_type& operator[](K&& x);
 ```
 *Constraints:* The *qualified-id* `Compare::is_transparent` is valid and
 denotes a type.
 *Effects:* Equivalent to:
 `return try_emplace(std::forward<K>(x)).first->second;`
 ``` cpp
-mapped_type&       at(const key_type& x);
-const mapped_type& at(const key_type& x) const;
 ```
 *Returns:* A reference to the `mapped_type` corresponding to `x` in
 `*this`.
@@ -1657,12 +1656,12 @@ const mapped_type& at(const key_type& x) const;
 is present.
 *Complexity:* Logarithmic.
 ``` cpp
-template<class K> mapped_type&       at(const K& x);
-template<class K> const mapped_type& at(const K& x) const;
 ```
 *Constraints:* The *qualified-id* `Compare::is_transparent` is valid and
 denotes a type.
@@ -1678,11 +1677,11 @@ is present.
 *Complexity:* Logarithmic.
 #### Modifiers <a id="flat.map.modifiers">[[flat.map.modifiers]]</a>
 ``` cpp
-template<class... Args> pair<iterator, bool> emplace(Args&&... args);
 ```
 *Constraints:*
 `is_constructible_v<pair<key_type, mapped_type>, Args...>` is `true`.
@@ -1701,12 +1700,12 @@ c.values.insert(value_it, std::move(t.second));
 *Returns:* The `bool` component of the returned pair is `true` if and
 only if the insertion took place, and the iterator component of the pair
 points to the element with key equivalent to `t.first`.
 ``` cpp
-template<class P> pair<iterator, bool> insert(P&& x);
-template<class P> iterator insert(const_iterator position, P&& x);
 ```
 *Constraints:* `is_constructible_v<pair<key_type, mapped_type>, P>` is
 `true`.
@@ -1714,14 +1713,14 @@ template<class P> iterator insert(const_iterator position, P&& x);
 `return emplace(std::forward<P>(x));`. The second form is equivalent to
 `return emplace_hint(position, std::forward<P>(x));`.
 ``` cpp
 template<class InputIterator>
-  void insert(InputIterator first, InputIterator last);
 ```
-*Effects:* Adds elements to `c` as if by:
 ``` cpp
 for (; first != last; ++first) {
   value_type value = *first;
   c.keys.insert(c.keys.end(), std::move(value.first));
@@ -1733,12 +1732,12 @@ Then, sorts the range of newly inserted elements with respect to
 `value_comp()`; merges the resulting sorted range and the sorted range
 of pre-existing elements into a single sorted range; and finally erases
 the duplicate elements as if by:
 ``` cpp
-auto zv = ranges::zip_view(c.keys, c.values);
-auto it = ranges::unique(zv, key_equiv(compare)).begin();
 auto dist = distance(zv.begin(), it);
 c.keys.erase(c.keys.begin() + dist, c.keys.end());
 c.values.erase(c.values.begin() + dist, c.values.end());
 ```
@@ -1748,46 +1747,23 @@ M is `distance(first, last)`.
 *Remarks:* Since this operation performs an in-place merge, it may
 allocate memory.
 ``` cpp
 template<class InputIterator>
-  void insert(sorted_unique_t, InputIterator first, InputIterator last);
 ```
-*Effects:* Adds elements to `c` as if by:
-``` cpp
-for (; first != last; ++first) {
-  value_type value = *first;
-  c.keys.insert(c.keys.end(), std::move(value.first));
-  c.values.insert(c.values.end(), std::move(value.second));
-}
-```
-Then, merges the sorted range of newly added elements and the sorted
-range of pre-existing elements into a single sorted range; and finally
-erases the duplicate elements as if by:
-``` cpp
-auto zv = ranges::zip_view(c.keys, c.values);
-auto it = ranges::unique(zv, key_equiv(compare)).begin();
-auto dist = distance(zv.begin(), it);
-c.keys.erase(c.keys.begin() + dist, c.keys.end());
-c.values.erase(c.values.begin() + dist, c.values.end());
-```
 *Complexity:* Linear in N, where N is `size()` after the operation.
-*Remarks:* Since this operation performs an in-place merge, it may
-allocate memory.
 ``` cpp
 template<container-compatible-range<value_type> R>
-  void insert_range(R&& rg);
 ```
-*Effects:* Adds elements to `c` as if by:
 ``` cpp
 for (const auto& e : rg) {
   c.keys.insert(c.keys.end(), e.first);
   c.values.insert(c.values.end(), e.second);
@@ -1798,12 +1774,12 @@ Then, sorts the range of newly inserted elements with respect to
 `value_comp()`; merges the resulting sorted range and the sorted range
 of pre-existing elements into a single sorted range; and finally erases
 the duplicate elements as if by:
 ``` cpp
-auto zv = ranges::zip_view(c.keys, c.values);
-auto it = ranges::unique(zv, key_equiv(compare)).begin();
 auto dist = distance(zv.begin(), it);
 c.keys.erase(c.keys.begin() + dist, c.keys.end());
 c.values.erase(c.values.begin() + dist, c.values.end());
 ```
@@ -1813,17 +1789,17 @@ M is `ranges::distance(rg)`.
 *Remarks:* Since this operation performs an in-place merge, it may
 allocate memory.
 ``` cpp
 template<class... Args>
-  pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
 template<class... Args>
-  pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
 template<class... Args>
-  iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args);
 template<class... Args>
-  iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);
 ```
 *Constraints:* `is_constructible_v<mapped_type, Args...>` is `true`.
 *Effects:* If the map already contains an element whose key is
@@ -1845,13 +1821,13 @@ returned iterator points to the map element whose key is equivalent to
 *Complexity:* The same as `emplace` for the first two overloads, and the
 same as `emplace_hint` for the last two overloads.
 ``` cpp
 template<class K, class... Args>
-  pair<iterator, bool> try_emplace(K&& k, Args&&... args);
 template<class K, class... Args>
-  iterator try_emplace(const_iterator hint, K&& k, Args&&... args);
 ```
 *Constraints:*
 - The *qualified-id* `Compare::is_transparent` is valid and denotes a
@@ -1867,11 +1843,11 @@ object `u`, for which `find(k) == find(u)` is `true`.
 *Effects:* If the map already contains an element whose key is
 equivalent to `k`, `*this` and `args...` are unchanged. Otherwise
 equivalent to:
 ``` cpp
-auto key_it = ranges::upper_bound(c.keys, k, compare);
 auto value_it = c.values.begin() + distance(c.keys.begin(), key_it);
 c.keys.emplace(key_it, std::forward<K>(k));
 c.values.emplace(value_it, std::forward<Args>(args)...);
 ```
@@ -1881,17 +1857,17 @@ iterator points to the map element whose key is equivalent to `k`.
 *Complexity:* The same as `emplace` and `emplace_hint`, respectively.
 ``` cpp
 template<class M>
-  pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);
 template<class M>
-  pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj);
 template<class M>
-  iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);
 template<class M>
-  iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj);
 ```
 *Constraints:* `is_assignable_v<mapped_type&, M>` is `true` and
 `is_constructible_v<mapped_type, M>` is `true`.
@@ -1919,13 +1895,13 @@ returned iterator points to the map element whose key is equivalent to
 *Complexity:* The same as `emplace` for the first two overloads and the
 same as `emplace_hint` for the last two overloads.
 ``` cpp
 template<class K, class M>
-  pair<iterator, bool> insert_or_assign(K&& k, M&& obj);
 template<class K, class M>
-  iterator insert_or_assign(const_iterator hint, K&& k, M&& obj);
 ```
 *Constraints:*
 - The *qualified-id* `Compare::is_transparent` is valid and denotes a
@@ -1958,11 +1934,11 @@ pair is `true` if and only if the insertion took place. The returned
 iterator points to the map element whose key is equivalent to `k`.
 *Complexity:* The same as `emplace` and `emplace_hint`, respectively.
 ``` cpp
-void swap(flat_map& y) noexcept;
 ```
 *Effects:* Equivalent to:
 ``` cpp
@@ -1970,24 +1946,24 @@ ranges::swap(compare, y.compare);
 ranges::swap(c.keys, y.c.keys);
 ranges::swap(c.values, y.c.values);
 ```
 ``` cpp
-containers extract() &&;
 ```
 *Ensures:* `*this` is emptied, even if the function exits via an
 exception.
-*Returns:* `std::move(c)`.
 ``` cpp
-void replace(key_container_type&& key_cont, mapped_container_type&& mapped_cont);
 ```
 *Preconditions:* `key_cont.size() == mapped_cont.size()` is `true`, the
-elements of `key_cont` are sorted with respect to `compare`, and
 `key_cont` contains no equal elements.
 *Effects:* Equivalent to:
 ``` cpp
@@ -1998,11 +1974,11 @@ c.values = std::move(mapped_cont);
 #### Erasure <a id="flat.map.erasure">[[flat.map.erasure]]</a>
 ``` cpp
 template<class Key, class T, class Compare, class KeyContainer, class MappedContainer,
          class Predicate>
-  typename flat_map<Key, T, Compare, KeyContainer, MappedContainer>::size_type
     erase_if(flat_map<Key, T, Compare, KeyContainer, MappedContainer>& c, Predicate pred);
 ```
 *Preconditions:* `Key` and `T` meet the *Cpp17MoveAssignable*
 requirements.
@@ -2092,14 +2068,17 @@ The program is ill-formed if `Key` is not the same type as
 The effect of calling a constructor that takes both `key_container_type`
 and `mapped_container_type` arguments with containers of different sizes
 is undefined.
-The effect of calling a constructor or member function that takes a
 `sorted_equivalent_t` argument with a container, containers, or range
 that are not sorted with respect to `key_comp()` is undefined.
 #### Definition <a id="flat.multimap.defn">[[flat.multimap.defn]]</a>
 ``` cpp
 namespace std {
   template<class Key, class T, class Compare = less<Key>,
@@ -2123,209 +2102,219 @@ namespace std {
     using mapped_container_type  = MappedContainer;
     class value_compare {
     private:
       key_compare comp;                                         // exposition only
-      value_compare(key_compare c) : comp(c) { } // exposition only
     public:
-      bool operator()(const_reference x, const_reference y) const {
         return comp(x.first, y.first);
       }
     };
     struct containers {
       key_container_type keys;
       mapped_container_type values;
     };
-    // [flat.multimap.cons], construct/copy/destroy
-    flat_multimap() : flat_multimap(key_compare()) { }
-    flat_multimap(key_container_type key_cont, mapped_container_type mapped_cont,
                             const key_compare& comp = key_compare());
-    template<class Allocator>
-      flat_multimap(const key_container_type& key_cont, const mapped_container_type& mapped_cont,
-                    const Allocator& a);
-    template<class Allocator>
-      flat_multimap(const key_container_type& key_cont, const mapped_container_type& mapped_cont,
-                    const key_compare& comp, const Allocator& a);
-    flat_multimap(sorted_equivalent_t,
                             key_container_type key_cont, mapped_container_type mapped_cont,
                   const key_compare& comp = key_compare());
-    template<class Allocator>
-      flat_multimap(sorted_equivalent_t, const key_container_type& key_cont,
-                    const mapped_container_type& mapped_cont, const Allocator& a);
-    template<class Allocator>
-      flat_multimap(sorted_equivalent_t, const key_container_type& key_cont,
-                    const mapped_container_type& mapped_cont,
-                    const key_compare& comp, const Allocator& a);
-    explicit flat_multimap(const key_compare& comp)
-      : c(), compare(comp) { }
-    template<class Allocator>
-      flat_multimap(const key_compare& comp, const Allocator& a);
-    template<class Allocator>
-      explicit flat_multimap(const Allocator& a);
     template<class InputIterator>
-      flat_multimap(InputIterator first, InputIterator last,
                               const key_compare& comp = key_compare())
         : c(), compare(comp)
         { insert(first, last); }
-    template<class InputIterator, class Allocator>
-      flat_multimap(InputIterator first, InputIterator last,
-                    const key_compare& comp, const Allocator& a);
-    template<class InputIterator, class Allocator>
-      flat_multimap(InputIterator first, InputIterator last, const Allocator& a);
     template<container-compatible-range<value_type> R>
-      flat_multimap(from_range_t fr, R&& rg)
-        : flat_multimap(fr, std::forward<R>(rg), key_compare()) { }
-    template<container-compatible-range<value_type> R, class Allocator>
-      flat_multimap(from_range_t, R&& rg, const Allocator& a);
     template<container-compatible-range<value_type> R>
-      flat_multimap(from_range_t, R&& rg, const key_compare& comp)
         : flat_multimap(comp) { insert_range(std::forward<R>(rg)); }
-    template<container-compatible-range<value_type> R, class Allocator>
-      flat_multimap(from_range_t, R&& rg, const key_compare& comp, const Allocator& a);
- template<class InputIterator>
-      flat_multimap(sorted_equivalent_t s, InputIterator first, InputIterator last,
                             const key_compare& comp = key_compare())
-        : c(), compare(comp) { insert(s, first, last); }
-    template<class InputIterator, class Allocator>
-      flat_multimap(sorted_equivalent_t, InputIterator first, InputIterator last,
-                    const key_compare& comp, const Allocator& a);
-    template<class InputIterator, class Allocator>
-      flat_multimap(sorted_equivalent_t, InputIterator first, InputIterator last,
-                    const Allocator& a);
-    flat_multimap(initializer_list<value_type> il, const key_compare& comp = key_compare())
         : flat_multimap(il.begin(), il.end(), comp) { }
-    template<class Allocator>
-      flat_multimap(initializer_list<value_type> il, const key_compare& comp,
-                    const Allocator& a);
-    template<class Allocator>
-      flat_multimap(initializer_list<value_type> il, const Allocator& a);
-    flat_multimap(sorted_equivalent_t s, initializer_list<value_type> il,
                             const key_compare& comp = key_compare())
-        : flat_multimap(s, il.begin(), il.end(), comp) { }
-    template<class Allocator>
-      flat_multimap(sorted_equivalent_t, initializer_list<value_type> il,
-                    const key_compare& comp, const Allocator& a);
-    template<class Allocator>
-      flat_multimap(sorted_equivalent_t, initializer_list<value_type> il, const Allocator& a);
- flat_multimap& operator=(initializer_list<value_type> il);
     // iterators
-    iterator               begin() noexcept;
-    const_iterator         begin() const noexcept;
-    iterator               end() noexcept;
-    const_iterator         end() const noexcept;
-    reverse_iterator       rbegin() noexcept;
-    const_reverse_iterator rbegin() const noexcept;
-    reverse_iterator       rend() noexcept;
-    const_reverse_iterator rend() const noexcept;
-    const_iterator         cbegin() const noexcept;
-    const_iterator         cend() const noexcept;
-    const_reverse_iterator crbegin() const noexcept;
-    const_reverse_iterator crend() const noexcept;
     // capacity
- [[nodiscard]] bool empty() const noexcept;
-    size_type size() const noexcept;
-    size_type max_size() const noexcept;
     // modifiers
-    template<class... Args> iterator emplace(Args&&... args);
     template<class... Args>
-      iterator emplace_hint(const_iterator position, Args&&... args);
-    iterator insert(const value_type& x)
       { return emplace(x); }
-    iterator insert(value_type&& x)
       { return emplace(std::move(x)); }
-    iterator insert(const_iterator position, const value_type& x)
       { return emplace_hint(position, x); }
-    iterator insert(const_iterator position, value_type&& x)
       { return emplace_hint(position, std::move(x)); }
-    template<class P> iterator insert(P&& x);
     template<class P>
-      iterator insert(const_iterator position, P&&);
     template<class InputIterator>
-      void insert(InputIterator first, InputIterator last);
     template<class InputIterator>
-      void insert(sorted_equivalent_t, InputIterator first, InputIterator last);
     template<container-compatible-range<value_type> R>
-      void insert_range(R&& rg);
-    void insert(initializer_list<value_type> il)
       { insert(il.begin(), il.end()); }
-    void insert(sorted_equivalent_t s, initializer_list<value_type> il)
-      { insert(s, il.begin(), il.end()); }
-    containers extract() &&;
-    void replace(key_container_type&& key_cont, mapped_container_type&& mapped_cont);
-    iterator erase(iterator position);
-    iterator erase(const_iterator position);
-    size_type erase(const key_type& x);
-    template<class K> size_type erase(K&& x);
-    iterator erase(const_iterator first, const_iterator last);
-    void swap(flat_multimap&) noexcept;
-    void clear() noexcept;
     // observers
-    key_compare key_comp() const;
-    value_compare value_comp() const;
-    const key_container_type& keys() const noexcept { return c.keys; }
-    const mapped_container_type& values() const noexcept { return c.values; }
     // map operations
-    iterator find(const key_type& x);
-    const_iterator find(const key_type& x) const;
-    template<class K> iterator find(const K& x);
-    template<class K> const_iterator find(const K& x) const;
-    size_type count(const key_type& x) const;
-    template<class K> size_type count(const K& x) const;
-    bool contains(const key_type& x) const;
-    template<class K> bool contains(const K& x) const;
-    iterator lower_bound(const key_type& x);
-    const_iterator lower_bound(const key_type& x) const;
-    template<class K> iterator lower_bound(const K& x);
-    template<class K> const_iterator lower_bound(const K& x) const;
-    iterator upper_bound(const key_type& x);
-    const_iterator upper_bound(const key_type& x) const;
-    template<class K> iterator upper_bound(const K& x);
-    template<class K> const_iterator upper_bound(const K& x) const;
-    pair<iterator, iterator> equal_range(const key_type& x);
-    pair<const_iterator, const_iterator> equal_range(const key_type& x) const;
     template<class K>
-      pair<iterator, iterator> equal_range(const K& x);
     template<class K>
-      pair<const_iterator, const_iterator> equal_range(const K& x) const;
-    friend bool operator==(const flat_multimap& x, const flat_multimap& y);
-    friend synth-three-way-result<value_type>
       operator<=>(const flat_multimap& x, const flat_multimap& y);
-    friend void swap(flat_multimap& x, flat_multimap& y) noexcept
       { x.swap(y); }
   private:
     containers c;               // exposition only
     key_compare compare;        // exposition only
@@ -2408,119 +2397,122 @@ specified above. It has no base classes or members other than those
 specified.
 #### Constructors <a id="flat.multimap.cons">[[flat.multimap.cons]]</a>
 ``` cpp
-flat_multimap(key_container_type key_cont, mapped_container_type mapped_cont,
                         const key_compare& comp = key_compare());
 ```
-*Effects:* Initializes `c.keys` with `std::move(key_cont)`, `c.values`
-with `std::move(mapped_cont)`, and `compare` with `comp`; sorts the
-range \[`begin()`, `end()`) with respect to `value_comp()`.
 *Complexity:* Linear in N if the container arguments are already sorted
 with respect to `value_comp()` and otherwise N log N, where N is the
 value of `key_cont.size()` before this call.
 ``` cpp
-template<class Allocator>
-  flat_multimap(const key_container_type& key_cont, const mapped_container_type& mapped_cont,
- const Allocator& a);
-template<class Allocator>
-  flat_multimap(const key_container_type& key_cont, const mapped_container_type& mapped_cont,
-                const key_compare& comp, const Allocator& a);
 ```
-*Constraints:* `uses_allocator_v<key_container_type, Allocator>` is
-`true` and `uses_allocator_v<mapped_container_type, Allocator>` is
-`true`.
 *Effects:* Equivalent to `flat_multimap(key_cont, mapped_cont)` and
 `flat_multimap(key_cont, mapped_cont, comp)`, respectively, except that
-`c.keys` and `c.values` are constructed with uses-allocator
 construction [[allocator.uses.construction]].
 *Complexity:* Same as `flat_multimap(key_cont, mapped_cont)` and
 `flat_multimap(key_cont, mapped_cont, comp)`, respectively.
 ``` cpp
-flat_multimap(sorted_equivalent_t, key_container_type key_cont, mapped_container_type mapped_cont,
- const key_compare& comp = key_compare());
-```
-*Effects:* Initializes `c.keys` with `std::move(key_cont)`, `c.values`
-with `std::move(mapped_cont)`, and `compare` with `comp`.
-*Complexity:* Constant.
-``` cpp
-template<class Allocator>
-  flat_multimap(sorted_equivalent_t s, const key_container_type& key_cont,
-                const mapped_container_type& mapped_cont, const Allocator& a);
-template<class Allocator>
-  flat_multimap(sorted_equivalent_t s, const key_container_type& key_cont,
                 const mapped_container_type& mapped_cont, const key_compare& comp,
-                const Allocator& a);
 ```
-*Constraints:* `uses_allocator_v<key_container_type, Allocator>` is
-`true` and `uses_allocator_v<mapped_container_type, Allocator>` is
-`true`.
-*Effects:* Equivalent to `flat_multimap(s, key_cont, mapped_cont)` and
-`flat_multimap(s, key_cont, mapped_cont, comp)`, respectively, except
-that `c.keys` and `c.values` are constructed with uses-allocator
 construction [[allocator.uses.construction]].
 *Complexity:* Linear.
 ``` cpp
-template<class Allocator>
-  flat_multimap(const key_compare& comp, const Allocator& a);
-template<class Allocator>
- explicit flat_multimap(const Allocator& a);
-template<class InputIterator, class Allocator>
-  flat_multimap(InputIterator first, InputIterator last, const key_compare& comp,
-                const Allocator& a);
-template<class InputIterator, class Allocator>
-  flat_multimap(InputIterator first, InputIterator last, const Allocator& a);
-template<container-compatible-range<value_type> R, class Allocator>
-  flat_multimap(from_range_t, R&& rg, const Allocator& a);
-template<container-compatible-range<value_type> R, class Allocator>
-  flat_multimap(from_range_t, R&& rg, const key_compare& comp, const Allocator& a);
-template<class InputIterator, class Allocator>
-  flat_multimap(sorted_equivalent_t, InputIterator first, InputIterator last,
- const key_compare& comp, const Allocator& a);
-template<class InputIterator, class Allocator>
-  flat_multimap(sorted_equivalent_t, InputIterator first, InputIterator last,
- const Allocator& a);
-template<class Allocator>
-  flat_multimap(initializer_list<value_type> il, const key_compare& comp, const Allocator& a);
-template<class Allocator>
-  flat_multimap(initializer_list<value_type> il, const Allocator& a);
-template<class Allocator>
-  flat_multimap(sorted_equivalent_t, initializer_list<value_type> il,
-                const key_compare& comp, const Allocator& a);
-template<class Allocator>
-  flat_multimap(sorted_equivalent_t, initializer_list<value_type> il, const Allocator& a);
 ```
-*Constraints:* `uses_allocator_v<key_container_type, Allocator>` is
-`true` and `uses_allocator_v<mapped_container_type, Allocator>` is
-`true`.
 *Effects:* Equivalent to the corresponding non-allocator constructors
-except that `c.keys` and `c.values` are constructed with uses-allocator
-construction [[allocator.uses.construction]].
 #### Erasure <a id="flat.multimap.erasure">[[flat.multimap.erasure]]</a>
 ``` cpp
 template<class Key, class T, class Compare, class KeyContainer, class MappedContainer,
          class Predicate>
-  typename flat_multimap<Key, T, Compare, KeyContainer, MappedContainer>::size_type
     erase_if(flat_multimap<Key, T, Compare, KeyContainer, MappedContainer>& c, Predicate pred);
 ```
 *Preconditions:* `Key` and `T` meet the *Cpp17MoveAssignable*
 requirements.
@@ -2537,10 +2529,49 @@ exits via an exception, `c` is in a valid but unspecified
 state [[defns.valid]].
 [*Note 1*: `c` still meets its invariants, but can be
 empty. — *end note*]
 ### Class template `flat_set` <a id="flat.set">[[flat.set]]</a>
 #### Overview <a id="flat.set.overview">[[flat.set.overview]]</a>
 A `flat_set` is a container adaptor that provides an associative
@@ -2593,13 +2624,16 @@ particular, `vector` [[vector]] and `deque` [[deque]] can be used.
 [*Note 3*: `vector<bool>` is not a sequence container. — *end note*]
 The program is ill-formed if `Key` is not the same type as
 `KeyContainer::value_type`.
-The effect of calling a constructor or member function that takes a
-`sorted_unique_t` argument with a range that is not sorted with respect
-to `key_comp()`, or that contains equal elements, is undefined.
 #### Definition <a id="flat.set.defn">[[flat.set.defn]]</a>
 ``` cpp
 namespace std {
@@ -2611,192 +2645,203 @@ namespace std {
     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                 = typename KeyContainer::size_type;
-    using difference_type           = typename KeyContainer::difference_type;
     using iterator                  = implementation-defined  // type of flat_set::iterator;  // see [container.requirements]
     using const_iterator            = implementation-defined  // type of flat_set::const_iterator;  // see [container.requirements]
     using reverse_iterator          = std::reverse_iterator<iterator>;
     using const_reverse_iterator    = std::reverse_iterator<const_iterator>;
     using container_type            = KeyContainer;
     // [flat.set.cons], constructors
-    flat_set() : flat_set(key_compare()) { }
-    explicit flat_set(container_type cont, const key_compare& comp = key_compare());
-    template<class Allocator>
-      flat_set(const container_type& cont, const Allocator& a);
-    template<class Allocator>
-      flat_set(const container_type& cont, const key_compare& comp, const Allocator& a);
-    flat_set(sorted_unique_t, container_type cont, const key_compare& comp = key_compare())
-      : c(std::move(cont)), compare(comp) { }
-    template<class Allocator>
-      flat_set(sorted_unique_t, const container_type& cont, const Allocator& a);
-    template<class Allocator>
-      flat_set(sorted_unique_t, const container_type& cont,
-               const key_compare& comp, const Allocator& a);
-    explicit flat_set(const key_compare& comp)
       : c(), compare(comp) { }
-    template<class Allocator>
- flat_set(const key_compare& comp, const Allocator& a);
-    template<class Allocator>
-      explicit flat_set(const Allocator& a);
     template<class InputIterator>
-      flat_set(InputIterator first, InputIterator last, const key_compare& comp = key_compare())
         : c(), compare(comp)
         { insert(first, last); }
-    template<class InputIterator, class Allocator>
-      flat_set(InputIterator first, InputIterator last,
-               const key_compare& comp, const Allocator& a);
-    template<class InputIterator, class Allocator>
-      flat_set(InputIterator first, InputIterator last, const Allocator& a);
     template<container-compatible-range<value_type> R>
-      flat_set(from_range_t fr, R&& rg)
-        : flat_set(fr, std::forward<R>(rg), key_compare()) { }
-    template<container-compatible-range<value_type> R, class Allocator>
-      flat_set(from_range_t, R&& rg, const Allocator& a);
     template<container-compatible-range<value_type> R>
-      flat_set(from_range_t, R&& rg, const key_compare& comp)
         : flat_set(comp)
         { insert_range(std::forward<R>(rg)); }
-    template<container-compatible-range<value_type> R, class Allocator>
-       flat_set(from_range_t, R&& rg, const key_compare& comp, const Allocator& a);
- template<class InputIterator>
-      flat_set(sorted_unique_t, InputIterator first, InputIterator last,
-               const key_compare& comp = key_compare())
-        : c(first, last), compare(comp) { }
-    template<class InputIterator, class Allocator>
-      flat_set(sorted_unique_t, InputIterator first, InputIterator last,
-               const key_compare& comp, const Allocator& a);
-    template<class InputIterator, class Allocator>
-      flat_set(sorted_unique_t, InputIterator first, InputIterator last, const Allocator& a);
-    flat_set(initializer_list<value_type> il, const key_compare& comp = key_compare())
         : flat_set(il.begin(), il.end(), comp) { }
-    template<class Allocator>
-      flat_set(initializer_list<value_type> il, const key_compare& comp, const Allocator& a);
-    template<class Allocator>
-      flat_set(initializer_list<value_type> il, const Allocator& a);
-    flat_set(sorted_unique_t s, initializer_list<value_type> il,
              const key_compare& comp = key_compare())
-        : flat_set(s, il.begin(), il.end(), comp) { }
-    template<class Allocator>
-      flat_set(sorted_unique_t, initializer_list<value_type> il,
-               const key_compare& comp, const Allocator& a);
-    template<class Allocator>
-      flat_set(sorted_unique_t, initializer_list<value_type> il, const Allocator& a);
- flat_set& operator=(initializer_list<value_type>);
     // iterators
-    iterator               begin() noexcept;
-    const_iterator         begin() const noexcept;
-    iterator               end() noexcept;
-    const_iterator         end() const noexcept;
-    reverse_iterator       rbegin() noexcept;
-    const_reverse_iterator rbegin() const noexcept;
-    reverse_iterator       rend() noexcept;
-    const_reverse_iterator rend() const noexcept;
-    const_iterator         cbegin() const noexcept;
-    const_iterator         cend() const noexcept;
-    const_reverse_iterator crbegin() const noexcept;
-    const_reverse_iterator crend() const noexcept;
     // capacity
- [[nodiscard]] bool empty() const noexcept;
-    size_type size() const noexcept;
-    size_type max_size() const noexcept;
     // [flat.set.modifiers], modifiers
-    template<class... Args> pair<iterator, bool> emplace(Args&&... args);
     template<class... Args>
-      iterator emplace_hint(const_iterator position, Args&&... args);
-    pair<iterator, bool> insert(const value_type& x)
       { return emplace(x); }
-    pair<iterator, bool> insert(value_type&& x)
       { return emplace(std::move(x)); }
-    template<class K> pair<iterator, bool> insert(K&& x);
-    iterator insert(const_iterator position, const value_type& x)
       { return emplace_hint(position, x); }
-    iterator insert(const_iterator position, value_type&& x)
       { return emplace_hint(position, std::move(x)); }
-    template<class K> iterator insert(const_iterator hint, K&& x);
     template<class InputIterator>
-      void insert(InputIterator first, InputIterator last);
     template<class InputIterator>
-      void insert(sorted_unique_t, InputIterator first, InputIterator last);
     template<container-compatible-range<value_type> R>
-      void insert_range(R&& rg);
-    void insert(initializer_list<value_type> il)
       { insert(il.begin(), il.end()); }
-    void insert(sorted_unique_t s, initializer_list<value_type> il)
-      { insert(s, il.begin(), il.end()); }
-    container_type extract() &&;
-    void replace(container_type&&);
-    iterator erase(iterator position);
-    iterator erase(const_iterator position);
-    size_type erase(const key_type& x);
-    template<class K> size_type erase(K&& x);
-    iterator erase(const_iterator first, const_iterator last);
-    void swap(flat_set& y) noexcept;
-    void clear() noexcept;
     // observers
-    key_compare key_comp() const;
-    value_compare value_comp() const;
     // set operations
-    iterator find(const key_type& x);
-    const_iterator find(const key_type& x) const;
-    template<class K> iterator find(const K& x);
-    template<class K> const_iterator find(const K& x) const;
-    size_type count(const key_type& x) const;
-    template<class K> size_type count(const K& x) const;
-    bool contains(const key_type& x) const;
-    template<class K> bool contains(const K& x) const;
-    iterator lower_bound(const key_type& x);
-    const_iterator lower_bound(const key_type& x) const;
-    template<class K> iterator lower_bound(const K& x);
-    template<class K> const_iterator lower_bound(const K& x) const;
-    iterator upper_bound(const key_type& x);
-    const_iterator upper_bound(const key_type& x) const;
-    template<class K> iterator upper_bound(const K& x);
-    template<class K> const_iterator upper_bound(const K& x) const;
-    pair<iterator, iterator> equal_range(const key_type& x);
-    pair<const_iterator, const_iterator> equal_range(const key_type& x) const;
     template<class K>
-      pair<iterator, iterator> equal_range(const K& x);
     template<class K>
-      pair<const_iterator, const_iterator> equal_range(const K& x) const;
-    friend bool operator==(const flat_set& x, const flat_set& y);
-    friend synth-three-way-result<value_type>
       operator<=>(const flat_set& x, const flat_set& y);
-    friend void swap(flat_set& x, flat_set& y) noexcept { x.swap(y); }
   private:
     container_type c;           // exposition only
     key_compare compare;        // exposition only
   };
@@ -2859,101 +2904,106 @@ namespace std {
 ```
 #### Constructors <a id="flat.set.cons">[[flat.set.cons]]</a>
 ``` cpp
-explicit flat_set(container_type cont, const key_compare& comp = key_compare());
 ```
 *Effects:* Initializes *c* with `std::move(cont)` and *compare* with
 `comp`, sorts the range \[`begin()`, `end()`) with respect to *compare*,
 and finally erases all but the first element from each group of
 consecutive equivalent elements.
-*Complexity:* Linear in N if `cont` is sorted with respect to *compare*
-and otherwise N log N, where N is the value of `cont.size()` before this
-call.
 ``` cpp
-template<class Allocator>
-  flat_set(const container_type& cont, const Allocator& a);
-template<class Allocator>
-  flat_set(const container_type& cont, const key_compare& comp, const Allocator& a);
 ```
-*Constraints:* `uses_allocator_v<container_type, Allocator>` is `true`.
 *Effects:* Equivalent to `flat_set(cont)` and `flat_set(cont, comp)`,
 respectively, except that *c* is constructed with uses-allocator
 construction [[allocator.uses.construction]].
 *Complexity:* Same as `flat_set(cont)` and `flat_set(cont, comp)`,
 respectively.
 ``` cpp
-template<class Allocator>
-  flat_set(sorted_unique_t s, const container_type& cont, const Allocator& a);
-template<class Allocator>
-  flat_set(sorted_unique_t s, const container_type& cont,
- const key_compare& comp, const Allocator& a);
 ```
-*Constraints:* `uses_allocator_v<container_type, Allocator>` is `true`.
-*Effects:* Equivalent to `flat_set(s, cont)` and
-`flat_set(s, cont, comp)`, respectively, except that *c* is constructed
-with uses-allocator construction [[allocator.uses.construction]].
 *Complexity:* Linear.
 ``` cpp
-template<class Allocator>
-  flat_set(const key_compare& comp, const Allocator& a);
-template<class Allocator>
- explicit flat_set(const Allocator& a);
-template<class InputIterator, class Allocator>
-  flat_set(InputIterator first, InputIterator last, const key_compare& comp, const Allocator& a);
-template<class InputIterator, class Allocator>
-  flat_set(InputIterator first, InputIterator last, const Allocator& a);
-template<container-compatible-range<value_type> R, class Allocator>
-  flat_set(from_range_t, R&& rg, const Allocator& a);
-template<container-compatible-range<value_type> R, class Allocator>
-  flat_set(from_range_t, R&& rg, const key_compare& comp, const Allocator& a);
-template<class InputIterator, class Allocator>
-  flat_set(sorted_unique_t, InputIterator first, InputIterator last,
-           const key_compare& comp, const Allocator& a);
-template<class InputIterator, class Allocator>
-  flat_set(sorted_unique_t, InputIterator first, InputIterator last, const Allocator& a);
-template<class Allocator>
-  flat_set(initializer_list<value_type> il, const key_compare& comp, const Allocator& a);
-template<class Allocator>
-  flat_set(initializer_list<value_type> il, const Allocator& a);
-template<class Allocator>
-  flat_set(sorted_unique_t, initializer_list<value_type> il,
-           const key_compare& comp, const Allocator& a);
-template<class Allocator>
-  flat_set(sorted_unique_t, initializer_list<value_type> il, const Allocator& a);
 ```
-*Constraints:* `uses_allocator_v<container_type, Allocator>` is `true`.
 *Effects:* Equivalent to the corresponding non-allocator constructors
 except that *c* is constructed with uses-allocator
 construction [[allocator.uses.construction]].
 #### Modifiers <a id="flat.set.modifiers">[[flat.set.modifiers]]</a>
 ``` cpp
-template<class K> pair<iterator, bool> insert(K&& x);
-template<class K> iterator insert(const_iterator hint, K&& x);
 ```
 *Constraints:* The *qualified-id* `Compare::is_transparent` is valid and
 denotes a type. `is_constructible_v<value_type, K>` is `true`.
 *Preconditions:* The conversion from `x` into `value_type` constructs an
-object `u`, for which `find(x) == find(u)` is true.
 *Effects:* If the set already contains an element equivalent to `x`,
 `*this` and `x` are unchanged. Otherwise, inserts a new element as if by
 `emplace(std::forward<K>(x))`.
@@ -2961,11 +3011,11 @@ object `u`, for which `find(x) == find(u)` is true.
 pair is `true` if and only if the insertion took place. The returned
 iterator points to the element whose key is equivalent to `x`.
 ``` cpp
 template<class InputIterator>
-  void insert(InputIterator first, InputIterator last);
 ```
 *Effects:* Adds elements to *c* as if by:
 ``` cpp
@@ -2984,20 +3034,20 @@ M is `distance(first, last)`.
 *Remarks:* Since this operation performs an in-place merge, it may
 allocate memory.
 ``` cpp
 template<class InputIterator>
-  void insert(sorted_unique_t, InputIterator first, InputIterator last);
 ```
 *Effects:* Equivalent to `insert(first, last)`.
 *Complexity:* Linear.
 ``` cpp
 template<container-compatible-range<value_type> R>
-  void insert_range(R&& rg);
 ```
 *Effects:* Adds elements to *c* as if by:
 ``` cpp
@@ -3017,31 +3067,31 @@ M is `ranges::distance(rg)`.
 *Remarks:* Since this operation performs an in-place merge, it may
 allocate memory.
 ``` cpp
-void swap(flat_set& y) noexcept;
 ```
 *Effects:* Equivalent to:
 ``` cpp
 ranges::swap(compare, y.compare);
 ranges::swap(c, y.c);
 ```
 ``` cpp
-container_type extract() &&;
 ```
 *Ensures:* `*this` is emptied, even if the function exits via an
 exception.
 *Returns:* `std::move(`*`c`*`)`.
 ``` cpp
-void replace(container_type&& cont);
 ```
 *Preconditions:* The elements of `cont` are sorted with respect to
 *compare*, and `cont` contains no equal elements.
@@ -3049,11 +3099,11 @@ void replace(container_type&& cont);
 #### Erasure <a id="flat.set.erasure">[[flat.set.erasure]]</a>
 ``` cpp
 template<class Key, class Compare, class KeyContainer, class Predicate>
-  typename flat_set<Key, Compare, KeyContainer>::size_type
     erase_if(flat_set<Key, Compare, KeyContainer>& c, Predicate pred);
 ```
 *Preconditions:* `Key` meets the *Cpp17MoveAssignable* requirements.
@@ -3126,14 +3176,17 @@ In particular, `vector` [[vector]] and `deque` [[deque]] can be used.
 [*Note 3*: `vector<bool>` is not a sequence container. — *end note*]
 The program is ill-formed if `Key` is not the same type as
 `KeyContainer::value_type`.
-The effect of calling a constructor or member function that takes a
 `sorted_equivalent_t` argument with a range that is not sorted with
 respect to `key_comp()` is undefined.
 #### Definition <a id="flat.multiset.defn">[[flat.multiset.defn]]</a>
 ``` cpp
 namespace std {
   template<class Key, class Compare = less<Key>, class KeyContainer = vector<Key>>
@@ -3144,194 +3197,205 @@ namespace std {
     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                 = typename KeyContainer::size_type;
-    using difference_type           = typename KeyContainer::difference_type;
     using iterator                  = implementation-defined  // type of flat_multiset::iterator;  // see [container.requirements]
     using const_iterator            = implementation-defined  // type of flat_multiset::const_iterator;  // see [container.requirements]
     using reverse_iterator          = std::reverse_iterator<iterator>;
     using const_reverse_iterator    = std::reverse_iterator<const_iterator>;
     using container_type            = KeyContainer;
     // [flat.multiset.cons], constructors
-    flat_multiset() : flat_multiset(key_compare()) { }
-    explicit flat_multiset(container_type cont, const key_compare& comp = key_compare());
-    template<class Allocator>
-      flat_multiset(const container_type& cont, const Allocator& a);
-    template<class Allocator>
-      flat_multiset(const container_type& cont, const key_compare& comp, const Allocator& a);
-    flat_multiset(sorted_equivalent_t, container_type cont,
-                  const key_compare& comp = key_compare())
-      : c(std::move(cont)), compare(comp) { }
-    template<class Allocator>
-      flat_multiset(sorted_equivalent_t, const container_type&, const Allocator& a);
-    template<class Allocator>
-      flat_multiset(sorted_equivalent_t, const container_type& cont,
-                    const key_compare& comp, const Allocator& a);
-    explicit flat_multiset(const key_compare& comp)
       : c(), compare(comp) { }
-    template<class Allocator>
- flat_multiset(const key_compare& comp, const Allocator& a);
-    template<class Allocator>
-      explicit flat_multiset(const Allocator& a);
     template<class InputIterator>
-      flat_multiset(InputIterator first, InputIterator last,
                               const key_compare& comp = key_compare())
         : c(), compare(comp)
         { insert(first, last); }
-    template<class InputIterator, class Allocator>
-      flat_multiset(InputIterator first, InputIterator last,
-                    const key_compare& comp, const Allocator& a);
-    template<class InputIterator, class Allocator>
-      flat_multiset(InputIterator first, InputIterator last, const Allocator& a);
     template<container-compatible-range<value_type> R>
-      flat_multiset(from_range_t fr, R&& rg)
-        : flat_multiset(fr, std::forward<R>(rg), key_compare()) { }
-    template<container-compatible-range<value_type> R, class Allocator>
-      flat_multiset(from_range_t, R&& rg, const Allocator& a);
     template<container-compatible-range<value_type> R>
-      flat_multiset(from_range_t, R&& rg, const key_compare& comp)
         : flat_multiset(comp)
         { insert_range(std::forward<R>(rg)); }
-    template<container-compatible-range<value_type> R, class Allocator>
-      flat_multiset(from_range_t, R&& rg, const key_compare& comp, const Allocator& a);
- template<class InputIterator>
-      flat_multiset(sorted_equivalent_t, InputIterator first, InputIterator last,
                             const key_compare& comp = key_compare())
-        : c(first, last), compare(comp) { }
-    template<class InputIterator, class Allocator>
-      flat_multiset(sorted_equivalent_t, InputIterator first, InputIterator last,
-                    const key_compare& comp, const Allocator& a);
-    template<class InputIterator, class Allocator>
-      flat_multiset(sorted_equivalent_t, InputIterator first, InputIterator last,
-                    const Allocator& a);
-    flat_multiset(initializer_list<value_type> il, const key_compare& comp = key_compare())
       : flat_multiset(il.begin(), il.end(), comp) { }
-    template<class Allocator>
-      flat_multiset(initializer_list<value_type> il, const key_compare& comp,
-                    const Allocator& a);
-    template<class Allocator>
-      flat_multiset(initializer_list<value_type> il, const Allocator& a);
-    flat_multiset(sorted_equivalent_t s, initializer_list<value_type> il,
                             const key_compare& comp = key_compare())
-        : flat_multiset(s, il.begin(), il.end(), comp) { }
-    template<class Allocator>
-      flat_multiset(sorted_equivalent_t, initializer_list<value_type> il,
-                    const key_compare& comp, const Allocator& a);
-    template<class Allocator>
-      flat_multiset(sorted_equivalent_t, initializer_list<value_type> il, const Allocator& a);
- flat_multiset& operator=(initializer_list<value_type>);
     // iterators
-    iterator               begin() noexcept;
-    const_iterator         begin() const noexcept;
-    iterator               end() noexcept;
-    const_iterator         end() const noexcept;
-    reverse_iterator       rbegin() noexcept;
-    const_reverse_iterator rbegin() const noexcept;
-    reverse_iterator       rend() noexcept;
-    const_reverse_iterator rend() const noexcept;
-    const_iterator         cbegin() const noexcept;
-    const_iterator         cend() const noexcept;
-    const_reverse_iterator crbegin() const noexcept;
-    const_reverse_iterator crend() const noexcept;
     // capacity
- [[nodiscard]] bool empty() const noexcept;
-    size_type size() const noexcept;
-    size_type max_size() const noexcept;
     // [flat.multiset.modifiers], modifiers
-    template<class... Args> iterator emplace(Args&&... args);
     template<class... Args>
-      iterator emplace_hint(const_iterator position, Args&&... args);
-    iterator insert(const value_type& x)
       { return emplace(x); }
-    iterator insert(value_type&& x)
       { return emplace(std::move(x)); }
-    iterator insert(const_iterator position, const value_type& x)
       { return emplace_hint(position, x); }
-    iterator insert(const_iterator position, value_type&& x)
       { return emplace_hint(position, std::move(x)); }
     template<class InputIterator>
-      void insert(InputIterator first, InputIterator last);
     template<class InputIterator>
-      void insert(sorted_equivalent_t, InputIterator first, InputIterator last);
     template<container-compatible-range<value_type> R>
-      void insert_range(R&& rg);
-    void insert(initializer_list<value_type> il)
       { insert(il.begin(), il.end()); }
-    void insert(sorted_equivalent_t s, initializer_list<value_type> il)
-      { insert(s, il.begin(), il.end()); }
-    container_type extract() &&;
-    void replace(container_type&&);
-    iterator erase(iterator position);
-    iterator erase(const_iterator position);
-    size_type erase(const key_type& x);
-    template<class K> size_type erase(K&& x);
-    iterator erase(const_iterator first, const_iterator last);
-    void swap(flat_multiset& y) noexcept;
-    void clear() noexcept;
     // observers
-    key_compare key_comp() const;
-    value_compare value_comp() const;
     // set operations
-    iterator find(const key_type& x);
-    const_iterator find(const key_type& x) const;
-    template<class K> iterator find(const K& x);
-    template<class K> const_iterator find(const K& x) const;
-    size_type count(const key_type& x) const;
-    template<class K> size_type count(const K& x) const;
-    bool contains(const key_type& x) const;
-    template<class K> bool contains(const K& x) const;
-    iterator lower_bound(const key_type& x);
-    const_iterator lower_bound(const key_type& x) const;
-    template<class K> iterator lower_bound(const K& x);
-    template<class K> const_iterator lower_bound(const K& x) const;
-    iterator upper_bound(const key_type& x);
-    const_iterator upper_bound(const key_type& x) const;
-    template<class K> iterator upper_bound(const K& x);
-    template<class K> const_iterator upper_bound(const K& x) const;
-    pair<iterator, iterator> equal_range(const key_type& x);
-    pair<const_iterator, const_iterator> equal_range(const key_type& x) const;
     template<class K>
-      pair<iterator, iterator> equal_range(const K& x);
     template<class K>
-      pair<const_iterator, const_iterator> equal_range(const K& x) const;
-    friend bool operator==(const flat_multiset& x, const flat_multiset& y);
-    friend synth-three-way-result<value_type>
       operator<=>(const flat_multiset& x, const flat_multiset& y);
-    friend void swap(flat_multiset& x, flat_multiset& y) noexcept
       { x.swap(y); }
   private:
     container_type c;           // exposition only
     key_compare compare;        // exposition only
@@ -3359,15 +3423,15 @@ namespace std {
     flat_multiset(sorted_equivalent_t, KeyContainer, Compare, Allocator)
       -> flat_multiset<typename KeyContainer::value_type, Compare, KeyContainer>;
   template<class InputIterator, class Compare = less<iter-value-type<InputIterator>>>
     flat_multiset(InputIterator, InputIterator, Compare = Compare())
-      -> flat_multiset<iter-value-type<InputIterator>, iter-value-type<InputIterator>, Compare>;
   template<class InputIterator, class Compare = less<iter-value-type<InputIterator>>>
     flat_multiset(sorted_equivalent_t, InputIterator, InputIterator, Compare = Compare())
-      -> flat_multiset<iter-value-type<InputIterator>, iter-value-type<InputIterator>, Compare>;
   template<ranges::input_range R, class Compare = less<ranges::range_value_t<R>>,
            class Allocator = allocator<ranges::range_value_t<R>>>
     flat_multiset(from_range_t, R&&, Compare = Compare(), Allocator = Allocator())
       -> flat_multiset<ranges::range_value_t<R>, Compare,
@@ -3395,95 +3459,100 @@ namespace std {
 ```
 #### Constructors <a id="flat.multiset.cons">[[flat.multiset.cons]]</a>
 ``` cpp
-explicit flat_multiset(container_type cont, const key_compare& comp = key_compare());
 ```
 *Effects:* Initializes *c* with `std::move(cont)` and *compare* with
 `comp`, and sorts the range \[`begin()`, `end()`) with respect to
 *compare*.
-*Complexity:* Linear in N if `cont` is sorted with respect to *compare*
-and otherwise N log N, where N is the value of `cont.size()` before this
-call.
 ``` cpp
-template<class Allocator>
-  flat_multiset(const container_type& cont, const Allocator& a);
-template<class Allocator>
-  flat_multiset(const container_type& cont, const key_compare& comp, const Allocator& a);
 ```
-*Constraints:* `uses_allocator_v<container_type, Allocator>` is `true`.
 *Effects:* Equivalent to `flat_multiset(cont)` and
 `flat_multiset(cont, comp)`, respectively, except that *c* is
 constructed with uses-allocator
 construction [[allocator.uses.construction]].
 *Complexity:* Same as `flat_multiset(cont)` and
 `flat_multiset(cont, comp)`, respectively.
 ``` cpp
-template<class Allocator>
-  flat_multiset(sorted_equivalent_t s, const container_type& cont, const Allocator& a);
-template<class Allocator>
-  flat_multiset(sorted_equivalent_t s, const container_type& cont,
- const key_compare& comp, const Allocator& a);
 ```
-*Constraints:* `uses_allocator_v<container_type, Allocator>` is `true`.
-*Effects:* Equivalent to `flat_multiset(s, cont)` and
-`flat_multiset(s, cont, comp)`, respectively, except that *c* is
-constructed with uses-allocator
 construction [[allocator.uses.construction]].
 *Complexity:* Linear.
 ``` cpp
-template<class Allocator>
-  flat_multiset(const key_compare& comp, const Allocator& a);
-template<class Allocator>
- explicit flat_multiset(const Allocator& a);
-template<class InputIterator, class Allocator>
-  flat_multiset(InputIterator first, InputIterator last,
-                const key_compare& comp, const Allocator& a);
-template<class InputIterator, class Allocator>
-  flat_multiset(InputIterator first, InputIterator last, const Allocator& a);
-template<container-compatible-range<value_type> R, class Allocator>
-  flat_multiset(from_range_t, R&& rg, const Allocator& a);
-template<container-compatible-range<value_type> R, class Allocator>
-  flat_multiset(from_range_t, R&& rg, const key_compare& comp, const Allocator& a);
-template<class InputIterator, class Allocator>
-  flat_multiset(sorted_equivalent_t, InputIterator first, InputIterator last,
- const key_compare& comp, const Allocator& a);
-template<class InputIterator, class Allocator>
-  flat_multiset(sorted_equivalent_t, InputIterator first, InputIterator last, const Allocator& a);
-template<class Allocator>
-  flat_multiset(initializer_list<value_type> il, const key_compare& comp, const Allocator& a);
-template<class Allocator>
-  flat_multiset(initializer_list<value_type> il, const Allocator& a);
-template<class Allocator>
-  flat_multiset(sorted_equivalent_t, initializer_list<value_type> il,
-                const key_compare& comp, const Allocator& a);
-template<class Allocator>
-  flat_multiset(sorted_equivalent_t, initializer_list<value_type> il, const Allocator& a);
 ```
-*Constraints:* `uses_allocator_v<container_type, Allocator>` is `true`.
 *Effects:* Equivalent to the corresponding non-allocator constructors
 except that *c* is constructed with uses-allocator
 construction [[allocator.uses.construction]].
 #### Modifiers <a id="flat.multiset.modifiers">[[flat.multiset.modifiers]]</a>
 ``` cpp
-template<class... Args> iterator emplace(Args&&... args);
 ```
 *Constraints:* `is_constructible_v<value_type, Args...>` is `true`.
 *Effects:* First, initializes an object `t` of type `value_type` with
@@ -3496,11 +3565,11 @@ c.insert(it, std::move(t));
 *Returns:* An iterator that points to the inserted element.
 ``` cpp
 template<class InputIterator>
-  void insert(InputIterator first, InputIterator last);
 ```
 *Effects:* Adds elements to *c* as if by:
 ``` cpp
@@ -3517,51 +3586,51 @@ M is `distance(first, last)`.
 *Remarks:* Since this operation performs an in-place merge, it may
 allocate memory.
 ``` cpp
 template<class InputIterator>
-  void insert(sorted_equivalent_t, InputIterator first, InputIterator last);
 ```
 *Effects:* Equivalent to `insert(first, last)`.
 *Complexity:* Linear.
 ``` cpp
-void swap(flat_multiset& y) noexcept;
 ```
 *Effects:* Equivalent to:
 ``` cpp
 ranges::swap(compare, y.compare);
 ranges::swap(c, y.c);
 ```
 ``` cpp
-container_type extract() &&;
 ```
 *Ensures:* `*this` is emptied, even if the function exits via an
 exception.
-*Returns:* `std::move(c)`.
 ``` cpp
-void replace(container_type&& cont);
 ```
 *Preconditions:* The elements of `cont` are sorted with respect to
 *compare*.
-*Effects:* Equivalent to: `c = std::move(cont);`
 #### Erasure <a id="flat.multiset.erasure">[[flat.multiset.erasure]]</a>
 ``` cpp
 template<class Key, class Compare, class KeyContainer, class Predicate>
-  typename flat_multiset<Key, Compare, KeyContainer>::size_type
     erase_if(flat_multiset<Key, Compare, KeyContainer>& c, Predicate pred);
 ```
 *Preconditions:* `Key` meets the *Cpp17MoveAssignable* requirements.

 ## Container adaptors <a id="container.adaptors">[[container.adaptors]]</a>
+### General <a id="container.adaptors.general">[[container.adaptors.general]]</a>
 The headers `<queue>`, `<stack>`, `<flat_map>`, and `<flat_set>` define
 the container adaptors `queue` and `priority_queue`, `stack`, `flat_map`
 and `flat_multimap`, and `flat_set` and `flat_multiset`, respectively.
 The following exposition-only alias template may appear in deduction
 guides for container adaptors:
 ``` cpp
 template<class Allocator, class T>
+  using alloc-rebind = allocator_traits<Allocator>::template rebind_alloc<T>;   // exposition only
 ```
 ### Header `<queue>` synopsis <a id="queue.syn">[[queue.syn]]</a>
 ``` cpp
 namespace std {
   // [queue], class template queue
   template<class T, class Container = deque<T>> class queue;
   template<class T, class Container>
+ constexpr bool operator==(const queue<T, Container>& x, const queue<T, Container>& y);
   template<class T, class Container>
+ constexpr bool operator!=(const queue<T, Container>& x, const queue<T, Container>& y);
   template<class T, class Container>
+ constexpr bool operator< (const queue<T, Container>& x, const queue<T, Container>& y);
   template<class T, class Container>
+ constexpr bool operator> (const queue<T, Container>& x, const queue<T, Container>& y);
   template<class T, class Container>
+ constexpr bool operator<=(const queue<T, Container>& x, const queue<T, Container>& y);
   template<class T, class Container>
+ constexpr bool operator>=(const queue<T, Container>& x, const queue<T, Container>& y);
   template<class T, three_way_comparable Container>
+ constexpr compare_three_way_result_t<Container>
       operator<=>(const queue<T, Container>& x, const queue<T, Container>& y);
   template<class T, class Container>
+ constexpr void swap(queue<T, Container>& x, queue<T, Container>& y)
+      noexcept(noexcept(x.swap(y)));
   template<class T, class Container, class Alloc>
     struct uses_allocator<queue<T, Container>, Alloc>;
+  // [container.adaptors.format], formatter specialization for queue
+  template<class charT, class T, formattable<charT> Container>
+    struct formatter<queue<T, Container>, charT>;
   // [priority.queue], class template priority_queue
   template<class T, class Container = vector<T>,
            class Compare = less<typename Container::value_type>>
     class priority_queue;
   template<class T, class Container, class Compare>
+ constexpr void swap(priority_queue<T, Container, Compare>& x,
                         priority_queue<T, Container, Compare>& y) noexcept(noexcept(x.swap(y)));
   template<class T, class Container, class Compare, class Alloc>
     struct uses_allocator<priority_queue<T, Container, Compare>, Alloc>;
+  // [container.adaptors.format], formatter specialization for priority_queue
+  template<class charT, class T, formattable<charT> Container, class Compare>
+    struct formatter<priority_queue<T, Container, Compare>, charT>;
 }
 ```
 ### Class template `queue` <a id="queue">[[queue]]</a>
 ``` cpp
 namespace std {
   template<class T, class Container = deque<T>>
   class queue {
   public:
+    using value_type      = Container::value_type;
+    using reference       = Container::reference;
+    using const_reference = Container::const_reference;
+    using size_type       = Container::size_type;
     using container_type  = Container;
   protected:
     Container c;
   public:
+ constexpr queue() : queue(Container()) {}
+ constexpr explicit queue(const Container&);
+ constexpr explicit queue(Container&&);
+    template<class InputIterator> constexpr queue(InputIterator first, InputIterator last);
+    template<container-compatible-range<T> R> constexpr queue(from_range_t, R&& rg);
+    template<class Alloc> constexpr explicit queue(const Alloc&);
+    template<class Alloc> constexpr queue(const Container&, const Alloc&);
+    template<class Alloc> constexpr queue(Container&&, const Alloc&);
+    template<class Alloc> constexpr queue(const queue&, const Alloc&);
+    template<class Alloc> constexpr queue(queue&&, const Alloc&);
     template<class InputIterator, class Alloc>
+ constexpr queue(InputIterator first, InputIterator last, const Alloc&);
     template<container-compatible-range<T> R, class Alloc>
+ constexpr queue(from_range_t, R&& rg, const Alloc&);
+ constexpr bool empty() const { return c.empty(); }
+ constexpr size_type         size()  const     { return c.size(); }
+ constexpr reference         front()           { return c.front(); }
+ constexpr const_reference   front() const     { return c.front(); }
+ constexpr reference         back()            { return c.back(); }
+ constexpr const_reference   back() const      { return c.back(); }
+ constexpr void push(const value_type& x)      { c.push_back(x); }
+ constexpr void push(value_type&& x)           { c.push_back(std::move(x)); }
+    template<container-compatible-range<T> R> constexpr void push_range(R&& rg);
     template<class... Args>
+ constexpr decltype(auto) emplace(Args&&... args)
         { return c.emplace_back(std::forward<Args>(args)...); }
+ constexpr void pop()                          { c.pop_front(); }
+ constexpr void swap(queue& q) noexcept(is_nothrow_swappable_v<Container>)
       { using std::swap; swap(c, q.c); }
   };
   template<class Container>
     queue(Container) -> queue<typename Container::value_type, Container>;
 ```
 #### Constructors <a id="queue.cons">[[queue.cons]]</a>
 ``` cpp
+constexpr explicit queue(const Container& cont);
 ```
 *Effects:* Initializes `c` with `cont`.
 ``` cpp
+constexpr explicit queue(Container&& cont);
 ```
 *Effects:* Initializes `c` with `std::move(cont)`.
 ``` cpp
 template<class InputIterator>
+ constexpr queue(InputIterator first, InputIterator last);
 ```
 *Effects:* Initializes `c` with `first` as the first argument and `last`
 as the second argument.
 ``` cpp
 template<container-compatible-range<T> R>
+ constexpr queue(from_range_t, R&& rg);
 ```
 *Effects:* Initializes `c` with
 `ranges::to<Container>(std::forward<R>(rg))`.
 If `uses_allocator_v<container_type, Alloc>` is `false` the constructors
 in this subclause shall not participate in overload resolution.
 ``` cpp
+template<class Alloc> constexpr explicit queue(const Alloc& a);
 ```
 *Effects:* Initializes `c` with `a`.
 ``` cpp
+template<class Alloc> constexpr queue(const container_type& cont, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `cont` as the first argument and `a` as
 the second argument.
 ``` cpp
+template<class Alloc> constexpr queue(container_type&& cont, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `std::move(cont)` as the first argument
 and `a` as the second argument.
 ``` cpp
+template<class Alloc> constexpr queue(const queue& q, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `q.c` as the first argument and `a` as
 the second argument.
 ``` cpp
+template<class Alloc> constexpr queue(queue&& q, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `std::move(q.c)` as the first argument
 and `a` as the second argument.
 ``` cpp
 template<class InputIterator, class Alloc>
+ constexpr queue(InputIterator first, InputIterator last, const Alloc& alloc);
 ```
 *Effects:* Initializes `c` with `first` as the first argument, `last` as
 the second argument, and `alloc` as the third argument.
 ``` cpp
 template<container-compatible-range<T> R, class Alloc>
+ constexpr queue(from_range_t, R&& rg, const Alloc& a);
 ```
 *Effects:* Initializes `c` with
 `ranges::to<Container>(std::forward<R>(rg), a)`.
 #### Modifiers <a id="queue.mod">[[queue.mod]]</a>
 ``` cpp
 template<container-compatible-range<T> R>
+ constexpr void push_range(R&& rg);
 ```
 *Effects:* Equivalent to `c.append_range(std::forward<R>(rg))` if that
 is a valid expression, otherwise `ranges::copy(rg, back_inserter(c))`.
 #### Operators <a id="queue.ops">[[queue.ops]]</a>
 ``` cpp
 template<class T, class Container>
+ constexpr bool operator==(const queue<T, Container>& x, const queue<T, Container>& y);
 ```
 *Returns:* `x.c == y.c`.
 ``` cpp
 template<class T, class Container>
+ constexpr bool operator!=(const queue<T, Container>& x,  const queue<T, Container>& y);
 ```
 *Returns:* `x.c != y.c`.
 ``` cpp
 template<class T, class Container>
+ constexpr bool operator< (const queue<T, Container>& x, const queue<T, Container>& y);
 ```
 *Returns:* `x.c < y.c`.
 ``` cpp
 template<class T, class Container>
+ constexpr bool operator> (const queue<T, Container>& x, const queue<T, Container>& y);
 ```
 *Returns:* `x.c > y.c`.
 ``` cpp
 template<class T, class Container>
+ constexpr bool operator<=(const queue<T, Container>& x, const queue<T, Container>& y);
 ```
 *Returns:* `x.c <= y.c`.
 ``` cpp
 template<class T, class Container>
+  constexpr bool operator>=(const queue<T, Container>& x, const queue<T, Container>& y);
 ```
 *Returns:* `x.c >= y.c`.
 ``` cpp
 template<class T, three_way_comparable Container>
+ constexpr compare_three_way_result_t<Container>
     operator<=>(const queue<T, Container>& x, const queue<T, Container>& y);
 ```
 *Returns:* `x.c <=> y.c`.
 #### Specialized algorithms <a id="queue.special">[[queue.special]]</a>
 ``` cpp
 template<class T, class Container>
+ constexpr void swap(queue<T, Container>& x, queue<T, Container>& y)
+    noexcept(noexcept(x.swap(y)));
 ```
 *Constraints:* `is_swappable_v<Container>` is `true`.
 *Effects:* As if by `x.swap(y)`.
 namespace std {
   template<class T, class Container = vector<T>,
            class Compare = less<typename Container::value_type>>
   class priority_queue {
   public:
+    using value_type      = Container::value_type;
+    using reference       = Container::reference;
+    using const_reference = Container::const_reference;
+    using size_type       = Container::size_type;
     using container_type  = Container;
     using value_compare   = Compare;
   protected:
     Container c;
     Compare comp;
   public:
+ constexpr priority_queue() : priority_queue(Compare()) {}
+ constexpr explicit priority_queue(const Compare& x) : priority_queue(x, Container()) {}
+ constexpr priority_queue(const Compare& x, const Container&);
+ constexpr priority_queue(const Compare& x, Container&&);
     template<class InputIterator>
+ constexpr priority_queue(InputIterator first, InputIterator last,
+                               const Compare& x = Compare());
     template<class InputIterator>
+ constexpr priority_queue(InputIterator first, InputIterator last, const Compare& x,
                                const Container&);
     template<class InputIterator>
+ constexpr priority_queue(InputIterator first, InputIterator last, const Compare& x,
                                Container&&);
     template<container-compatible-range<T> R>
+ constexpr priority_queue(from_range_t, R&& rg, const Compare& x = Compare());
+    template<class Alloc> constexpr explicit priority_queue(const Alloc&);
+    template<class Alloc> constexpr priority_queue(const Compare&, const Alloc&);
+    template<class Alloc>
+      constexpr priority_queue(const Compare&, const Container&, const Alloc&);
+    template<class Alloc> constexpr priority_queue(const Compare&, Container&&, const Alloc&);
+    template<class Alloc> constexpr priority_queue(const priority_queue&, const Alloc&);
+    template<class Alloc> constexpr priority_queue(priority_queue&&, const Alloc&);
     template<class InputIterator, class Alloc>
+ constexpr priority_queue(InputIterator, InputIterator, const Alloc&);
     template<class InputIterator, class Alloc>
+ constexpr priority_queue(InputIterator, InputIterator, const Compare&, const Alloc&);
     template<class InputIterator, class Alloc>
+ constexpr priority_queue(InputIterator, InputIterator, const Compare&, const Container&,
                                const Alloc&);
     template<class InputIterator, class Alloc>
+ constexpr priority_queue(InputIterator, InputIterator, const Compare&, Container&&,
+                               const Alloc&);
     template<container-compatible-range<T> R, class Alloc>
+ constexpr priority_queue(from_range_t, R&& rg, const Compare&, const Alloc&);
     template<container-compatible-range<T> R, class Alloc>
+ constexpr priority_queue(from_range_t, R&& rg, const Alloc&);
+ constexpr bool empty() const { return c.empty(); }
+ constexpr size_type       size()  const { return c.size(); }
+ constexpr const_reference top() const { return c.front(); }
+ constexpr void push(const value_type& x);
+ constexpr void push(value_type&& x);
     template<container-compatible-range<T> R>
+ constexpr void push_range(R&& rg);
+    template<class... Args> constexpr void emplace(Args&&... args);
+ constexpr void pop();
+ constexpr void swap(priority_queue& q)
+      noexcept(is_nothrow_swappable_v<Container> && is_nothrow_swappable_v<Compare>)
       { using std::swap; swap(c, q.c); swap(comp, q.comp); }
   };
   template<class Compare, class Container>
     priority_queue(Compare, Container)
 ```
 #### Constructors <a id="priqueue.cons">[[priqueue.cons]]</a>
 ``` cpp
+constexpr priority_queue(const Compare& x, const Container& y);
+constexpr priority_queue(const Compare& x, Container&& y);
 ```
 *Preconditions:* `x` defines a strict weak ordering [[alg.sorting]].
 *Effects:* Initializes `comp` with `x` and `c` with `y` (copy
 constructing or move constructing as appropriate); calls
 `make_heap(c.begin(), c.end(), comp)`.
 ``` cpp
 template<class InputIterator>
+ constexpr priority_queue(InputIterator first, InputIterator last, const Compare& x = Compare());
 ```
 *Preconditions:* `x` defines a strict weak ordering [[alg.sorting]].
 *Effects:* Initializes `c` with `first` as the first argument and `last`
 as the second argument, and initializes `comp` with `x`; then calls
 `make_heap(c.begin(), c.end(), comp)`.
 ``` cpp
 template<class InputIterator>
+ constexpr priority_queue(InputIterator first, InputIterator last, const Compare& x,
+                           const Container& y);
 template<class InputIterator>
+ constexpr priority_queue(InputIterator first, InputIterator last, const Compare& x,
+                           Container&& y);
 ```
 *Preconditions:* `x` defines a strict weak ordering [[alg.sorting]].
 *Effects:* Initializes `comp` with `x` and `c` with `y` (copy
 `c.insert(c.end(), first, last)`; and finally calls
 `make_heap(c.begin(), c.end(), comp)`.
 ``` cpp
 template<container-compatible-range<T> R>
+ constexpr priority_queue(from_range_t, R&& rg, const Compare& x = Compare());
 ```
 *Preconditions:* `x` defines a strict weak ordering [[alg.sorting]].
 *Effects:* Initializes `comp` with `x` and `c` with
 If `uses_allocator_v<container_type, Alloc>` is `false` the constructors
 in this subclause shall not participate in overload resolution.
 ``` cpp
+template<class Alloc> constexpr explicit priority_queue(const Alloc& a);
 ```
 *Effects:* Initializes `c` with `a` and value-initializes `comp`.
 ``` cpp
+template<class Alloc> constexpr priority_queue(const Compare& compare, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `a` and initializes `comp` with
 `compare`.
 ``` cpp
 template<class Alloc>
+ constexpr priority_queue(const Compare& compare, const Container& cont, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `cont` as the first argument and `a` as
 the second argument, and initializes `comp` with `compare`; calls
 `make_heap(c.begin(), c.end(), comp)`.
 ``` cpp
 template<class Alloc>
+ constexpr priority_queue(const Compare& compare, Container&& cont, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `std::move(cont)` as the first argument
 and `a` as the second argument, and initializes `comp` with `compare`;
 calls `make_heap(c.begin(), c.end(), comp)`.
 ``` cpp
+template<class Alloc> constexpr priority_queue(const priority_queue& q, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `q.c` as the first argument and `a` as
 the second argument, and initializes `comp` with `q.comp`.
 ``` cpp
+template<class Alloc> constexpr priority_queue(priority_queue&& q, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `std::move(q.c)` as the first argument
 and `a` as the second argument, and initializes `comp` with
 `std::move(q.comp)`.
 ``` cpp
 template<class InputIterator, class Alloc>
+ constexpr priority_queue(InputIterator first, InputIterator last, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `first` as the first argument, `last` as
 the second argument, and `a` as the third argument, and
 value-initializes `comp`; calls `make_heap(c.begin(), c.end(), comp)`.
 ``` cpp
 template<class InputIterator, class Alloc>
+ constexpr priority_queue(InputIterator first, InputIterator last,
+                           const Compare& compare, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `first` as the first argument, `last` as
 the second argument, and `a` as the third argument, and initializes
 `comp` with `compare`; calls `make_heap(c.begin(), c.end(), comp)`.
 ``` cpp
 template<class InputIterator, class Alloc>
+ constexpr priority_queue(InputIterator first, InputIterator last, const Compare& compare,
                            const Container& cont, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `cont` as the first argument and `a` as
 the second argument, and initializes `comp` with `compare`; calls
 `c.insert(c.end(), first, last)`; and finally calls
 `make_heap(c.begin(), c.end(), comp)`.
 ``` cpp
 template<class InputIterator, class Alloc>
+ constexpr priority_queue(InputIterator first, InputIterator last, const Compare& compare,
+                           Container&& cont, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `std::move(cont)` as the first argument
 and `a` as the second argument, and initializes `comp` with `compare`;
 calls `c.insert(c.end(), first, last)`; and finally calls
 `make_heap(c.begin(), c.end(), comp)`.
 ``` cpp
 template<container-compatible-range<T> R, class Alloc>
+ constexpr priority_queue(from_range_t, R&& rg, const Compare& compare, const Alloc& a);
 ```
 *Effects:* Initializes `comp` with `compare` and `c` with
 `ranges::to<Container>(std::forward<R>(rg), a)`; calls
 `make_heap(c.begin(), c.end(), comp)`.
 ``` cpp
 template<container-compatible-range<T> R, class Alloc>
+ constexpr priority_queue(from_range_t, R&& rg, const Alloc& a);
 ```
 *Effects:* Initializes `c` with
+`ranges::to<Container>(std::forward<R>(rg), a)` and value-initializes
+`comp`; calls `make_heap(c.begin(), c.end(), comp)`.
 #### Members <a id="priqueue.members">[[priqueue.members]]</a>
 ``` cpp
+constexpr void push(const value_type& x);
 ```
 *Effects:* As if by:
 ``` cpp
 c.push_back(x);
 push_heap(c.begin(), c.end(), comp);
 ```
 ``` cpp
+constexpr void push(value_type&& x);
 ```
 *Effects:* As if by:
 ``` cpp
 push_heap(c.begin(), c.end(), comp);
 ```
 ``` cpp
 template<container-compatible-range<T> R>
+ constexpr void push_range(R&& rg);
 ```
 *Effects:* Inserts all elements of `rg` in `c` via
 `c.append_range(std::forward<R>(rg))` if that is a valid expression, or
 `ranges::copy(rg, back_inserter(c))` otherwise. Then restores the heap
 property as if by `make_heap(c.begin(), c.end(), comp)`.
 *Ensures:* `is_heap(c.begin(), c.end(), comp)` is `true`.
 ``` cpp
+template<class... Args> constexpr void emplace(Args&&... args);
 ```
 *Effects:* As if by:
 ``` cpp
 c.emplace_back(std::forward<Args>(args)...);
 push_heap(c.begin(), c.end(), comp);
 ```
 ``` cpp
+constexpr void pop();
 ```
 *Effects:* As if by:
 ``` cpp
 #### Specialized algorithms <a id="priqueue.special">[[priqueue.special]]</a>
 ``` cpp
 template<class T, class Container, class Compare>
+ constexpr void swap(priority_queue<T, Container, Compare>& x,
                       priority_queue<T, Container, Compare>& y) noexcept(noexcept(x.swap(y)));
 ```
 *Constraints:* `is_swappable_v<Container>` is `true` and
 `is_swappable_v<Compare>` is `true`.
 *Effects:* As if by `x.swap(y)`.
+### Header `<stack>` synopsis <a id="stack.syn">[[stack.syn]]</a>
+``` cpp
+#include <compare>              // see [compare.syn]
+#include <initializer_list>     // see [initializer.list.syn]
+namespace std {
+  // [stack], class template stack
+  template<class T, class Container = deque<T>> class stack;
+  template<class T, class Container>
+    constexpr bool operator==(const stack<T, Container>& x, const stack<T, Container>& y);
+  template<class T, class Container>
+    constexpr bool operator!=(const stack<T, Container>& x, const stack<T, Container>& y);
+  template<class T, class Container>
+    constexpr bool operator< (const stack<T, Container>& x, const stack<T, Container>& y);
+  template<class T, class Container>
+    constexpr bool operator> (const stack<T, Container>& x, const stack<T, Container>& y);
+  template<class T, class Container>
+    constexpr bool operator<=(const stack<T, Container>& x, const stack<T, Container>& y);
+  template<class T, class Container>
+    constexpr bool operator>=(const stack<T, Container>& x, const stack<T, Container>& y);
+  template<class T, three_way_comparable Container>
+    constexpr compare_three_way_result_t<Container>
+      operator<=>(const stack<T, Container>& x, const stack<T, Container>& y);
+  template<class T, class Container>
+    constexpr void swap(stack<T, Container>& x, stack<T, Container>& y)
+      noexcept(noexcept(x.swap(y)));
+  template<class T, class Container, class Alloc>
+    struct uses_allocator<stack<T, Container>, Alloc>;
+  // [container.adaptors.format], formatter specialization for stack
+  template<class charT, class T, formattable<charT> Container>
+    struct formatter<stack<T, Container>, charT>;
+}
+```
 ### Class template `stack` <a id="stack">[[stack]]</a>
 #### General <a id="stack.general">[[stack.general]]</a>
 Any sequence container supporting operations `back()`, `push_back()` and
 ``` cpp
 namespace std {
   template<class T, class Container = deque<T>>
   class stack {
   public:
+    using value_type      = Container::value_type;
+    using reference       = Container::reference;
+    using const_reference = Container::const_reference;
+    using size_type       = Container::size_type;
     using container_type  = Container;
   protected:
     Container c;
   public:
+ constexpr stack() : stack(Container()) {}
+ constexpr explicit stack(const Container&);
+ constexpr explicit stack(Container&&);
+    template<class InputIterator> constexpr stack(InputIterator first, InputIterator last);
+    template<container-compatible-range<T> R>
+      constexpr stack(from_range_t, R&& rg);
+    template<class Alloc> constexpr explicit stack(const Alloc&);
+    template<class Alloc> constexpr stack(const Container&, const Alloc&);
+    template<class Alloc> constexpr stack(Container&&, const Alloc&);
+    template<class Alloc> constexpr stack(const stack&, const Alloc&);
+    template<class Alloc> constexpr stack(stack&&, const Alloc&);
     template<class InputIterator, class Alloc>
+ constexpr stack(InputIterator first, InputIterator last, const Alloc&);
     template<container-compatible-range<T> R, class Alloc>
+ constexpr stack(from_range_t, R&& rg, const Alloc&);
+ constexpr bool empty() const { return c.empty(); }
+ constexpr size_type         size()  const { return c.size(); }
+ constexpr reference         top()             { return c.back(); }
+ constexpr const_reference   top() const { return c.back(); }
+ constexpr void push(const value_type& x)      { c.push_back(x); }
+ constexpr void push(value_type&& x)           { c.push_back(std::move(x)); }
     template<container-compatible-range<T> R>
+ constexpr void push_range(R&& rg);
     template<class... Args>
+ constexpr decltype(auto) emplace(Args&&... args)
         { return c.emplace_back(std::forward<Args>(args)...); }
+ constexpr void pop()                          { c.pop_back(); }
+ constexpr void swap(stack& s) noexcept(is_nothrow_swappable_v<Container>)
       { using std::swap; swap(c, s.c); }
   };
   template<class Container>
     stack(Container) -> stack<typename Container::value_type, Container>;
 ```
 #### Constructors <a id="stack.cons">[[stack.cons]]</a>
 ``` cpp
+constexpr explicit stack(const Container& cont);
 ```
 *Effects:* Initializes `c` with `cont`.
 ``` cpp
+constexpr explicit stack(Container&& cont);
 ```
 *Effects:* Initializes `c` with `std::move(cont)`.
 ``` cpp
 template<class InputIterator>
+ constexpr stack(InputIterator first, InputIterator last);
 ```
 *Effects:* Initializes `c` with `first` as the first argument and `last`
 as the second argument.
 ``` cpp
 template<container-compatible-range<T> R>
+ constexpr stack(from_range_t, R&& rg);
 ```
 *Effects:* Initializes `c` with
 `ranges::to<Container>(std::forward<R>(rg))`.
 If `uses_allocator_v<container_type, Alloc>` is `false` the constructors
 in this subclause shall not participate in overload resolution.
 ``` cpp
+template<class Alloc> constexpr explicit stack(const Alloc& a);
 ```
 *Effects:* Initializes `c` with `a`.
 ``` cpp
+template<class Alloc> constexpr stack(const container_type& cont, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `cont` as the first argument and `a` as
 the second argument.
 ``` cpp
+template<class Alloc> constexpr stack(container_type&& cont, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `std::move(cont)` as the first argument
 and `a` as the second argument.
 ``` cpp
+template<class Alloc> constexpr stack(const stack& s, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `s.c` as the first argument and `a` as
 the second argument.
 ``` cpp
+template<class Alloc> constexpr stack(stack&& s, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `std::move(s.c)` as the first argument
 and `a` as the second argument.
 ``` cpp
 template<class InputIterator, class Alloc>
+ constexpr stack(InputIterator first, InputIterator last, const Alloc& alloc);
 ```
 *Effects:* Initializes `c` with `first` as the first argument, `last` as
 the second argument, and `alloc` as the third argument.
 ``` cpp
 template<container-compatible-range<T> R, class Alloc>
+ constexpr stack(from_range_t, R&& rg, const Alloc& a);
 ```
 *Effects:* Initializes `c` with
 `ranges::to<Container>(std::forward<R>(rg), a)`.
 #### Modifiers <a id="stack.mod">[[stack.mod]]</a>
 ``` cpp
 template<container-compatible-range<T> R>
+ constexpr void push_range(R&& rg);
 ```
 *Effects:* Equivalent to `c.append_range(std::forward<R>(rg))` if that
 is a valid expression, otherwise `ranges::copy(rg, back_inserter(c))`.
 #### Operators <a id="stack.ops">[[stack.ops]]</a>
 ``` cpp
 template<class T, class Container>
+ constexpr bool operator==(const stack<T, Container>& x, const stack<T, Container>& y);
 ```
 *Returns:* `x.c == y.c`.
 ``` cpp
 template<class T, class Container>
+ constexpr bool operator!=(const stack<T, Container>& x, const stack<T, Container>& y);
 ```
 *Returns:* `x.c != y.c`.
 ``` cpp
 template<class T, class Container>
+ constexpr bool operator< (const stack<T, Container>& x, const stack<T, Container>& y);
 ```
 *Returns:* `x.c < y.c`.
 ``` cpp
 template<class T, class Container>
+ constexpr bool operator> (const stack<T, Container>& x, const stack<T, Container>& y);
 ```
 *Returns:* `x.c > y.c`.
 ``` cpp
 template<class T, class Container>
+ constexpr bool operator<=(const stack<T, Container>& x, const stack<T, Container>& y);
 ```
 *Returns:* `x.c <= y.c`.
 ``` cpp
 template<class T, class Container>
+ constexpr bool operator>=(const stack<T, Container>& x, const stack<T, Container>& y);
 ```
 *Returns:* `x.c >= y.c`.
 ``` cpp
 template<class T, three_way_comparable Container>
+ constexpr compare_three_way_result_t<Container>
     operator<=>(const stack<T, Container>& x, const stack<T, Container>& y);
 ```
 *Returns:* `x.c <=> y.c`.
 #### Specialized algorithms <a id="stack.special">[[stack.special]]</a>
 ``` cpp
 template<class T, class Container>
+ constexpr void swap(stack<T, Container>& x, stack<T, Container>& y)
+    noexcept(noexcept(x.swap(y)));
 ```
 *Constraints:* `is_swappable_v<Container>` is `true`.
 *Effects:* As if by `x.swap(y)`.
+### Header `<flat_map>` synopsis <a id="flat.map.syn">[[flat.map.syn]]</a>
+``` cpp
+#include <compare>              // see [compare.syn]
+#include <initializer_list>     // see [initializer.list.syn]
+namespace std {
+  // [flat.map], class template flat_map
+  template<class Key, class T, class Compare = less<Key>,
+           class KeyContainer = vector<Key>, class MappedContainer = vector<T>>
+    class flat_map;
+  struct sorted_unique_t { explicit sorted_unique_t() = default; };
+  inline constexpr sorted_unique_t sorted_unique{};
+  template<class Key, class T, class Compare, class KeyContainer, class MappedContainer,
+           class Allocator>
+    struct uses_allocator<flat_map<Key, T, Compare, KeyContainer, MappedContainer>,
+                          Allocator>;
+  // [flat.map.erasure], erasure for flat_map
+  template<class Key, class T, class Compare, class KeyContainer, class MappedContainer,
+           class Predicate>
+    constexpr typename flat_map<Key, T, Compare, KeyContainer, MappedContainer>::size_type
+      erase_if(flat_map<Key, T, Compare, KeyContainer, MappedContainer>& c, Predicate pred);
+  // [flat.multimap], class template flat_multimap
+  template<class Key, class T, class Compare = less<Key>,
+           class KeyContainer = vector<Key>, class MappedContainer = vector<T>>
+    class flat_multimap;
+  struct sorted_equivalent_t { explicit sorted_equivalent_t() = default; };
+  inline constexpr sorted_equivalent_t sorted_equivalent{};
+  template<class Key, class T, class Compare, class KeyContainer, class MappedContainer,
+           class Allocator>
+    struct uses_allocator<flat_multimap<Key, T, Compare, KeyContainer, MappedContainer>,
+                          Allocator>;
+  // [flat.multimap.erasure], erasure for flat_multimap
+  template<class Key, class T, class Compare, class KeyContainer, class MappedContainer,
+           class Predicate>
+    constexpr typename flat_multimap<Key, T, Compare, KeyContainer, MappedContainer>::size_type
+      erase_if(flat_multimap<Key, T, Compare, KeyContainer, MappedContainer>& c, Predicate pred);
+}
+```
 ### Class template `flat_map` <a id="flat.map">[[flat.map]]</a>
 #### Overview <a id="flat.map.overview">[[flat.map.overview]]</a>
 A `flat_map` is a container adaptor that provides an associative
 The effect of calling a constructor that takes both `key_container_type`
 and `mapped_container_type` arguments with containers of different sizes
 is undefined.
+The effect of calling a member function that takes a `sorted_unique_t`
+argument with a container, containers, or range that is not sorted with
+respect to `key_comp()`, or that contains equal elements, is undefined.
+The types `iterator` and `const_iterator` meet the constexpr iterator
+requirements [[iterator.requirements.general]].
 #### Definition <a id="flat.map.defn">[[flat.map.defn]]</a>
 ``` cpp
 namespace std {
     using mapped_container_type  = MappedContainer;
     class value_compare {
     private:
       key_compare comp;                                         // exposition only
+ constexpr value_compare(key_compare c) : comp(c) { } // exposition only
     public:
+ constexpr bool operator()(const_reference x, const_reference y) const {
         return comp(x.first, y.first);
       }
     };
     struct containers {
       key_container_type keys;
       mapped_container_type values;
     };
+    // [flat.map.cons], constructors
+ constexpr flat_map() : flat_map(key_compare()) { }
+ constexpr explicit flat_map(const key_compare& comp)
       : c(), compare(comp) { }
+    constexpr flat_map(key_container_type key_cont, mapped_container_type mapped_cont,
+                       const key_compare& comp = key_compare());
+    constexpr flat_map(sorted_unique_t, key_container_type key_cont,
+                       mapped_container_type mapped_cont,
+                       const key_compare& comp = key_compare());
     template<class InputIterator>
+ constexpr flat_map(InputIterator first, InputIterator last,
+                         const key_compare& comp = key_compare())
         : c(), compare(comp) { insert(first, last); }
+    template<class InputIterator>
+      constexpr flat_map(sorted_unique_t, InputIterator first, InputIterator last,
+                         const key_compare& comp = key_compare())
+        : c(), compare(comp) { insert(sorted_unique, first, last); }
     template<container-compatible-range<value_type> R>
+ constexpr flat_map(from_range_t, R&& rg)
+        : flat_map(from_range, std::forward<R>(rg), key_compare()) { }
     template<container-compatible-range<value_type> R>
+ constexpr flat_map(from_range_t, R&& rg, const key_compare& comp)
         : flat_map(comp) { insert_range(std::forward<R>(rg)); }
+ constexpr flat_map(initializer_list<value_type> il, const key_compare& comp = key_compare())
         : flat_map(il.begin(), il.end(), comp) { }
+ constexpr flat_map(sorted_unique_t, initializer_list<value_type> il,
                        const key_compare& comp = key_compare())
+        : flat_map(sorted_unique, il.begin(), il.end(), comp) { }
+ // [flat.map.cons.alloc], constructors with allocators
+    template<class Alloc>
+      constexpr explicit flat_map(const Alloc& a);
+    template<class Alloc>
+      constexpr flat_map(const key_compare& comp, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_map(const key_container_type& key_cont,
+                         const mapped_container_type& mapped_cont,
+                         const Alloc& a);
+    template<class Alloc>
+      constexpr flat_map(const key_container_type& key_cont,
+                         const mapped_container_type& mapped_cont,
+                         const key_compare& comp, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_map(sorted_unique_t, const key_container_type& key_cont,
+                         const mapped_container_type& mapped_cont, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_map(sorted_unique_t, const key_container_type& key_cont,
+                         const mapped_container_type& mapped_cont, const key_compare& comp,
+                         const Alloc& a);
+    template<class Alloc>
+      constexpr flat_map(const flat_map&, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_map(flat_map&&, const Alloc& a);
+    template<class InputIterator, class Alloc>
+      constexpr flat_map(InputIterator first, InputIterator last, const Alloc& a);
+    template<class InputIterator, class Alloc>
+      constexpr flat_map(InputIterator first, InputIterator last,
+                         const key_compare& comp, const Alloc& a);
+    template<class InputIterator, class Alloc>
+      constexpr flat_map(sorted_unique_t, InputIterator first, InputIterator last,
+                         const Alloc& a);
+    template<class InputIterator, class Alloc>
+      constexpr flat_map(sorted_unique_t, InputIterator first, InputIterator last,
+                         const key_compare& comp, const Alloc& a);
+    template<container-compatible-range<value_type> R, class Alloc>
+      constexpr flat_map(from_range_t, R&& rg, const Alloc& a);
+    template<container-compatible-range<value_type> R, class Alloc>
+      constexpr flat_map(from_range_t, R&& rg, const key_compare& comp, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_map(initializer_list<value_type> il, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_map(initializer_list<value_type> il, const key_compare& comp,
+                         const Alloc& a);
+    template<class Alloc>
+      constexpr flat_map(sorted_unique_t, initializer_list<value_type> il, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_map(sorted_unique_t, initializer_list<value_type> il,
+                         const key_compare& comp, const Alloc& a);
+    constexpr flat_map& operator=(initializer_list<value_type>);
     // iterators
+ constexpr iterator               begin() noexcept;
+ constexpr const_iterator         begin() const noexcept;
+ constexpr iterator               end() noexcept;
+ constexpr const_iterator         end() const noexcept;
+ constexpr reverse_iterator       rbegin() noexcept;
+ constexpr const_reverse_iterator rbegin() const noexcept;
+ constexpr reverse_iterator       rend() noexcept;
+ constexpr const_reverse_iterator rend() const noexcept;
+ constexpr const_iterator         cbegin() const noexcept;
+ constexpr const_iterator         cend() const noexcept;
+ constexpr const_reverse_iterator crbegin() const noexcept;
+ constexpr const_reverse_iterator crend() const noexcept;
     // [flat.map.capacity], capacity
+ constexpr bool empty() const noexcept;
+ constexpr size_type size() const noexcept;
+ constexpr size_type max_size() const noexcept;
     // [flat.map.access], element access
+ constexpr mapped_type& operator[](const key_type& x);
+ constexpr mapped_type& operator[](key_type&& x);
+    template<class K> constexpr mapped_type& operator[](K&& x);
+ constexpr mapped_type& at(const key_type& x);
+ constexpr const mapped_type& at(const key_type& x) const;
+    template<class K> constexpr mapped_type& at(const K& x);
+    template<class K> constexpr const mapped_type& at(const K& x) const;
     // [flat.map.modifiers], modifiers
+    template<class... Args> constexpr pair<iterator, bool> emplace(Args&&... args);
     template<class... Args>
+ constexpr iterator emplace_hint(const_iterator position, Args&&... args);
+ constexpr pair<iterator, bool> insert(const value_type& x)
       { return emplace(x); }
+ constexpr pair<iterator, bool> insert(value_type&& x)
       { return emplace(std::move(x)); }
+ constexpr iterator insert(const_iterator position, const value_type& x)
       { return emplace_hint(position, x); }
+ constexpr iterator insert(const_iterator position, value_type&& x)
       { return emplace_hint(position, std::move(x)); }
+    template<class P> constexpr pair<iterator, bool> insert(P&& x);
     template<class P>
+ constexpr iterator insert(const_iterator position, P&&);
     template<class InputIterator>
+ constexpr void insert(InputIterator first, InputIterator last);
     template<class InputIterator>
+ constexpr void insert(sorted_unique_t, InputIterator first, InputIterator last);
     template<container-compatible-range<value_type> R>
+ constexpr void insert_range(R&& rg);
+ constexpr void insert(initializer_list<value_type> il)
       { insert(il.begin(), il.end()); }
+ constexpr void insert(sorted_unique_t, initializer_list<value_type> il)
+      { insert(sorted_unique, il.begin(), il.end()); }
+ constexpr containers extract() &&;
+ constexpr void replace(key_container_type&& key_cont, mapped_container_type&& mapped_cont);
     template<class... Args>
+ constexpr pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
     template<class... Args>
+ constexpr pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
     template<class K, class... Args>
+ constexpr pair<iterator, bool> try_emplace(K&& k, Args&&... args);
     template<class... Args>
+ constexpr iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args);
     template<class... Args>
+ constexpr iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);
     template<class K, class... Args>
+ constexpr iterator try_emplace(const_iterator hint, K&& k, Args&&... args);
     template<class M>
+ constexpr pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);
     template<class M>
+ constexpr pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj);
     template<class K, class M>
+ constexpr pair<iterator, bool> insert_or_assign(K&& k, M&& obj);
     template<class M>
+ constexpr iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);
     template<class M>
+ constexpr iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj);
     template<class K, class M>
+ constexpr iterator insert_or_assign(const_iterator hint, K&& k, M&& obj);
+ constexpr iterator erase(iterator position);
+ constexpr iterator erase(const_iterator position);
+ constexpr size_type erase(const key_type& x);
+    template<class K> constexpr size_type erase(K&& x);
+ constexpr iterator erase(const_iterator first, const_iterator last);
+ constexpr void swap(flat_map& y) noexcept;
+ constexpr void clear() noexcept;
     // observers
+ constexpr key_compare key_comp() const;
+ constexpr value_compare value_comp() const;
+ constexpr const key_container_type& keys() const noexcept      { return c.keys; }
+ constexpr const mapped_container_type& values() const noexcept { return c.values; }
     // map operations
+ constexpr iterator find(const key_type& x);
+ constexpr const_iterator find(const key_type& x) const;
+    template<class K> constexpr iterator find(const K& x);
+    template<class K> constexpr const_iterator find(const K& x) const;
+ constexpr size_type count(const key_type& x) const;
+    template<class K> constexpr size_type count(const K& x) const;
+ constexpr bool contains(const key_type& x) const;
+    template<class K> constexpr bool contains(const K& x) const;
+ constexpr iterator lower_bound(const key_type& x);
+ constexpr const_iterator lower_bound(const key_type& x) const;
+    template<class K> constexpr iterator lower_bound(const K& x);
+    template<class K> constexpr const_iterator lower_bound(const K& x) const;
+ constexpr iterator upper_bound(const key_type& x);
+ constexpr const_iterator upper_bound(const key_type& x) const;
+    template<class K> constexpr iterator upper_bound(const K& x);
+    template<class K> constexpr const_iterator upper_bound(const K& x) const;
+ constexpr pair<iterator, iterator> equal_range(const key_type& x);
+ constexpr pair<const_iterator, const_iterator> equal_range(const key_type& x) const;
+    template<class K> constexpr pair<iterator, iterator> equal_range(const K& x);
+    template<class K>
+      constexpr pair<const_iterator, const_iterator> equal_range(const K& x) const;
+    friend constexpr bool operator==(const flat_map& x, const flat_map& y);
+    friend constexpr synth-three-way-result<value_type>
       operator<=>(const flat_map& x, const flat_map& y);
+    friend constexpr void swap(flat_map& x, flat_map& y) noexcept
       { x.swap(y); }
   private:
     containers c;               // exposition only
     key_compare compare;        // exposition only
+    struct key-equiv {  // exposition only
+ constexpr key-equiv(key_compare c) : comp(c) { }
+ constexpr bool operator()(const_reference x, const_reference y) const {
         return !comp(x.first, y.first) && !comp(y.first, x.first);
       }
       key_compare comp;
     };
   };
 specified.
 #### Constructors <a id="flat.map.cons">[[flat.map.cons]]</a>
 ``` cpp
+constexpr flat_map(key_container_type key_cont, mapped_container_type mapped_cont,
                    const key_compare& comp = key_compare());
 ```
+*Effects:* Initializes *`c`*`.keys` with `std::move(key_cont)`,
+*`c`*`.values` with `std::move(mapped_cont)`, and *compare* with `comp`;
+sorts the range \[`begin()`, `end()`) with respect to `value_comp()`;
+and finally erases the duplicate elements as if by:
 ``` cpp
+auto zv = views::zip(c.keys, c.values);
+auto it = ranges::unique(zv, key-equiv(compare)).begin();
 auto dist = distance(zv.begin(), it);
 c.keys.erase(c.keys.begin() + dist, c.keys.end());
 c.values.erase(c.values.begin() + dist, c.values.end());
 ```
 *Complexity:* Linear in N if the container arguments are already sorted
 with respect to `value_comp()` and otherwise N log N, where N is the
 value of `key_cont.size()` before this call.
 ``` cpp
+constexpr flat_map(sorted_unique_t, key_container_type key_cont, mapped_container_type mapped_cont,
+ const key_compare& comp = key_compare());
 ```
+*Effects:* Initializes *`c`*`.keys` with `std::move(key_cont)`,
+*`c`*`.values` with `std::move(mapped_cont)`, and *compare* with `comp`.
+*Complexity:* Constant.
+#### Constructors with allocators <a id="flat.map.cons.alloc">[[flat.map.cons.alloc]]</a>
+The constructors in this subclause shall not participate in overload
+resolution unless `uses_allocator_v<key_container_type, Alloc>` is
+`true` and `uses_allocator_v<mapped_container_type, Alloc>` is `true`.
+``` cpp
+template<class Alloc>
+  constexpr flat_map(const key_container_type& key_cont, const mapped_container_type& mapped_cont,
+                     const Alloc& a);
+template<class Alloc>
+  constexpr flat_map(const key_container_type& key_cont, const mapped_container_type& mapped_cont,
+                     const key_compare& comp, const Alloc& a);
+```
 *Effects:* Equivalent to `flat_map(key_cont, mapped_cont)` and
 `flat_map(key_cont, mapped_cont, comp)`, respectively, except that
+*`c`*`.keys` and *`c`*`.values` are constructed with uses-allocator
 construction [[allocator.uses.construction]].
 *Complexity:* Same as `flat_map(key_cont, mapped_cont)` and
 `flat_map(key_cont, mapped_cont, comp)`, respectively.
 ``` cpp
+template<class Alloc>
+  constexpr flat_map(sorted_unique_t, const key_container_type& key_cont,
+                     const mapped_container_type& mapped_cont, const Alloc& a);
+template<class Alloc>
+  constexpr flat_map(sorted_unique_t, const key_container_type& key_cont,
                      const mapped_container_type& mapped_cont, const key_compare& comp,
+ const Alloc& a);
 ```
+*Effects:* Equivalent to
+`flat_map(sorted_unique, key_cont, mapped_cont)` and
+`flat_map(sorted_unique, key_cont, mapped_cont, comp)`, respectively,
+except that *`c`*`.keys` and *`c`*`.values` are constructed with
+uses-allocator construction [[allocator.uses.construction]].
 *Complexity:* Linear.
 ``` cpp
+template<class Alloc>
+ constexpr explicit flat_map(const Alloc& a);
+template<class Alloc>
+ constexpr flat_map(const key_compare& comp, const Alloc& a);
+template<class Alloc>
+ constexpr flat_map(const flat_map&, const Alloc& a);
+template<class Alloc>
+ constexpr flat_map(flat_map&&, const Alloc& a);
+template<class InputIterator, class Alloc>
+ constexpr flat_map(InputIterator first, InputIterator last, const Alloc& a);
+template<class InputIterator, class Alloc>
+ constexpr flat_map(InputIterator first, InputIterator last, const key_compare& comp,
+                     const Alloc& a);
+template<class InputIterator, class Alloc>
+  constexpr flat_map(sorted_unique_t, InputIterator first, InputIterator last, const Alloc& a);
+template<class InputIterator, class Alloc>
+ constexpr flat_map(sorted_unique_t, InputIterator first, InputIterator last,
+                     const key_compare& comp, const Alloc& a);
+template<container-compatible-range<value_type> R, class Alloc>
+  constexpr flat_map(from_range_t, R&& rg, const Alloc& a);
+template<container-compatible-range<value_type> R, class Alloc>
+  constexpr flat_map(from_range_t, R&& rg, const key_compare& comp, const Alloc& a);
+template<class Alloc>
+  constexpr flat_map(initializer_list<value_type> il, const Alloc& a);
+template<class Alloc>
+ constexpr flat_map(initializer_list<value_type> il, const key_compare& comp, const Alloc& a);
+template<class Alloc>
+  constexpr flat_map(sorted_unique_t, initializer_list<value_type> il, const Alloc& a);
+template<class Alloc>
+  constexpr flat_map(sorted_unique_t, initializer_list<value_type> il,
+                     const key_compare& comp, const Alloc& a);
 ```
 *Effects:* Equivalent to the corresponding non-allocator constructors
+except that *`c`*`.keys` and *`c`*`.values` are constructed with
+uses-allocator construction [[allocator.uses.construction]].
 #### Capacity <a id="flat.map.capacity">[[flat.map.capacity]]</a>
 ``` cpp
+constexpr size_type size() const noexcept;
 ```
+*Returns:* *`c`*`.keys.size()`.
 ``` cpp
+constexpr size_type max_size() const noexcept;
 ```
+*Returns:*
+`min<size_type>(`*`c`*`.keys.max_size(), `*`c`*`.values.max_size())`.
 #### Access <a id="flat.map.access">[[flat.map.access]]</a>
 ``` cpp
+constexpr mapped_type& operator[](const key_type& x);
 ```
 *Effects:* Equivalent to: `return try_emplace(x).first->second;`
 ``` cpp
+constexpr mapped_type& operator[](key_type&& x);
 ```
 *Effects:* Equivalent to:
 `return try_emplace(std::move(x)).first->second;`
 ``` cpp
+template<class K> constexpr mapped_type& operator[](K&& x);
 ```
 *Constraints:* The *qualified-id* `Compare::is_transparent` is valid and
 denotes a type.
 *Effects:* Equivalent to:
 `return try_emplace(std::forward<K>(x)).first->second;`
 ``` cpp
+constexpr mapped_type&       at(const key_type& x);
+constexpr const mapped_type& at(const key_type& x) const;
 ```
 *Returns:* A reference to the `mapped_type` corresponding to `x` in
 `*this`.
 is present.
 *Complexity:* Logarithmic.
 ``` cpp
+template<class K> constexpr mapped_type&       at(const K& x);
+template<class K> constexpr const mapped_type& at(const K& x) const;
 ```
 *Constraints:* The *qualified-id* `Compare::is_transparent` is valid and
 denotes a type.
 *Complexity:* Logarithmic.
 #### Modifiers <a id="flat.map.modifiers">[[flat.map.modifiers]]</a>
 ``` cpp
+template<class... Args> constexpr pair<iterator, bool> emplace(Args&&... args);
 ```
 *Constraints:*
 `is_constructible_v<pair<key_type, mapped_type>, Args...>` is `true`.
 *Returns:* The `bool` component of the returned pair is `true` if and
 only if the insertion took place, and the iterator component of the pair
 points to the element with key equivalent to `t.first`.
 ``` cpp
+template<class P> constexpr pair<iterator, bool> insert(P&& x);
+template<class P> constexpr iterator insert(const_iterator position, P&& x);
 ```
 *Constraints:* `is_constructible_v<pair<key_type, mapped_type>, P>` is
 `true`.
 `return emplace(std::forward<P>(x));`. The second form is equivalent to
 `return emplace_hint(position, std::forward<P>(x));`.
 ``` cpp
 template<class InputIterator>
+ constexpr void insert(InputIterator first, InputIterator last);
 ```
+*Effects:* Adds elements to *c* as if by:
 ``` cpp
 for (; first != last; ++first) {
   value_type value = *first;
   c.keys.insert(c.keys.end(), std::move(value.first));
 `value_comp()`; merges the resulting sorted range and the sorted range
 of pre-existing elements into a single sorted range; and finally erases
 the duplicate elements as if by:
 ``` cpp
+auto zv = views::zip(c.keys, c.values);
+auto it = ranges::unique(zv, key-equiv(compare)).begin();
 auto dist = distance(zv.begin(), it);
 c.keys.erase(c.keys.begin() + dist, c.keys.end());
 c.values.erase(c.values.begin() + dist, c.values.end());
 ```
 *Remarks:* Since this operation performs an in-place merge, it may
 allocate memory.
 ``` cpp
 template<class InputIterator>
+ constexpr void insert(sorted_unique_t, InputIterator first, InputIterator last);
 ```
+*Effects:* Equivalent to `insert(first, last)`.
 *Complexity:* Linear in N, where N is `size()` after the operation.
 ``` cpp
 template<container-compatible-range<value_type> R>
+ constexpr void insert_range(R&& rg);
 ```
+*Effects:* Adds elements to *c* as if by:
 ``` cpp
 for (const auto& e : rg) {
   c.keys.insert(c.keys.end(), e.first);
   c.values.insert(c.values.end(), e.second);
 `value_comp()`; merges the resulting sorted range and the sorted range
 of pre-existing elements into a single sorted range; and finally erases
 the duplicate elements as if by:
 ``` cpp
+auto zv = views::zip(c.keys, c.values);
+auto it = ranges::unique(zv, key-equiv(compare)).begin();
 auto dist = distance(zv.begin(), it);
 c.keys.erase(c.keys.begin() + dist, c.keys.end());
 c.values.erase(c.values.begin() + dist, c.values.end());
 ```
 *Remarks:* Since this operation performs an in-place merge, it may
 allocate memory.
 ``` cpp
 template<class... Args>
+ constexpr pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
 template<class... Args>
+ constexpr pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
 template<class... Args>
+ constexpr iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args);
 template<class... Args>
+ constexpr iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);
 ```
 *Constraints:* `is_constructible_v<mapped_type, Args...>` is `true`.
 *Effects:* If the map already contains an element whose key is
 *Complexity:* The same as `emplace` for the first two overloads, and the
 same as `emplace_hint` for the last two overloads.
 ``` cpp
 template<class K, class... Args>
+ constexpr pair<iterator, bool> try_emplace(K&& k, Args&&... args);
 template<class K, class... Args>
+ constexpr iterator try_emplace(const_iterator hint, K&& k, Args&&... args);
 ```
 *Constraints:*
 - The *qualified-id* `Compare::is_transparent` is valid and denotes a
 *Effects:* If the map already contains an element whose key is
 equivalent to `k`, `*this` and `args...` are unchanged. Otherwise
 equivalent to:
 ``` cpp
+auto key_it = upper_bound(c.keys.begin(), c.keys.end(), k, compare);
 auto value_it = c.values.begin() + distance(c.keys.begin(), key_it);
 c.keys.emplace(key_it, std::forward<K>(k));
 c.values.emplace(value_it, std::forward<Args>(args)...);
 ```
 *Complexity:* The same as `emplace` and `emplace_hint`, respectively.
 ``` cpp
 template<class M>
+ constexpr pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);
 template<class M>
+ constexpr pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj);
 template<class M>
+ constexpr iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);
 template<class M>
+ constexpr iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj);
 ```
 *Constraints:* `is_assignable_v<mapped_type&, M>` is `true` and
 `is_constructible_v<mapped_type, M>` is `true`.
 *Complexity:* The same as `emplace` for the first two overloads and the
 same as `emplace_hint` for the last two overloads.
 ``` cpp
 template<class K, class M>
+ constexpr pair<iterator, bool> insert_or_assign(K&& k, M&& obj);
 template<class K, class M>
+ constexpr iterator insert_or_assign(const_iterator hint, K&& k, M&& obj);
 ```
 *Constraints:*
 - The *qualified-id* `Compare::is_transparent` is valid and denotes a
 iterator points to the map element whose key is equivalent to `k`.
 *Complexity:* The same as `emplace` and `emplace_hint`, respectively.
 ``` cpp
+constexpr void swap(flat_map& y) noexcept;
 ```
 *Effects:* Equivalent to:
 ``` cpp
 ranges::swap(c.keys, y.c.keys);
 ranges::swap(c.values, y.c.values);
 ```
 ``` cpp
+constexpr containers extract() &&;
 ```
 *Ensures:* `*this` is emptied, even if the function exits via an
 exception.
+*Returns:* `std::move(`*`c`*`)`.
 ``` cpp
+constexpr void replace(key_container_type&& key_cont, mapped_container_type&& mapped_cont);
 ```
 *Preconditions:* `key_cont.size() == mapped_cont.size()` is `true`, the
+elements of `key_cont` are sorted with respect to *compare*, and
 `key_cont` contains no equal elements.
 *Effects:* Equivalent to:
 ``` cpp
 #### Erasure <a id="flat.map.erasure">[[flat.map.erasure]]</a>
 ``` cpp
 template<class Key, class T, class Compare, class KeyContainer, class MappedContainer,
          class Predicate>
+ constexpr typename flat_map<Key, T, Compare, KeyContainer, MappedContainer>::size_type
     erase_if(flat_map<Key, T, Compare, KeyContainer, MappedContainer>& c, Predicate pred);
 ```
 *Preconditions:* `Key` and `T` meet the *Cpp17MoveAssignable*
 requirements.
 The effect of calling a constructor that takes both `key_container_type`
 and `mapped_container_type` arguments with containers of different sizes
 is undefined.
+The effect of calling a member function that takes a
 `sorted_equivalent_t` argument with a container, containers, or range
 that are not sorted with respect to `key_comp()` is undefined.
+The types `iterator` and `const_iterator` meet the constexpr iterator
+requirements [[iterator.requirements.general]].
 #### Definition <a id="flat.multimap.defn">[[flat.multimap.defn]]</a>
 ``` cpp
 namespace std {
   template<class Key, class T, class Compare = less<Key>,
     using mapped_container_type  = MappedContainer;
     class value_compare {
     private:
       key_compare comp;                                         // exposition only
+ constexpr value_compare(key_compare c) : comp(c) { } // exposition only
     public:
+ constexpr bool operator()(const_reference x, const_reference y) const {
         return comp(x.first, y.first);
       }
     };
     struct containers {
       key_container_type keys;
       mapped_container_type values;
     };
+    // [flat.multimap.cons], constructors
+ constexpr flat_multimap() : flat_multimap(key_compare()) { }
+ constexpr explicit flat_multimap(const key_compare& comp)
+      : c(), compare(comp) { }
+    constexpr flat_multimap(key_container_type key_cont, mapped_container_type mapped_cont,
                             const key_compare& comp = key_compare());
+ constexpr flat_multimap(sorted_equivalent_t,
                             key_container_type key_cont, mapped_container_type mapped_cont,
                   const key_compare& comp = key_compare());
     template<class InputIterator>
+ constexpr flat_multimap(InputIterator first, InputIterator last,
                               const key_compare& comp = key_compare())
         : c(), compare(comp)
         { insert(first, last); }
+    template<class InputIterator>
+      constexpr flat_multimap(sorted_equivalent_t, InputIterator first, InputIterator last,
+                              const key_compare& comp = key_compare())
+        : c(), compare(comp) { insert(sorted_equivalent, first, last); }
     template<container-compatible-range<value_type> R>
+ constexpr flat_multimap(from_range_t, R&& rg)
+        : flat_multimap(from_range, std::forward<R>(rg), key_compare()) { }
     template<container-compatible-range<value_type> R>
+ constexpr flat_multimap(from_range_t, R&& rg, const key_compare& comp)
         : flat_multimap(comp) { insert_range(std::forward<R>(rg)); }
+ constexpr flat_multimap(initializer_list<value_type> il,
                             const key_compare& comp = key_compare())
         : flat_multimap(il.begin(), il.end(), comp) { }
+ constexpr flat_multimap(sorted_equivalent_t, initializer_list<value_type> il,
                             const key_compare& comp = key_compare())
+        : flat_multimap(sorted_equivalent, il.begin(), il.end(), comp) { }
+ // [flat.multimap.cons.alloc], constructors with allocators
+    template<class Alloc>
+      constexpr explicit flat_multimap(const Alloc& a);
+    template<class Alloc>
+      constexpr flat_multimap(const key_compare& comp, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_multimap(const key_container_type& key_cont,
+                              const mapped_container_type& mapped_cont, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_multimap(const key_container_type& key_cont,
+                              const mapped_container_type& mapped_cont,
+                              const key_compare& comp, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_multimap(sorted_equivalent_t, const key_container_type& key_cont,
+                              const mapped_container_type& mapped_cont, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_multimap(sorted_equivalent_t, const key_container_type& key_cont,
+                              const mapped_container_type& mapped_cont,
+                              const key_compare& comp, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_multimap(const flat_multimap&, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_multimap(flat_multimap&&, const Alloc& a);
+    template<class InputIterator, class Alloc>
+      constexpr flat_multimap(InputIterator first, InputIterator last, const Alloc& a);
+    template<class InputIterator, class Alloc>
+      constexpr flat_multimap(InputIterator first, InputIterator last,
+                              const key_compare& comp, const Alloc& a);
+    template<class InputIterator, class Alloc>
+      constexpr flat_multimap(sorted_equivalent_t, InputIterator first, InputIterator last,
+                              const Alloc& a);
+    template<class InputIterator, class Alloc>
+      constexpr flat_multimap(sorted_equivalent_t, InputIterator first, InputIterator last,
+                              const key_compare& comp, const Alloc& a);
+    template<container-compatible-range<value_type> R, class Alloc>
+      constexpr flat_multimap(from_range_t, R&& rg, const Alloc& a);
+    template<container-compatible-range<value_type> R, class Alloc>
+      constexpr flat_multimap(from_range_t, R&& rg, const key_compare& comp, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_multimap(initializer_list<value_type> il, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_multimap(initializer_list<value_type> il, const key_compare& comp,
+                              const Alloc& a);
+    template<class Alloc>
+      constexpr flat_multimap(sorted_equivalent_t, initializer_list<value_type> il,
+                              const Alloc& a);
+    template<class Alloc>
+      constexpr flat_multimap(sorted_equivalent_t, initializer_list<value_type> il,
+                              const key_compare& comp, const Alloc& a);
+    flat_multimap& operator=(initializer_list<value_type>);
     // iterators
+ constexpr iterator               begin() noexcept;
+ constexpr const_iterator         begin() const noexcept;
+ constexpr iterator               end() noexcept;
+ constexpr const_iterator         end() const noexcept;
+ constexpr reverse_iterator       rbegin() noexcept;
+ constexpr const_reverse_iterator rbegin() const noexcept;
+ constexpr reverse_iterator       rend() noexcept;
+ constexpr const_reverse_iterator rend() const noexcept;
+ constexpr const_iterator         cbegin() const noexcept;
+ constexpr const_iterator         cend() const noexcept;
+ constexpr const_reverse_iterator crbegin() const noexcept;
+ constexpr const_reverse_iterator crend() const noexcept;
     // capacity
+ constexpr bool empty() const noexcept;
+ constexpr size_type size() const noexcept;
+ constexpr size_type max_size() const noexcept;
     // modifiers
+    template<class... Args> constexpr iterator emplace(Args&&... args);
     template<class... Args>
+ constexpr iterator emplace_hint(const_iterator position, Args&&... args);
+ constexpr iterator insert(const value_type& x)
       { return emplace(x); }
+ constexpr iterator insert(value_type&& x)
       { return emplace(std::move(x)); }
+ constexpr iterator insert(const_iterator position, const value_type& x)
       { return emplace_hint(position, x); }
+ constexpr iterator insert(const_iterator position, value_type&& x)
       { return emplace_hint(position, std::move(x)); }
+    template<class P> constexpr iterator insert(P&& x);
     template<class P>
+ constexpr iterator insert(const_iterator position, P&&);
     template<class InputIterator>
+ constexpr void insert(InputIterator first, InputIterator last);
     template<class InputIterator>
+ constexpr void insert(sorted_equivalent_t, InputIterator first, InputIterator last);
     template<container-compatible-range<value_type> R>
+ constexpr void insert_range(R&& rg);
+ constexpr void insert(initializer_list<value_type> il)
       { insert(il.begin(), il.end()); }
+ constexpr void insert(sorted_equivalent_t, initializer_list<value_type> il)
+      { insert(sorted_equivalent, il.begin(), il.end()); }
+ constexpr containers extract() &&;
+ constexpr void replace(key_container_type&& key_cont, mapped_container_type&& mapped_cont);
+ constexpr iterator erase(iterator position);
+ constexpr iterator erase(const_iterator position);
+ constexpr size_type erase(const key_type& x);
+    template<class K> constexpr size_type erase(K&& x);
+ constexpr iterator erase(const_iterator first, const_iterator last);
+ constexpr void swap(flat_multimap&) noexcept;
+ constexpr void clear() noexcept;
     // observers
+ constexpr key_compare key_comp() const;
+ constexpr value_compare value_comp() const;
+ constexpr const key_container_type& keys() const noexcept { return c.keys; }
+ constexpr const mapped_container_type& values() const noexcept { return c.values; }
     // map operations
+ constexpr iterator find(const key_type& x);
+ constexpr const_iterator find(const key_type& x) const;
+    template<class K> constexpr iterator find(const K& x);
+    template<class K> constexpr const_iterator find(const K& x) const;
+ constexpr size_type count(const key_type& x) const;
+    template<class K> constexpr size_type count(const K& x) const;
+ constexpr bool contains(const key_type& x) const;
+    template<class K> constexpr bool contains(const K& x) const;
+ constexpr iterator lower_bound(const key_type& x);
+ constexpr const_iterator lower_bound(const key_type& x) const;
+    template<class K> constexpr iterator lower_bound(const K& x);
+    template<class K> constexpr const_iterator lower_bound(const K& x) const;
+ constexpr iterator upper_bound(const key_type& x);
+ constexpr const_iterator upper_bound(const key_type& x) const;
+    template<class K> constexpr iterator upper_bound(const K& x);
+    template<class K> constexpr const_iterator upper_bound(const K& x) const;
+ constexpr pair<iterator, iterator> equal_range(const key_type& x);
+ constexpr pair<const_iterator, const_iterator> equal_range(const key_type& x) const;
     template<class K>
+ constexpr pair<iterator, iterator> equal_range(const K& x);
     template<class K>
+ constexpr pair<const_iterator, const_iterator> equal_range(const K& x) const;
+    friend constexpr bool operator==(const flat_multimap& x, const flat_multimap& y);
+    friend constexpr synth-three-way-result<value_type>
       operator<=>(const flat_multimap& x, const flat_multimap& y);
+    friend constexpr void swap(flat_multimap& x, flat_multimap& y) noexcept
       { x.swap(y); }
   private:
     containers c;               // exposition only
     key_compare compare;        // exposition only
 specified.
 #### Constructors <a id="flat.multimap.cons">[[flat.multimap.cons]]</a>
 ``` cpp
+constexpr flat_multimap(key_container_type key_cont, mapped_container_type mapped_cont,
                         const key_compare& comp = key_compare());
 ```
+*Effects:* Initializes *`c`*`.keys` with `std::move(key_cont)`,
+*`c`*`.values` with `std::move(mapped_cont)`, and *compare* with `comp`;
+sorts the range \[`begin()`, `end()`) with respect to `value_comp()`.
 *Complexity:* Linear in N if the container arguments are already sorted
 with respect to `value_comp()` and otherwise N log N, where N is the
 value of `key_cont.size()` before this call.
 ``` cpp
+constexpr flat_multimap(sorted_equivalent_t, key_container_type key_cont,
+ mapped_container_type mapped_cont,
+ const key_compare& comp = key_compare());
 ```
+*Effects:* Initializes *`c`*`.keys` with `std::move(key_cont)`,
+*`c`*`.values` with `std::move(mapped_cont)`, and *compare* with `comp`.
+*Complexity:* Constant.
+#### Constructors with allocators <a id="flat.multimap.cons.alloc">[[flat.multimap.cons.alloc]]</a>
+The constructors in this subclause shall not participate in overload
+resolution unless `uses_allocator_v<key_container_type, Alloc>` is
+`true` and `uses_allocator_v<mapped_container_type, Alloc>` is `true`.
+``` cpp
+template<class Alloc>
+  constexpr flat_multimap(const key_container_type& key_cont,
+                          const mapped_container_type& mapped_cont, const Alloc& a);
+template<class Alloc>
+  constexpr flat_multimap(const key_container_type& key_cont,
+                          const mapped_container_type& mapped_cont,
+                          const key_compare& comp, const Alloc& a);
+```
 *Effects:* Equivalent to `flat_multimap(key_cont, mapped_cont)` and
 `flat_multimap(key_cont, mapped_cont, comp)`, respectively, except that
+*`c`*`.keys` and *`c`*`.values` are constructed with uses-allocator
 construction [[allocator.uses.construction]].
 *Complexity:* Same as `flat_multimap(key_cont, mapped_cont)` and
 `flat_multimap(key_cont, mapped_cont, comp)`, respectively.
 ``` cpp
+template<class Alloc>
+  constexpr flat_multimap(sorted_equivalent_t, const key_container_type& key_cont,
+                const mapped_container_type& mapped_cont, const Alloc& a);
+template<class Alloc>
+  constexpr flat_multimap(sorted_equivalent_t, const key_container_type& key_cont,
                 const mapped_container_type& mapped_cont, const key_compare& comp,
+                const Alloc& a);
 ```
+*Effects:* Equivalent to
+`flat_multimap(sorted_equivalent, key_cont, mapped_cont)` and
+`flat_multimap(sorted_equivalent, key_cont, mapped_cont, comp)`,
+respectively, except that *`c`*`.keys` and *`c`*`.values` are
+constructed with uses-allocator
 construction [[allocator.uses.construction]].
 *Complexity:* Linear.
 ``` cpp
+template<class Alloc>
+ constexpr explicit flat_multimap(const Alloc& a);
+template<class Alloc>
+ constexpr flat_multimap(const key_compare& comp, const Alloc& a);
+template<class Alloc>
+ constexpr flat_multimap(const flat_multimap&, const Alloc& a);
+template<class Alloc>
+  constexpr flat_multimap(flat_multimap&&, const Alloc& a);
+template<class InputIterator, class Alloc>
+  constexpr flat_multimap(InputIterator first, InputIterator last, const Alloc& a);
+template<class InputIterator, class Alloc>
+  constexpr flat_multimap(InputIterator first, InputIterator last, const key_compare& comp,
+ const Alloc& a);
+template<class InputIterator, class Alloc>
+ constexpr flat_multimap(sorted_equivalent_t, InputIterator first, InputIterator last,
+ const Alloc& a);
+template<class InputIterator, class Alloc>
+ constexpr flat_multimap(sorted_equivalent_t, InputIterator first, InputIterator last,
+ const key_compare& comp, const Alloc& a);
+template<container-compatible-range<value_type> R, class Alloc>
+ constexpr flat_multimap(from_range_t, R&& rg, const Alloc& a);
+template<container-compatible-range<value_type> R, class Alloc>
+ constexpr flat_multimap(from_range_t, R&& rg, const key_compare& comp, const Alloc& a);
+template<class Alloc>
+ constexpr flat_multimap(initializer_list<value_type> il, const Alloc& a);
+template<class Alloc>
+  constexpr flat_multimap(initializer_list<value_type> il, const key_compare& comp,
+ const Alloc& a);
+template<class Alloc>
+  constexpr flat_multimap(sorted_equivalent_t, initializer_list<value_type> il, const Alloc& a);
+template<class Alloc>
+  constexpr flat_multimap(sorted_equivalent_t, initializer_list<value_type> il,
+                          const key_compare& comp, const Alloc& a);
 ```
 *Effects:* Equivalent to the corresponding non-allocator constructors
+except that *`c`*`.keys` and *`c`*`.values` are constructed with
+uses-allocator construction [[allocator.uses.construction]].
 #### Erasure <a id="flat.multimap.erasure">[[flat.multimap.erasure]]</a>
 ``` cpp
 template<class Key, class T, class Compare, class KeyContainer, class MappedContainer,
          class Predicate>
+ constexpr typename flat_multimap<Key, T, Compare, KeyContainer, MappedContainer>::size_type
     erase_if(flat_multimap<Key, T, Compare, KeyContainer, MappedContainer>& c, Predicate pred);
 ```
 *Preconditions:* `Key` and `T` meet the *Cpp17MoveAssignable*
 requirements.
 state [[defns.valid]].
 [*Note 1*: `c` still meets its invariants, but can be
 empty. — *end note*]
+### Header `<flat_set>` synopsis <a id="flat.set.syn">[[flat.set.syn]]</a>
+``` cpp
+#include <compare>              // see [compare.syn]
+#include <initializer_list>     // see [initializer.list.syn]
+namespace std {
+  // [flat.set], class template flat_set
+  template<class Key, class Compare = less<Key>, class KeyContainer = vector<Key>>
+    class flat_set;
+  struct sorted_unique_t { explicit sorted_unique_t() = default; };
+  inline constexpr sorted_unique_t sorted_unique{};
+  template<class Key, class Compare, class KeyContainer, class Allocator>
+    struct uses_allocator<flat_set<Key, Compare, KeyContainer>, Allocator>;
+  // [flat.set.erasure], erasure for flat_set
+  template<class Key, class Compare, class KeyContainer, class Predicate>
+    constexpr typename flat_set<Key, Compare, KeyContainer>::size_type
+      erase_if(flat_set<Key, Compare, KeyContainer>& c, Predicate pred);
+  // [flat.multiset], class template flat_multiset
+  template<class Key, class Compare = less<Key>, class KeyContainer = vector<Key>>
+    class flat_multiset;
+  struct sorted_equivalent_t { explicit sorted_equivalent_t() = default; };
+  inline constexpr sorted_equivalent_t sorted_equivalent{};
+  template<class Key, class Compare, class KeyContainer, class Allocator>
+    struct uses_allocator<flat_multiset<Key, Compare, KeyContainer>, Allocator>;
+  // [flat.multiset.erasure], erasure for flat_multiset
+  template<class Key, class Compare, class KeyContainer, class Predicate>
+    constexpr typename flat_multiset<Key, Compare, KeyContainer>::size_type
+      erase_if(flat_multiset<Key, Compare, KeyContainer>& c, Predicate pred);
+}
+```
 ### Class template `flat_set` <a id="flat.set">[[flat.set]]</a>
 #### Overview <a id="flat.set.overview">[[flat.set.overview]]</a>
 A `flat_set` is a container adaptor that provides an associative
 [*Note 3*: `vector<bool>` is not a sequence container. — *end note*]
 The program is ill-formed if `Key` is not the same type as
 `KeyContainer::value_type`.
+The effect of calling a member function that takes a `sorted_unique_t`
+argument with a range that is not sorted with respect to `key_comp()`,
+or that contains equal elements, is undefined.
+The types `iterator` and `const_iterator` meet the constexpr iterator
+requirements [[iterator.requirements.general]].
 #### Definition <a id="flat.set.defn">[[flat.set.defn]]</a>
 ``` cpp
 namespace std {
     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                 = KeyContainer::size_type;
+    using difference_type           = KeyContainer::difference_type;
     using iterator                  = implementation-defined  // type of flat_set::iterator;  // see [container.requirements]
     using const_iterator            = implementation-defined  // type of flat_set::const_iterator;  // see [container.requirements]
     using reverse_iterator          = std::reverse_iterator<iterator>;
     using const_reverse_iterator    = std::reverse_iterator<const_iterator>;
     using container_type            = KeyContainer;
     // [flat.set.cons], constructors
+ constexpr flat_set() : flat_set(key_compare()) { }
+ constexpr explicit flat_set(const key_compare& comp)
       : c(), compare(comp) { }
+    constexpr explicit flat_set(container_type cont, const key_compare& comp = key_compare());
+    constexpr flat_set(sorted_unique_t, container_type cont,
+                       const key_compare& comp = key_compare())
+      : c(std::move(cont)), compare(comp) { }
     template<class InputIterator>
+ constexpr flat_set(InputIterator first, InputIterator last,
+                         const key_compare& comp = key_compare())
         : c(), compare(comp)
         { insert(first, last); }
+    template<class InputIterator>
+      constexpr flat_set(sorted_unique_t, InputIterator first, InputIterator last,
+               const key_compare& comp = key_compare())
+        : c(first, last), compare(comp) { }
     template<container-compatible-range<value_type> R>
+ constexpr flat_set(from_range_t, R&& rg)
+        : flat_set(from_range, std::forward<R>(rg), key_compare()) { }
     template<container-compatible-range<value_type> R>
+ constexpr flat_set(from_range_t, R&& rg, const key_compare& comp)
         : flat_set(comp)
         { insert_range(std::forward<R>(rg)); }
+ constexpr flat_set(initializer_list<value_type> il, const key_compare& comp = key_compare())
         : flat_set(il.begin(), il.end(), comp) { }
+ constexpr flat_set(sorted_unique_t, initializer_list<value_type> il,
              const key_compare& comp = key_compare())
+        : flat_set(sorted_unique, il.begin(), il.end(), comp) { }
+ // [flat.set.cons.alloc], constructors with allocators
+    template<class Alloc>
+      constexpr explicit flat_set(const Alloc& a);
+    template<class Alloc>
+      constexpr flat_set(const key_compare& comp, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_set(const container_type& cont, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_set(const container_type& cont, const key_compare& comp, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_set(sorted_unique_t, const container_type& cont, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_set(sorted_unique_t, const container_type& cont,
+                         const key_compare& comp, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_set(const flat_set&, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_set(flat_set&&, const Alloc& a);
+    template<class InputIterator, class Alloc>
+      constexpr flat_set(InputIterator first, InputIterator last, const Alloc& a);
+    template<class InputIterator, class Alloc>
+      constexpr flat_set(InputIterator first, InputIterator last,
+                         const key_compare& comp, const Alloc& a);
+    template<class InputIterator, class Alloc>
+      constexpr flat_set(sorted_unique_t, InputIterator first, InputIterator last,
+                         const Alloc& a);
+    template<class InputIterator, class Alloc>
+      constexpr flat_set(sorted_unique_t, InputIterator first, InputIterator last,
+                         const key_compare& comp, const Alloc& a);
+    template<container-compatible-range<value_type> R, class Alloc>
+      constexpr flat_set(from_range_t, R&& rg, const Alloc& a);
+    template<container-compatible-range<value_type> R, class Alloc>
+      constexpr flat_set(from_range_t, R&& rg, const key_compare& comp, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_set(initializer_list<value_type> il, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_set(initializer_list<value_type> il, const key_compare& comp,
+                         const Alloc& a);
+    template<class Alloc>
+      constexpr flat_set(sorted_unique_t, initializer_list<value_type> il, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_set(sorted_unique_t, initializer_list<value_type> il,
+                         const key_compare& comp, const Alloc& a);
+    constexpr flat_set& operator=(initializer_list<value_type>);
     // iterators
+ constexpr iterator               begin() noexcept;
+ constexpr const_iterator         begin() const noexcept;
+ constexpr iterator               end() noexcept;
+ constexpr const_iterator         end() const noexcept;
+ constexpr reverse_iterator       rbegin() noexcept;
+ constexpr const_reverse_iterator rbegin() const noexcept;
+ constexpr reverse_iterator       rend() noexcept;
+ constexpr const_reverse_iterator rend() const noexcept;
+ constexpr const_iterator         cbegin() const noexcept;
+ constexpr const_iterator         cend() const noexcept;
+ constexpr const_reverse_iterator crbegin() const noexcept;
+ constexpr const_reverse_iterator crend() const noexcept;
     // capacity
+ constexpr bool empty() const noexcept;
+ constexpr size_type size() const noexcept;
+ constexpr size_type max_size() const noexcept;
     // [flat.set.modifiers], modifiers
+    template<class... Args> constexpr pair<iterator, bool> emplace(Args&&... args);
     template<class... Args>
+ constexpr iterator emplace_hint(const_iterator position, Args&&... args);
+ constexpr pair<iterator, bool> insert(const value_type& x)
       { return emplace(x); }
+ constexpr pair<iterator, bool> insert(value_type&& x)
       { return emplace(std::move(x)); }
+    template<class K> constexpr pair<iterator, bool> insert(K&& x);
+ constexpr iterator insert(const_iterator position, const value_type& x)
       { return emplace_hint(position, x); }
+ constexpr iterator insert(const_iterator position, value_type&& x)
       { return emplace_hint(position, std::move(x)); }
+    template<class K> constexpr iterator insert(const_iterator hint, K&& x);
     template<class InputIterator>
+ constexpr void insert(InputIterator first, InputIterator last);
     template<class InputIterator>
+ constexpr void insert(sorted_unique_t, InputIterator first, InputIterator last);
     template<container-compatible-range<value_type> R>
+ constexpr void insert_range(R&& rg);
+ constexpr void insert(initializer_list<value_type> il)
       { insert(il.begin(), il.end()); }
+ constexpr void insert(sorted_unique_t, initializer_list<value_type> il)
+      { insert(sorted_unique, il.begin(), il.end()); }
+ constexpr container_type extract() &&;
+ constexpr void replace(container_type&&);
+ constexpr iterator erase(iterator position);
+ constexpr iterator erase(const_iterator position);
+ constexpr size_type erase(const key_type& x);
+    template<class K> constexpr size_type erase(K&& x);
+ constexpr iterator erase(const_iterator first, const_iterator last);
+ constexpr void swap(flat_set& y) noexcept;
+ constexpr void clear() noexcept;
     // observers
+ constexpr key_compare key_comp() const;
+ constexpr value_compare value_comp() const;
     // set operations
+ constexpr iterator find(const key_type& x);
+ constexpr const_iterator find(const key_type& x) const;
+    template<class K> constexpr iterator find(const K& x);
+    template<class K> constexpr const_iterator find(const K& x) const;
+ constexpr size_type count(const key_type& x) const;
+    template<class K> constexpr size_type count(const K& x) const;
+ constexpr bool contains(const key_type& x) const;
+    template<class K> constexpr bool contains(const K& x) const;
+ constexpr iterator lower_bound(const key_type& x);
+ constexpr const_iterator lower_bound(const key_type& x) const;
+    template<class K> constexpr iterator lower_bound(const K& x);
+    template<class K> constexpr const_iterator lower_bound(const K& x) const;
+ constexpr iterator upper_bound(const key_type& x);
+ constexpr const_iterator upper_bound(const key_type& x) const;
+    template<class K> constexpr iterator upper_bound(const K& x);
+    template<class K> constexpr const_iterator upper_bound(const K& x) const;
+ constexpr pair<iterator, iterator> equal_range(const key_type& x);
+ constexpr pair<const_iterator, const_iterator> equal_range(const key_type& x) const;
     template<class K>
+ constexpr pair<iterator, iterator> equal_range(const K& x);
     template<class K>
+ constexpr pair<const_iterator, const_iterator> equal_range(const K& x) const;
+    friend constexpr bool operator==(const flat_set& x, const flat_set& y);
+    friend constexpr synth-three-way-result<value_type>
       operator<=>(const flat_set& x, const flat_set& y);
+    friend constexpr void swap(flat_set& x, flat_set& y) noexcept { x.swap(y); }
   private:
     container_type c;           // exposition only
     key_compare compare;        // exposition only
   };
 ```
 #### Constructors <a id="flat.set.cons">[[flat.set.cons]]</a>
 ``` cpp
+constexpr explicit flat_set(container_type cont, const key_compare& comp = key_compare());
 ```
 *Effects:* Initializes *c* with `std::move(cont)` and *compare* with
 `comp`, sorts the range \[`begin()`, `end()`) with respect to *compare*,
 and finally erases all but the first element from each group of
 consecutive equivalent elements.
+*Complexity:* Linear in N if `cont` is already sorted with respect to
+*compare* and otherwise N log N, where N is the value of `cont.size()`
+before this call.
+#### Constructors with allocators <a id="flat.set.cons.alloc">[[flat.set.cons.alloc]]</a>
+The constructors in this subclause shall not participate in overload
+resolution unless `uses_allocator_v<container_type, Alloc>` is `true`.
 ``` cpp
+template<class Alloc>
+ constexpr flat_set(const container_type& cont, const Alloc& a);
+template<class Alloc>
+ constexpr flat_set(const container_type& cont, const key_compare& comp, const Alloc& a);
 ```
 *Effects:* Equivalent to `flat_set(cont)` and `flat_set(cont, comp)`,
 respectively, except that *c* is constructed with uses-allocator
 construction [[allocator.uses.construction]].
 *Complexity:* Same as `flat_set(cont)` and `flat_set(cont, comp)`,
 respectively.
 ``` cpp
+template<class Alloc>
+ constexpr flat_set(sorted_unique_t, const container_type& cont, const Alloc& a);
+template<class Alloc>
+ constexpr flat_set(sorted_unique_t, const container_type& cont,
+ const key_compare& comp, const Alloc& a);
 ```
+*Effects:* Equivalent to `flat_set(sorted_unique, cont)` and
+`flat_set(sorted_unique, cont,comp)`, respectively, except that *c* is
+constructed with uses-allocator
+construction [[allocator.uses.construction]].
 *Complexity:* Linear.
 ``` cpp
+template<class Alloc>
+ constexpr explicit flat_set(const Alloc& a);
+template<class Alloc>
+ constexpr flat_set(const key_compare& comp, const Alloc& a);
+template<class Alloc>
+ constexpr flat_set(const flat_set&, const Alloc& a);
+template<class Alloc>
+ constexpr flat_set(flat_set&&, const Alloc& a);
+template<class InputIterator, class Alloc>
+ constexpr flat_set(InputIterator first, InputIterator last, const Alloc& a);
+template<class InputIterator, class Alloc>
+ constexpr flat_set(InputIterator first, InputIterator last, const key_compare& comp,
+                     const Alloc& a);
+template<class InputIterator, class Alloc>
+  constexpr flat_set(sorted_unique_t, InputIterator first, InputIterator last, const Alloc& a);
+template<class InputIterator, class Alloc>
+ constexpr flat_set(sorted_unique_t, InputIterator first, InputIterator last,
+                     const key_compare& comp, const Alloc& a);
+template<container-compatible-range<value_type> R, class Alloc>
+  constexpr flat_set(from_range_t, R&& rg, const Alloc& a);
+template<container-compatible-range<value_type> R, class Alloc>
+  constexpr flat_set(from_range_t, R&& rg, const key_compare& comp, const Alloc& a);
+template<class Alloc>
+  constexpr flat_set(initializer_list<value_type> il, const Alloc& a);
+template<class Alloc>
+ constexpr flat_set(initializer_list<value_type> il, const key_compare& comp, const Alloc& a);
+template<class Alloc>
+  constexpr flat_set(sorted_unique_t, initializer_list<value_type> il, const Alloc& a);
+template<class Alloc>
+  constexpr flat_set(sorted_unique_t, initializer_list<value_type> il,
+                     const key_compare& comp, const Alloc& a);
 ```
 *Effects:* Equivalent to the corresponding non-allocator constructors
 except that *c* is constructed with uses-allocator
 construction [[allocator.uses.construction]].
 #### Modifiers <a id="flat.set.modifiers">[[flat.set.modifiers]]</a>
 ``` cpp
+template<class K> constexpr pair<iterator, bool> insert(K&& x);
+template<class K> constexpr iterator insert(const_iterator hint, K&& x);
 ```
 *Constraints:* The *qualified-id* `Compare::is_transparent` is valid and
 denotes a type. `is_constructible_v<value_type, K>` is `true`.
 *Preconditions:* The conversion from `x` into `value_type` constructs an
+object `u`, for which `find(x) == find(u)` is `true`.
 *Effects:* If the set already contains an element equivalent to `x`,
 `*this` and `x` are unchanged. Otherwise, inserts a new element as if by
 `emplace(std::forward<K>(x))`.
 pair is `true` if and only if the insertion took place. The returned
 iterator points to the element whose key is equivalent to `x`.
 ``` cpp
 template<class InputIterator>
+ constexpr void insert(InputIterator first, InputIterator last);
 ```
 *Effects:* Adds elements to *c* as if by:
 ``` cpp
 *Remarks:* Since this operation performs an in-place merge, it may
 allocate memory.
 ``` cpp
 template<class InputIterator>
+ constexpr void insert(sorted_unique_t, InputIterator first, InputIterator last);
 ```
 *Effects:* Equivalent to `insert(first, last)`.
 *Complexity:* Linear.
 ``` cpp
 template<container-compatible-range<value_type> R>
+ constexpr void insert_range(R&& rg);
 ```
 *Effects:* Adds elements to *c* as if by:
 ``` cpp
 *Remarks:* Since this operation performs an in-place merge, it may
 allocate memory.
 ``` cpp
+constexpr void swap(flat_set& y) noexcept;
 ```
 *Effects:* Equivalent to:
 ``` cpp
 ranges::swap(compare, y.compare);
 ranges::swap(c, y.c);
 ```
 ``` cpp
+constexpr container_type extract() &&;
 ```
 *Ensures:* `*this` is emptied, even if the function exits via an
 exception.
 *Returns:* `std::move(`*`c`*`)`.
 ``` cpp
+constexpr void replace(container_type&& cont);
 ```
 *Preconditions:* The elements of `cont` are sorted with respect to
 *compare*, and `cont` contains no equal elements.
 #### Erasure <a id="flat.set.erasure">[[flat.set.erasure]]</a>
 ``` cpp
 template<class Key, class Compare, class KeyContainer, class Predicate>
+ constexpr typename flat_set<Key, Compare, KeyContainer>::size_type
     erase_if(flat_set<Key, Compare, KeyContainer>& c, Predicate pred);
 ```
 *Preconditions:* `Key` meets the *Cpp17MoveAssignable* requirements.
 [*Note 3*: `vector<bool>` is not a sequence container. — *end note*]
 The program is ill-formed if `Key` is not the same type as
 `KeyContainer::value_type`.
+The effect of calling a member function that takes a
 `sorted_equivalent_t` argument with a range that is not sorted with
 respect to `key_comp()` is undefined.
+The types `iterator` and `const_iterator` meet the constexpr iterator
+requirements [[iterator.requirements.general]].
 #### Definition <a id="flat.multiset.defn">[[flat.multiset.defn]]</a>
 ``` cpp
 namespace std {
   template<class Key, class Compare = less<Key>, class KeyContainer = vector<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                 = KeyContainer::size_type;
+    using difference_type           = KeyContainer::difference_type;
     using iterator                  = implementation-defined  // type of flat_multiset::iterator;  // see [container.requirements]
     using const_iterator            = implementation-defined  // type of flat_multiset::const_iterator;  // see [container.requirements]
     using reverse_iterator          = std::reverse_iterator<iterator>;
     using const_reverse_iterator    = std::reverse_iterator<const_iterator>;
     using container_type            = KeyContainer;
     // [flat.multiset.cons], constructors
+ constexpr flat_multiset() : flat_multiset(key_compare()) { }
+ constexpr explicit flat_multiset(const key_compare& comp)
       : c(), compare(comp) { }
+    constexpr explicit flat_multiset(container_type cont,
+                                     const key_compare& comp = key_compare());
+    constexpr flat_multiset(sorted_equivalent_t, container_type cont,
+                            const key_compare& comp = key_compare())
+      : c(std::move(cont)), compare(comp) { }
     template<class InputIterator>
+ constexpr flat_multiset(InputIterator first, InputIterator last,
                               const key_compare& comp = key_compare())
         : c(), compare(comp)
         { insert(first, last); }
+    template<class InputIterator>
+      constexpr flat_multiset(sorted_equivalent_t, InputIterator first, InputIterator last,
+                              const key_compare& comp = key_compare())
+        : c(first, last), compare(comp) { }
     template<container-compatible-range<value_type> R>
+ constexpr flat_multiset(from_range_t, R&& rg)
+        : flat_multiset(from_range, std::forward<R>(rg), key_compare()) { }
     template<container-compatible-range<value_type> R>
+ constexpr flat_multiset(from_range_t, R&& rg, const key_compare& comp)
         : flat_multiset(comp)
         { insert_range(std::forward<R>(rg)); }
+ constexpr flat_multiset(initializer_list<value_type> il,
                             const key_compare& comp = key_compare())
       : flat_multiset(il.begin(), il.end(), comp) { }
+ constexpr flat_multiset(sorted_equivalent_t, initializer_list<value_type> il,
                             const key_compare& comp = key_compare())
+        : flat_multiset(sorted_equivalent, il.begin(), il.end(), comp) { }
+ // [flat.multiset.cons.alloc], constructors with allocators
+    template<class Alloc>
+      constexpr explicit flat_multiset(const Alloc& a);
+    template<class Alloc>
+      constexpr flat_multiset(const key_compare& comp, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_multiset(const container_type& cont, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_multiset(const container_type& cont, const key_compare& comp,
+                              const Alloc& a);
+    template<class Alloc>
+      constexpr flat_multiset(sorted_equivalent_t, const container_type& cont, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_multiset(sorted_equivalent_t, const container_type& cont,
+                              const key_compare& comp, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_multiset(const flat_multiset&, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_multiset(flat_multiset&&, const Alloc& a);
+    template<class InputIterator, class Alloc>
+      constexpr flat_multiset(InputIterator first, InputIterator last, const Alloc& a);
+    template<class InputIterator, class Alloc>
+      constexpr flat_multiset(InputIterator first, InputIterator last,
+                              const key_compare& comp, const Alloc& a);
+    template<class InputIterator, class Alloc>
+      constexpr flat_multiset(sorted_equivalent_t, InputIterator first, InputIterator last,
+                              const Alloc& a);
+    template<class InputIterator, class Alloc>
+      constexpr flat_multiset(sorted_equivalent_t, InputIterator first, InputIterator last,
+                              const key_compare& comp, const Alloc& a);
+    template<container-compatible-range<value_type> R, class Alloc>
+      constexpr flat_multiset(from_range_t, R&& rg, const Alloc& a);
+    template<container-compatible-range<value_type> R, class Alloc>
+      constexpr flat_multiset(from_range_t, R&& rg, const key_compare& comp, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_multiset(initializer_list<value_type> il, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_multiset(initializer_list<value_type> il, const key_compare& comp,
+                              const Alloc& a);
+    template<class Alloc>
+      constexpr flat_multiset(sorted_equivalent_t, initializer_list<value_type> il,
+                              const Alloc& a);
+    template<class Alloc>
+      constexpr flat_multiset(sorted_equivalent_t, initializer_list<value_type> il,
+                              const key_compare& comp, const Alloc& a);
+    constexpr flat_multiset& operator=(initializer_list<value_type>);
     // iterators
+ constexpr iterator               begin() noexcept;
+ constexpr const_iterator         begin() const noexcept;
+ constexpr iterator               end() noexcept;
+ constexpr const_iterator         end() const noexcept;
+ constexpr reverse_iterator       rbegin() noexcept;
+ constexpr const_reverse_iterator rbegin() const noexcept;
+ constexpr reverse_iterator       rend() noexcept;
+ constexpr const_reverse_iterator rend() const noexcept;
+ constexpr const_iterator         cbegin() const noexcept;
+ constexpr const_iterator         cend() const noexcept;
+ constexpr const_reverse_iterator crbegin() const noexcept;
+ constexpr const_reverse_iterator crend() const noexcept;
     // capacity
+ constexpr bool empty() const noexcept;
+ constexpr size_type size() const noexcept;
+ constexpr size_type max_size() const noexcept;
     // [flat.multiset.modifiers], modifiers
+    template<class... Args> constexpr iterator emplace(Args&&... args);
     template<class... Args>
+ constexpr iterator emplace_hint(const_iterator position, Args&&... args);
+ constexpr iterator insert(const value_type& x)
       { return emplace(x); }
+ constexpr iterator insert(value_type&& x)
       { return emplace(std::move(x)); }
+ constexpr iterator insert(const_iterator position, const value_type& x)
       { return emplace_hint(position, x); }
+ constexpr iterator insert(const_iterator position, value_type&& x)
       { return emplace_hint(position, std::move(x)); }
     template<class InputIterator>
+ constexpr void insert(InputIterator first, InputIterator last);
     template<class InputIterator>
+ constexpr void insert(sorted_equivalent_t, InputIterator first, InputIterator last);
     template<container-compatible-range<value_type> R>
+ constexpr void insert_range(R&& rg);
+ constexpr void insert(initializer_list<value_type> il)
       { insert(il.begin(), il.end()); }
+ constexpr void insert(sorted_equivalent_t, initializer_list<value_type> il)
+      { insert(sorted_equivalent, il.begin(), il.end()); }
+ constexpr container_type extract() &&;
+ constexpr void replace(container_type&&);
+ constexpr iterator erase(iterator position);
+ constexpr iterator erase(const_iterator position);
+ constexpr size_type erase(const key_type& x);
+    template<class K> constexpr size_type erase(K&& x);
+ constexpr iterator erase(const_iterator first, const_iterator last);
+ constexpr void swap(flat_multiset& y) noexcept;
+ constexpr void clear() noexcept;
     // observers
+ constexpr key_compare key_comp() const;
+ constexpr value_compare value_comp() const;
     // set operations
+ constexpr iterator find(const key_type& x);
+ constexpr const_iterator find(const key_type& x) const;
+    template<class K> constexpr iterator find(const K& x);
+    template<class K> constexpr const_iterator find(const K& x) const;
+ constexpr size_type count(const key_type& x) const;
+    template<class K> constexpr size_type count(const K& x) const;
+ constexpr bool contains(const key_type& x) const;
+    template<class K> constexpr bool contains(const K& x) const;
+ constexpr iterator lower_bound(const key_type& x);
+ constexpr const_iterator lower_bound(const key_type& x) const;
+    template<class K> constexpr iterator lower_bound(const K& x);
+    template<class K> constexpr const_iterator lower_bound(const K& x) const;
+ constexpr iterator upper_bound(const key_type& x);
+ constexpr const_iterator upper_bound(const key_type& x) const;
+    template<class K> constexpr iterator upper_bound(const K& x);
+    template<class K> constexpr const_iterator upper_bound(const K& x) const;
+ constexpr pair<iterator, iterator> equal_range(const key_type& x);
+ constexpr pair<const_iterator, const_iterator> equal_range(const key_type& x) const;
     template<class K>
+ constexpr pair<iterator, iterator> equal_range(const K& x);
     template<class K>
+ constexpr pair<const_iterator, const_iterator> equal_range(const K& x) const;
+    friend constexpr bool operator==(const flat_multiset& x, const flat_multiset& y);
+    friend constexpr synth-three-way-result<value_type>
       operator<=>(const flat_multiset& x, const flat_multiset& y);
+    friend constexpr void swap(flat_multiset& x, flat_multiset& y) noexcept
       { x.swap(y); }
   private:
     container_type c;           // exposition only
     key_compare compare;        // exposition only
     flat_multiset(sorted_equivalent_t, KeyContainer, Compare, Allocator)
       -> flat_multiset<typename KeyContainer::value_type, Compare, KeyContainer>;
   template<class InputIterator, class Compare = less<iter-value-type<InputIterator>>>
     flat_multiset(InputIterator, InputIterator, Compare = Compare())
+      -> flat_multiset<iter-value-type<InputIterator>, Compare>;
   template<class InputIterator, class Compare = less<iter-value-type<InputIterator>>>
     flat_multiset(sorted_equivalent_t, InputIterator, InputIterator, Compare = Compare())
+      -> flat_multiset<iter-value-type<InputIterator>, Compare>;
   template<ranges::input_range R, class Compare = less<ranges::range_value_t<R>>,
            class Allocator = allocator<ranges::range_value_t<R>>>
     flat_multiset(from_range_t, R&&, Compare = Compare(), Allocator = Allocator())
       -> flat_multiset<ranges::range_value_t<R>, Compare,
 ```
 #### Constructors <a id="flat.multiset.cons">[[flat.multiset.cons]]</a>
 ``` cpp
+constexpr explicit flat_multiset(container_type cont, const key_compare& comp = key_compare());
 ```
 *Effects:* Initializes *c* with `std::move(cont)` and *compare* with
 `comp`, and sorts the range \[`begin()`, `end()`) with respect to
 *compare*.
+*Complexity:* Linear in N if `cont` is already sorted with respect to
+*compare* and otherwise N log N, where N is the value of `cont.size()`
+before this call.
+#### Constructors with allocators <a id="flat.multiset.cons.alloc">[[flat.multiset.cons.alloc]]</a>
+The constructors in this subclause shall not participate in overload
+resolution unless `uses_allocator_v<container_type, Alloc>` is `true`.
 ``` cpp
+template<class Alloc>
+ constexpr flat_multiset(const container_type& cont, const Alloc& a);
+template<class Alloc>
+ constexpr flat_multiset(const container_type& cont, const key_compare& comp, const Alloc& a);
 ```
 *Effects:* Equivalent to `flat_multiset(cont)` and
 `flat_multiset(cont, comp)`, respectively, except that *c* is
 constructed with uses-allocator
 construction [[allocator.uses.construction]].
 *Complexity:* Same as `flat_multiset(cont)` and
 `flat_multiset(cont, comp)`, respectively.
 ``` cpp
+template<class Alloc>
+ constexpr flat_multiset(sorted_equivalent_t, const container_type& cont, const Alloc& a);
+template<class Alloc>
+ constexpr flat_multiset(sorted_equivalent_t, const container_type& cont,
+ const key_compare& comp, const Alloc& a);
 ```
+*Effects:* Equivalent to `flat_multiset(sorted_equivalent, cont)` and
+`flat_multiset(sorted_equivalent, cont, comp)`, respectively, except
+that *c* is constructed with uses-allocator
 construction [[allocator.uses.construction]].
 *Complexity:* Linear.
 ``` cpp
+template<class Alloc>
+ constexpr explicit flat_multiset(const Alloc& a);
+template<class Alloc>
+ constexpr flat_multiset(const key_compare& comp, const Alloc& a);
+template<class Alloc>
+ constexpr flat_multiset(const flat_multiset&, const Alloc& a);
+template<class Alloc>
+  constexpr flat_multiset(flat_multiset&&, const Alloc& a);
+template<class InputIterator, class Alloc>
+  constexpr flat_multiset(InputIterator first, InputIterator last, const Alloc& a);
+template<class InputIterator, class Alloc>
+  constexpr flat_multiset(InputIterator first, InputIterator last,
+ const key_compare& comp, const Alloc& a);
+template<class InputIterator, class Alloc>
+ constexpr flat_multiset(sorted_equivalent_t, InputIterator first, InputIterator last,
+ const Alloc& a);
+template<class InputIterator, class Alloc>
+ constexpr flat_multiset(sorted_equivalent_t, InputIterator first, InputIterator last,
+                          const key_compare& comp, const Alloc& a);
+template<container-compatible-range<value_type> R, class Alloc>
+  constexpr flat_multiset(from_range_t, R&& rg, const Alloc& a);
+template<container-compatible-range<value_type> R, class Alloc>
+  constexpr flat_multiset(from_range_t, R&& rg, const key_compare& comp, const Alloc& a);
+template<class Alloc>
+  constexpr flat_multiset(initializer_list<value_type> il, const Alloc& a);
+template<class Alloc>
+ constexpr flat_multiset(initializer_list<value_type> il, const key_compare& comp,
+                          const Alloc& a);
+template<class Alloc>
+  constexpr flat_multiset(sorted_equivalent_t, initializer_list<value_type> il, const Alloc& a);
+template<class Alloc>
+  constexpr flat_multiset(sorted_equivalent_t, initializer_list<value_type> il,
+                          const key_compare& comp, const Alloc& a);
 ```
 *Effects:* Equivalent to the corresponding non-allocator constructors
 except that *c* is constructed with uses-allocator
 construction [[allocator.uses.construction]].
 #### Modifiers <a id="flat.multiset.modifiers">[[flat.multiset.modifiers]]</a>
 ``` cpp
+template<class... Args> constexpr iterator emplace(Args&&... args);
 ```
 *Constraints:* `is_constructible_v<value_type, Args...>` is `true`.
 *Effects:* First, initializes an object `t` of type `value_type` with
 *Returns:* An iterator that points to the inserted element.
 ``` cpp
 template<class InputIterator>
+ constexpr void insert(InputIterator first, InputIterator last);
 ```
 *Effects:* Adds elements to *c* as if by:
 ``` cpp
 *Remarks:* Since this operation performs an in-place merge, it may
 allocate memory.
 ``` cpp
 template<class InputIterator>
+ constexpr void insert(sorted_equivalent_t, InputIterator first, InputIterator last);
 ```
 *Effects:* Equivalent to `insert(first, last)`.
 *Complexity:* Linear.
 ``` cpp
+constexpr void swap(flat_multiset& y) noexcept;
 ```
 *Effects:* Equivalent to:
 ``` cpp
 ranges::swap(compare, y.compare);
 ranges::swap(c, y.c);
 ```
 ``` cpp
+constexpr container_type extract() &&;
 ```
 *Ensures:* `*this` is emptied, even if the function exits via an
 exception.
+*Returns:* `std::move(`*`c`*`)`.
 ``` cpp
+constexpr void replace(container_type&& cont);
 ```
 *Preconditions:* The elements of `cont` are sorted with respect to
 *compare*.
+*Effects:* Equivalent to: *`c`*` = std::move(cont);`
 #### Erasure <a id="flat.multiset.erasure">[[flat.multiset.erasure]]</a>
 ``` cpp
 template<class Key, class Compare, class KeyContainer, class Predicate>
+ constexpr typename flat_multiset<Key, Compare, KeyContainer>::size_type
     erase_if(flat_multiset<Key, Compare, KeyContainer>& c, Predicate pred);
 ```
 *Preconditions:* `Key` meets the *Cpp17MoveAssignable* requirements.

Diff to HTML by rtfpessoa