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

Files changed (1) hide show

tmp/tmpqe4kvbl3/{from.md → to.md} +2971 -29

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

@@ -1,46 +1,94 @@
 ## Container adaptors <a id="container.adaptors">[[container.adaptors]]</a>
 ### In general <a id="container.adaptors.general">[[container.adaptors.general]]</a>
-The headers `<queue>` and `<stack>` define the container adaptors
-`queue`, `priority_queue`, and `stack`.
-The container adaptors each take a `Container` template parameter, and
-each constructor takes a `Container` reference argument. This container
-is copied into the `Container` member of each adaptor. If the container
-takes an allocator, then a compatible allocator may be passed in to the
-adaptor’s constructor. Otherwise, normal copy or move construction is
-used for the container argument. The first template parameter `T` of the
-container adaptors shall denote the same type as
-`Container::value_type`.
 For container adaptors, no `swap` function throws an exception unless
-that exception is thrown by the swap of the adaptor’s `Container` or
-`Compare` object (if any).
 A deduction guide for a container adaptor shall not participate in
 overload resolution if any of the following are true:
 - It has an `InputIterator` template parameter and a type that does not
   qualify as an input iterator is deduced for that parameter.
 - It has a `Compare` template parameter and a type that qualifies as an
   allocator is deduced for that parameter.
-- It has a `Container` template parameter and a type that qualifies as
-  an allocator is deduced for that parameter.
-- It has an `Allocator` template parameter and a type that does not
-  qualify as an allocator is deduced for that parameter.
 - It has both `Container` and `Allocator` template parameters, and
   `uses_allocator_v<Container, Allocator>` is `false`.
 ### Header `<queue>` synopsis <a id="queue.syn">[[queue.syn]]</a>
 ``` cpp
 #include <compare>              // see [compare.syn]
 #include <initializer_list>     // see [initializer.list.syn]
 namespace std {
   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>
@@ -60,10 +108,11 @@ namespace std {
   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>;
   template<class T, class Container = vector<T>,
            class Compare = less<typename Container::value_type>>
     class priority_queue;
   template<class T, class Container, class Compare>
@@ -79,10 +128,11 @@ namespace std {
 ``` cpp
 #include <compare>              // see [compare.syn]
 #include <initializer_list>     // see [initializer.list.syn]
 namespace std {
   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>
@@ -104,10 +154,96 @@ namespace std {
   template<class T, class Container, class Alloc>
     struct uses_allocator<stack<T, Container>, Alloc>;
 }
 ```
 ### Class template `queue` <a id="queue">[[queue]]</a>
 #### Definition <a id="queue.defn">[[queue.defn]]</a>
 Any sequence container supporting operations `front()`, `back()`,
@@ -130,24 +266,31 @@ namespace std {
   public:
     queue() : queue(Container()) {}
     explicit queue(const Container&);
     explicit queue(Container&&);
     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&);
     [[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<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>)
@@ -155,15 +298,27 @@ namespace std {
   };
   template<class Container>
     queue(Container) -> queue<typename Container::value_type, Container>;
   template<class Container, class Allocator>
     queue(Container, Allocator) -> queue<typename Container::value_type, Container>;
-  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>
       : uses_allocator<Container, Alloc>::type { };
 }
@@ -181,10 +336,26 @@ explicit queue(const Container& cont);
 explicit queue(Container&& cont);
 ```
 *Effects:* Initializes `c` with `std::move(cont)`.
 #### Constructors with allocators <a id="queue.cons.alloc">[[queue.cons.alloc]]</a>
 If `uses_allocator_v<container_type, Alloc>` is `false` the constructors
 in this subclause shall not participate in overload resolution.
@@ -220,10 +391,36 @@ 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.
 #### 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);
@@ -318,28 +515,47 @@ namespace std {
   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,
                      const Container&);
     template<class InputIterator>
-      priority_queue(InputIterator first, InputIterator last,
- const Compare& x = Compare(), Container&& = Container());
     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&);
     [[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<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); }
@@ -348,25 +564,49 @@ namespace std {
   template<class Compare, class Container>
     priority_queue(Compare, Container)
       -> priority_queue<typename Container::value_type, Container, Compare>;
   template<class InputIterator,
-           class Compare = less<typename iterator_traits<InputIterator>::value_type>,
-           class Container = vector<typename iterator_traits<InputIterator>::value_type>>
     priority_queue(InputIterator, InputIterator, Compare = Compare(), Container = Container())
-      -> priority_queue<typename iterator_traits<InputIterator>::value_type, Container, Compare>;
   template<class Compare, class Container, class Allocator>
     priority_queue(Compare, Container, Allocator)
       -> priority_queue<typename Container::value_type, Container, Compare>;
   // no equality is provided
-  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>
       : uses_allocator<Container, Alloc>::type { };
 }
 ```
@@ -382,25 +622,46 @@ priority_queue(const Compare& x, Container&& y);
 *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, const Container& y);
 template<class InputIterator>
-  priority_queue(InputIterator first, InputIterator last, const Compare& x = Compare(),
-                 Container&& y = Container());
 ```
 *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
 `c.insert(c.end(), first, last)`; and finally calls
 `make_heap(c.begin(), c.end(), comp)`.
 #### Constructors with allocators <a id="priqueue.cons.alloc">[[priqueue.cons.alloc]]</a>
 If `uses_allocator_v<container_type, Alloc>` is `false` the constructors
 in this subclause shall not participate in overload resolution.
@@ -448,10 +709,68 @@ 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)`.
 #### Members <a id="priqueue.members">[[priqueue.members]]</a>
 ``` cpp
 void push(const value_type& x);
 ```
@@ -472,10 +791,22 @@ void push(value_type&& x);
 ``` cpp
 c.push_back(std::move(x));
 push_heap(c.begin(), c.end(), comp);
 ```
 ``` cpp
 template<class... Args> void emplace(Args&&... args);
 ```
 *Effects:* As if by:
@@ -509,10 +840,12 @@ template<class T, class Container, class Compare>
 *Effects:* As if by `x.swap(y)`.
 ### Class template `stack` <a id="stack">[[stack]]</a>
 Any sequence container supporting operations `back()`, `push_back()` and
 `pop_back()` can be used to instantiate `stack`. In particular, `vector`
 [[vector]], `list` [[list]] and `deque` [[deque]] can be used.
 #### Definition <a id="stack.defn">[[stack.defn]]</a>
@@ -533,22 +866,30 @@ namespace std {
   public:
     stack() : stack(Container()) {}
     explicit stack(const Container&);
     explicit stack(Container&&);
     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&);
     [[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<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>)
@@ -556,13 +897,28 @@ namespace std {
   };
   template<class Container>
     stack(Container) -> stack<typename Container::value_type, Container>;
   template<class Container, class Allocator>
     stack(Container, Allocator) -> stack<typename Container::value_type, Container>;
   template<class T, class Container, class Alloc>
     struct uses_allocator<stack<T, Container>, Alloc>
       : uses_allocator<Container, Alloc>::type { };
 }
 ```
@@ -579,10 +935,26 @@ explicit stack(const Container& cont);
 explicit stack(Container&& cont);
 ```
 *Effects:* Initializes `c` with `std::move(cont)`.
 #### Constructors with allocators <a id="stack.cons.alloc">[[stack.cons.alloc]]</a>
 If `uses_allocator_v<container_type, Alloc>` is `false` the constructors
 in this subclause shall not participate in overload resolution.
@@ -618,10 +990,36 @@ 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.
 #### 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);
@@ -681,5 +1079,2549 @@ template<class T, class Container>
 *Constraints:* `is_swappable_v<Container>` is `true`.
 *Effects:* As if by `x.swap(y)`.

 ## 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.
+Each container adaptor takes one or more template parameters named
+`Container`, `KeyContainer`, or `MappedContainer` that denote the types
+of containers that the container adaptor adapts. Each container adaptor
+has at least one constructor that takes a reference argument to one or
+more such template parameters. For each constructor reference argument
+to a container `C`, the constructor copies the container into the
+container adaptor. If `C` takes an allocator, then a compatible
+allocator may be passed in to the adaptor’s constructor. Otherwise,
+normal copy or move construction is used for the container argument. For
+the container adaptors that take a single container template parameter
+`Container`, the first template parameter `T` of the container adaptor
+shall denote the same type as `Container::value_type`.
 For container adaptors, no `swap` function throws an exception unless
+that exception is thrown by the swap of the adaptor’s `Container`,
+`KeyContainer`, `MappedContainer`, or `Compare` object (if any).
+A constructor template of a container adaptor shall not participate in
+overload resolution if it has an `InputIterator` template parameter and
+a type that does not qualify as an input iterator is deduced for that
+parameter.
+For container adaptors that have them, the `insert`, `emplace`, and
+`erase` members affect the validity of iterators, references, and
+pointers to the adaptor’s container(s) in the same way that the
+containers’ respective `insert`, `emplace`, and `erase` members do.
+[*Example 1*: A call to `flat_map<Key, T>::insert` can invalidate all
+iterators to the `flat_map`. — *end example*]
 A deduction guide for a container adaptor shall not participate in
 overload resolution if any of the following are true:
 - It has an `InputIterator` template parameter and a type that does not
   qualify as an input iterator is deduced for that parameter.
 - It has a `Compare` template parameter and a type that qualifies as an
   allocator is deduced for that parameter.
+- It has a `Container`, `KeyContainer`, or `MappedContainer` template
+ parameter and a type that qualifies as an allocator is deduced for
+ that parameter.
+- It has no `Container`, `KeyContainer`, or `MappedContainer` template
+  parameter, and it has an `Allocator` template parameter, and a type
+  that does not qualify as an allocator is deduced for that parameter.
 - It has both `Container` and `Allocator` template parameters, and
   `uses_allocator_v<Container, Allocator>` is `false`.
+- It has both `KeyContainer` and `Allocator` template parameters, and
+  `uses_allocator_v<KeyContainer, Allocator>` is `false`.
+- It has both `KeyContainer` and `Compare` template parameters, and
+  ``` cpp
+  is_invocable_v<const Compare&,
+                const typename KeyContainer::value_type&,
+                const typename KeyContainer::value_type&>
+  ```
+  is not a valid expression or is `false`.
+- It has both `MappedContainer` and `Allocator` template parameters, and
+  `uses_allocator_v<MappedContainer, Allocator>` is `false`.
+The exposition-only alias template *`iter-value-type`* defined in
+[[sequences.general]] and the exposition-only alias templates
+*`iter-key-type`*, *`iter-mapped-type`*, *`range-key-type`*, and
+*`range-mapped-type`* defined in [[associative.general]] may appear in
+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
 #include <compare>              // see [compare.syn]
 #include <initializer_list>     // see [initializer.list.syn]
 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>
   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>
 ``` 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>
   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>
 #### Definition <a id="queue.defn">[[queue.defn]]</a>
 Any sequence container supporting operations `front()`, `back()`,
   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>)
   };
   template<class Container>
     queue(Container) -> queue<typename Container::value_type, Container>;
+  template<class InputIterator>
+    queue(InputIterator, InputIterator) -> queue<iter-value-type<InputIterator>>;
+  template<ranges::input_range R>
+    queue(from_range_t, R&&) -> queue<ranges::range_value_t<R>>;
   template<class Container, class Allocator>
     queue(Container, Allocator) -> queue<typename Container::value_type, Container>;
+  template<class InputIterator, class Allocator>
+    queue(InputIterator, InputIterator, Allocator)
+      -> queue<iter-value-type<InputIterator>, deque<iter-value-type<InputIterator>,
+               Allocator>>;
+  template<ranges::input_range R, class Allocator>
+    queue(from_range_t, R&&, Allocator)
+      -> queue<ranges::range_value_t<R>, deque<ranges::range_value_t<R>, Allocator>>;
   template<class T, class Container, class Alloc>
     struct uses_allocator<queue<T, Container>, Alloc>
       : uses_allocator<Container, Alloc>::type { };
 }
 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))`.
 #### Constructors with allocators <a id="queue.cons.alloc">[[queue.cons.alloc]]</a>
 If `uses_allocator_v<container_type, Alloc>` is `false` the constructors
 in this subclause shall not participate in overload resolution.
 ```
 *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);
   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)
       -> priority_queue<typename Container::value_type, Container, Compare>;
   template<class InputIterator,
+           class Compare = less<iter-value-type<InputIterator>>,
+           class Container = vector<iter-value-type<InputIterator>>>
     priority_queue(InputIterator, InputIterator, Compare = Compare(), Container = Container())
+      -> priority_queue<iter-value-type<InputIterator>, Container, Compare>;
+  template<ranges::input_range R, class Compare = less<ranges::range_value_t<R>>>
+    priority_queue(from_range_t, R&&, Compare = Compare())
+      -> priority_queue<ranges::range_value_t<R>, vector<ranges::range_value_t<R>>, Compare>;
   template<class Compare, class Container, class Allocator>
     priority_queue(Compare, Container, Allocator)
       -> priority_queue<typename Container::value_type, Container, Compare>;
+  template<class InputIterator, class Allocator>
+    priority_queue(InputIterator, InputIterator, Allocator)
+      -> priority_queue<iter-value-type<InputIterator>,
+                        vector<iter-value-type<InputIterator>, Allocator>,
+                        less<iter-value-type<InputIterator>>>;
+  template<class InputIterator, class Compare, class Allocator>
+    priority_queue(InputIterator, InputIterator, Compare, Allocator)
+      -> priority_queue<iter-value-type<InputIterator>,
+                        vector<iter-value-type<InputIterator>, Allocator>, Compare>;
+  template<class InputIterator, class Compare, class Container, class Allocator>
+    priority_queue(InputIterator, InputIterator, Compare, Container, Allocator)
+      -> priority_queue<typename Container::value_type, Container, Compare>;
+  template<ranges::input_range R, class Compare, class Allocator>
+    priority_queue(from_range_t, R&&, Compare, Allocator)
+      -> priority_queue<ranges::range_value_t<R>, vector<ranges::range_value_t<R>, Allocator>,
+                        Compare>;
+  template<ranges::input_range R, class Allocator>
+    priority_queue(from_range_t, R&&, Allocator)
+      -> priority_queue<ranges::range_value_t<R>, vector<ranges::range_value_t<R>, Allocator>>;
   // no equality is provided
   template<class T, class Container, class Compare, class Alloc>
     struct uses_allocator<priority_queue<T, Container, Compare>, Alloc>
       : uses_allocator<Container, Alloc>::type { };
 }
 ```
 *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
 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
+`ranges::to<Container>(std::forward<R>(rg))` and finally calls
+`make_heap(c.begin(), c.end(), comp)`.
 #### Constructors with allocators <a id="priqueue.cons.alloc">[[priqueue.cons.alloc]]</a>
 If `uses_allocator_v<container_type, Alloc>` is `false` the constructors
 in this subclause shall not participate in overload resolution.
 *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);
 ```
 ``` cpp
 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:
 *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
 `pop_back()` can be used to instantiate `stack`. In particular, `vector`
 [[vector]], `list` [[list]] and `deque` [[deque]] can be used.
 #### Definition <a id="stack.defn">[[stack.defn]]</a>
   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>)
   };
   template<class Container>
     stack(Container) -> stack<typename Container::value_type, Container>;
+  template<class InputIterator>
+    stack(InputIterator, InputIterator) -> stack<iter-value-type<InputIterator>>;
+  template<ranges::input_range R>
+    stack(from_range_t, R&&) -> stack<ranges::range_value_t<R>>;
   template<class Container, class Allocator>
     stack(Container, Allocator) -> stack<typename Container::value_type, Container>;
+  template<class InputIterator, class Allocator>
+    stack(InputIterator, InputIterator, Allocator)
+      -> stack<iter-value-type<InputIterator>, deque<iter-value-type<InputIterator>,
+               Allocator>>;
+  template<ranges::input_range R, class Allocator>
+    stack(from_range_t, R&&, Allocator)
+      -> stack<ranges::range_value_t<R>, deque<ranges::range_value_t<R>, Allocator>>;
   template<class T, class Container, class Alloc>
     struct uses_allocator<stack<T, Container>, Alloc>
       : uses_allocator<Container, Alloc>::type { };
 }
 ```
 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))`.
 #### Constructors with allocators <a id="stack.cons.alloc">[[stack.cons.alloc]]</a>
 If `uses_allocator_v<container_type, Alloc>` is `false` the constructors
 in this subclause shall not participate in overload resolution.
 ```
 *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);
 *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
+container interface that supports unique keys (i.e., contains at most
+one of each key value) and provides for fast retrieval of values of
+another type `T` based on the keys. `flat_map` supports iterators that
+meet the *Cpp17InputIterator* requirements and model the
+`random_access_iterator` concept [[iterator.concept.random.access]].
+A `flat_map` meets all of the requirements of a container
+[[container.reqmts]] and of a reversible container
+[[container.rev.reqmts]], plus the optional container requirements
+[[container.opt.reqmts]]. `flat_map` meets the requirements of an
+associative container [[associative.reqmts]], except that:
+- it does not meet the requirements related to node handles
+  [[container.node]],
+- it does not meet the requirements related to iterator invalidation,
+  and
+- the time complexity of the operations that insert or erase a single
+  element from the map is linear, including the ones that take an
+  insertion position iterator.
+[*Note 1*: A `flat_map` does not meet the additional requirements of an
+allocator-aware container [[container.alloc.reqmts]]. — *end note*]
+A `flat_map` also provides most operations described in
+[[associative.reqmts]] for unique keys. This means that a `flat_map`
+supports the `a_uniq` operations in [[associative.reqmts]] but not the
+`a_eq` operations. For a `flat_map<Key, T>` the `key_type` is `Key` and
+the `value_type` is `pair<Key, T>`.
+Descriptions are provided here only for operations on `flat_map` that
+are not described in one of those sets of requirements or for operations
+where there is additional semantic information.
+A `flat_map` maintains the following invariants:
+- it contains the same number of keys and values;
+- the keys are sorted with respect to the comparison object; and
+- the value at offset `off` within the value container is the value
+  associated with the key at offset `off` within the key container.
+If any member function in [[flat.map.defn]] exits via an exception the
+invariants are restored.
+[*Note 2*: This can result in the `flat_map` being
+emptied. — *end note*]
+Any type `C` that meets the sequence container requirements
+[[sequence.reqmts]] can be used to instantiate `flat_map`, as long as
+`C::iterator` meets the *Cpp17RandomAccessIterator* requirements and
+invocations of member functions `C::size` and `C::max_size` do not exit
+via an exception. 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` or `T` is not the same type as
+`MappedContainer::value_type`.
+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 {
+  template<class Key, class T, class Compare = less<Key>,
+           class KeyContainer = vector<Key>, class MappedContainer = vector<T>>
+  class flat_map {
+  public:
+    // types
+    using key_type               = Key;
+    using mapped_type            = T;
+    using value_type             = pair<key_type, mapped_type>;
+    using key_compare            = Compare;
+    using reference              = pair<const key_type&, mapped_type&>;
+    using const_reference        = pair<const key_type&, const mapped_type&>;
+    using size_type              = size_t;
+    using difference_type        = ptrdiff_t;
+    using iterator               = implementation-defined  // type of flat_map::iterator; // see [container.requirements]
+    using const_iterator         = implementation-defined  // type of flat_map::const_iterator; // see [container.requirements]
+    using reverse_iterator       = std::reverse_iterator<iterator>;
+    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+    using key_container_type     = KeyContainer;
+    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;
+    };
+  };
+  template<class KeyContainer, class MappedContainer,
+           class Compare = less<typename KeyContainer::value_type>>
+    flat_map(KeyContainer, MappedContainer, Compare = Compare())
+      -> flat_map<typename KeyContainer::value_type, typename MappedContainer::value_type,
+                  Compare, KeyContainer, MappedContainer>;
+  template<class KeyContainer, class MappedContainer, class Allocator>
+    flat_map(KeyContainer, MappedContainer, Allocator)
+      -> flat_map<typename KeyContainer::value_type, typename MappedContainer::value_type,
+                  less<typename KeyContainer::value_type>, KeyContainer, MappedContainer>;
+  template<class KeyContainer, class MappedContainer, class Compare, class Allocator>
+    flat_map(KeyContainer, MappedContainer, Compare, Allocator)
+      -> flat_map<typename KeyContainer::value_type, typename MappedContainer::value_type,
+                  Compare, KeyContainer, MappedContainer>;
+  template<class KeyContainer, class MappedContainer,
+           class Compare = less<typename KeyContainer::value_type>>
+    flat_map(sorted_unique_t, KeyContainer, MappedContainer, Compare = Compare())
+      -> flat_map<typename KeyContainer::value_type, typename MappedContainer::value_type,
+                  Compare, KeyContainer, MappedContainer>;
+  template<class KeyContainer, class MappedContainer, class Allocator>
+    flat_map(sorted_unique_t, KeyContainer, MappedContainer, Allocator)
+      -> flat_map<typename KeyContainer::value_type, typename MappedContainer::value_type,
+                  less<typename KeyContainer::value_type>, KeyContainer, MappedContainer>;
+  template<class KeyContainer, class MappedContainer, class Compare, class Allocator>
+    flat_map(sorted_unique_t, KeyContainer, MappedContainer, Compare, Allocator)
+      -> flat_map<typename KeyContainer::value_type, typename MappedContainer::value_type,
+                  Compare, KeyContainer, MappedContainer>;
+  template<class InputIterator, class Compare = less<iter-key-type<InputIterator>>>
+    flat_map(InputIterator, InputIterator, Compare = Compare())
+      -> flat_map<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>, Compare>;
+  template<class InputIterator, class Compare = less<iter-key-type<InputIterator>>>
+    flat_map(sorted_unique_t, InputIterator, InputIterator, Compare = Compare())
+      -> flat_map<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>, Compare>;
+  template<ranges::input_range R, class Compare = less<range-key-type<R>>,
+           class Allocator = allocator<byte>>
+    flat_map(from_range_t, R&&, Compare = Compare(), Allocator = Allocator())
+      -> flat_map<range-key-type<R>, range-mapped-type<R>, Compare,
+                  vector<range-key-type<R>, alloc-rebind<Allocator, range-key-type<R>>>,
+                  vector<range-mapped-type<R>, alloc-rebind<Allocator, range-mapped-type<R>>>>;
+  template<ranges::input_range R, class Allocator>
+    flat_map(from_range_t, R&&, Allocator)
+      -> flat_map<range-key-type<R>, range-mapped-type<R>, less<range-key-type<R>>,
+                  vector<range-key-type<R>, alloc-rebind<Allocator, range-key-type<R>>>,
+                  vector<range-mapped-type<R>, alloc-rebind<Allocator, range-mapped-type<R>>>>;
+  template<class Key, class T, class Compare = less<Key>>
+    flat_map(initializer_list<pair<Key, T>>, Compare = Compare())
+      -> flat_map<Key, T, Compare>;
+  template<class Key, class T, class Compare = less<Key>>
+    flat_map(sorted_unique_t, initializer_list<pair<Key, T>>, Compare = Compare())
+        -> flat_map<Key, T, Compare>;
+  template<class Key, class T, class Compare, class KeyContainer, class MappedContainer,
+            class Allocator>
+    struct uses_allocator<flat_map<Key, T, Compare, KeyContainer, MappedContainer>, Allocator>
+      : bool_constant<uses_allocator_v<KeyContainer, Allocator> &&
+                      uses_allocator_v<MappedContainer, Allocator>> { };
+}
+```
+The member type `containers` has the data members and special members
+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`.
+*Throws:* An exception object of type `out_of_range` if no such element
+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.
+*Preconditions:* The expression `find(x)` is well-formed and has
+well-defined behavior.
+*Returns:* A reference to the `mapped_type` corresponding to `x` in
+`*this`.
+*Throws:* An exception object of type `out_of_range` if no such element
+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`.
+*Effects:* Initializes an object `t` of type
+`pair<key_type, mapped_type>` with `std::forward<Args>(args)...`; if the
+map already contains an element whose key is equivalent to `t.first`,
+`*this` is unchanged. Otherwise, equivalent to:
+``` cpp
+auto key_it = ranges::upper_bound(c.keys, t.first, compare);
+auto value_it = c.values.begin() + distance(c.keys.begin(), key_it);
+c.keys.insert(key_it, std::move(t.first));
+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`.
+*Effects:* The first form is equivalent to
+`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));
+  c.values.insert(c.values.end(), std::move(value.second));
+}
+```
+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());
+```
+*Complexity:* N + M log M, where N is `size()` before the operation and
+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);
+}
+```
+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());
+```
+*Complexity:* N + M log M, where N is `size()` before the operation and
+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
+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.insert(key_it, std::forward<decltype(k)>(k));
+c.values.emplace(value_it, std::forward<Args>(args)...);
+```
+*Returns:* In the first two overloads, the `bool` component of the
+returned 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` 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
+  type.
+- `is_constructible_v<key_type, K>` is `true`.
+- `is_constructible_v<mapped_type, Args...>` is `true`.
+- For the first overload, `is_convertible_v<K&&, const_iterator>` and
+  `is_convertible_v<K&&, iterator>` are both `false`.
+*Preconditions:* The conversion from `k` into `key_type` constructs an
+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)...);
+```
+*Returns:* In the first overload, the `bool` component of the returned
+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
+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`.
+*Effects:* If the map already contains an element `e` whose key is
+equivalent to `k`, assigns `std::forward<M>(obj)` to `e.second`.
+Otherwise, equivalent to
+``` cpp
+try_emplace(std::forward<decltype(k)>(k), std::forward<M>(obj))
+```
+for the first two overloads or
+``` cpp
+try_emplace(hint, std::forward<decltype(k)>(k), std::forward<M>(obj))
+```
+for the last two overloads.
+*Returns:* In the first two overloads, the `bool` component of the
+returned 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` 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
+  type.
+- `is_constructible_v<key_type, K>` is `true`.
+- `is_assignable_v<mapped_type&, M>` is `true`.
+- `is_constructible_v<mapped_type, M>` is `true`.
+*Preconditions:* The conversion from `k` into `key_type` constructs an
+object `u`, for which `find(k) == find(u)` is `true`.
+*Effects:* If the map already contains an element `e` whose key is
+equivalent to `k`, assigns `std::forward<M>(obj)` to `e.second`.
+Otherwise, equivalent to
+``` cpp
+try_emplace(std::forward<K>(k), std::forward<M>(obj))
+```
+for the first overload or
+``` cpp
+try_emplace(hint, std::forward<K>(k), std::forward<M>(obj))
+```
+for the second overload.
+*Returns:* In the first overload, the `bool` component of the returned
+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
+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
+c.keys = std::move(key_cont);
+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.
+*Effects:* Let E be `bool(pred(pair<const Key&, const T&>(e)))`. Erases
+all elements `e` in `c` for which E holds.
+*Returns:* The number of elements erased.
+*Complexity:* Exactly `c.size()` applications of the predicate.
+*Remarks:* Stable [[algorithm.stable]]. If an invocation of `erase_if`
+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_multimap` <a id="flat.multimap">[[flat.multimap]]</a>
+#### Overview <a id="flat.multimap.overview">[[flat.multimap.overview]]</a>
+A `flat_multimap` is a container adaptor that provides an associative
+container interface that supports equivalent keys (i.e., possibly
+containing multiple copies of the same key value) and provides for fast
+retrieval of values of another type `T` based on the keys.
+`flat_multimap` supports iterators that meet the *Cpp17InputIterator*
+requirements and model the `random_access_iterator` concept
+[[iterator.concept.random.access]].
+A `flat_multimap` meets all of the requirements for a container
+[[container.reqmts]] and for a reversible container
+[[container.rev.reqmts]], plus the optional container requirements
+[[container.opt.reqmts]]. `flat_multimap` meets the requirements of an
+associative container [[associative.reqmts]], except that:
+- it does not meet the requirements related to node handles
+  [[container.node]],
+- it does not meet the requirements related to iterator invalidation,
+  and
+- the time complexity of the operations that insert or erase a single
+  element from the map is linear, including the ones that take an
+  insertion position iterator.
+[*Note 1*: A `flat_multimap` does not meet the additional requirements
+of an allocator-aware container
+[[container.alloc.reqmts]]. — *end note*]
+A `flat_multimap` also provides most operations described in
+[[associative.reqmts]] for equal keys. This means that a `flat_multimap`
+supports the `a_eq` operations in [[associative.reqmts]] but not the
+`a_uniq` operations. For a `flat_multimap<Key, T>` the `key_type` is
+`Key` and the `value_type` is `pair<Key, T>`.
+Except as otherwise noted, operations on `flat_multimap` are equivalent
+to those of `flat_map`, except that `flat_multimap` operations do not
+remove or replace elements with equal keys.
+[*Example 1*: `flat_multimap` constructors and emplace do not erase
+non-unique elements after sorting them. — *end example*]
+A `flat_multimap` maintains the following invariants:
+- it contains the same number of keys and values;
+- the keys are sorted with respect to the comparison object; and
+- the value at offset `off` within the value container is the value
+  associated with the key at offset `off` within the key container.
+If any member function in [[flat.multimap.defn]] exits via an exception,
+the invariants are restored.
+[*Note 2*: This can result in the `flat_multimap` being
+emptied. — *end note*]
+Any type `C` that meets the sequence container requirements
+[[sequence.reqmts]] can be used to instantiate `flat_multimap`, as long
+as `C::iterator` meets the *Cpp17RandomAccessIterator* requirements and
+invocations of member functions `C::size` and `C::max_size` do not exit
+via an exception. 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` or `T` is not the same type as
+`MappedContainer::value_type`.
+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>,
+           class KeyContainer = vector<Key>, class MappedContainer = vector<T>>
+  class flat_multimap {
+  public:
+    // types
+    using key_type               = Key;
+    using mapped_type            = T;
+    using value_type             = pair<key_type, mapped_type>;
+    using key_compare            = Compare;
+    using reference              = pair<const key_type&, mapped_type&>;
+    using const_reference        = pair<const key_type&, const mapped_type&>;
+    using size_type              = size_t;
+    using difference_type        = ptrdiff_t;
+    using iterator               = implementation-defined  // type of flat_multimap::iterator;     // see [container.requirements]
+    using const_iterator         = implementation-defined  // type of flat_multimap::const_iterator;     // see [container.requirements]
+    using reverse_iterator       = std::reverse_iterator<iterator>;
+    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+    using key_container_type     = KeyContainer;
+    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
+  };
+  template<class KeyContainer, class MappedContainer,
+           class Compare = less<typename KeyContainer::value_type>>
+    flat_multimap(KeyContainer, MappedContainer, Compare = Compare())
+      -> flat_multimap<typename KeyContainer::value_type, typename MappedContainer::value_type,
+                       Compare, KeyContainer, MappedContainer>;
+  template<class KeyContainer, class MappedContainer, class Allocator>
+    flat_multimap(KeyContainer, MappedContainer, Allocator)
+      -> flat_multimap<typename KeyContainer::value_type, typename MappedContainer::value_type,
+                       less<typename KeyContainer::value_type>, KeyContainer, MappedContainer>;
+  template<class KeyContainer, class MappedContainer, class Compare, class Allocator>
+    flat_multimap(KeyContainer, MappedContainer, Compare, Allocator)
+      -> flat_multimap<typename KeyContainer::value_type, typename MappedContainer::value_type,
+                       Compare, KeyContainer, MappedContainer>;
+  template<class KeyContainer, class MappedContainer,
+           class Compare = less<typename KeyContainer::value_type>>
+    flat_multimap(sorted_equivalent_t, KeyContainer, MappedContainer, Compare = Compare())
+      -> flat_multimap<typename KeyContainer::value_type, typename MappedContainer::value_type,
+                       Compare, KeyContainer, MappedContainer>;
+  template<class KeyContainer, class MappedContainer, class Allocator>
+    flat_multimap(sorted_equivalent_t, KeyContainer, MappedContainer, Allocator)
+      -> flat_multimap<typename KeyContainer::value_type, typename MappedContainer::value_type,
+                       less<typename KeyContainer::value_type>, KeyContainer, MappedContainer>;
+  template<class KeyContainer, class MappedContainer, class Compare, class Allocator>
+    flat_multimap(sorted_equivalent_t, KeyContainer, MappedContainer, Compare, Allocator)
+      -> flat_multimap<typename KeyContainer::value_type, typename MappedContainer::value_type,
+                       Compare, KeyContainer, MappedContainer>;
+  template<class InputIterator, class Compare = less<iter-key-type<InputIterator>>>
+    flat_multimap(InputIterator, InputIterator, Compare = Compare())
+      -> flat_multimap<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>, Compare>;
+  template<class InputIterator, class Compare = less<iter-key-type<InputIterator>>>
+    flat_multimap(sorted_equivalent_t, InputIterator, InputIterator, Compare = Compare())
+      -> flat_multimap<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>, Compare>;
+  template<ranges::input_range R, class Compare = less<range-key-type<R>>,
+           class Allocator = allocator<byte>>
+    flat_multimap(from_range_t, R&&, Compare = Compare(), Allocator = Allocator())
+      -> flat_multimap<range-key-type<R>, range-mapped-type<R>, Compare,
+                       vector<range-key-type<R>,
+                              alloc-rebind<Allocator, range-key-type<R>>>,
+                       vector<range-mapped-type<R>,
+                              alloc-rebind<Allocator, range-mapped-type<R>>>>;
+  template<ranges::input_range R, class Allocator>
+    flat_multimap(from_range_t, R&&, Allocator)
+      -> flat_multimap<range-key-type<R>, range-mapped-type<R>, less<range-key-type<R>>,
+                       vector<range-key-type<R>,
+                              alloc-rebind<Allocator, range-key-type<R>>>,
+                       vector<range-mapped-type<R>,
+                              alloc-rebind<Allocator, range-mapped-type<R>>>>;
+  template<class Key, class T, class Compare = less<Key>>
+    flat_multimap(initializer_list<pair<Key, T>>, Compare = Compare())
+      -> flat_multimap<Key, T, Compare>;
+  template<class Key, class T, class Compare = less<Key>>
+    flat_multimap(sorted_equivalent_t, initializer_list<pair<Key, T>>, Compare = Compare())
+        -> flat_multimap<Key, T, Compare>;
+  template<class Key, class T, class Compare, class KeyContainer, class MappedContainer,
+            class Allocator>
+    struct uses_allocator<flat_multimap<Key, T, Compare, KeyContainer, MappedContainer>,
+                          Allocator>
+      : bool_constant<uses_allocator_v<KeyContainer, Allocator> &&
+                      uses_allocator_v<MappedContainer, Allocator>> { };
+}
+```
+The member type `containers` has the data members and special members
+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.
+*Effects:* Let E be `bool(pred(pair<const Key&, const T&>(e)))`. Erases
+all elements `e` in `c` for which E holds.
+*Returns:* The number of elements erased.
+*Complexity:* Exactly `c.size()` applications of the predicate.
+*Remarks:* Stable [[algorithm.stable]]. If an invocation of `erase_if`
+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
+container interface that supports unique keys (i.e., contains at most
+one of each key value) and provides for fast retrieval of the keys
+themselves. `flat_set` supports iterators that model the
+`random_access_iterator` concept [[iterator.concept.random.access]].
+A `flat_set` meets all of the requirements for a container
+[[container.reqmts]] and for a reversible container
+[[container.rev.reqmts]], plus the optional container requirements
+[[container.opt.reqmts]]. `flat_set` meets the requirements of an
+associative container [[associative.reqmts]], except that:
+- it does not meet the requirements related to node handles
+  [[container.node.overview]],
+- it does not meet the requirements related to iterator invalidation,
+  and
+- the time complexity of the operations that insert or erase a single
+  element from the set is linear, including the ones that take an
+  insertion position iterator.
+[*Note 1*: A `flat_set` does not meet the additional requirements of an
+allocator-aware container, as described in
+[[container.alloc.reqmts]]. — *end note*]
+A `flat_set` also provides most operations described in
+[[associative.reqmts]] for unique keys. This means that a `flat_set`
+supports the `a_uniq` operations in [[associative.reqmts]] but not the
+`a_eq` operations. For a `flat_set<Key>`, both the `key_type` and
+`value_type` are `Key`.
+Descriptions are provided here only for operations on `flat_set` that
+are not described in one of those sets of requirements or for operations
+where there is additional semantic information.
+A `flat_set` maintains the invariant that the keys are sorted with
+respect to the comparison object.
+If any member function in [[flat.set.defn]] exits via an exception, the
+invariant is restored.
+[*Note 2*: This can result in the `flat_set`’s being
+emptied. — *end note*]
+Any sequence container [[sequence.reqmts]] supporting
+*Cpp17RandomAccessIterator* can be used to instantiate `flat_set`. 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_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 {
+  template<class Key, class Compare = less<Key>, class KeyContainer = vector<Key>>
+  class flat_set {
+  public:
+    // types
+    using key_type                  = Key;
+    using value_type                = Key;
+    using key_compare               = Compare;
+    using value_compare             = Compare;
+    using reference                 = value_type&;
+    using const_reference           = const value_type&;
+    using size_type                 = 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
+  };
+  template<class KeyContainer, class Compare = less<typename KeyContainer::value_type>>
+    flat_set(KeyContainer, Compare = Compare())
+      -> flat_set<typename KeyContainer::value_type, Compare, KeyContainer>;
+  template<class KeyContainer, class Allocator>
+    flat_set(KeyContainer, Allocator)
+      -> flat_set<typename KeyContainer::value_type,
+                  less<typename KeyContainer::value_type>, KeyContainer>;
+  template<class KeyContainer, class Compare, class Allocator>
+    flat_set(KeyContainer, Compare, Allocator)
+      -> flat_set<typename KeyContainer::value_type, Compare, KeyContainer>;
+  template<class KeyContainer, class Compare = less<typename KeyContainer::value_type>>
+    flat_set(sorted_unique_t, KeyContainer, Compare = Compare())
+      -> flat_set<typename KeyContainer::value_type, Compare, KeyContainer>;
+  template<class KeyContainer, class Allocator>
+    flat_set(sorted_unique_t, KeyContainer, Allocator)
+      -> flat_set<typename KeyContainer::value_type,
+                  less<typename KeyContainer::value_type>, KeyContainer>;
+  template<class KeyContainer, class Compare, class Allocator>
+    flat_set(sorted_unique_t, KeyContainer, Compare, Allocator)
+      -> flat_set<typename KeyContainer::value_type, Compare, KeyContainer>;
+  template<class InputIterator, class Compare = less<iter-value-type<InputIterator>>>
+    flat_set(InputIterator, InputIterator, Compare = Compare())
+      -> flat_set<iter-value-type<InputIterator>, Compare>;
+  template<class InputIterator, class Compare = less<iter-value-type<InputIterator>>>
+    flat_set(sorted_unique_t, InputIterator, InputIterator, Compare = Compare())
+      -> flat_set<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_set(from_range_t, R&&, Compare = Compare(), Allocator = Allocator())
+      -> flat_set<ranges::range_value_t<R>, Compare,
+                  vector<ranges::range_value_t<R>,
+                         alloc-rebind<Allocator, ranges::range_value_t<R>>>>;
+  template<ranges::input_range R, class Allocator>
+    flat_set(from_range_t, R&&, Allocator)
+      -> flat_set<ranges::range_value_t<R>, less<ranges::range_value_t<R>>,
+                  vector<ranges::range_value_t<R>,
+                         alloc-rebind<Allocator, ranges::range_value_t<R>>>>;
+  template<class Key, class Compare = less<Key>>
+    flat_set(initializer_list<Key>, Compare = Compare())
+      -> flat_set<Key, Compare>;
+  template<class Key, class Compare = less<Key>>
+    flat_set(sorted_unique_t, initializer_list<Key>, Compare = Compare())
+      -> flat_set<Key, Compare>;
+  template<class Key, class Compare, class KeyContainer, class Allocator>
+    struct uses_allocator<flat_set<Key, Compare, KeyContainer>, Allocator>
+      : bool_constant<uses_allocator_v<KeyContainer, Allocator>> { };
+}
+```
+#### 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))`.
+*Returns:* In the first overload, the `bool` component of the returned
+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
+c.insert(c.end(), first, last);
+```
+Then, sorts the range of newly inserted elements with respect to
+*compare*; merges the resulting sorted range and the sorted range of
+pre-existing elements into a single sorted range; and finally erases all
+but the first element from each group of consecutive equivalent
+elements.
+*Complexity:* N + M log M, where N is `size()` before the operation and
+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
+for (const auto& e : rg) {
+  c.insert(c.end(), e);
+}
+```
+Then, sorts the range of newly inserted elements with respect to
+*compare*; merges the resulting sorted range and the sorted range of
+pre-existing elements into a single sorted range; and finally erases all
+but the first element from each group of consecutive equivalent
+elements.
+*Complexity:* N + M log M, where N is `size()` before the operation and
+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.
+*Effects:* Equivalent to: *`c`*` = std::move(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.
+*Effects:* Let E be `bool(pred(as_const(e)))`. Erases all elements `e`
+in `c` for which E holds.
+*Returns:* The number of elements erased.
+*Complexity:* Exactly `c.size()` applications of the predicate.
+*Remarks:* Stable [[algorithm.stable]]. If an invocation of `erase_if`
+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_multiset` <a id="flat.multiset">[[flat.multiset]]</a>
+#### Overview <a id="flat.multiset.overview">[[flat.multiset.overview]]</a>
+A `flat_multiset` is a container adaptor that provides an associative
+container interface that supports equivalent keys (i.e., possibly
+containing multiple copies of the same key value) and provides for fast
+retrieval of the keys themselves. `flat_multiset` supports iterators
+that model the `random_access_iterator` concept
+[[iterator.concept.random.access]].
+A `flat_multiset` meets all of the requirements for a container
+[[container.reqmts]] and for a reversible container
+[[container.rev.reqmts]], plus the optional container requirements
+[[container.opt.reqmts]]. `flat_multiset` meets the requirements of an
+associative container [[associative.reqmts]], except that:
+- it does not meet the requirements related to node handles
+  [[container.node.overview]],
+- it does not meet the requirements related to iterator invalidation,
+  and
+- the time complexity of the operations that insert or erase a single
+  element from the set is linear, including the ones that take an
+  insertion position iterator.
+[*Note 1*: A `flat_multiset` does not meet the additional requirements
+of an allocator-aware container, as described in
+[[container.alloc.reqmts]]. — *end note*]
+A `flat_multiset` also provides most operations described in
+[[associative.reqmts]] for equal keys. This means that a `flat_multiset`
+supports the `a_eq` operations in [[associative.reqmts]] but not the
+`a_uniq` operations. For a `flat_multiset<Key>`, both the `key_type` and
+`value_type` are `Key`.
+Descriptions are provided here only for operations on `flat_multiset`
+that are not described in one of the general sections or for operations
+where there is additional semantic information.
+A `flat_multiset` maintains the invariant that the keys are sorted with
+respect to the comparison object.
+If any member function in [[flat.multiset.defn]] exits via an exception,
+the invariant is restored.
+[*Note 2*: This can result in the `flat_multiset`’s being
+emptied. — *end note*]
+Any sequence container [[sequence.reqmts]] supporting
+*Cpp17RandomAccessIterator* can be used to instantiate `flat_multiset`.
+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>>
+  class flat_multiset {
+  public:
+    // types
+    using key_type                  = Key;
+    using value_type                = Key;
+    using key_compare               = Compare;
+    using value_compare             = Compare;
+    using reference                 = value_type&;
+    using const_reference           = const value_type&;
+    using size_type                 = 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
+  };
+  template<class KeyContainer, class Compare = less<typename KeyContainer::value_type>>
+    flat_multiset(KeyContainer, Compare = Compare())
+      -> flat_multiset<typename KeyContainer::value_type, Compare, KeyContainer>;
+  template<class KeyContainer, class Allocator>
+    flat_multiset(KeyContainer, Allocator)
+      -> flat_multiset<typename KeyContainer::value_type,
+                       less<typename KeyContainer::value_type>, KeyContainer>;
+  template<class KeyContainer, class Compare, class Allocator>
+    flat_multiset(KeyContainer, Compare, Allocator)
+      -> flat_multiset<typename KeyContainer::value_type, Compare, KeyContainer>;
+  template<class KeyContainer, class Compare = less<typename KeyContainer::value_type>>
+    flat_multiset(sorted_equivalent_t, KeyContainer, Compare = Compare())
+      -> flat_multiset<typename KeyContainer::value_type, Compare, KeyContainer>;
+  template<class KeyContainer, class Allocator>
+    flat_multiset(sorted_equivalent_t, KeyContainer, Allocator)
+      -> flat_multiset<typename KeyContainer::value_type,
+                       less<typename KeyContainer::value_type>, KeyContainer>;
+  template<class KeyContainer, class Compare, class Allocator>
+    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,
+                       vector<ranges::range_value_t<R>,
+                              alloc-rebind<Allocator, ranges::range_value_t<R>>>>;
+  template<ranges::input_range R, class Allocator>
+    flat_multiset(from_range_t, R&&, Allocator)
+      -> flat_multiset<ranges::range_value_t<R>, less<ranges::range_value_t<R>>,
+                       vector<ranges::range_value_t<R>,
+                              alloc-rebind<Allocator, ranges::range_value_t<R>>>>;
+  template<class Key, class Compare = less<Key>>
+    flat_multiset(initializer_list<Key>, Compare = Compare())
+      -> flat_multiset<Key, Compare>;
+  template<class Key, class Compare = less<Key>>
+  flat_multiset(sorted_equivalent_t, initializer_list<Key>, Compare = Compare())
+      -> flat_multiset<Key, Compare>;
+  template<class Key, class Compare, class KeyContainer, class Allocator>
+    struct uses_allocator<flat_multiset<Key, Compare, KeyContainer>, Allocator>
+      : bool_constant<uses_allocator_v<KeyContainer, Allocator>> { };
+}
+```
+#### 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
+`std::forward<Args>(args)...`, then inserts `t` as if by:
+``` cpp
+auto it = ranges::upper_bound(c, t, compare);
+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
+c.insert(c.end(), first, last);
+```
+Then, sorts the range of newly inserted elements with respect to
+*compare*, and merges the resulting sorted range and the sorted range of
+pre-existing elements into a single sorted range.
+*Complexity:* N + M log M, where N is `size()` before the operation and
+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.
+*Effects:* Let E be `bool(pred(as_const(e)))`. Erases all elements `e`
+in `c` for which E holds.
+*Returns:* The number of elements erased.
+*Complexity:* Exactly `c.size()` applications of the predicate.
+*Remarks:* Stable [[algorithm.stable]]. If an invocation of `erase_if`
+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*]
+### Container adaptors formatting <a id="container.adaptors.format">[[container.adaptors.format]]</a>
+For each of `queue`, `priority_queue`, and `stack`, the library provides
+the following formatter specialization where `adaptor-type` is the name
+of the template:
+``` cpp
+namespace std {
+  template<class charT, class T, formattable<charT> Container, class... U>
+  struct formatter<adaptor-type<T, Container, U...>, charT> {
+  private:
+    using maybe-const-container =                                             // exposition only
+      fmt-maybe-const<Container, charT>;
+    using maybe-const-adaptor =                                               // exposition only
+      maybe-const<is_const_v<maybe-const-container>,                          // see [ranges.syn]
+                  adaptor-type<T, Container, U...>>;
+    formatter<ranges::ref_view<maybe-const-container>, charT> underlying_;    // exposition only
+  public:
+    template<class ParseContext>
+      constexpr typename ParseContext::iterator
+        parse(ParseContext& ctx);
+    template<class FormatContext>
+      typename FormatContext::iterator
+        format(maybe-const-adaptor& r, FormatContext& ctx) const;
+  };
+}
+```
+``` cpp
+template<class ParseContext>
+  constexpr typename ParseContext::iterator
+    parse(ParseContext& ctx);
+```
+*Effects:* Equivalent to: `return `*`underlying_`*`.parse(ctx);`
+``` cpp
+template<class FormatContext>
+  typename FormatContext::iterator
+    format(maybe-const-adaptor& r, FormatContext& ctx) const;
+```
+*Effects:* Equivalent to: `return `*`underlying_`*`.format(r.c, ctx);`

Diff to HTML by rtfpessoa