[containers] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpldpya7hb/{from.md → to.md} +6677 -3046

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

@@ -10,13 +10,13 @@ for sequence containers and associative containers, as summarized in
 [[containers.summary]].
 **Table: Containers library summary** <a id="containers.summary">[containers.summary]</a>
 | Subclause                  |                                  | Header                                           |
-| -------------------------- | -------------------------------- | ------------------------------------------------------------ |
 | [[container.requirements]] | Requirements                     |                                                  |
-| [[sequences]]              | Sequence containers              | `<array>`, `<deque>`, `<forward_list>`, `<list>`, `<vector>` |
 | [[associative]]            | Associative containers           | `<map>`, `<set>`                                 |
 | [[unord]]                  | Unordered associative containers | `<unordered_map>`, `<unordered_set>`             |
 | [[container.adaptors]]     | Container adaptors               | `<queue>`, `<stack>`, `<flat_map>`, `<flat_set>` |
 | [[views]]                  | Views                            | `<span>`, `<mdspan>`                             |
@@ -48,15 +48,15 @@ for internal types used by the container.
 [*Note 1*: This means, for example, that a node-based container would
 need to construct nodes containing aligned buffers and call `construct`
 to place the element into the buffer. — *end note*]
-### General containers <a id="container.gen.reqmts">[[container.gen.reqmts]]</a>
-#### General <a id="container.requirements.general">[[container.requirements.general]]</a>
-In subclause [[container.gen.reqmts]],
 - `X` denotes a container class containing objects of type `T`,
 - `a` denotes a value of type `X`,
 - `b` and `c` denote values of type (possibly const) `X`,
 - `i` and `j` denote values of type (possibly const) `X::iterator`,
@@ -73,11 +73,11 @@ containers:
 template<class R, class T>
 concept container-compatible-range =    // exposition only
   ranges::input_range<R> && convertible_to<ranges::range_reference_t<R>, T>;
 ```
-#### Containers <a id="container.reqmts">[[container.reqmts]]</a>
 A type `X` meets the *container* requirements if the following types,
 statements, and expressions are well-formed and have the specified
 semantics.
@@ -157,15 +157,15 @@ X u = rv;
 ```
 *Ensures:* `u` is equal to the value that `rv` had before this
 construction.
-*Complexity:* Linear for `array` and constant for all other standard
-containers.
 ``` cpp
-t = v;
 ```
 *Result:* `X&`.
 *Ensures:* `t == v`.
@@ -278,12 +278,12 @@ t.swap(s)
 *Result:* `void`.
 *Effects:* Exchanges the contents of `t` and `s`.
-*Complexity:* Linear for `array` and constant for all other standard
-containers.
 ``` cpp
 swap(t, s)
 ```
@@ -365,11 +365,11 @@ these container types take a `const allocator_type&` argument.
 [*Note 2*: If an invocation of a constructor uses the default value of
 an optional allocator argument, then the allocator type must support
 value-initialization. — *end note*]
 A copy of this allocator is used for any memory allocation and element
-construction performed, by these constructors and by all member
 functions, during the lifetime of each container object or until the
 allocator is replaced. The allocator may be replaced only via assignment
 or `swap()`. Allocator replacement is performed by copy assignment, move
 assignment, or swapping of the allocator only if
@@ -383,15 +383,15 @@ operation. In all container types defined in this Clause, the member
 `get_allocator()` returns a copy of the allocator used to construct the
 container or, if that allocator has been replaced, a copy of the most
 recent replacement.
 The expression `a.swap(b)`, for containers `a` and `b` of a standard
-container type other than `array`, shall exchange the values of `a` and
-`b` without invoking any move, copy, or swap operations on the
-individual container elements. Any `Compare`, `Pred`, or `Hash` types
-belonging to `a` and `b` shall meet the *Cpp17Swappable* requirements
-and shall be exchanged by calling `swap` as described in
 [[swappable.requirements]]. If
 `allocator_traits<allocator_type>::propagate_on_container_swap::value`
 is `true`, then `allocator_type` shall meet the *Cpp17Swappable*
 requirements and the allocators of `a` and `b` shall also be exchanged
 by calling `swap` as described in  [[swappable.requirements]].
@@ -401,13 +401,13 @@ iterator referring to an element in one container before the swap shall
 refer to the same element in the other container after the swap. It is
 unspecified whether an iterator with value `a.end()` before the swap
 will have value `b.end()` after the swap.
 Unless otherwise specified (see  [[associative.reqmts.except]],
-[[unord.req.except]], [[deque.modifiers]], and [[vector.modifiers]]) all
-container types defined in this Clause meet the following additional
-requirements:
 - If an exception is thrown by an `insert()` or `emplace()` function
   while inserting a single element, that function has no effects.
 - If an exception is thrown by a `push_back()`, `push_front()`,
   `emplace_back()`, or `emplace_front()` function, that function has no
@@ -523,13 +523,13 @@ are implemented by constexpr functions.
 a <=> b
 ```
 *Result:* *`synth-three-way-result`*`<X::value_type>`.
-*Preconditions:* Either `<=>` is defined for values of type (possibly
-const) `T`, or `<` is defined for values of type (possibly const) `T`
-and `<` is a total ordering relationship.
 *Returns:*
 `lexicographical_compare_three_way(a.begin(), a.end(), b.begin(), b.end(), `*`synth-three-way`*`)`
 [*Note 1*: The algorithm `lexicographical_compare_three_way` is defined
@@ -537,23 +537,25 @@ in [[algorithms]]. — *end note*]
 *Complexity:* Linear.
 #### Allocator-aware containers <a id="container.alloc.reqmts">[[container.alloc.reqmts]]</a>
-All of the containers defined in [[containers]] and in  [[basic.string]]
-except `array` meet the additional requirements of an
 *allocator-aware container*, as described below.
 Given an allocator type `A` and given a container type `X` having a
 `value_type` identical to `T` and an `allocator_type` identical to
 `allocator_traits<A>::rebind_alloc<T>` and given an lvalue `m` of type
-`A`, a pointer `p` of type `T*`, an expression `v` of type `T` or
-`const T`, and an rvalue `rv` of type `T`, the following terms are
-defined. If `X` is not allocator-aware or is a specialization of
-`basic_string`, the terms below are defined as if `A` were
-`allocator<T>` — no allocator object needs to be created and user
-specializations of `allocator<T>` are not instantiated:
 - `T` is **Cpp17DefaultInsertable* into `X`* means that the following
   expression is well-formed:
   ``` cpp
   allocator_traits<A>::construct(m, p)
@@ -574,11 +576,11 @@ specializations of `allocator<T>` are not instantiated:
   and its evaluation causes the following postcondition to hold: The
   value of `*p` is equivalent to the value of `rv` before the
   evaluation.
   \[*Note 1*: `rv` remains a valid object. Its state is
-  unspecified — *end note*]
 - `T` is **Cpp17CopyInsertable* into `X`* means that, in addition to `T`
   being *Cpp17MoveInsertable* into `X`, the following expression is
   well-formed:
   ``` cpp
   allocator_traits<A>::construct(m, p, v)
@@ -658,11 +660,11 @@ X u(m);
 X u(t, m);
 ```
 *Preconditions:* `T` is *Cpp17CopyInsertable* into `X`.
-*Ensures:* `u == t`, `u.get_allocator() == m`
 *Complexity:* Linear.
 ``` cpp
 X u(rv);
@@ -748,29 +750,22 @@ can result in a data race. As an exception to the general rule, for a
 `y[1] = true`. — *end note*]
 ### Sequence containers <a id="sequence.reqmts">[[sequence.reqmts]]</a>
 A sequence container organizes a finite set of objects, all of the same
-type, into a strictly linear arrangement. The library provides four
-basic kinds of sequence containers: `vector`, `forward_list`, `list`,
-and `deque`. In addition, `array` is provided as a sequence container
-which provides limited sequence operations because it has a fixed number
-of elements. The library also provides container adaptors that make it
 easy to construct abstract data types, such as `stack`s, `queue`s,
 `flat_map`s, `flat_multimap`s, `flat_set`s, or `flat_multiset`s, out of
 the basic sequence container kinds (or out of other program-defined
 sequence containers).
-[*Note 1*: The sequence containers offer the programmer different
-complexity trade-offs. `vector` is appropriate in most circumstances.
-`array` has a fixed size known during translation. `list` or
-`forward_list` support frequent insertions and deletions from the middle
-of the sequence. `deque` supports efficient insertions and deletions
-taking place at the beginning or at the end of the sequence. When
-choosing a container, remember `vector` is best; leave a comment to
-explain if you choose from the rest! — *end note*]
 In this subclause,
 - `X` denotes a sequence container class,
 - `a` denotes a value of type `X` containing elements of type `T`,
 - `u` denotes the name of a variable being declared,
@@ -778,18 +773,18 @@ In this subclause,
   `X::allocator_type` is valid and denotes a type [[temp.deduct]] and
   `allocator<T>` if it doesn’t,
 - `i` and `j` denote iterators that meet the *Cpp17InputIterator*
   requirements and refer to elements implicitly convertible to
   `value_type`,
-- `[i, j)` denotes a valid range,
 - `rg` denotes a value of a type `R` that models
   `container-compatible-range<T>`,
 - `il` designates an object of type `initializer_list<value_type>`,
 - `n` denotes a value of type `X::size_type`,
 - `p` denotes a valid constant iterator to `a`,
 - `q` denotes a valid dereferenceable constant iterator to `a`,
-- `[q1, q2)` denotes a valid range of constant iterators in `a`,
 - `t` denotes an lvalue or a const rvalue of `X::value_type`, and
 - `rv` denotes a non-const rvalue of `X::value_type`.
 - `Args` denotes a template parameter pack;
 - `args` denotes a function parameter pack with the pattern `Args&&`.
@@ -816,27 +811,34 @@ X u(i, j);
 *Preconditions:* `T` is *Cpp17EmplaceConstructible* into `X` from `*i`.
 For `vector`, if the iterator does not meet the *Cpp17ForwardIterator*
 requirements [[forward.iterators]], `T` is also *Cpp17MoveInsertable*
 into `X`.
-*Effects:* Constructs a sequence container equal to the range `[i, j)`.
-Each iterator in the range \[`i`, `j`) is dereferenced exactly once.
 *Ensures:* `distance(u.begin(), u.end()) == distance(i, j)` is `true`.
 ``` cpp
 X(from_range, rg)
 ```
 *Preconditions:* `T` is *Cpp17EmplaceConstructible* into `X` from
-`*ranges::begin(rg)`. For `vector`, if `R` models neither
-`ranges::sized_range` nor `ranges::forward_range`, `T` is also
-*Cpp17MoveInsertable* into `X`.
 *Effects:* Constructs a sequence container equal to the range `rg`. Each
 iterator in the range `rg` is dereferenced exactly once.
 *Ensures:* `distance(begin(), end()) == ranges::distance(rg)` is `true`.
 ``` cpp
 X(il)
 ```
@@ -862,30 +864,29 @@ a.emplace(p, args)
 ```
 *Result:* `iterator`.
 *Preconditions:* `T` is *Cpp17EmplaceConstructible* into `X` from
-`args`. For `vector` and `deque`, `T` is also *Cpp17MoveInsertable* into
-`X` and *Cpp17MoveAssignable*.
 *Effects:* Inserts an object of type `T` constructed with
 `std::forward<Args>(args)...` before `p`.
 [*Note 1*: `args` can directly or indirectly refer to a value in
 `a`. — *end note*]
-*Returns:* An iterator that points to the new element constructed from
-`args` into `a`.
 ``` cpp
 a.insert(p, t)
 ```
 *Result:* `iterator`.
-*Preconditions:* `T` is *Cpp17CopyInsertable* into `X`. For `vector` and
-`deque`, `T` is also *Cpp17CopyAssignable*.
 *Effects:* Inserts a copy of `t` before `p`.
 *Returns:* An iterator that points to the copy of `t` inserted into `a`.
@@ -893,12 +894,12 @@ a.insert(p, t)
 a.insert(p, rv)
 ```
 *Result:* `iterator`.
-*Preconditions:* `T` is *Cpp17MoveInsertable* into `X`. For `vector` and
-`deque`, `T` is also *Cpp17MoveAssignable*.
 *Effects:* Inserts a copy of `rv` before `p`.
 *Returns:* An iterator that points to the copy of `rv` inserted into
 `a`.
@@ -922,16 +923,17 @@ a.insert(p, i, j)
 ```
 *Result:* `iterator`.
 *Preconditions:* `T` is *Cpp17EmplaceConstructible* into `X` from `*i`.
-For `vector` and `deque`, `T` is also *Cpp17MoveInsertable* into `X`,
-and `T` meets the *Cpp17MoveConstructible*, *Cpp17MoveAssignable*, and
 *Cpp17Swappable*[[swappable.requirements]] requirements. Neither `i` nor
 `j` are iterators into `a`.
-*Effects:* Inserts copies of elements in `[i, j)` before `p`. Each
 iterator in the range \[`i`, `j`) shall be dereferenced exactly once.
 *Returns:* An iterator that points to the copy of the first element
 inserted into `a`, or `p` if `i == j`.
@@ -940,12 +942,12 @@ a.insert_range(p, rg)
 ```
 *Result:* `iterator`.
 *Preconditions:* `T` is *Cpp17EmplaceConstructible* into `X` from
-`*ranges::begin(rg)`. For `vector` and `deque`, `T` is also
-*Cpp17MoveInsertable* into `X`, and `T` meets the
 *Cpp17MoveConstructible*, *Cpp17MoveAssignable*, and
 *Cpp17Swappable*[[swappable.requirements]] requirements. `rg` and `a` do
 not overlap.
 *Effects:* Inserts copies of elements in `rg` before `p`. Each iterator
@@ -964,11 +966,12 @@ a.insert(p, il)
 a.erase(q)
 ```
 *Result:* `iterator`.
-*Preconditions:* For `vector` and `deque`, `T` is *Cpp17MoveAssignable*.
 *Effects:* Erases the element pointed to by `q`.
 *Returns:* An iterator that points to the element immediately following
 `q` prior to the element being erased. If no such element exists,
@@ -978,13 +981,14 @@ a.erase(q)
 a.erase(q1, q2)
 ```
 *Result:* `iterator`.
-*Preconditions:* For `vector` and `deque`, `T` is *Cpp17MoveAssignable*.
-*Effects:* Erases the elements in the range `[q1, q2)`.
 *Returns:* An iterator that points to the element pointed to by `q2`
 prior to any elements being erased. If no such element exists, `a.end()`
 is returned.
@@ -1012,14 +1016,15 @@ a.assign(i, j)
 and assignable from `*i`. For `vector`, if the iterator does not meet
 the forward iterator requirements [[forward.iterators]], `T` is also
 *Cpp17MoveInsertable* into `X`. Neither `i` nor `j` are iterators into
 `a`.
-*Effects:* Replaces elements in `a` with a copy of `[i, j)`. Invalidates
-all references, pointers and iterators referring to the elements of `a`.
-For `vector` and `deque`, also invalidates the past-the-end iterator.
-Each iterator in the range \[`i`, `j`) is dereferenced exactly once.
 ``` cpp
 a.assign_range(rg)
 ```
@@ -1027,20 +1032,26 @@ a.assign_range(rg)
 *Mandates:* `assignable_from<T&, ranges::range_reference_t<R>>` is
 modeled.
 *Preconditions:* `T` is *Cpp17EmplaceConstructible* into `X` from
-`*ranges::begin(rg)`. For `vector`, if `R` models neither
-`ranges::sized_range` nor `ranges::forward_range`, `T` is also
-*Cpp17MoveInsertable* into `X`. `rg` and `a` do not overlap.
 *Effects:* Replaces elements in `a` with a copy of each element in `rg`.
 Invalidates all references, pointers, and iterators referring to the
 elements of `a`. For `vector` and `deque`, also invalidates the
 past-the-end iterator. Each iterator in the range `rg` is dereferenced
 exactly once.
 ``` cpp
 a.assign(il)
 ```
 *Effects:* Equivalent to `a.assign(il.begin(), il.end())`.
@@ -1102,31 +1113,35 @@ containers but not others. Operations other than `prepend_range` and
 a.front()
 ```
 *Result:* `reference; const_reference` for constant `a`.
 *Returns:* `*a.begin()`
 *Remarks:* Required for `basic_string`, `array`, `deque`,
-`forward_list`, `list`, and `vector`.
 ``` cpp
 a.back()
 ```
 *Result:* `reference; const_reference` for constant `a`.
 *Effects:* Equivalent to:
 ``` cpp
 auto tmp = a.end();
 --tmp;
 return *tmp;
 ```
-*Remarks:* Required for `basic_string`, `array`, `deque`, `list`, and
-`vector`.
 ``` cpp
 a.emplace_front(args)
 ```
@@ -1154,11 +1169,11 @@ a.emplace_back(args)
 *Effects:* Appends an object of type `T` constructed with
 `std::forward<Args>(args)...`.
 *Returns:* `a.back()`.
-*Remarks:* Required for `deque`, `list`, and `vector`.
 ``` cpp
 a.push_front(t)
 ```
@@ -1210,11 +1225,12 @@ a.push_back(t)
 *Preconditions:* `T` is *Cpp17CopyInsertable* into `X`.
 *Effects:* Appends a copy of `t`.
-*Remarks:* Required for `basic_string`, `deque`, `list`, and `vector`.
 ``` cpp
 a.push_back(rv)
 ```
@@ -1222,11 +1238,12 @@ a.push_back(rv)
 *Preconditions:* `T` is *Cpp17MoveInsertable* into `X`.
 *Effects:* Appends a copy of `rv`.
-*Remarks:* Required for `basic_string`, `deque`, `list`, and `vector`.
 ``` cpp
 a.append_range(rg)
 ```
@@ -1237,19 +1254,19 @@ a.append_range(rg)
 into `X`.
 *Effects:* Inserts copies of elements in `rg` before `end()`. Each
 iterator in the range `rg` is dereferenced exactly once.
-*Remarks:* Required for `deque`, `list`, and `vector`.
 ``` cpp
 a.pop_front()
 ```
 *Result:* `void`
-*Preconditions:* `a.empty()` is `false`.
 *Effects:* Destroys the first element.
 *Remarks:* Required for `deque`, `forward_list`, and `list`.
@@ -1257,37 +1274,42 @@ a.pop_front()
 a.pop_back()
 ```
 *Result:* `void`
-*Preconditions:* `a.empty()` is `false`.
 *Effects:* Destroys the last element.
-*Remarks:* Required for `basic_string`, `deque`, `list`, and `vector`.
 ``` cpp
 a[n]
 ```
-*Result:* `reference; const_reference` for constant `a`
-*Returns:* `*(a.begin() + n)`
-*Remarks:* Required for `basic_string`, `array`, `deque`, and `vector`.
 ``` cpp
 a.at(n)
 ```
-*Result:* `reference; const_reference` for constant `a`
 *Returns:* `*(a.begin() + n)`
 *Throws:* `out_of_range` if `n >= a.size()`.
-*Remarks:* Required for `basic_string`, `array`, `deque`, and `vector`.
 ### Node handles <a id="container.node">[[container.node]]</a>
 #### Overview <a id="container.node.overview">[[container.node.overview]]</a>
@@ -1333,167 +1355,170 @@ public:
   using key_type       = see below;     // not present for set containers
   using mapped_type    = see below;     // not present for set containers
   using allocator_type = see below;
 private:
-  using container_node_type = unspecified;                  // exposition only
-  using ator_traits = allocator_traits<allocator_type>;     // exposition only
-  typename ator_traits::template
-    rebind_traits<container_node_type>::pointer ptr_;       // exposition only
   optional<allocator_type> alloc_;                          // exposition only
 public:
   // [container.node.cons], constructors, copy, and assignment
   constexpr node-handle() noexcept : ptr_(), alloc_() {}
-  node-handle(node-handle&&) noexcept;
-  node-handle& operator=(node-handle&&);
   // [container.node.dtor], destructor
-  ~node-handle();
   // [container.node.observers], observers
-  value_type& value() const; // not present for map containers
   key_type& key() const;                        // not present for set containers
-  mapped_type& mapped() const; // not present for set containers
-  allocator_type get_allocator() const;
-  explicit operator bool() const noexcept;
- [[nodiscard]] bool empty() const noexcept;
   // [container.node.modifiers], modifiers
-  void swap(node-handle&)
-    noexcept(ator_traits::propagate_on_container_swap::value ||
- ator_traits::is_always_equal::value);
-  friend void swap(node-handle& x, node-handle& y) noexcept(noexcept(x.swap(y))) {
     x.swap(y);
   }
 };
 ```
 #### Constructors, copy, and assignment <a id="container.node.cons">[[container.node.cons]]</a>
 ``` cpp
-node-handle(node-handle&& nh) noexcept;
 ```
-*Effects:* Constructs a *node-handle* object initializing `ptr_` with
-`nh.ptr_`. Move constructs `alloc_` with `nh.alloc_`. Assigns `nullptr`
-to `nh.ptr_` and assigns `nullopt` to `nh.alloc_`.
 ``` cpp
-node-handle& operator=(node-handle&& nh);
 ```
-*Preconditions:* Either `!alloc_`, or
-`ator_traits::propagate_on_container_move_assignment::value` is `true`,
-or `alloc_ == nh.alloc_`.
 *Effects:*
-- If `ptr_ != nullptr`, destroys the `value_type` subobject in the
- `container_node_type` object pointed to by `ptr_` by calling
-  `ator_traits::destroy`, then deallocates `ptr_` by calling
- `ator_traits::template rebind_traits<container_node_type>::deallocate`.
-- Assigns `nh.ptr_` to `ptr_`.
-- If `!alloc` or
- `ator_traits::propagate_on_container_move_assignment::value` is
-  `true`, move assigns `nh.alloc_` to `alloc_`.
-- Assigns `nullptr` to `nh.ptr_` and assigns `nullopt` to `nh.alloc_`.
 *Returns:* `*this`.
 *Throws:* Nothing.
 #### Destructor <a id="container.node.dtor">[[container.node.dtor]]</a>
 ``` cpp
-~node-handle();
 ```
-*Effects:* If `ptr_ != nullptr`, destroys the `value_type` subobject in
-the `container_node_type` object pointed to by `ptr_` by calling
-`ator_traits::destroy`, then deallocates `ptr_` by calling
-`ator_traits::template rebind_traits<container_node_type>::deallocate`.
 #### Observers <a id="container.node.observers">[[container.node.observers]]</a>
 ``` cpp
-value_type& value() const;
 ```
 *Preconditions:* `empty() == false`.
 *Returns:* A reference to the `value_type` subobject in the
-`container_node_type` object pointed to by `ptr_`.
 *Throws:* Nothing.
 ``` cpp
 key_type& key() const;
 ```
 *Preconditions:* `empty() == false`.
 *Returns:* A non-const reference to the `key_type` member of the
-`value_type` subobject in the `container_node_type` object pointed to by
-`ptr_`.
 *Throws:* Nothing.
 *Remarks:* Modifying the key through the returned reference is
 permitted.
 ``` cpp
-mapped_type& mapped() const;
 ```
 *Preconditions:* `empty() == false`.
 *Returns:* A reference to the `mapped_type` member of the `value_type`
-subobject in the `container_node_type` object pointed to by `ptr_`.
 *Throws:* Nothing.
 ``` cpp
-allocator_type get_allocator() const;
 ```
 *Preconditions:* `empty() == false`.
-*Returns:* `*alloc_`.
 *Throws:* Nothing.
 ``` cpp
-explicit operator bool() const noexcept;
 ```
-*Returns:* `ptr_ != nullptr`.
 ``` cpp
-[[nodiscard]] bool empty() const noexcept;
 ```
-*Returns:* `ptr_ == nullptr`.
 #### Modifiers <a id="container.node.modifiers">[[container.node.modifiers]]</a>
 ``` cpp
-void swap(node-handle& nh)
-  noexcept(ator_traits::propagate_on_container_swap::value ||
- ator_traits::is_always_equal::value);
 ```
-*Preconditions:* `!alloc_`, or `!nh.alloc_`, or
-`ator_traits::propagate_on_container_swap::value` is `true`, or
-`alloc_ == nh.alloc_`.
-*Effects:* Calls `swap(ptr_, nh.ptr_)`. If `!alloc_`, or `!nh.alloc_`,
-or `ator_traits::propagate_on_container_swap::value` is `true` calls
-`swap(alloc_, nh.alloc_)`.
 ### Insert return type <a id="container.insert.return">[[container.insert.return]]</a>
 The associative containers with unique keys and the unordered containers
 with unique keys have a member function `insert` that returns a nested
@@ -1508,11 +1533,11 @@ struct insert-return-type
   bool     inserted;
   NodeType node;
 };
 ```
-The name *`insert-return-type`* is exposition only.
 *`insert-return-type`* has the template parameters, data members, and
 special members specified above. It has no base classes or members other
 than those specified.
 ### Associative containers <a id="associative.reqmts">[[associative.reqmts]]</a>
@@ -1571,14 +1596,14 @@ In this subclause,
 - `X` denotes an associative container class,
 - `a` denotes a value of type `X`,
 - `a2` denotes a value of a type with nodes compatible with type `X` (
   [[container.node.compat]]),
-- `b` denotes a value or type `X` or `const X`,
 - `u` denotes the name of a variable being declared,
 - `a_uniq` denotes a value of type `X` when `X` supports unique keys,
-- `a_eq` denotes a value of type `X` when `X` supports multiple keys,
 - `a_tran` denotes a value of type `X` or `const X` when the
   *qualified-id* `X::key_compare::is_transparent` is valid and denotes a
   type [[temp.deduct]],
 - `i` and `j` meet the *Cpp17InputIterator* requirements and refer to
   elements implicitly convertible to `value_type`,
@@ -1586,11 +1611,11 @@ In this subclause,
 - `rg` denotes a value of a type `R` that models
   `container-compatible-range<value_type>`,
 - `p` denotes a valid constant iterator to `a`,
 - `q` denotes a valid dereferenceable constant iterator to `a`,
 - `r` denotes a valid dereferenceable iterator to `a`,
-- `[q1, q2)` denotes a valid range of constant iterators in `a`,
 - `il` designates an object of type `initializer_list<value_type>`,
 - `t` denotes a value of type `X::value_type`,
 - `k` denotes a value of type `X::key_type`, and
 - `c` denotes a value of type `X::key_compare` or
   `const X::key_compare`;
@@ -1612,19 +1637,18 @@ In this subclause,
 - `m` denotes an allocator of a type convertible to `A`, and `nh`
   denotes a non-const rvalue of type `X::node_type`.
 A type `X` meets the *associative container* requirements if `X` meets
 all the requirements of an allocator-aware container
-[[container.requirements.general]] and the following types, statements,
-and expressions are well-formed and have the specified semantics, except
 that for `map` and `multimap`, the requirements placed on `value_type`
-in [[container.alloc.reqmts]] apply instead to `key_type` and
-`mapped_type`.
-[*Note 3*: For example, in some cases `key_type` and `mapped_type` are
-required to be *Cpp17CopyAssignable* even though the associated
-`value_type`, `pair<const key_type, mapped_type>`, is not
 *Cpp17CopyAssignable*. — *end note*]
 ``` cpp
 typename X::key_type
 ```
@@ -1843,12 +1867,11 @@ a.emplace_hint(p, args)
 *Effects:* Equivalent to `a.emplace(std::forward<Args>(args)...)`,
 except that the element is inserted as close as possible to the position
 just prior to `p`.
-*Returns:* An iterator pointing to the element with the key equivalent
-to the newly inserted element.
 *Complexity:* Logarithmic in general, but amortized constant if the
 element is inserted right before `p`.
 ``` cpp
@@ -2057,21 +2080,22 @@ a.extract(q)
 a.merge(a2)
 ```
 *Result:* `void`
-*Preconditions:* `a.get_allocator() == a2.get_allocator()`.
 *Effects:* Attempts to extract each element in `a2` and insert it into
 `a` using the comparison object of `a`. In containers with unique keys,
 if there is an element in `a` with key equivalent to the key of an
 element from `a2`, then that element is not extracted from `a2`.
 *Ensures:* Pointers and references to the transferred elements of `a2`
-refer to those same elements but as members of `a`. Iterators referring
-to the transferred elements will continue to refer to their elements,
-but they now behave as iterators into `a`, not into `a2`.
 *Throws:* Nothing unless the comparison object throws.
 *Complexity:* N log(`a.size()+` N), where N has the value `a2.size()`.
@@ -2243,11 +2267,11 @@ b.upper_bound(k)
 *Result:* `iterator`; `const_iterator` for constant `b`.
 *Returns:* An iterator pointing to the first element with key greater
 than `k`, or `b.end()` if such an element is not found.
-*Complexity:* Logarithmic,
 ``` cpp
 a_tran.upper_bound(ku)
 ```
@@ -2445,17 +2469,17 @@ In this subclause,
 - `a_tran` denotes a value of type `X` or `const X` when the
   *qualified-id*s `X::key_equal::is_transparent` and
   `X::hasher::is_transparent` are both valid and denote types
   [[temp.deduct]],
 - `i` and `j` denote input iterators that refer to `value_type`,
-- `[i, j)` denotes a valid range,
 - `rg` denotes a value of a type `R` that models
   `container-compatible-range<value_type>`,
 - `p` and `q2` denote valid constant iterators to `a`,
 - `q` and `q1` denote valid dereferenceable constant iterators to `a`,
 - `r` denotes a valid dereferenceable iterator to `a`,
-- `[q1, q2)` denotes a valid range in `a`,
 - `il` denotes a value of type `initializer_list<value_type>`,
 - `t` denotes a value of type `X::value_type`,
 - `k` denotes a value of type `key_type`,
 - `hf` denotes a value of type `hasher` or `const hasher`,
 - `eq` denotes a value of type `key_equal` or `const key_equal`,
@@ -2478,19 +2502,19 @@ In this subclause,
 - `z` denotes a value of type `float`, and
 - `nh` denotes an rvalue of type `X::node_type`.
 A type `X` meets the *unordered associative container* requirements if
 `X` meets all the requirements of an allocator-aware container
-[[container.requirements.general]] and the following types, statements,
-and expressions are well-formed and have the specified semantics, except
 that for `unordered_map` and `unordered_multimap`, the requirements
-placed on `value_type` in [[container.alloc.reqmts]] apply instead to
 `key_type` and `mapped_type`.
-[*Note 3*: For example, `key_type` and `mapped_type` are sometimes
-required to be *Cpp17CopyAssignable* even though the associated
-`value_type`, `pair<const key_type, mapped_type>`, is not
 *Cpp17CopyAssignable*. — *end note*]
 ``` cpp
 typename X::key_type
 ```
@@ -2757,12 +2781,12 @@ X(il, n, hf, eq)
 ``` cpp
 X(b)
 ```
 *Effects:* In addition to the container
-requirements [[container.requirements.general]], copies the hash
-function, predicate, and maximum load factor.
 *Complexity:* Average case linear in `b.size()`, worst case quadratic.
 ``` cpp
 a = b
@@ -2848,21 +2872,15 @@ from `args`.
 a.emplace_hint(p, args)
 ```
 *Result:* `iterator`
-*Preconditions:* `value_type` is *Cpp17EmplaceConstructible* into `X`
-from `args`.
-*Effects:* Equivalent to `a.emplace(std::forward<Args>(args)...)`.
-*Returns:* An iterator pointing to the element with the key equivalent
-to the newly inserted element. The `const_iterator` `p` is a hint
-pointing to where the search should start. Implementations are permitted
-to ignore the hint.
-*Complexity:* Average case 𝑂(1), worst case 𝑂(`a.size()`).
 ``` cpp
 a_uniq.insert(t)
 ```
@@ -2923,11 +2941,11 @@ a.insert(i, j)
 *Result:* `void`
 *Preconditions:* `value_type` is *Cpp17EmplaceConstructible* into `X`
 from `*i`. Neither `i` nor `j` are iterators into `a`.
-*Effects:* Equivalent to `a.insert(t)` for each element in `[i,j)`.
 *Complexity:* Average case 𝑂(N), where N is `distance(i, j)`, worst case
 𝑂(N(`a.size()` + 1)).
 ``` cpp
@@ -3129,11 +3147,11 @@ a.erase(r)
 a.erase(q1, q2)
 ```
 *Result:* `iterator`
-*Effects:* Erases all elements in the range `[q1, q2)`.
 *Returns:* The iterator immediately following the erased elements prior
 to the erasure.
 *Complexity:* Average case linear in `distance(q1, q2)`, worst case
@@ -3261,21 +3279,37 @@ b.bucket(k)
 *Preconditions:* `b.bucket_count() > 0`.
 *Returns:* The index of the bucket in which elements with keys
 equivalent to `k` would be found, if any such element existed. The
-return value is in the range `[0, b.bucket_count())`.
 *Complexity:* Constant.
 ``` cpp
 b.bucket_size(n)
 ```
 *Result:* `size_type`
-*Preconditions:* `n` shall be in the range `[0, b.bucket_count())`.
 *Returns:* The number of elements in the `n`ᵗʰ bucket.
 *Complexity:* 𝑂(`b.bucket_size(n)`)
@@ -3283,11 +3317,11 @@ b.bucket_size(n)
 b.begin(n)
 ```
 *Result:* `local_iterator`; `const_local_iterator` for constant `b`.
-*Preconditions:* `n` is in the range `[0, b.bucket_count())`.
 *Returns:* An iterator referring to the first element in the bucket. If
 the bucket is empty, then `b.begin(n) == b.end(n)`.
 *Complexity:* Constant.
@@ -3296,11 +3330,11 @@ the bucket is empty, then `b.begin(n) == b.end(n)`.
 b.end(n)
 ```
 *Result:* `local_iterator`; `const_local_iterator` for constant `b`.
-*Preconditions:* `n` is in the range `[0, b.bucket_count())`.
 *Returns:* An iterator which is the past-the-end value for the bucket.
 *Complexity:* Constant.
@@ -3308,11 +3342,11 @@ b.end(n)
 b.cbegin(n)
 ```
 *Result:* `const_local_iterator`
-*Preconditions:* `n` shall be in the range `[0, b.bucket_count())`.
 *Returns:* An iterator referring to the first element in the bucket. If
 the bucket is empty, then `b.cbegin(n) == b.cend(n)`.
 *Complexity:* Constant.
@@ -3321,11 +3355,11 @@ the bucket is empty, then `b.cbegin(n) == b.cend(n)`.
 b.cend(n)
 ```
 *Result:* `const_local_iterator`
-*Preconditions:* `n` is in the range `[0, b.bucket_count())`.
 *Returns:* An iterator which is the past-the-end value for the bucket.
 *Complexity:* Constant.
@@ -3430,15 +3464,15 @@ accessing the element through such pointers and references while the
 element is owned by a `node_type` is undefined behavior. References and
 pointers to an element obtained while it is owned by a `node_type` are
 invalidated if the element is successfully inserted.
 The member function templates `find`, `count`, `equal_range`,
-`contains`, `extract`, and `erase` shall not participate in overload
-resolution unless the *qualified-id*s `Pred::is_transparent` and
-`Hash::is_transparent` are both valid and denote types [[temp.deduct]].
-Additionally, the member function templates `extract` and `erase` shall
-not participate in overload resolution if
 `is_convertible_v<K&&, iterator> || is_convertible_v<K&&, const_iterator>`
 is `true`, where `K` is the type substituted as the first template
 argument.
 A deduction guide for an unordered associative container shall not
@@ -3472,33 +3506,34 @@ For unordered associative containers, if an exception is thrown from
 within a `rehash()` function other than by the container’s hash function
 or comparison function, the `rehash()` function has no effect.
 ## Sequence containers <a id="sequences">[[sequences]]</a>
-### In general <a id="sequences.general">[[sequences.general]]</a>
-The headers `<array>`, `<deque>`, `<forward_list>`, `<list>`, and
-`<vector>` define class templates that meet the requirements for
-sequence containers.
 The following exposition-only alias template may appear in deduction
 guides for sequence containers:
 ``` cpp
 template<class InputIterator>
-  using iter-value-type = typename iterator_traits<InputIterator>::value_type;  // exposition only
 ```
 ### Header `<array>` synopsis <a id="array.syn">[[array.syn]]</a>
 ``` cpp
 #include <compare>              // see [compare.syn]
 #include <initializer_list>     // see [initializer.list.syn]
 namespace std {
   // [array], class template array
-  template<class T, size_t N> struct array;
   template<class T, size_t N>
     constexpr bool operator==(const array<T, N>& x, const array<T, N>& y);
   template<class T, size_t N>
     constexpr synth-three-way-result<T>
@@ -3530,166 +3565,10 @@ namespace std {
   template<size_t I, class T, size_t N>
     constexpr const T&& get(const array<T, N>&&) noexcept;
 }
 ```
-### Header `<deque>` synopsis <a id="deque.syn">[[deque.syn]]</a>
-``` cpp
-#include <compare>              // see [compare.syn]
-#include <initializer_list>     // see [initializer.list.syn]
-namespace std {
-  // [deque], class template deque
-  template<class T, class Allocator = allocator<T>> class deque;
-  template<class T, class Allocator>
-    bool operator==(const deque<T, Allocator>& x, const deque<T, Allocator>& y);
-  template<class T, class Allocator>
-    synth-three-way-result<T> operator<=>(const deque<T, Allocator>& x,
-    \itcorr                                      const deque<T, Allocator>& y);
-  template<class T, class Allocator>
-    void swap(deque<T, Allocator>& x, deque<T, Allocator>& y)
-      noexcept(noexcept(x.swap(y)));
-  // [deque.erasure], erasure
-  template<class T, class Allocator, class U>
-    typename deque<T, Allocator>::size_type
-      erase(deque<T, Allocator>& c, const U& value);
-  template<class T, class Allocator, class Predicate>
-    typename deque<T, Allocator>::size_type
-      erase_if(deque<T, Allocator>& c, Predicate pred);
-  namespace pmr {
-    template<class T>
-      using deque = std::deque<T, polymorphic_allocator<T>>;
-  }
-}
-```
-### Header `<forward_list>` synopsis <a id="forward.list.syn">[[forward.list.syn]]</a>
-``` cpp
-#include <compare>              // see [compare.syn]
-#include <initializer_list>     // see [initializer.list.syn]
-namespace std {
-  // [forward.list], class template forward_list
-  template<class T, class Allocator = allocator<T>> class forward_list;
-  template<class T, class Allocator>
-    bool operator==(const forward_list<T, Allocator>& x, const forward_list<T, Allocator>& y);
-  template<class T, class Allocator>
-    synth-three-way-result<T> operator<=>(const forward_list<T, Allocator>& x,
-    \itcorr                                      const forward_list<T, Allocator>& y);
-  template<class T, class Allocator>
-    void swap(forward_list<T, Allocator>& x, forward_list<T, Allocator>& y)
-      noexcept(noexcept(x.swap(y)));
-  // [forward.list.erasure], erasure
-  template<class T, class Allocator, class U>
-    typename forward_list<T, Allocator>::size_type
-      erase(forward_list<T, Allocator>& c, const U& value);
-  template<class T, class Allocator, class Predicate>
-    typename forward_list<T, Allocator>::size_type
-      erase_if(forward_list<T, Allocator>& c, Predicate pred);
-  namespace pmr {
-    template<class T>
-      using forward_list = std::forward_list<T, polymorphic_allocator<T>>;
-  }
-}
-```
-### Header `<list>` synopsis <a id="list.syn">[[list.syn]]</a>
-``` cpp
-#include <compare>              // see [compare.syn]
-#include <initializer_list>     // see [initializer.list.syn]
-namespace std {
-  // [list], class template list
-  template<class T, class Allocator = allocator<T>> class list;
-  template<class T, class Allocator>
-    bool operator==(const list<T, Allocator>& x, const list<T, Allocator>& y);
-  template<class T, class Allocator>
-    synth-three-way-result<T> operator<=>(const list<T, Allocator>& x,
-    \itcorr                                      const list<T, Allocator>& y);
-  template<class T, class Allocator>
-    void swap(list<T, Allocator>& x, list<T, Allocator>& y)
-      noexcept(noexcept(x.swap(y)));
-  // [list.erasure], erasure
-  template<class T, class Allocator, class U>
-    typename list<T, Allocator>::size_type
-      erase(list<T, Allocator>& c, const U& value);
-  template<class T, class Allocator, class Predicate>
-    typename list<T, Allocator>::size_type
-      erase_if(list<T, Allocator>& c, Predicate pred);
-  namespace pmr {
-    template<class T>
-      using list = std::list<T, polymorphic_allocator<T>>;
-  }
-}
-```
-### Header `<vector>` synopsis <a id="vector.syn">[[vector.syn]]</a>
-``` cpp
-#include <compare>              // see [compare.syn]
-#include <initializer_list>     // see [initializer.list.syn]
-namespace std {
-  // [vector], class template vector
-  template<class T, class Allocator = allocator<T>> class vector;
-  template<class T, class Allocator>
-    constexpr bool operator==(const vector<T, Allocator>& x, const vector<T, Allocator>& y);
-  template<class T, class Allocator>
-    constexpr synth-three-way-result<T> operator<=>(const vector<T, Allocator>& x,
-              \itcorr                                      const vector<T, Allocator>& y);
-  template<class T, class Allocator>
-    constexpr void swap(vector<T, Allocator>& x, vector<T, Allocator>& y)
-      noexcept(noexcept(x.swap(y)));
-  // [vector.erasure], erasure
-  template<class T, class Allocator, class U>
-    constexpr typename vector<T, Allocator>::size_type
-      erase(vector<T, Allocator>& c, const U& value);
-  template<class T, class Allocator, class Predicate>
-    constexpr typename vector<T, Allocator>::size_type
-      erase_if(vector<T, Allocator>& c, Predicate pred);
-  namespace pmr {
-    template<class T>
-      using vector = std::vector<T, polymorphic_allocator<T>>;
-  }
-  // [vector.bool], specialization of vector for bool
-  // [vector.bool.pspc], partial class template specialization vector<bool, Allocator>
-  template<class Allocator>
-    class vector<bool, Allocator>;
-  template<class T>
-    constexpr bool is-vector-bool-reference = see below;          // exposition only
-  // hash support
-  template<class T> struct hash;
-  template<class Allocator> struct hash<vector<bool, Allocator>>;
-  // [vector.bool.fmt], formatter specialization for vector<bool>
-  template<class T, class charT> requires is-vector-bool-reference<T>
-    struct formatter<T, charT>;
-}
-```
 ### Class template `array` <a id="array">[[array]]</a>
 #### Overview <a id="array.overview">[[array.overview]]</a>
 The header `<array>` defines a class template for storing fixed-size
@@ -3708,12 +3587,12 @@ object is not empty if `N` > 0. An `array` meets some of the
 requirements of a sequence container [[sequence.reqmts]]. Descriptions
 are provided here only for operations on `array` that are not described
 in one of these tables and for operations where there is additional
 semantic information.
-`array<T, N>` is a structural type [[temp.param]] if `T` is a structural
-type. Two values `a1` and `a2` of type `array<T, N>` are
 template-argument-equivalent [[temp.type]] if and only if each pair of
 corresponding elements in `a1` and `a2` are
 template-argument-equivalent.
 The types `iterator` and `const_iterator` meet the constexpr iterator
@@ -3756,19 +3635,19 @@ namespace std {
     constexpr const_iterator         cend() const noexcept;
     constexpr const_reverse_iterator crbegin() const noexcept;
     constexpr const_reverse_iterator crend() const noexcept;
     // capacity
- [[nodiscard]] constexpr bool empty() const noexcept;
     constexpr size_type size() const noexcept;
     constexpr size_type max_size() const noexcept;
     // element access
     constexpr reference       operator[](size_type n);
     constexpr const_reference operator[](size_type n) const;
-    constexpr reference       at(size_type n);
-    constexpr const_reference at(size_type n) const;
     constexpr reference       front();
     constexpr const_reference front() const;
     constexpr reference       back();
     constexpr const_reference back() const;
@@ -3781,17 +3660,16 @@ namespace std {
 }
 ```
 #### Constructors, copy, and assignment <a id="array.cons">[[array.cons]]</a>
-The conditions for an aggregate [[dcl.init.aggr]] shall be met. Class
-`array` relies on the implicitly-declared special member functions
 [[class.default.ctor]], [[class.dtor]], [[class.copy.ctor]] to conform
 to the container requirements table in  [[container.requirements]]. In
 addition to the requirements specified in the container requirements
-table, the implicit move constructor and move assignment operator for
-`array` require that `T` be *Cpp17MoveConstructible* or
 *Cpp17MoveAssignable*, respectively.
 ``` cpp
 template<class T, class... U>
   array(T, U...) -> array<T, 1 + sizeof...(U)>;
@@ -3811,11 +3689,11 @@ constexpr size_type size() const noexcept;
 constexpr T* data() noexcept;
 constexpr const T* data() const noexcept;
 ```
 *Returns:* A pointer such that \[`data()`, `data() + size()`) is a valid
-range. For a non-empty array, `data()` `==` `addressof(front())`.
 ``` cpp
 constexpr void fill(const T& u);
 ```
@@ -3863,24 +3741,24 @@ specification.
 ``` cpp
 template<class T, size_t N>
   constexpr array<remove_cv_t<T>, N> to_array(T (&a)[N]);
 ```
-*Mandates:* `is_array_v<T>` is `false` and `is_constructible_v<T, T&>`
-is `true`.
 *Preconditions:* `T` meets the *Cpp17CopyConstructible* requirements.
 *Returns:* `{{ a[0], `…`, a[N - 1] }}`.
 ``` cpp
 template<class T, size_t N>
   constexpr array<remove_cv_t<T>, N> to_array(T (&&a)[N]);
 ```
-*Mandates:* `is_array_v<T>` is `false` and `is_move_constructible_v<T>`
-is `true`.
 *Preconditions:* `T` meets the *Cpp17MoveConstructible* requirements.
 *Returns:* `{{ std::move(a[0]), `…`, std::move(a[N - 1]) }}`.
@@ -3914,10 +3792,45 @@ template<size_t I, class T, size_t N>
 *Mandates:* `I < N` is `true`.
 *Returns:* A reference to the `I`ᵗʰ element of `a`, where indexing is
 zero-based.
 ### Class template `deque` <a id="deque">[[deque]]</a>
 #### Overview <a id="deque.overview">[[deque.overview]]</a>
 A `deque` is a sequence container that supports random access iterators
@@ -3934,121 +3847,125 @@ A `deque` meets all of the requirements of a container
 optional sequence container requirements [[sequence.reqmts]].
 Descriptions are provided here only for operations on `deque` that are
 not described in one of these tables or for operations where there is
 additional semantic information.
 ``` cpp
 namespace std {
   template<class T, class Allocator = allocator<T>>
   class deque {
   public:
     // types
     using value_type             = T;
     using allocator_type         = Allocator;
-    using pointer                = typename allocator_traits<Allocator>::pointer;
-    using const_pointer          = typename allocator_traits<Allocator>::const_pointer;
     using reference              = value_type&;
     using const_reference        = const value_type&;
     using size_type              = implementation-defined  // type of deque::size_type; // see [container.requirements]
     using difference_type        = implementation-defined  // type of deque::difference_type; // see [container.requirements]
     using iterator               = implementation-defined  // type of deque::iterator; // see [container.requirements]
     using const_iterator         = implementation-defined  // type of deque::const_iterator; // see [container.requirements]
     using reverse_iterator       = std::reverse_iterator<iterator>;
     using const_reverse_iterator = std::reverse_iterator<const_iterator>;
     // [deque.cons], construct/copy/destroy
-    deque() : deque(Allocator()) { }
-    explicit deque(const Allocator&);
-    explicit deque(size_type n, const Allocator& = Allocator());
-    deque(size_type n, const T& value, const Allocator& = Allocator());
     template<class InputIterator>
-      deque(InputIterator first, InputIterator last, const Allocator& = Allocator());
     template<container-compatible-range<T> R>
-      deque(from_range_t, R&& rg, const Allocator& = Allocator());
-    deque(const deque& x);
-    deque(deque&&);
-    deque(const deque&, const type_identity_t<Allocator>&);
-    deque(deque&&, const type_identity_t<Allocator>&);
-    deque(initializer_list<T>, const Allocator& = Allocator());
-    ~deque();
-    deque& operator=(const deque& x);
-    deque& operator=(deque&& x)
       noexcept(allocator_traits<Allocator>::is_always_equal::value);
-    deque& operator=(initializer_list<T>);
     template<class InputIterator>
-      void assign(InputIterator first, InputIterator last);
     template<container-compatible-range<T> R>
-      void assign_range(R&& rg);
-    void assign(size_type n, const T& t);
-    void assign(initializer_list<T>);
-    allocator_type get_allocator() const noexcept;
     // 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;
     // [deque.capacity], capacity
- [[nodiscard]] bool empty() const noexcept;
-    size_type size() const noexcept;
-    size_type max_size() const noexcept;
-    void      resize(size_type sz);
-    void      resize(size_type sz, const T& c);
-    void      shrink_to_fit();
     // element access
-    reference       operator[](size_type n);
-    const_reference operator[](size_type n) const;
-    reference       at(size_type n);
-    const_reference at(size_type n) const;
-    reference       front();
-    const_reference front() const;
-    reference       back();
-    const_reference back() const;
     // [deque.modifiers], modifiers
-    template<class... Args> reference emplace_front(Args&&... args);
-    template<class... Args> reference emplace_back(Args&&... args);
-    template<class... Args> iterator emplace(const_iterator position, Args&&... args);
-    void push_front(const T& x);
-    void push_front(T&& x);
     template<container-compatible-range<T> R>
-      void prepend_range(R&& rg);
-    void push_back(const T& x);
-    void push_back(T&& x);
     template<container-compatible-range<T> R>
-      void append_range(R&& rg);
-    iterator insert(const_iterator position, const T& x);
-    iterator insert(const_iterator position, T&& x);
-    iterator insert(const_iterator position, size_type n, const T& x);
     template<class InputIterator>
-      iterator insert(const_iterator position, InputIterator first, InputIterator last);
     template<container-compatible-range<T> R>
-      iterator insert_range(const_iterator position, R&& rg);
-    iterator insert(const_iterator position, initializer_list<T>);
-    void pop_front();
-    void pop_back();
-    iterator erase(const_iterator position);
-    iterator erase(const_iterator first, const_iterator last);
-    void     swap(deque&)
       noexcept(allocator_traits<Allocator>::is_always_equal::value);
-    void     clear() noexcept;
   };
   template<class InputIterator, class Allocator = allocator<iter-value-type<InputIterator>>>
     deque(InputIterator, InputIterator, Allocator = Allocator())
       -> deque<iter-value-type<InputIterator>, Allocator>;
@@ -4060,87 +3977,87 @@ namespace std {
 ```
 #### Constructors, copy, and assignment <a id="deque.cons">[[deque.cons]]</a>
 ``` cpp
-explicit deque(const Allocator&);
 ```
 *Effects:* Constructs an empty `deque`, using the specified allocator.
 *Complexity:* Constant.
 ``` cpp
-explicit deque(size_type n, const Allocator& = Allocator());
 ```
-*Preconditions:* `T` is *Cpp17DefaultInsertable* into `*this`.
 *Effects:* Constructs a `deque` with `n` default-inserted elements using
 the specified allocator.
 *Complexity:* Linear in `n`.
 ``` cpp
-deque(size_type n, const T& value, const Allocator& = Allocator());
 ```
-*Preconditions:* `T` is *Cpp17CopyInsertable* into `*this`.
 *Effects:* Constructs a `deque` with `n` copies of `value`, using the
 specified allocator.
 *Complexity:* Linear in `n`.
 ``` cpp
 template<class InputIterator>
-  deque(InputIterator first, InputIterator last, const Allocator& = Allocator());
 ```
 *Effects:* Constructs a `deque` equal to the range \[`first`, `last`),
 using the specified allocator.
 *Complexity:* Linear in `distance(first, last)`.
 ``` cpp
 template<container-compatible-range<T> R>
-  deque(from_range_t, R&& rg, const Allocator& = Allocator());
 ```
 *Effects:* Constructs a `deque` with the elements of the range `rg`,
 using the specified allocator.
 *Complexity:* Linear in `ranges::distance(rg)`.
 #### Capacity <a id="deque.capacity">[[deque.capacity]]</a>
 ``` cpp
-void resize(size_type sz);
 ```
 *Preconditions:* `T` is *Cpp17MoveInsertable* and
-*Cpp17DefaultInsertable* into `*this`.
 *Effects:* If `sz < size()`, erases the last `size() - sz` elements from
 the sequence. Otherwise, appends `sz - size()` default-inserted elements
 to the sequence.
 ``` cpp
-void resize(size_type sz, const T& c);
 ```
-*Preconditions:* `T` is *Cpp17CopyInsertable* into `*this`.
 *Effects:* If `sz < size()`, erases the last `size() - sz` elements from
 the sequence. Otherwise, appends `sz - size()` copies of `c` to the
 sequence.
 ``` cpp
-void shrink_to_fit();
 ```
-*Preconditions:* `T` is *Cpp17MoveInsertable* into `*this`.
 *Effects:* `shrink_to_fit` is a non-binding request to reduce memory use
 but does not change the size of the sequence.
 [*Note 1*: The request is non-binding to allow latitude for
@@ -4158,31 +4075,31 @@ invalidates all the references, pointers, and iterators referring to the
 elements in the sequence, as well as the past-the-end iterator.
 #### Modifiers <a id="deque.modifiers">[[deque.modifiers]]</a>
 ``` cpp
-iterator insert(const_iterator position, const T& x);
-iterator insert(const_iterator position, T&& x);
-iterator insert(const_iterator position, size_type n, const T& x);
 template<class InputIterator>
-  iterator insert(const_iterator position,
                             InputIterator first, InputIterator last);
 template<container-compatible-range<T> R>
-  iterator insert_range(const_iterator position, R&& rg);
-iterator insert(const_iterator position, initializer_list<T>);
-template<class... Args> reference emplace_front(Args&&... args);
-template<class... Args> reference emplace_back(Args&&... args);
-template<class... Args> iterator emplace(const_iterator position, Args&&... args);
-void push_front(const T& x);
-void push_front(T&& x);
 template<container-compatible-range<T> R>
-  void prepend_range(R&& rg);
-void push_back(const T& x);
-void push_back(T&& x);
 template<container-compatible-range<T> R>
-  void append_range(R&& rg);
 ```
 *Effects:* An insertion in the middle of the deque invalidates all the
 iterators and references to elements of the deque. An insertion at
 either end of the deque invalidates all the iterators to the deque, but
@@ -4194,20 +4111,20 @@ the deque. Inserting a single element at either the beginning or end of
 a deque always takes constant time and causes a single call to a
 constructor of `T`.
 *Remarks:* If an exception is thrown other than by the copy constructor,
 move constructor, assignment operator, or move assignment operator of
-`T` there are no effects. If an exception is thrown while inserting a
 single element at either end, there are no effects. Otherwise, if an
 exception is thrown by the move constructor of a
 non-*Cpp17CopyInsertable* `T`, the effects are unspecified.
 ``` cpp
-iterator erase(const_iterator position);
-iterator erase(const_iterator first, const_iterator last);
-void pop_front();
-void pop_back();
 ```
 *Effects:* An erase operation that erases the last element of a deque
 invalidates only the past-the-end iterator and all iterators and
 references to the erased elements. An erase operation that erases the
@@ -4230,12 +4147,12 @@ elements before the erased elements and the number of elements after the
 erased elements.
 #### Erasure <a id="deque.erasure">[[deque.erasure]]</a>
 ``` cpp
-template<class T, class Allocator, class U>
-  typename deque<T, Allocator>::size_type
     erase(deque<T, Allocator>& c, const U& value);
 ```
 *Effects:* Equivalent to:
@@ -4246,11 +4163,11 @@ c.erase(it, c.end());
 return r;
 ```
 ``` cpp
 template<class T, class Allocator, class Predicate>
-  typename deque<T, Allocator>::size_type
     erase_if(deque<T, Allocator>& c, Predicate pred);
 ```
 *Effects:* Equivalent to:
@@ -4259,10 +4176,47 @@ auto it = remove_if(c.begin(), c.end(), pred);
 auto r = distance(it, c.end());
 c.erase(it, c.end());
 return r;
 ```
 ### Class template `forward_list` <a id="forward.list">[[forward.list]]</a>
 #### Overview <a id="forward.list.overview">[[forward.list.overview]]</a>
 A `forward_list` is a container that supports forward iterators and
@@ -4274,11 +4228,11 @@ access to list elements is not supported.
 overhead relative to a hand-written C-style singly linked list. Features
 that would conflict with that goal have been omitted. — *end note*]
 A `forward_list` meets all of the requirements of a container
 [[container.reqmts]], except that the `size()` member function is not
-provided and `operator==` has linear complexity, A `forward_list` also
 meets all of the requirements for an allocator-aware container
 [[container.alloc.reqmts]]. In addition, a `forward_list` provides the
 `assign` member functions and several of the optional sequence container
 requirements [[sequence.reqmts]]. Descriptions are provided here only
 for operations on `forward_list` that are not described in that table or
@@ -4288,127 +4242,133 @@ for operations where there is additional semantic information.
 the first element of interest, but in a `forward_list` there is no
 constant-time way to access a preceding element. For this reason,
 `erase_after` and `splice_after` take fully-open ranges, not semi-open
 ranges. — *end note*]
 ``` cpp
 namespace std {
   template<class T, class Allocator = allocator<T>>
   class forward_list {
   public:
     // types
     using value_type      = T;
     using allocator_type  = Allocator;
-    using pointer         = typename allocator_traits<Allocator>::pointer;
-    using const_pointer   = typename allocator_traits<Allocator>::const_pointer;
     using reference       = value_type&;
     using const_reference = const value_type&;
     using size_type       = implementation-defined  // type of forward_list::size_type; // see [container.requirements]
     using difference_type = implementation-defined  // type of forward_list::difference_type; // see [container.requirements]
     using iterator        = implementation-defined  // type of forward_list::iterator; // see [container.requirements]
     using const_iterator  = implementation-defined  // type of forward_list::const_iterator; // see [container.requirements]
     // [forward.list.cons], construct/copy/destroy
-    forward_list() : forward_list(Allocator()) { }
-    explicit forward_list(const Allocator&);
-    explicit forward_list(size_type n, const Allocator& = Allocator());
-    forward_list(size_type n, const T& value, const Allocator& = Allocator());
     template<class InputIterator>
-      forward_list(InputIterator first, InputIterator last, const Allocator& = Allocator());
     template<container-compatible-range<T> R>
-      forward_list(from_range_t, R&& rg, const Allocator& = Allocator());
-    forward_list(const forward_list& x);
-    forward_list(forward_list&& x);
-    forward_list(const forward_list& x, const type_identity_t<Allocator>&);
-    forward_list(forward_list&& x, const type_identity_t<Allocator>&);
-    forward_list(initializer_list<T>, const Allocator& = Allocator());
-    ~forward_list();
-    forward_list& operator=(const forward_list& x);
-    forward_list& operator=(forward_list&& x)
       noexcept(allocator_traits<Allocator>::is_always_equal::value);
-    forward_list& operator=(initializer_list<T>);
     template<class InputIterator>
-      void assign(InputIterator first, InputIterator last);
     template<container-compatible-range<T> R>
-      void assign_range(R&& rg);
-    void assign(size_type n, const T& t);
-    void assign(initializer_list<T>);
-    allocator_type get_allocator() const noexcept;
     // [forward.list.iter], iterators
-    iterator before_begin() noexcept;
-    const_iterator before_begin() const noexcept;
-    iterator begin() noexcept;
-    const_iterator begin() const noexcept;
-    iterator end() noexcept;
-    const_iterator end() const noexcept;
-    const_iterator cbegin() const noexcept;
-    const_iterator cbefore_begin() const noexcept;
-    const_iterator cend() const noexcept;
     // capacity
- [[nodiscard]] bool empty() const noexcept;
-    size_type max_size() const noexcept;
     // [forward.list.access], element access
-    reference front();
-    const_reference front() const;
     // [forward.list.modifiers], modifiers
-    template<class... Args> reference emplace_front(Args&&... args);
-    void push_front(const T& x);
-    void push_front(T&& x);
     template<container-compatible-range<T> R>
-      void prepend_range(R&& rg);
-    void pop_front();
-    template<class... Args> iterator emplace_after(const_iterator position, Args&&... args);
- iterator insert_after(const_iterator position, const T& x);
-    iterator insert_after(const_iterator position, T&& x);
-    iterator insert_after(const_iterator position, size_type n, const T& x);
     template<class InputIterator>
-      iterator insert_after(const_iterator position, InputIterator first, InputIterator last);
-    iterator insert_after(const_iterator position, initializer_list<T> il);
     template<container-compatible-range<T> R>
-      iterator insert_range_after(const_iterator position, R&& rg);
-    iterator erase_after(const_iterator position);
-    iterator erase_after(const_iterator position, const_iterator last);
-    void swap(forward_list&)
       noexcept(allocator_traits<Allocator>::is_always_equal::value);
-    void resize(size_type sz);
-    void resize(size_type sz, const value_type& c);
-    void clear() noexcept;
     // [forward.list.ops], forward_list operations
-    void splice_after(const_iterator position, forward_list& x);
-    void splice_after(const_iterator position, forward_list&& x);
-    void splice_after(const_iterator position, forward_list& x, const_iterator i);
-    void splice_after(const_iterator position, forward_list&& x, const_iterator i);
-    void splice_after(const_iterator position, forward_list& x,
                                 const_iterator first, const_iterator last);
-    void splice_after(const_iterator position, forward_list&& x,
                                 const_iterator first, const_iterator last);
-    size_type remove(const T& value);
-    template<class Predicate> size_type remove_if(Predicate pred);
     size_type unique();
-    template<class BinaryPredicate> size_type unique(BinaryPredicate binary_pred);
-    void merge(forward_list& x);
-    void merge(forward_list&& x);
-    template<class Compare> void merge(forward_list& x, Compare comp);
-    template<class Compare> void merge(forward_list&& x, Compare comp);
-    void sort();
-    template<class Compare> void sort(Compare comp);
-    void reverse() noexcept;
   };
   template<class InputIterator, class Allocator = allocator<iter-value-type<InputIterator>>>
     forward_list(InputIterator, InputIterator, Allocator = Allocator())
       -> forward_list<iter-value-type<InputIterator>, Allocator>;
@@ -4426,66 +4386,66 @@ any member of the resulting specialization of `forward_list` is
 referenced.
 #### Constructors, copy, and assignment <a id="forward.list.cons">[[forward.list.cons]]</a>
 ``` cpp
-explicit forward_list(const Allocator&);
 ```
 *Effects:* Constructs an empty `forward_list` object using the specified
 allocator.
 *Complexity:* Constant.
 ``` cpp
-explicit forward_list(size_type n, const Allocator& = Allocator());
 ```
-*Preconditions:* `T` is *Cpp17DefaultInsertable* into `*this`.
 *Effects:* Constructs a `forward_list` object with `n` default-inserted
 elements using the specified allocator.
 *Complexity:* Linear in `n`.
 ``` cpp
-forward_list(size_type n, const T& value, const Allocator& = Allocator());
 ```
-*Preconditions:* `T` is *Cpp17CopyInsertable* into `*this`.
 *Effects:* Constructs a `forward_list` object with `n` copies of `value`
 using the specified allocator.
 *Complexity:* Linear in `n`.
 ``` cpp
 template<class InputIterator>
-  forward_list(InputIterator first, InputIterator last, const Allocator& = Allocator());
 ```
 *Effects:* Constructs a `forward_list` object equal to the range
 \[`first`, `last`).
 *Complexity:* Linear in `distance(first, last)`.
 ``` cpp
 template<container-compatible-range<T> R>
-  forward_list(from_range_t, R&& rg, const Allocator& = Allocator());
 ```
 *Effects:* Constructs a `forward_list` object with the elements of the
 range `rg`.
 *Complexity:* Linear in `ranges::distance(rg)`.
 #### Iterators <a id="forward.list.iter">[[forward.list.iter]]</a>
 ``` cpp
-iterator before_begin() noexcept;
-const_iterator before_begin() const noexcept;
-const_iterator cbefore_begin() const noexcept;
 ```
 *Effects:* `cbefore_begin()` is equivalent to
 `const_cast<forward_list const&>(*this).before_begin()`.
@@ -4495,59 +4455,60 @@ equal to the iterator returned by `begin()`.
 *Remarks:* `before_begin() == end()` shall equal `false`.
 #### Element access <a id="forward.list.access">[[forward.list.access]]</a>
 ``` cpp
-reference front();
-const_reference front() const;
 ```
 *Returns:* `*begin()`
 #### Modifiers <a id="forward.list.modifiers">[[forward.list.modifiers]]</a>
-None of the overloads of `insert_after` shall affect the validity of
-iterators and references, and `erase_after` shall invalidate only
-iterators and references to the erased elements. If an exception is
-thrown during `insert_after` there shall be no effect. Inserting `n`
-elements into a `forward_list` is linear in `n`, and the number of calls
-to the copy or move constructor of `T` is exactly equal to `n`. Erasing
-`n` elements from a `forward_list` is linear in `n` and the number of
-calls to the destructor of type `T` is exactly equal to `n`.
 ``` cpp
-template<class... Args> reference emplace_front(Args&&... args);
 ```
 *Effects:* Inserts an object of type `value_type` constructed with
 `value_type(std::forward<Args>(args)...)` at the beginning of the list.
 ``` cpp
-void push_front(const T& x);
-void push_front(T&& x);
 ```
 *Effects:* Inserts a copy of `x` at the beginning of the list.
 ``` cpp
 template<container-compatible-range<T> R>
-  void prepend_range(R&& rg);
 ```
 *Effects:* Inserts a copy of each element of `rg` at the beginning of
 the list.
 [*Note 1*: The order of elements is not reversed. — *end note*]
 ``` cpp
-void pop_front();
 ```
 *Effects:* As if by `erase_after(before_begin())`.
 ``` cpp
-iterator insert_after(const_iterator position, const T& x);
 ```
 *Preconditions:* `T` is *Cpp17CopyInsertable* into `forward_list`.
 `position` is `before_begin()` or is a dereferenceable iterator in the
 range \[`begin()`, `end()`).
@@ -4555,11 +4516,11 @@ range \[`begin()`, `end()`).
 *Effects:* Inserts a copy of `x` after `position`.
 *Returns:* An iterator pointing to the copy of `x`.
 ``` cpp
-iterator insert_after(const_iterator position, T&& x);
 ```
 *Preconditions:* `T` is *Cpp17MoveInsertable* into `forward_list`.
 `position` is `before_begin()` or is a dereferenceable iterator in the
 range \[`begin()`, `end()`).
@@ -4567,11 +4528,11 @@ range \[`begin()`, `end()`).
 *Effects:* Inserts a copy of `x` after `position`.
 *Returns:* An iterator pointing to the copy of `x`.
 ``` cpp
-iterator insert_after(const_iterator position, size_type n, const T& x);
 ```
 *Preconditions:* `T` is *Cpp17CopyInsertable* into `forward_list`.
 `position` is `before_begin()` or is a dereferenceable iterator in the
 range \[`begin()`, `end()`).
@@ -4581,11 +4542,12 @@ range \[`begin()`, `end()`).
 *Returns:* An iterator pointing to the last inserted copy of `x`, or
 `position` if `n == 0` is `true`.
 ``` cpp
 template<class InputIterator>
-  iterator insert_after(const_iterator position, InputIterator first, InputIterator last);
 ```
 *Preconditions:* `T` is *Cpp17EmplaceConstructible* into `forward_list`
 from `*first`. `position` is `before_begin()` or is a dereferenceable
 iterator in the range \[`begin()`, `end()`). Neither `first` nor `last`
@@ -4597,11 +4559,11 @@ are iterators in `*this`.
 *Returns:* An iterator pointing to the last inserted element, or
 `position` if `first == last` is `true`.
 ``` cpp
 template<container-compatible-range<T> R>
-  iterator insert_range_after(const_iterator position, R&& rg);
 ```
 *Preconditions:* `T` is *Cpp17EmplaceConstructible* into `forward_list`
 from `*ranges::begin(rg)`. `position` is `before_begin()` or is a
 dereferenceable iterator in the range \[`begin()`, `end()`). `rg` and
@@ -4612,19 +4574,19 @@ dereferenceable iterator in the range \[`begin()`, `end()`). `rg` and
 *Returns:* An iterator pointing to the last inserted element, or
 `position` if `rg` is empty.
 ``` cpp
-iterator insert_after(const_iterator position, initializer_list<T> il);
 ```
 *Effects:* Equivalent to:
 `return insert_after(position, il.begin(), il.end());`
 ``` cpp
 template<class... Args>
-  iterator emplace_after(const_iterator position, Args&&... args);
 ```
 *Preconditions:* `T` is *Cpp17EmplaceConstructible* into `forward_list`
 from `std::forward<Args>(args)...`. `position` is `before_begin()` or is
 a dereferenceable iterator in the range \[`begin()`, `end()`).
@@ -4634,11 +4596,11 @@ direct-non-list-initialized with `std::forward<Args>(args)...` after
 `position`.
 *Returns:* An iterator pointing to the new object.
 ``` cpp
-iterator erase_after(const_iterator position);
 ```
 *Preconditions:* The iterator following `position` is dereferenceable.
 *Effects:* Erases the element pointed to by the iterator following
@@ -4648,11 +4610,11 @@ iterator erase_after(const_iterator position);
 was erased, or `end()` if no such element exists.
 *Throws:* Nothing.
 ``` cpp
-iterator erase_after(const_iterator position, const_iterator last);
 ```
 *Preconditions:* All iterators in the range (`position`, `last`) are
 dereferenceable.
@@ -4661,33 +4623,33 @@ dereferenceable.
 *Returns:* `last`.
 *Throws:* Nothing.
 ``` cpp
-void resize(size_type sz);
 ```
-*Preconditions:* `T` is *Cpp17DefaultInsertable* into `*this`.
 *Effects:* If `sz < distance(begin(), end())`, erases the last
 `distance(begin(), end()) - sz` elements from the list. Otherwise,
 inserts `sz - distance(begin(), end())` default-inserted elements at the
 end of the list.
 ``` cpp
-void resize(size_type sz, const value_type& c);
 ```
-*Preconditions:* `T` is *Cpp17CopyInsertable* into `*this`.
 *Effects:* If `sz < distance(begin(), end())`, erases the last
 `distance(begin(), end()) - sz` elements from the list. Otherwise,
 inserts `sz - distance(begin(), end())` copies of `c` at the end of the
 list.
 ``` cpp
-void clear() noexcept;
 ```
 *Effects:* Erases all elements in the range \[`begin()`, `end()`).
 *Remarks:* Does not invalidate past-the-end iterators.
@@ -4702,12 +4664,12 @@ iterator into the list and `n` is an integer, are the same as those of
 list and `n` is an integer, means an iterator `j` such that `j + n == i`
 is `true`. For `merge` and `sort`, the definitions and requirements in
 [[alg.sorting]] apply.
 ``` cpp
-void splice_after(const_iterator position, forward_list& x);
-void splice_after(const_iterator position, forward_list&& x);
 ```
 *Preconditions:* `position` is `before_begin()` or is a dereferenceable
 iterator in the range \[`begin()`, `end()`).
 `get_allocator() == x.get_allocator()` is `true`. `addressof(x) != this`
@@ -4722,12 +4684,12 @@ now behave as iterators into `*this`, not into `x`.
 *Throws:* Nothing.
 *Complexity:* 𝑂(`distance(x.begin(), x.end())`)
 ``` cpp
-void splice_after(const_iterator position, forward_list& x, const_iterator i);
-void splice_after(const_iterator position, forward_list&& x, const_iterator i);
 ```
 *Preconditions:* `position` is `before_begin()` or is a dereferenceable
 iterator in the range \[`begin()`, `end()`). The iterator following `i`
 is a dereferenceable iterator in `x`.
@@ -4743,13 +4705,13 @@ behave as iterators into `*this`, not into `x`.
 *Throws:* Nothing.
 *Complexity:* 𝑂(1)
 ``` cpp
-void splice_after(const_iterator position, forward_list& x,
                             const_iterator first, const_iterator last);
-void splice_after(const_iterator position, forward_list&& x,
                             const_iterator first, const_iterator last);
 ```
 *Preconditions:* `position` is `before_begin()` or is a dereferenceable
 iterator in the range \[`begin()`, `end()`). (`first`, `last`) is a
@@ -4765,12 +4727,12 @@ continue to refer to their elements, but they now behave as iterators
 into `*this`, not into `x`.
 *Complexity:* 𝑂(`distance(first, last)`)
 ``` cpp
-size_type remove(const T& value);
-template<class Predicate> size_type remove_if(Predicate pred);
 ```
 *Effects:* Erases all the elements in the list referred to by a list
 iterator `i` for which the following conditions hold: `*i == value` (for
 `remove()`), `pred(*i)` is `true` (for `remove_if()`). Invalidates only
@@ -4785,12 +4747,12 @@ comparison or the predicate.
 corresponding predicate.
 *Remarks:* Stable [[algorithm.stable]].
 ``` cpp
-size_type unique();
-template<class BinaryPredicate> size_type unique(BinaryPredicate binary_pred);
 ```
 Let `binary_pred` be `equal_to<>{}` for the first overload.
 *Preconditions:* `binary_pred` is an equivalence relation.
@@ -4808,14 +4770,14 @@ only the iterators and references to the erased elements.
 *Complexity:* If `empty()` is `false`, exactly
 `distance(begin(), end()) - 1` applications of the corresponding
 predicate, otherwise no applications of the predicate.
 ``` cpp
-void merge(forward_list& x);
-void merge(forward_list&& x);
-template<class Compare> void merge(forward_list& x, Compare comp);
-template<class Compare> void merge(forward_list&& x, Compare comp);
 ```
 Let `comp` be `less<>` for the first two overloads.
 *Preconditions:* `*this` and `x` are both sorted with respect to the
@@ -4837,12 +4799,12 @@ performed.
 *Remarks:* Stable [[algorithm.stable]]. If `addressof(x) != this`, `x`
 is empty after the merge. No elements are copied by this operation. If
 an exception is thrown other than by a comparison, there are no effects.
 ``` cpp
-void sort();
-template<class Compare> void sort(Compare comp);
 ```
 *Effects:* Sorts the list according to the `operator<` or the `comp`
 function object. If an exception is thrown, the order of the elements in
 `*this` is unspecified. Does not affect the validity of iterators and
@@ -4852,37 +4814,847 @@ references.
 `distance(begin(), end())`.
 *Remarks:* Stable [[algorithm.stable]].
 ``` cpp
-void reverse() noexcept;
 ```
 *Effects:* Reverses the order of the elements in the list. Does not
 affect the validity of iterators and references.
 *Complexity:* Linear time.
 #### Erasure <a id="forward.list.erasure">[[forward.list.erasure]]</a>
 ``` cpp
-template<class T, class Allocator, class U>
-  typename forward_list<T, Allocator>::size_type
     erase(forward_list<T, Allocator>& c, const U& value);
 ```
 *Effects:* Equivalent to:
-`return erase_if(c, [&](auto& elem) { return elem == value; });`
 ``` cpp
 template<class T, class Allocator, class Predicate>
-  typename forward_list<T, Allocator>::size_type
     erase_if(forward_list<T, Allocator>& c, Predicate pred);
 ```
 *Effects:* Equivalent to: `return c.remove_if(pred);`
 ### Class template `list` <a id="list">[[list]]</a>
 #### Overview <a id="list.overview">[[list.overview]]</a>
 A `list` is a sequence container that supports bidirectional iterators
@@ -4901,137 +5673,143 @@ provided.[^2]
 Descriptions are provided here only for operations on `list` that are
 not described in one of these tables or for operations where there is
 additional semantic information.
 ``` cpp
 namespace std {
   template<class T, class Allocator = allocator<T>>
   class list {
   public:
     // types
     using value_type             = T;
     using allocator_type         = Allocator;
-    using pointer                = typename allocator_traits<Allocator>::pointer;
-    using const_pointer          = typename allocator_traits<Allocator>::const_pointer;
     using reference              = value_type&;
     using const_reference        = const value_type&;
     using size_type              = implementation-defined  // type of list::size_type; // see [container.requirements]
     using difference_type        = implementation-defined  // type of list::difference_type; // see [container.requirements]
     using iterator               = implementation-defined  // type of list::iterator; // see [container.requirements]
     using const_iterator         = implementation-defined  // type of list::const_iterator; // see [container.requirements]
     using reverse_iterator       = std::reverse_iterator<iterator>;
     using const_reverse_iterator = std::reverse_iterator<const_iterator>;
     // [list.cons], construct/copy/destroy
-    list() : list(Allocator()) { }
-    explicit list(const Allocator&);
-    explicit list(size_type n, const Allocator& = Allocator());
-    list(size_type n, const T& value, const Allocator& = Allocator());
     template<class InputIterator>
-      list(InputIterator first, InputIterator last, const Allocator& = Allocator());
     template<container-compatible-range<T> R>
-      list(from_range_t, R&& rg, const Allocator& = Allocator());
-    list(const list& x);
-    list(list&& x);
-    list(const list&, const type_identity_t<Allocator>&);
-    list(list&&, const type_identity_t<Allocator>&);
-    list(initializer_list<T>, const Allocator& = Allocator());
-    ~list();
-    list& operator=(const list& x);
-    list& operator=(list&& x)
       noexcept(allocator_traits<Allocator>::is_always_equal::value);
-    list& operator=(initializer_list<T>);
     template<class InputIterator>
-      void assign(InputIterator first, InputIterator last);
     template<container-compatible-range<T> R>
-      void assign_range(R&& rg);
-    void assign(size_type n, const T& t);
-    void assign(initializer_list<T>);
-    allocator_type get_allocator() const noexcept;
     // 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;
     // [list.capacity], capacity
- [[nodiscard]] bool empty() const noexcept;
-    size_type size() const noexcept;
-    size_type max_size() const noexcept;
-    void      resize(size_type sz);
-    void      resize(size_type sz, const T& c);
     // element access
-    reference       front();
-    const_reference front() const;
-    reference       back();
-    const_reference back() const;
     // [list.modifiers], modifiers
-    template<class... Args> reference emplace_front(Args&&... args);
-    template<class... Args> reference emplace_back(Args&&... args);
-    void push_front(const T& x);
-    void push_front(T&& x);
     template<container-compatible-range<T> R>
-      void prepend_range(R&& rg);
-    void pop_front();
-    void push_back(const T& x);
-    void push_back(T&& x);
     template<container-compatible-range<T> R>
-      void append_range(R&& rg);
-    void pop_back();
-    template<class... Args> iterator emplace(const_iterator position, Args&&... args);
-    iterator insert(const_iterator position, const T& x);
-    iterator insert(const_iterator position, T&& x);
-    iterator insert(const_iterator position, size_type n, const T& x);
     template<class InputIterator>
-      iterator insert(const_iterator position, InputIterator first, InputIterator last);
     template<container-compatible-range<T> R>
-      iterator insert_range(const_iterator position, R&& rg);
-    iterator insert(const_iterator position, initializer_list<T> il);
-    iterator erase(const_iterator position);
-    iterator erase(const_iterator position, const_iterator last);
-    void     swap(list&) noexcept(allocator_traits<Allocator>::is_always_equal::value);
-    void     clear() noexcept;
     // [list.ops], list operations
-    void splice(const_iterator position, list& x);
-    void splice(const_iterator position, list&& x);
-    void splice(const_iterator position, list& x, const_iterator i);
-    void splice(const_iterator position, list&& x, const_iterator i);
-    void splice(const_iterator position, list& x, const_iterator first, const_iterator last);
-    void splice(const_iterator position, list&& x, const_iterator first, const_iterator last);
-    size_type remove(const T& value);
-    template<class Predicate> size_type remove_if(Predicate pred);
-    size_type unique();
     template<class BinaryPredicate>
-      size_type unique(BinaryPredicate binary_pred);
-    void merge(list& x);
-    void merge(list&& x);
-    template<class Compare> void merge(list& x, Compare comp);
-    template<class Compare> void merge(list&& x, Compare comp);
-    void sort();
-    template<class Compare> void sort(Compare comp);
-    void reverse() noexcept;
   };
   template<class InputIterator, class Allocator = allocator<iter-value-type<InputIterator>>>
     list(InputIterator, InputIterator, Allocator = Allocator())
       -> list<iter-value-type<InputIterator>, Allocator>;
@@ -5048,65 +5826,65 @@ allocator meets the allocator completeness requirements
 any member of the resulting specialization of `list` is referenced.
 #### Constructors, copy, and assignment <a id="list.cons">[[list.cons]]</a>
 ``` cpp
-explicit list(const Allocator&);
 ```
 *Effects:* Constructs an empty list, using the specified allocator.
 *Complexity:* Constant.
 ``` cpp
-explicit list(size_type n, const Allocator& = Allocator());
 ```
-*Preconditions:* `T` is *Cpp17DefaultInsertable* into `*this`.
 *Effects:* Constructs a `list` with `n` default-inserted elements using
 the specified allocator.
 *Complexity:* Linear in `n`.
 ``` cpp
-list(size_type n, const T& value, const Allocator& = Allocator());
 ```
-*Preconditions:* `T` is *Cpp17CopyInsertable* into `*this`.
 *Effects:* Constructs a `list` with `n` copies of `value`, using the
 specified allocator.
 *Complexity:* Linear in `n`.
 ``` cpp
 template<class InputIterator>
-  list(InputIterator first, InputIterator last, const Allocator& = Allocator());
 ```
 *Effects:* Constructs a `list` equal to the range \[`first`, `last`).
 *Complexity:* Linear in `distance(first, last)`.
 ``` cpp
 template<container-compatible-range<T> R>
-  list(from_range_t, R&& rg, const Allocator& = Allocator());
 ```
 *Effects:* Constructs a `list` object with the elements of the range
 `rg`.
 *Complexity:* Linear in `ranges::distance(rg)`.
 #### Capacity <a id="list.capacity">[[list.capacity]]</a>
 ``` cpp
-void resize(size_type sz);
 ```
-*Preconditions:* `T` is *Cpp17DefaultInsertable* into `*this`.
 *Effects:* If `size() < sz`, appends `sz - size()` default-inserted
 elements to the sequence. If `sz <= size()`, equivalent to:
 ``` cpp
@@ -5114,14 +5892,14 @@ list<T>::iterator it = begin();
 advance(it, sz);
 erase(it, end());
 ```
 ``` cpp
-void resize(size_type sz, const T& c);
 ```
-*Preconditions:* `T` is *Cpp17CopyInsertable* into `*this`.
 *Effects:* As if by:
 ``` cpp
 if (sz > size())
@@ -5136,49 +5914,48 @@ else
 ```
 #### Modifiers <a id="list.modifiers">[[list.modifiers]]</a>
 ``` cpp
-iterator insert(const_iterator position, const T& x);
-iterator insert(const_iterator position, T&& x);
-iterator insert(const_iterator position, size_type n, const T& x);
 template<class InputIterator>
-  iterator insert(const_iterator position, InputIterator first,
- InputIterator last);
 template<container-compatible-range<T> R>
-  iterator insert_range(const_iterator position, R&& rg);
-iterator insert(const_iterator position, initializer_list<T>);
-template<class... Args> reference emplace_front(Args&&... args);
-template<class... Args> reference emplace_back(Args&&... args);
-template<class... Args> iterator emplace(const_iterator position, Args&&... args);
-void push_front(const T& x);
-void push_front(T&& x);
 template<container-compatible-range<T> R>
-  void prepend_range(R&& rg);
-void push_back(const T& x);
-void push_back(T&& x);
 template<container-compatible-range<T> R>
-  void append_range(R&& rg);
 ```
 *Complexity:* Insertion of a single element into a list takes constant
 time and exactly one call to a constructor of `T`. Insertion of multiple
 elements into a list is linear in the number of elements inserted, and
 the number of calls to the copy constructor or move constructor of `T`
 is exactly equal to the number of elements inserted.
 *Remarks:* Does not affect the validity of iterators and references. If
-an exception is thrown there are no effects.
 ``` cpp
-iterator erase(const_iterator position);
-iterator erase(const_iterator first, const_iterator last);
-void pop_front();
-void pop_back();
-void clear() noexcept;
 ```
 *Effects:* Invalidates only the iterators and references to the erased
 elements.
@@ -5205,12 +5982,12 @@ those of `next(i, n)` and `prev(i, n)`, respectively. For `merge` and
 from one list to another. The behavior of splice operations is undefined
 if `get_allocator() !=
 x.get_allocator()`.
 ``` cpp
-void splice(const_iterator position, list& x);
-void splice(const_iterator position, list&& x);
 ```
 *Preconditions:* `addressof(x) != this` is `true`.
 *Effects:* Inserts the contents of `x` before `position` and `x` becomes
@@ -5222,12 +5999,12 @@ now behave as iterators into `*this`, not into `x`.
 *Throws:* Nothing.
 *Complexity:* Constant time.
 ``` cpp
-void splice(const_iterator position, list& x, const_iterator i);
-void splice(const_iterator position, list&& x, const_iterator i);
 ```
 *Preconditions:* `i` is a valid dereferenceable iterator of `x`.
 *Effects:* Inserts an element pointed to by `i` from list `x` before
@@ -5240,18 +6017,18 @@ element, but now behave as iterators into `*this`, not into `x`.
 *Throws:* Nothing.
 *Complexity:* Constant time.
 ``` cpp
-void splice(const_iterator position, list& x, const_iterator first,
- const_iterator last);
-void splice(const_iterator position, list&& x, const_iterator first,
- const_iterator last);
 ```
-*Preconditions:* `[first, last)` is a valid range in `x`. `position` is
-not an iterator in the range \[`first`, `last`).
 *Effects:* Inserts elements in the range \[`first`, `last`) before
 `position` and removes the elements from `x`. Pointers and references to
 the moved elements of `x` now refer to those same elements but as
 members of `*this`. Iterators referring to the moved elements will
@@ -5262,12 +6039,12 @@ into `*this`, not into `x`.
 *Complexity:* Constant time if `addressof(x) == this`; otherwise, linear
 time.
 ``` cpp
-size_type remove(const T& value);
-template<class Predicate> size_type remove_if(Predicate pred);
 ```
 *Effects:* Erases all the elements in the list referred to by a list
 iterator `i` for which the following conditions hold: `*i == value`,
 `pred(*i) != false`. Invalidates only the iterators and references to
@@ -5282,12 +6059,12 @@ the erased elements.
 predicate.
 *Remarks:* Stable [[algorithm.stable]].
 ``` cpp
-size_type unique();
-template<class BinaryPredicate> size_type unique(BinaryPredicate binary_pred);
 ```
 Let `binary_pred` be `equal_to<>{}` for the first overload.
 *Preconditions:* `binary_pred` is an equivalence relation.
@@ -5305,14 +6082,14 @@ only the iterators and references to the erased elements.
 *Complexity:* If `empty()` is `false`, exactly `size() - 1` applications
 of the corresponding predicate, otherwise no applications of the
 predicate.
 ``` cpp
-void merge(list& x);
-void merge(list&& x);
-template<class Compare> void merge(list& x, Compare comp);
-template<class Compare> void merge(list&& x, Compare comp);
 ```
 Let `comp` be `less<>` for the first two overloads.
 *Preconditions:* `*this` and `x` are both sorted with respect to the
@@ -5329,14 +6106,14 @@ elements, but they now behave as iterators into `*this`, not into `x`.
 *Complexity:* At most `size() + x.size() - 1` comparisons if
 `addressof(x) != this`; otherwise, no comparisons are performed.
 *Remarks:* Stable [[algorithm.stable]]. If `addressof(x) != this`, `x`
 is empty after the merge. No elements are copied by this operation. If
-an exception is thrown other than by a comparison there are no effects.
 ``` cpp
-void reverse() noexcept;
 ```
 *Effects:* Reverses the order of the elements in the list. Does not
 affect the validity of iterators and references.
@@ -5350,33 +6127,87 @@ template<class Compare> void sort(Compare comp);
 *Effects:* Sorts the list according to the `operator<` or a `Compare`
 function object. If an exception is thrown, the order of the elements in
 `*this` is unspecified. Does not affect the validity of iterators and
 references.
-*Complexity:* Approximately N log N comparisons, where `N == size()`.
 *Remarks:* Stable [[algorithm.stable]].
 #### Erasure <a id="list.erasure">[[list.erasure]]</a>
 ``` cpp
-template<class T, class Allocator, class U>
   typename list<T, Allocator>::size_type
-    erase(list<T, Allocator>& c, const U& value);
 ```
 *Effects:* Equivalent to:
-`return erase_if(c, [&](auto& elem) { return elem == value; });`
 ``` cpp
 template<class T, class Allocator, class Predicate>
   typename list<T, Allocator>::size_type
-    erase_if(list<T, Allocator>& c, Predicate pred);
 ```
 *Effects:* Equivalent to: `return c.remove_if(pred);`
 ### Class template `vector` <a id="vector">[[vector]]</a>
 #### Overview <a id="vector.overview">[[vector.overview]]</a>
 A `vector` is a sequence container that supports (amortized) constant
@@ -5405,12 +6236,12 @@ namespace std {
   class vector {
   public:
     // types
     using value_type             = T;
     using allocator_type         = Allocator;
-    using pointer                = typename allocator_traits<Allocator>::pointer;
-    using const_pointer          = typename allocator_traits<Allocator>::const_pointer;
     using reference              = value_type&;
     using const_reference        = const value_type&;
     using size_type              = implementation-defined  // type of vector::size_type; // see [container.requirements]
     using difference_type        = implementation-defined  // type of vector::difference_type; // see [container.requirements]
     using iterator               = implementation-defined  // type of vector::iterator; // see [container.requirements]
@@ -5460,11 +6291,11 @@ namespace std {
     constexpr const_iterator         cend() const noexcept;
     constexpr const_reverse_iterator crbegin() const noexcept;
     constexpr const_reverse_iterator crend() const noexcept;
     // [vector.capacity], capacity
- [[nodiscard]] constexpr bool empty() const noexcept;
     constexpr size_type size() const noexcept;
     constexpr size_type max_size() const noexcept;
     constexpr size_type capacity() const noexcept;
     constexpr void      resize(size_type sz);
     constexpr void      resize(size_type sz, const T& c);
@@ -5472,12 +6303,12 @@ namespace std {
     constexpr void      shrink_to_fit();
     // element access
     constexpr reference       operator[](size_type n);
     constexpr const_reference operator[](size_type n) const;
-    constexpr const_reference at(size_type n) const;
     constexpr reference       at(size_type n);
     constexpr reference       front();
     constexpr const_reference front() const;
     constexpr reference       back();
     constexpr const_reference back() const;
@@ -5538,11 +6369,11 @@ constexpr explicit vector(const Allocator&) noexcept;
 ``` cpp
 constexpr explicit vector(size_type n, const Allocator& = Allocator());
 ```
-*Preconditions:* `T` is *Cpp17DefaultInsertable* into `*this`.
 *Effects:* Constructs a `vector` with `n` default-inserted elements
 using the specified allocator.
 *Complexity:* Linear in `n`.
@@ -5550,11 +6381,11 @@ using the specified allocator.
 ``` cpp
 constexpr vector(size_type n, const T& value,
                  const Allocator& = Allocator());
 ```
-*Preconditions:* `T` is *Cpp17CopyInsertable* into `*this`.
 *Effects:* Constructs a `vector` with `n` copies of `value`, using the
 specified allocator.
 *Complexity:* Linear in `n`.
@@ -5568,13 +6399,13 @@ template<class InputIterator>
 *Effects:* Constructs a `vector` equal to the range \[`first`, `last`),
 using the specified allocator.
 *Complexity:* Makes only N calls to the copy constructor of `T` (where N
 is the distance between `first` and `last`) and no reallocations if
-iterators `first` and `last` are of forward, bidirectional, or random
-access categories. It makes order N calls to the copy constructor of `T`
-and order log N reallocations if they are just input iterators.
 ``` cpp
 template<container-compatible-range<T> R>
   constexpr vector(from_range_t, R&& rg, const Allocator& = Allocator());
 ```
@@ -5582,14 +6413,21 @@ template<container-compatible-range<T> R>
 *Effects:* Constructs a `vector` object with the elements of the range
 `rg`, using the specified allocator.
 *Complexity:* Initializes exactly N elements from the results of
 dereferencing successive iterators of `rg`, where N is
-`ranges::distance(rg)`. Performs no reallocations if `R` models
-`ranges::forward_range` or `ranges::sized_range`; otherwise, performs
-order log N reallocations and order N calls to the copy or move
-constructor of `T`.
 #### Capacity <a id="vector.capacity">[[vector.capacity]]</a>
 ``` cpp
 constexpr size_type capacity() const noexcept;
@@ -5602,11 +6440,11 @@ requiring reallocation.
 ``` cpp
 constexpr void reserve(size_type n);
 ```
-*Preconditions:* `T` is *Cpp17MoveInsertable* into `*this`.
 *Effects:* A directive that informs a `vector` of a planned change in
 size, so that it can manage the storage allocation accordingly. After
 `reserve()`, `capacity()` is greater or equal to the argument of
 `reserve` if reallocation happens; and equal to the previous value of
@@ -5615,16 +6453,15 @@ if the current capacity is less than the argument of `reserve()`. If an
 exception is thrown other than by the move constructor of a
 non-*Cpp17CopyInsertable* type, there are no effects.
 *Throws:* `length_error` if `n > max_size()`.[^4]
-*Complexity:* It does not change the size of the sequence and takes at
-most linear time in the size of the sequence.
-*Remarks:* Reallocation invalidates all the references, pointers, and
-iterators referring to the elements in the sequence, as well as the
-past-the-end iterator.
 [*Note 1*: If no reallocation happens, they remain
 valid. — *end note*]
 No reallocation shall take place during insertions that happen after a
@@ -5633,21 +6470,21 @@ greater than the value of `capacity()`.
 ``` cpp
 constexpr void shrink_to_fit();
 ```
-*Preconditions:* `T` is *Cpp17MoveInsertable* into `*this`.
 *Effects:* `shrink_to_fit` is a non-binding request to reduce
 `capacity()` to `size()`.
 [*Note 2*: The request is non-binding to allow latitude for
 implementation-specific optimizations. — *end note*]
 It does not increase `capacity()`, but may reduce `capacity()` by
 causing reallocation. If an exception is thrown other than by the move
-constructor of a non-*Cpp17CopyInsertable* `T` there are no effects.
 *Complexity:* If reallocation happens, linear in the size of the
 sequence.
 *Remarks:* Reallocation invalidates all the references, pointers, and
@@ -5671,40 +6508,40 @@ of `x`.
 ``` cpp
 constexpr void resize(size_type sz);
 ```
 *Preconditions:* `T` is *Cpp17MoveInsertable* and
-*Cpp17DefaultInsertable* into `*this`.
 *Effects:* If `sz < size()`, erases the last `size() - sz` elements from
 the sequence. Otherwise, appends `sz - size()` default-inserted elements
 to the sequence.
 *Remarks:* If an exception is thrown other than by the move constructor
-of a non-*Cpp17CopyInsertable* `T` there are no effects.
 ``` cpp
 constexpr void resize(size_type sz, const T& c);
 ```
-*Preconditions:* `T` is *Cpp17CopyInsertable* into `*this`.
 *Effects:* If `sz < size()`, erases the last `size() - sz` elements from
 the sequence. Otherwise, appends `sz - size()` copies of `c` to the
 sequence.
-*Remarks:* If an exception is thrown there are no effects.
 #### Data <a id="vector.data">[[vector.data]]</a>
 ``` cpp
 constexpr T*       data() noexcept;
 constexpr const T* data() const noexcept;
 ```
 *Returns:* A pointer such that \[`data()`, `data() + size()`) is a valid
-range. For a non-empty vector, `data()` `==` `addressof(front())`.
 *Complexity:* Constant time.
 #### Modifiers <a id="vector.modifiers">[[vector.modifiers]]</a>
@@ -5736,17 +6573,29 @@ iterators referring to the elements in the sequence, as well as the
 past-the-end iterator. If no reallocation happens, then references,
 pointers, and iterators before the insertion point remain valid but
 those at or after the insertion point, including the past-the-end
 iterator, are invalidated. If an exception is thrown other than by the
 copy constructor, move constructor, assignment operator, or move
-assignment operator of `T` or by any `InputIterator` operation there are
-no effects. If an exception is thrown while inserting a single element
-at the end and `T` is *Cpp17CopyInsertable* or
 `is_nothrow_move_constructible_v<T>` is `true`, there are no effects.
 Otherwise, if an exception is thrown by the move constructor of a
 non-*Cpp17CopyInsertable* `T`, the effects are unspecified.
 ``` cpp
 constexpr iterator erase(const_iterator position);
 constexpr iterator erase(const_iterator first, const_iterator last);
 constexpr void pop_back();
 ```
@@ -5763,11 +6612,11 @@ is called the number of times equal to the number of elements in the
 vector after the erased elements.
 #### Erasure <a id="vector.erasure">[[vector.erasure]]</a>
 ``` cpp
-template<class T, class Allocator, class U>
   constexpr typename vector<T, Allocator>::size_type
     erase(vector<T, Allocator>& c, const U& value);
 ```
 *Effects:* Equivalent to:
@@ -5819,13 +6668,10 @@ namespace std {
     using reverse_iterator       = std::reverse_iterator<iterator>;
     using const_reverse_iterator = std::reverse_iterator<const_iterator>;
     // bit reference
     class reference {
-      friend class vector;
-      constexpr reference() noexcept;
     public:
       constexpr reference(const reference&) = default;
       constexpr ~reference();
       constexpr operator bool() const noexcept;
       constexpr reference& operator=(bool x) noexcept;
@@ -5876,23 +6722,23 @@ namespace std {
     constexpr const_iterator         cend() const noexcept;
     constexpr const_reverse_iterator crbegin() const noexcept;
     constexpr const_reverse_iterator crend() const noexcept;
     // capacity
- [[nodiscard]] constexpr bool empty() const noexcept;
     constexpr size_type size() const noexcept;
     constexpr size_type max_size() const noexcept;
     constexpr size_type capacity() const noexcept;
     constexpr void      resize(size_type sz, bool c = false);
     constexpr void      reserve(size_type n);
     constexpr void      shrink_to_fit();
     // element access
     constexpr reference       operator[](size_type n);
     constexpr const_reference operator[](size_type n) const;
-    constexpr const_reference at(size_type n) const;
     constexpr reference       at(size_type n);
     constexpr reference       front();
     constexpr const_reference front() const;
     constexpr reference       back();
     constexpr const_reference back() const;
@@ -5923,11 +6769,11 @@ namespace std {
   };
 }
 ```
 Unless described below, all operations have the same requirements and
-semantics as the primary `vector` template, except that operations
 dealing with the `bool` value type map to bit values in the container
 storage and `allocator_traits::construct` [[allocator.traits.members]]
 is not used to construct these values.
 There is no requirement that the data be stored as a contiguous
@@ -6011,42 +6857,515 @@ template<class FormatContext>
     format(const T& ref, FormatContext& ctx) const;
 ```
 Equivalent to: `return `*`underlying_`*`.format(ref, ctx);`
 ## Associative containers <a id="associative">[[associative]]</a>
-### In general <a id="associative.general">[[associative.general]]</a>
 The header `<map>` defines the class templates `map` and `multimap`; the
 header `<set>` defines the class templates `set` and `multiset`.
 The following exposition-only alias templates may appear in deduction
 guides for associative containers:
 ``` cpp
 template<class InputIterator>
-  using iter-value-type =
-    typename iterator_traits<InputIterator>::value_type;                // exposition only
 template<class InputIterator>
   using iter-key-type = remove_const_t<
     tuple_element_t<0, iter-value-type<InputIterator>>>;                // exposition only
 template<class InputIterator>
   using iter-mapped-type =
     tuple_element_t<1, iter-value-type<InputIterator>>;                 // exposition only
 template<class InputIterator>
   using iter-to-alloc-type = pair<
- add_const_t<tuple_element_t<0, iter-value-type<InputIterator>>>,
     tuple_element_t<1, iter-value-type<InputIterator>>>;                // exposition only
 template<ranges::input_range Range>
   using range-key-type =
     remove_const_t<typename ranges::range_value_t<Range>::first_type>;  // exposition only
 template<ranges::input_range Range>
-  using range-mapped-type = typename ranges::range_value_t<Range>::second_type; // exposition only
 template<ranges::input_range Range>
   using range-to-alloc-type =
-    pair<add_const_t<typename ranges::range_value_t<Range>::first_type>,
          typename ranges::range_value_t<Range>::second_type>;           // exposition only
 ```
 ### Header `<map>` synopsis <a id="associative.map.syn">[[associative.map.syn]]</a>
@@ -6059,48 +7378,48 @@ namespace std {
   template<class Key, class T, class Compare = less<Key>,
            class Allocator = allocator<pair<const Key, T>>>
     class map;
   template<class Key, class T, class Compare, class Allocator>
-    bool operator==(const map<Key, T, Compare, Allocator>& x,
                               const map<Key, T, Compare, Allocator>& y);
   template<class Key, class T, class Compare, class Allocator>
-    synth-three-way-result<pair<const Key, T>>
       operator<=>(const map<Key, T, Compare, Allocator>& x,
                   const map<Key, T, Compare, Allocator>& y);
   template<class Key, class T, class Compare, class Allocator>
-    void swap(map<Key, T, Compare, Allocator>& x,
                         map<Key, T, Compare, Allocator>& y)
       noexcept(noexcept(x.swap(y)));
   // [map.erasure], erasure for map
   template<class Key, class T, class Compare, class Allocator, class Predicate>
-    typename map<Key, T, Compare, Allocator>::size_type
       erase_if(map<Key, T, Compare, Allocator>& c, Predicate pred);
   // [multimap], class template multimap
   template<class Key, class T, class Compare = less<Key>,
            class Allocator = allocator<pair<const Key, T>>>
     class multimap;
   template<class Key, class T, class Compare, class Allocator>
-    bool operator==(const multimap<Key, T, Compare, Allocator>& x,
                               const multimap<Key, T, Compare, Allocator>& y);
   template<class Key, class T, class Compare, class Allocator>
-    synth-three-way-result<pair<const Key, T>>
       operator<=>(const multimap<Key, T, Compare, Allocator>& x,
                   const multimap<Key, T, Compare, Allocator>& y);
   template<class Key, class T, class Compare, class Allocator>
-    void swap(multimap<Key, T, Compare, Allocator>& x,
               multimap<Key, T, Compare, Allocator>& y)
       noexcept(noexcept(x.swap(y)));
   // [multimap.erasure], erasure for multimap
   template<class Key, class T, class Compare, class Allocator, class Predicate>
-    typename multimap<Key, T, Compare, Allocator>::size_type
       erase_if(multimap<Key, T, Compare, Allocator>& c, Predicate pred);
   namespace pmr {
     template<class Key, class T, class Compare = less<Key>>
       using map = std::map<Key, T, Compare,
@@ -6111,69 +7430,10 @@ namespace std {
                                      polymorphic_allocator<pair<const Key, T>>>;
   }
 }
 ```
-### Header `<set>` synopsis <a id="associative.set.syn">[[associative.set.syn]]</a>
-``` cpp
-#include <compare>              // see [compare.syn]
-#include <initializer_list>     // see [initializer.list.syn]
-namespace std {
-  // [set], class template set
-  template<class Key, class Compare = less<Key>, class Allocator = allocator<Key>>
-    class set;
-  template<class Key, class Compare, class Allocator>
-    bool operator==(const set<Key, Compare, Allocator>& x,
-                    const set<Key, Compare, Allocator>& y);
-  template<class Key, class Compare, class Allocator>
-    synth-three-way-result<Key> operator<=>(const set<Key, Compare, Allocator>& x,
-    \itcorr                                        const set<Key, Compare, Allocator>& y);
-  template<class Key, class Compare, class Allocator>
-    void swap(set<Key, Compare, Allocator>& x,
-              set<Key, Compare, Allocator>& y)
-      noexcept(noexcept(x.swap(y)));
-  // [set.erasure], erasure for set
-  template<class Key, class Compare, class Allocator, class Predicate>
-    typename set<Key, Compare, Allocator>::size_type
-      erase_if(set<Key, Compare, Allocator>& c, Predicate pred);
-  // [multiset], class template multiset
-  template<class Key, class Compare = less<Key>, class Allocator = allocator<Key>>
-    class multiset;
-  template<class Key, class Compare, class Allocator>
-    bool operator==(const multiset<Key, Compare, Allocator>& x,
-                    const multiset<Key, Compare, Allocator>& y);
-  template<class Key, class Compare, class Allocator>
-    synth-three-way-result<Key> operator<=>(const multiset<Key, Compare, Allocator>& x,
-    \itcorr                                        const multiset<Key, Compare, Allocator>& y);
-  template<class Key, class Compare, class Allocator>
-    void swap(multiset<Key, Compare, Allocator>& x,
-              multiset<Key, Compare, Allocator>& y)
-      noexcept(noexcept(x.swap(y)));
-  // [multiset.erasure], erasure for multiset
-  template<class Key, class Compare, class Allocator, class Predicate>
-    typename multiset<Key, Compare, Allocator>::size_type
-      erase_if(multiset<Key, Compare, Allocator>& c, Predicate pred);
-  namespace pmr {
-    template<class Key, class Compare = less<Key>>
-      using set = std::set<Key, Compare, polymorphic_allocator<Key>>;
-    template<class Key, class Compare = less<Key>>
-      using multiset = std::multiset<Key, Compare, polymorphic_allocator<Key>>;
-  }
-}
-```
 ### Class template `map` <a id="map">[[map]]</a>
 #### Overview <a id="map.overview">[[map.overview]]</a>
 A `map` is an associative container that supports unique keys (i.e.,
@@ -6182,19 +7442,22 @@ of values of another type `T` based on the keys. The `map` class
 supports bidirectional iterators.
 A `map` meets all of the requirements of a container
 [[container.reqmts]], of a reversible container
 [[container.rev.reqmts]], of an allocator-aware container
-[[container.alloc.reqmts]]. and of an associative container
 [[associative.reqmts]]. A `map` also provides most operations described
 in  [[associative.reqmts]] for unique keys. This means that a `map`
 supports the `a_uniq` operations in  [[associative.reqmts]] but not the
 `a_eq` operations. For a `map<Key,T>` the `key_type` is `Key` and the
 `value_type` is `pair<const Key,T>`. Descriptions are provided here only
 for operations on `map` that are not described in one of those tables or
 for operations where there is additional semantic information.
 ``` cpp
 namespace std {
   template<class Key, class T, class Compare = less<Key>,
            class Allocator = allocator<pair<const Key, T>>>
   class map {
@@ -6203,12 +7466,12 @@ namespace std {
     using key_type               = Key;
     using mapped_type            = T;
     using value_type             = pair<const Key, T>;
     using key_compare            = Compare;
     using allocator_type         = Allocator;
-    using pointer                = typename allocator_traits<Allocator>::pointer;
-    using const_pointer          = typename allocator_traits<Allocator>::const_pointer;
     using reference              = value_type&;
     using const_reference        = const value_type&;
     using size_type              = implementation-defined  // type of map::size_type; // see [container.requirements]
     using difference_type        = implementation-defined  // type of map::difference_type; // see [container.requirements]
     using iterator               = implementation-defined  // type of map::iterator; // see [container.requirements]
@@ -6217,170 +7480,181 @@ namespace std {
     using const_reverse_iterator = std::reverse_iterator<const_iterator>;
     using node_type              = unspecified;
     using insert_return_type     = insert-return-type<iterator, node_type>;
     class value_compare {
-      friend class map;
     protected:
       Compare comp;
-      value_compare(Compare c) : comp(c) {}
     public:
-      bool operator()(const value_type& x, const value_type& y) const {
         return comp(x.first, y.first);
       }
     };
     // [map.cons], construct/copy/destroy
-    map() : map(Compare()) { }
-    explicit map(const Compare& comp, const Allocator& = Allocator());
     template<class InputIterator>
-      map(InputIterator first, InputIterator last,
                     const Compare& comp = Compare(), const Allocator& = Allocator());
     template<container-compatible-range<value_type> R>
-      map(from_range_t, R&& rg, const Compare& comp = Compare(), const Allocator& = Allocator());
-    map(const map& x);
-    map(map&& x);
     explicit map(const Allocator&);
-    map(const map&, const type_identity_t<Allocator>&);
-    map(map&&, const type_identity_t<Allocator>&);
-    map(initializer_list<value_type>,
-      const Compare& = Compare(),
                   const Allocator& = Allocator());
     template<class InputIterator>
-      map(InputIterator first, InputIterator last, const Allocator& a)
         : map(first, last, Compare(), a) { }
     template<container-compatible-range<value_type> R>
-      map(from_range_t, R&& rg, const Allocator& a))
         : map(from_range, std::forward<R>(rg), Compare(), a) { }
-    map(initializer_list<value_type> il, const Allocator& a)
       : map(il, Compare(), a) { }
-    ~map();
-    map& operator=(const map& x);
-    map& operator=(map&& x)
       noexcept(allocator_traits<Allocator>::is_always_equal::value &&
                is_nothrow_move_assignable_v<Compare>);
-    map& operator=(initializer_list<value_type>);
-    allocator_type get_allocator() const noexcept;
     // 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;
     // [map.access], element access
-    mapped_type& operator[](const key_type& x);
-    mapped_type& operator[](key_type&& x);
-    mapped_type&       at(const key_type& x);
- const mapped_type& at(const key_type& x) const;
     // [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);
-    pair<iterator, bool> insert(value_type&& x);
- template<class P> pair<iterator, bool> insert(P&& x);
- iterator insert(const_iterator position, const value_type& x);
-    iterator insert(const_iterator position, value_type&& x);
     template<class P>
-      iterator insert(const_iterator position, P&&);
     template<class InputIterator>
-      void insert(InputIterator first, InputIterator last);
     template<container-compatible-range<value_type> R>
-      void insert_range(R&& rg);
-    void insert(initializer_list<value_type>);
-    node_type extract(const_iterator position);
-    node_type extract(const key_type& x);
-    template<class K> node_type extract(K&& x);
-    insert_return_type insert(node_type&& nh);
-    iterator           insert(const_iterator hint, node_type&& nh);
     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);
     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);
-    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(map&)
       noexcept(allocator_traits<Allocator>::is_always_equal::value &&
                is_nothrow_swappable_v<Compare>);
-    void      clear() noexcept;
     template<class C2>
-      void merge(map<Key, T, C2, Allocator>& source);
     template<class C2>
-      void merge(map<Key, T, C2, Allocator>&& source);
     template<class C2>
-      void merge(multimap<Key, T, C2, Allocator>& source);
     template<class C2>
-      void merge(multimap<Key, T, C2, Allocator>&& source);
     // observers
-    key_compare key_comp() const;
-    value_compare value_comp() const;
     // 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;
   };
   template<class InputIterator, class Compare = less<iter-key-type<InputIterator>>,
            class Allocator = allocator<iter-to-alloc-type<InputIterator>>>
     map(InputIterator, InputIterator, Compare = Compare(), Allocator = Allocator())
@@ -6411,21 +7685,21 @@ namespace std {
 ```
 #### Constructors, copy, and assignment <a id="map.cons">[[map.cons]]</a>
 ``` cpp
-explicit map(const Compare& comp, const Allocator& = Allocator());
 ```
 *Effects:* Constructs an empty `map` using the specified comparison
 object and allocator.
 *Complexity:* Constant.
 ``` cpp
 template<class InputIterator>
-  map(InputIterator first, InputIterator last,
                 const Compare& comp = Compare(), const Allocator& = Allocator());
 ```
 *Effects:* Constructs an empty `map` using the specified comparison
 object and allocator, and inserts elements from the range \[`first`,
@@ -6435,11 +7709,12 @@ object and allocator, and inserts elements from the range \[`first`,
 sorted with respect to `comp` and otherwise N log N, where N is
 `last - first`.
 ``` cpp
 template<container-compatible-range<value_type> R>
-  map(from_range_t, R&& rg, const Compare& comp = Compare(), const Allocator& = Allocator());
 ```
 *Effects:* Constructs an empty `map` using the specified comparison
 object and allocator, and inserts elements from the range `rg`.
@@ -6447,55 +7722,83 @@ object and allocator, and inserts elements from the range `rg`.
 `comp` and otherwise N log N, where N is `ranges::distance(rg)`.
 #### Element access <a id="map.access">[[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
-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.
 #### Modifiers <a id="map.modifiers">[[map.modifiers]]</a>
 ``` cpp
 template<class P>
-  pair<iterator, bool> insert(P&& x);
 template<class P>
-  iterator insert(const_iterator position, P&& x);
 ```
 *Constraints:* `is_constructible_v<value_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... Args>
-  pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
 template<class... Args>
-  iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args);
 ```
 *Preconditions:* `value_type` is *Cpp17EmplaceConstructible* into `map`
 from `piecewise_construct`, `forward_as_tuple(k)`,
 `forward_as_tuple(std::forward<Args>(args)...)`.
@@ -6511,13 +7814,13 @@ iterator points to the map element whose key is equivalent to `k`.
 *Complexity:* The same as `emplace` and `emplace_hint`, respectively.
 ``` cpp
 template<class... Args>
-  pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
 template<class... Args>
-  iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);
 ```
 *Preconditions:* `value_type` is *Cpp17EmplaceConstructible* into `map`
 from `piecewise_construct`, `forward_as_tuple(std::move(k))`,
 `forward_as_tuple(std::forward<Args>(args)...)`.
@@ -6532,15 +7835,44 @@ type `value_type` constructed with `piecewise_construct`,
 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>
-  iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);
 ```
 *Mandates:* `is_assignable_v<mapped_type&, M&&>` is `true`.
 *Preconditions:* `value_type` is *Cpp17EmplaceConstructible* into `map`
@@ -6557,13 +7889,13 @@ 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(key_type&& k, M&& obj);
 template<class M>
-  iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj);
 ```
 *Mandates:* `is_assignable_v<mapped_type&, M&&>` is `true`.
 *Preconditions:* `value_type` is *Cpp17EmplaceConstructible* into `map`
@@ -6578,16 +7910,44 @@ Otherwise inserts an object of type `value_type` constructed with
 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.
 #### Erasure <a id="map.erasure">[[map.erasure]]</a>
 ``` cpp
 template<class Key, class T, class Compare, class Allocator, class Predicate>
   typename map<Key, T, Compare, Allocator>::size_type
-    erase_if(map<Key, T, Compare, Allocator>& c, Predicate pred);
 ```
 *Effects:* Equivalent to:
 ``` cpp
@@ -6622,10 +7982,13 @@ not the `a_uniq` operations. For a `multimap<Key,T>` the `key_type` is
 `Key` and the `value_type` is `pair<const Key,T>`. Descriptions are
 provided here only for operations on `multimap` that are not described
 in one of those tables or for operations where there is additional
 semantic information.
 ``` cpp
 namespace std {
   template<class Key, class T, class Compare = less<Key>,
            class Allocator = allocator<pair<const Key, T>>>
   class multimap {
@@ -6634,12 +7997,12 @@ namespace std {
     using key_type               = Key;
     using mapped_type            = T;
     using value_type             = pair<const Key, T>;
     using key_compare            = Compare;
     using allocator_type         = Allocator;
-    using pointer                = typename allocator_traits<Allocator>::pointer;
-    using const_pointer          = typename allocator_traits<Allocator>::const_pointer;
     using reference              = value_type&;
     using const_reference        = const value_type&;
     using size_type              = implementation-defined  // type of multimap::size_type; // see [container.requirements]
     using difference_type        = implementation-defined  // type of multimap::difference_type; // see [container.requirements]
     using iterator               = implementation-defined  // type of multimap::iterator; // see [container.requirements]
@@ -6647,148 +8010,146 @@ namespace std {
     using reverse_iterator       = std::reverse_iterator<iterator>;
     using const_reverse_iterator = std::reverse_iterator<const_iterator>;
     using node_type              = unspecified;
     class value_compare {
-      friend class multimap;
     protected:
       Compare comp;
-      value_compare(Compare c) : comp(c) { }
     public:
-      bool operator()(const value_type& x, const value_type& y) const {
         return comp(x.first, y.first);
       }
     };
     // [multimap.cons], construct/copy/destroy
-    multimap() : multimap(Compare()) { }
-    explicit multimap(const Compare& comp, const Allocator& = Allocator());
     template<class InputIterator>
-      multimap(InputIterator first, InputIterator last,
- const Compare& comp = Compare(),
-               const Allocator& = Allocator());
     template<container-compatible-range<value_type> R>
-      multimap(from_range_t, R&& rg,
                          const Compare& comp = Compare(), const Allocator& = Allocator());
-    multimap(const multimap& x);
-    multimap(multimap&& x);
-    explicit multimap(const Allocator&);
-    multimap(const multimap&, const type_identity_t<Allocator>&);
-    multimap(multimap&&, const type_identity_t<Allocator>&);
-    multimap(initializer_list<value_type>,
- const Compare& = Compare(),
-      const Allocator& = Allocator());
     template<class InputIterator>
-      multimap(InputIterator first, InputIterator last, const Allocator& a)
         : multimap(first, last, Compare(), a) { }
     template<container-compatible-range<value_type> R>
-      multimap(from_range_t, R&& rg, const Allocator& a))
         : multimap(from_range, std::forward<R>(rg), Compare(), a) { }
-    multimap(initializer_list<value_type> il, const Allocator& a)
       : multimap(il, Compare(), a) { }
-    ~multimap();
-    multimap& operator=(const multimap& x);
-    multimap& operator=(multimap&& x)
       noexcept(allocator_traits<Allocator>::is_always_equal::value &&
                is_nothrow_move_assignable_v<Compare>);
-    multimap& operator=(initializer_list<value_type>);
-    allocator_type get_allocator() const noexcept;
     // 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;
     // [multimap.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);
-    iterator insert(value_type&& x);
- template<class P> iterator insert(P&& x);
- iterator insert(const_iterator position, const value_type& x);
-    iterator insert(const_iterator position, value_type&& x);
- template<class P> iterator insert(const_iterator position, P&& x);
     template<class InputIterator>
-      void insert(InputIterator first, InputIterator last);
     template<container-compatible-range<value_type> R>
-      void insert_range(R&& rg);
-    void insert(initializer_list<value_type>);
-    node_type extract(const_iterator position);
-    node_type extract(const key_type& x);
     template<class K> node_type extract(K&& x);
-    iterator insert(node_type&& nh);
-    iterator insert(const_iterator hint, node_type&& nh);
-    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(multimap&)
       noexcept(allocator_traits<Allocator>::is_always_equal::value &&
                is_nothrow_swappable_v<Compare>);
-    void      clear() noexcept;
     template<class C2>
-      void merge(multimap<Key, T, C2, Allocator>& source);
     template<class C2>
-      void merge(multimap<Key, T, C2, Allocator>&& source);
     template<class C2>
-      void merge(map<Key, T, C2, Allocator>& source);
     template<class C2>
-      void merge(map<Key, T, C2, Allocator>&& source);
     // observers
-    key_compare key_comp() const;
-    value_compare value_comp() const;
     // 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;
   };
   template<class InputIterator, class Compare = less<iter-key-type<InputIterator>>,
            class Allocator = allocator<iter-to-alloc-type<InputIterator>>>
     multimap(InputIterator, InputIterator, Compare = Compare(), Allocator = Allocator())
@@ -6821,23 +8182,22 @@ namespace std {
 ```
 #### Constructors <a id="multimap.cons">[[multimap.cons]]</a>
 ``` cpp
-explicit multimap(const Compare& comp, const Allocator& = Allocator());
 ```
 *Effects:* Constructs an empty `multimap` using the specified comparison
 object and allocator.
 *Complexity:* Constant.
 ``` cpp
 template<class InputIterator>
-  multimap(InputIterator first, InputIterator last,
- const Compare& comp = Compare(),
-           const Allocator& = Allocator());
 ```
 *Effects:* Constructs an empty `multimap` using the specified comparison
 object and allocator, and inserts elements from the range \[`first`,
 `last`).
@@ -6846,11 +8206,12 @@ object and allocator, and inserts elements from the range \[`first`,
 sorted with respect to `comp` and otherwise N log N, where N is
 `last - first`.
 ``` cpp
 template<container-compatible-range<value_type> R>
-  multimap(from_range_t, R&& rg, const Compare& comp = Compare(), const Allocator& = Allocator());
 ```
 *Effects:* Constructs an empty `multimap` using the specified comparison
 object and allocator, and inserts elements from the range `rg`.
@@ -6858,12 +8219,12 @@ object and allocator, and inserts elements from the range `rg`.
 `comp` and otherwise N log N, where N is `ranges::distance(rg)`.
 #### Modifiers <a id="multimap.modifiers">[[multimap.modifiers]]</a>
 ``` cpp
-template<class P> iterator insert(P&& x);
-template<class P> iterator insert(const_iterator position, P&& x);
 ```
 *Constraints:* `is_constructible_v<value_type, P&&>` is `true`.
 *Effects:* The first form is equivalent to
@@ -6873,11 +8234,11 @@ template<class P> iterator insert(const_iterator position, P&& x);
 #### Erasure <a id="multimap.erasure">[[multimap.erasure]]</a>
 ``` cpp
 template<class Key, class T, class Compare, class Allocator, class Predicate>
   typename multimap<Key, T, Compare, Allocator>::size_type
-    erase_if(multimap<Key, T, Compare, Allocator>& c, Predicate pred);
 ```
 *Effects:* Equivalent to:
 ``` cpp
@@ -6890,10 +8251,71 @@ for (auto i = c.begin(), last = c.end(); i != last; ) {
   }
 }
 return original_size - c.size();
 ```
 ### Class template `set` <a id="set">[[set]]</a>
 #### Overview <a id="set.overview">[[set.overview]]</a>
 A `set` is an associative container that supports unique keys (i.e.,
@@ -6902,19 +8324,22 @@ of the keys themselves. The `set` class supports bidirectional
 iterators.
 A `set` meets all of the requirements of a container
 [[container.reqmts]], of a reversible container
 [[container.rev.reqmts]], of an allocator-aware container
-[[container.alloc.reqmts]]. and of an associative container
 [[associative.reqmts]]. A `set` also provides most operations described
 in  [[associative.reqmts]] for unique keys. This means that a `set`
 supports the `a_uniq` operations in  [[associative.reqmts]] but not the
 `a_eq` operations. For a `set<Key>` both the `key_type` and `value_type`
 are `Key`. Descriptions are provided here only for operations on `set`
 that are not described in one of these tables and for operations where
 there is additional semantic information.
 ``` cpp
 namespace std {
   template<class Key, class Compare = less<Key>,
            class Allocator = allocator<Key>>
   class set {
@@ -6923,12 +8348,12 @@ namespace std {
     using key_type               = Key;
     using key_compare            = Compare;
     using value_type             = Key;
     using value_compare          = Compare;
     using allocator_type         = Allocator;
-    using pointer                = typename allocator_traits<Allocator>::pointer;
-    using const_pointer          = typename allocator_traits<Allocator>::const_pointer;
     using reference              = value_type&;
     using const_reference        = const value_type&;
     using size_type              = implementation-defined  // type of set::size_type; // see [container.requirements]
     using difference_type        = implementation-defined  // type of set::difference_type; // see [container.requirements]
     using iterator               = implementation-defined  // type of set::iterator; // see [container.requirements]
@@ -6937,132 +8362,136 @@ namespace std {
     using const_reverse_iterator = std::reverse_iterator<const_iterator>;
     using node_type              = unspecified;
     using insert_return_type     = insert-return-type<iterator, node_type>;
     // [set.cons], construct/copy/destroy
-    set() : set(Compare()) { }
-    explicit set(const Compare& comp, const Allocator& = Allocator());
     template<class InputIterator>
-      set(InputIterator first, InputIterator last,
                     const Compare& comp = Compare(), const Allocator& = Allocator());
     template<container-compatible-range<value_type> R>
-      set(from_range_t, R&& rg, const Compare& comp = Compare(), const Allocator& = Allocator());
-    set(const set& x);
-    set(set&& x);
- explicit set(const Allocator&);
-    set(const set&, const type_identity_t<Allocator>&);
-    set(set&&, const type_identity_t<Allocator>&);
-    set(initializer_list<value_type>, const Compare& = Compare(),
-        const Allocator& = Allocator());
     template<class InputIterator>
-      set(InputIterator first, InputIterator last, const Allocator& a)
         : set(first, last, Compare(), a) { }
     template<container-compatible-range<value_type> R>
-      set(from_range_t, R&& rg, const Allocator& a))
         : set(from_range, std::forward<R>(rg), Compare(), a) { }
-    set(initializer_list<value_type> il, const Allocator& a)
       : set(il, Compare(), a) { }
-    ~set();
-    set& operator=(const set& x);
-    set& operator=(set&& x)
       noexcept(allocator_traits<Allocator>::is_always_equal::value &&
                is_nothrow_move_assignable_v<Compare>);
-    set& operator=(initializer_list<value_type>);
-    allocator_type get_allocator() const noexcept;
     // 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> 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);
-    pair<iterator,bool> insert(value_type&& x);
-    iterator insert(const_iterator position, const value_type& x);
- iterator insert(const_iterator position, value_type&& x);
     template<class InputIterator>
-      void insert(InputIterator first, InputIterator last);
     template<container-compatible-range<value_type> R>
-      void insert_range(R&& rg);
-    void insert(initializer_list<value_type>);
-    node_type extract(const_iterator position);
-    node_type extract(const key_type& x);
-    template<class K> node_type extract(K&& x);
-    insert_return_type insert(node_type&& nh);
-    iterator           insert(const_iterator hint, node_type&& nh);
-    iterator  erase(iterator position)
       requires (!same_as<iterator, const_iterator>);
-    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(set&)
       noexcept(allocator_traits<Allocator>::is_always_equal::value &&
                is_nothrow_swappable_v<Compare>);
-    void      clear() noexcept;
     template<class C2>
-      void merge(set<Key, C2, Allocator>& source);
     template<class C2>
-      void merge(set<Key, C2, Allocator>&& source);
     template<class C2>
-      void merge(multiset<Key, C2, Allocator>& source);
     template<class C2>
-      void merge(multiset<Key, C2, Allocator>&& source);
     // 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;
   };
   template<class InputIterator,
            class Compare = less<iter-value-type<InputIterator>>,
            class Allocator = allocator<iter-value-type<InputIterator>>>
@@ -7094,21 +8523,21 @@ namespace std {
 ```
 #### Constructors, copy, and assignment <a id="set.cons">[[set.cons]]</a>
 ``` cpp
-explicit set(const Compare& comp, const Allocator& = Allocator());
 ```
 *Effects:* Constructs an empty `set` using the specified comparison
 object and allocator.
 *Complexity:* Constant.
 ``` cpp
 template<class InputIterator>
-  set(InputIterator first, InputIterator last,
                 const Compare& comp = Compare(), const Allocator& = Allocator());
 ```
 *Effects:* Constructs an empty `set` using the specified comparison
 object and allocator, and inserts elements from the range \[`first`,
@@ -7118,11 +8547,12 @@ object and allocator, and inserts elements from the range \[`first`,
 sorted with respect to `comp` and otherwise N log N, where N is
 `last - first`.
 ``` cpp
 template<container-compatible-range<value_type> R>
-  set(from_range_t, R&& rg, const Compare& comp = Compare(), const Allocator& = Allocator());
 ```
 *Effects:* Constructs an empty `set` using the specified comparison
 object and allocator, and inserts elements from the range `rg`.
@@ -7131,11 +8561,11 @@ object and allocator, and inserts elements from the range `rg`.
 #### Erasure <a id="set.erasure">[[set.erasure]]</a>
 ``` cpp
 template<class Key, class Compare, class Allocator, class Predicate>
-  typename set<Key, Compare, Allocator>::size_type
     erase_if(set<Key, Compare, Allocator>& c, Predicate pred);
 ```
 *Effects:* Equivalent to:
@@ -7149,10 +8579,37 @@ for (auto i = c.begin(), last = c.end(); i != last; ) {
   }
 }
 return original_size - c.size();
 ```
 ### Class template `multiset` <a id="multiset">[[multiset]]</a>
 #### Overview <a id="multiset.overview">[[multiset.overview]]</a>
 A `multiset` is an associative container that supports equivalent keys
@@ -7161,20 +8618,23 @@ provides for fast retrieval of the keys themselves. The `multiset` class
 supports bidirectional iterators.
 A `multiset` meets all of the requirements of a container
 [[container.reqmts]], of a reversible container
 [[container.rev.reqmts]], of an allocator-aware container
-[[container.alloc.reqmts]], of an associative container
 [[associative.reqmts]]. `multiset` also provides most operations
 described in  [[associative.reqmts]] for duplicate keys. This means that
 a `multiset` supports the `a_eq` operations in  [[associative.reqmts]]
 but not the `a_uniq` operations. For a `multiset<Key>` both the
 `key_type` and `value_type` are `Key`. Descriptions are provided here
 only for operations on `multiset` that are not described in one of these
 tables and for operations where there is additional semantic
 information.
 ``` cpp
 namespace std {
   template<class Key, class Compare = less<Key>,
            class Allocator = allocator<Key>>
   class multiset {
@@ -7183,12 +8643,12 @@ namespace std {
     using key_type               = Key;
     using key_compare            = Compare;
     using value_type             = Key;
     using value_compare          = Compare;
     using allocator_type         = Allocator;
-    using pointer                = typename allocator_traits<Allocator>::pointer;
-    using const_pointer          = typename allocator_traits<Allocator>::const_pointer;
     using reference              = value_type&;
     using const_reference        = const value_type&;
     using size_type              = implementation-defined  // type of multiset::size_type; // see [container.requirements]
     using difference_type        = implementation-defined  // type of multiset::difference_type; // see [container.requirements]
     using iterator               = implementation-defined  // type of multiset::iterator; // see [container.requirements]
@@ -7196,133 +8656,134 @@ namespace std {
     using reverse_iterator       = std::reverse_iterator<iterator>;
     using const_reverse_iterator = std::reverse_iterator<const_iterator>;
     using node_type              = unspecified;
     // [multiset.cons], construct/copy/destroy
-    multiset() : multiset(Compare()) { }
-    explicit multiset(const Compare& comp, const Allocator& = Allocator());
     template<class InputIterator>
-      multiset(InputIterator first, InputIterator last,
                          const Compare& comp = Compare(), const Allocator& = Allocator());
     template<container-compatible-range<value_type> R>
-      multiset(from_range_t, R&& rg,
                          const Compare& comp = Compare(), const Allocator& = Allocator());
-    multiset(const multiset& x);
-    multiset(multiset&& x);
-    explicit multiset(const Allocator&);
-    multiset(const multiset&, const type_identity_t<Allocator>&);
-    multiset(multiset&&, const type_identity_t<Allocator>&);
-    multiset(initializer_list<value_type>, const Compare& = Compare(),
                        const Allocator& = Allocator());
     template<class InputIterator>
-      multiset(InputIterator first, InputIterator last, const Allocator& a)
         : multiset(first, last, Compare(), a) { }
     template<container-compatible-range<value_type> R>
-      multiset(from_range_t, R&& rg, const Allocator& a))
         : multiset(from_range, std::forward<R>(rg), Compare(), a) { }
-    multiset(initializer_list<value_type> il, const Allocator& a)
       : multiset(il, Compare(), a) { }
-    ~multiset();
-    multiset& operator=(const multiset& x);
-    multiset& operator=(multiset&& x)
       noexcept(allocator_traits<Allocator>::is_always_equal::value &&
                is_nothrow_move_assignable_v<Compare>);
-    multiset& operator=(initializer_list<value_type>);
-    allocator_type get_allocator() const noexcept;
     // 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);
-    iterator insert(value_type&& x);
-    iterator insert(const_iterator position, const value_type& x);
-    iterator insert(const_iterator position, value_type&& x);
     template<class InputIterator>
-      void insert(InputIterator first, InputIterator last);
     template<container-compatible-range<value_type> R>
-      void insert_range(R&& rg);
-    void insert(initializer_list<value_type>);
-    node_type extract(const_iterator position);
-    node_type extract(const key_type& x);
-    template<class K> node_type extract(K&& x);
-    iterator insert(node_type&& nh);
-    iterator insert(const_iterator hint, node_type&& nh);
-    iterator  erase(iterator position)
       requires (!same_as<iterator, const_iterator>);
-    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(multiset&)
       noexcept(allocator_traits<Allocator>::is_always_equal::value &&
                is_nothrow_swappable_v<Compare>);
-    void      clear() noexcept;
     template<class C2>
-      void merge(multiset<Key, C2, Allocator>& source);
     template<class C2>
-      void merge(multiset<Key, C2, Allocator>&& source);
     template<class C2>
-      void merge(set<Key, C2, Allocator>& source);
     template<class C2>
-      void merge(set<Key, C2, Allocator>&& source);
     // 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;
   };
   template<class InputIterator,
            class Compare = less<iter-value-type<InputIterator>>,
            class Allocator = allocator<iter-value-type<InputIterator>>>
@@ -7354,21 +8815,21 @@ namespace std {
 ```
 #### Constructors <a id="multiset.cons">[[multiset.cons]]</a>
 ``` cpp
-explicit multiset(const Compare& comp, const Allocator& = Allocator());
 ```
 *Effects:* Constructs an empty `multiset` using the specified comparison
 object and allocator.
 *Complexity:* Constant.
 ``` cpp
 template<class InputIterator>
-  multiset(InputIterator first, InputIterator last,
                      const Compare& comp = Compare(), const Allocator& = Allocator());
 ```
 *Effects:* Constructs an empty `multiset` using the specified comparison
 object and allocator, and inserts elements from the range \[`first`,
@@ -7378,11 +8839,12 @@ object and allocator, and inserts elements from the range \[`first`,
 sorted with respect to `comp` and otherwise N log N, where N is
 `last - first`.
 ``` cpp
 template<container-compatible-range<value_type> R>
-  multiset(from_range_t, R&& rg, const Compare& comp = Compare(), const Allocator& = Allocator());
 ```
 *Effects:* Constructs an empty `multiset` using the specified comparison
 object and allocator, and inserts elements from the range `rg`.
@@ -7391,11 +8853,11 @@ object and allocator, and inserts elements from the range `rg`.
 #### Erasure <a id="multiset.erasure">[[multiset.erasure]]</a>
 ``` cpp
 template<class Key, class Compare, class Allocator, class Predicate>
-  typename multiset<Key, Compare, Allocator>::size_type
     erase_if(multiset<Key, Compare, Allocator>& c, Predicate pred);
 ```
 *Effects:* Equivalent to:
@@ -7411,11 +8873,11 @@ for (auto i = c.begin(), last = c.end(); i != last; ) {
 return original_size - c.size();
 ```
 ## Unordered associative containers <a id="unord">[[unord]]</a>
-### In general <a id="unord.general">[[unord.general]]</a>
 The header `<unordered_map>` defines the class templates `unordered_map`
 and `unordered_multimap`; the header `<unordered_set>` defines the class
 templates `unordered_set` and `unordered_multiset`.
@@ -7447,35 +8909,35 @@ namespace std {
            class Pred = equal_to<Key>,
            class Alloc = allocator<pair<const Key, T>>>
     class unordered_multimap;
   template<class Key, class T, class Hash, class Pred, class Alloc>
-    bool operator==(const unordered_map<Key, T, Hash, Pred, Alloc>& a,
                               const unordered_map<Key, T, Hash, Pred, Alloc>& b);
   template<class Key, class T, class Hash, class Pred, class Alloc>
-    bool operator==(const unordered_multimap<Key, T, Hash, Pred, Alloc>& a,
                               const unordered_multimap<Key, T, Hash, Pred, Alloc>& b);
   template<class Key, class T, class Hash, class Pred, class Alloc>
-    void swap(unordered_map<Key, T, Hash, Pred, Alloc>& x,
                         unordered_map<Key, T, Hash, Pred, Alloc>& y)
       noexcept(noexcept(x.swap(y)));
   template<class Key, class T, class Hash, class Pred, class Alloc>
-    void swap(unordered_multimap<Key, T, Hash, Pred, Alloc>& x,
                         unordered_multimap<Key, T, Hash, Pred, Alloc>& y)
       noexcept(noexcept(x.swap(y)));
   // [unord.map.erasure], erasure for unordered_map
   template<class K, class T, class H, class P, class A, class Predicate>
-    typename unordered_map<K, T, H, P, A>::size_type
       erase_if(unordered_map<K, T, H, P, A>& c, Predicate pred);
   // [unord.multimap.erasure], erasure for unordered_multimap
   template<class K, class T, class H, class P, class A, class Predicate>
-    typename unordered_multimap<K, T, H, P, A>::size_type
       erase_if(unordered_multimap<K, T, H, P, A>& c, Predicate pred);
   namespace pmr {
     template<class Key,
              class T,
@@ -7494,75 +8956,10 @@ namespace std {
   }
 }
 ```
-### Header `<unordered_set>` synopsis <a id="unord.set.syn">[[unord.set.syn]]</a>
-``` cpp
-#include <compare>              // see [compare.syn]
-#include <initializer_list>     // see [initializer.list.syn]
-namespace std {
-  // [unord.set], class template unordered_set
-  template<class Key,
-           class Hash = hash<Key>,
-           class Pred = equal_to<Key>,
-           class Alloc = allocator<Key>>
-    class unordered_set;
-  // [unord.multiset], class template unordered_multiset
-  template<class Key,
-           class Hash = hash<Key>,
-           class Pred = equal_to<Key>,
-           class Alloc = allocator<Key>>
-    class unordered_multiset;
-  template<class Key, class Hash, class Pred, class Alloc>
-    bool operator==(const unordered_set<Key, Hash, Pred, Alloc>& a,
-                    const unordered_set<Key, Hash, Pred, Alloc>& b);
-  template<class Key, class Hash, class Pred, class Alloc>
-    bool operator==(const unordered_multiset<Key, Hash, Pred, Alloc>& a,
-                    const unordered_multiset<Key, Hash, Pred, Alloc>& b);
-  template<class Key, class Hash, class Pred, class Alloc>
-    void swap(unordered_set<Key, Hash, Pred, Alloc>& x,
-              unordered_set<Key, Hash, Pred, Alloc>& y)
-      noexcept(noexcept(x.swap(y)));
-  template<class Key, class Hash, class Pred, class Alloc>
-    void swap(unordered_multiset<Key, Hash, Pred, Alloc>& x,
-              unordered_multiset<Key, Hash, Pred, Alloc>& y)
-      noexcept(noexcept(x.swap(y)));
-  // [unord.set.erasure], erasure for unordered_set
-  template<class K, class H, class P, class A, class Predicate>
-    typename unordered_set<K, H, P, A>::size_type
-      erase_if(unordered_set<K, H, P, A>& c, Predicate pred);
-  // [unord.multiset.erasure], erasure for unordered_multiset
-  template<class K, class H, class P, class A, class Predicate>
-    typename unordered_multiset<K, H, P, A>::size_type
-      erase_if(unordered_multiset<K, H, P, A>& c, Predicate pred);
-  namespace pmr {
-    template<class Key,
-             class Hash = hash<Key>,
-             class Pred = equal_to<Key>>
-      using unordered_set = std::unordered_set<Key, Hash, Pred,
-                                               polymorphic_allocator<Key>>;
-    template<class Key,
-             class Hash = hash<Key>,
-             class Pred = equal_to<Key>>
-      using unordered_multiset = std::unordered_multiset<Key, Hash, Pred,
-                                                         polymorphic_allocator<Key>>;
-  }
-}
-```
 ### Class template `unordered_map` <a id="unord.map">[[unord.map]]</a>
 #### Overview <a id="unord.map.overview">[[unord.map.overview]]</a>
 An `unordered_map` is an unordered associative container that supports
@@ -7581,10 +8978,13 @@ the `a_uniq` operations in that table, not the `a_eq` operations. For an
 Subclause  [[unord.map]] only describes operations on `unordered_map`
 that are not described in one of the requirement tables, or for which
 there is additional semantic information.
 ``` cpp
 namespace std {
   template<class Key,
            class T,
            class Hash = hash<Key>,
@@ -7597,12 +8997,12 @@ namespace std {
     using mapped_type          = T;
     using value_type           = pair<const Key, T>;
     using hasher               = Hash;
     using key_equal            = Pred;
     using allocator_type       = Allocator;
-    using pointer              = typename allocator_traits<Allocator>::pointer;
-    using const_pointer        = typename allocator_traits<Allocator>::const_pointer;
     using reference            = value_type&;
     using const_reference      = const value_type&;
     using size_type            = implementation-defined  // type of unordered_map::size_type; // see [container.requirements]
     using difference_type      = implementation-defined  // type of unordered_map::difference_type; // see [container.requirements]
@@ -7612,185 +9012,197 @@ namespace std {
     using const_local_iterator = implementation-defined  // type of unordered_map::const_local_iterator; // see [container.requirements]
     using node_type            = unspecified;
     using insert_return_type   = insert-return-type<iterator, node_type>;
     // [unord.map.cnstr], construct/copy/destroy
-    unordered_map();
-    explicit unordered_map(size_type n,
-                           const hasher& hf = hasher(),
                                      const key_equal& eql = key_equal(),
                                      const allocator_type& a = allocator_type());
     template<class InputIterator>
-      unordered_map(InputIterator f, InputIterator l,
- size_type n = see below,
-                    const hasher& hf = hasher(),
                               const key_equal& eql = key_equal(),
                               const allocator_type& a = allocator_type());
     template<container-compatible-range<value_type> R>
-      unordered_map(from_range_t, R&& rg, size_type n = see below,
                               const hasher& hf = hasher(), const key_equal& eql = key_equal(),
                               const allocator_type& a = allocator_type());
-    unordered_map(const unordered_map&);
-    unordered_map(unordered_map&&);
-    explicit unordered_map(const Allocator&);
-    unordered_map(const unordered_map&, const type_identity_t<Allocator>&);
-    unordered_map(unordered_map&&, const type_identity_t<Allocator>&);
-    unordered_map(initializer_list<value_type> il,
-                  size_type n = see below,
                             const hasher& hf = hasher(),
                             const key_equal& eql = key_equal(),
                             const allocator_type& a = allocator_type());
-    unordered_map(size_type n, const allocator_type& a)
       : unordered_map(n, hasher(), key_equal(), a) { }
-    unordered_map(size_type n, const hasher& hf, const allocator_type& a)
       : unordered_map(n, hf, key_equal(), a) { }
     template<class InputIterator>
-      unordered_map(InputIterator f, InputIterator l, size_type n, const allocator_type& a)
         : unordered_map(f, l, n, hasher(), key_equal(), a) { }
     template<class InputIterator>
-      unordered_map(InputIterator f, InputIterator l, size_type n, const hasher& hf,
                               const allocator_type& a)
         : unordered_map(f, l, n, hf, key_equal(), a) { }
     template<container-compatible-range<value_type> R>
-      unordered_map(from_range_t, R&& rg, size_type n, const allocator_type& a)
         : unordered_map(from_range, std::forward<R>(rg), n, hasher(), key_equal(), a) { }
     template<container-compatible-range<value_type> R>
-      unordered_map(from_range_t, R&& rg, size_type n, const hasher& hf, const allocator_type& a)
         : unordered_map(from_range, std::forward<R>(rg), n, hf, key_equal(), a) { }
-    unordered_map(initializer_list<value_type> il, size_type n, const allocator_type& a)
       : unordered_map(il, n, hasher(), key_equal(), a) { }
-    unordered_map(initializer_list<value_type> il, size_type n, const hasher& hf,
                             const allocator_type& a)
       : unordered_map(il, n, hf, key_equal(), a) { }
-    ~unordered_map();
-    unordered_map& operator=(const unordered_map&);
-    unordered_map& operator=(unordered_map&&)
       noexcept(allocator_traits<Allocator>::is_always_equal::value &&
                is_nothrow_move_assignable_v<Hash> &&
                is_nothrow_move_assignable_v<Pred>);
-    unordered_map& operator=(initializer_list<value_type>);
-    allocator_type get_allocator() const noexcept;
     // iterators
-    iterator       begin() noexcept;
-    const_iterator begin() const noexcept;
-    iterator       end() noexcept;
-    const_iterator end() const noexcept;
-    const_iterator cbegin() const noexcept;
-    const_iterator cend() const noexcept;
     // capacity
- [[nodiscard]] bool empty() const noexcept;
-    size_type size() const noexcept;
-    size_type max_size() const noexcept;
     // [unord.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& obj);
-    pair<iterator, bool> insert(value_type&& obj);
- template<class P> pair<iterator, bool> insert(P&& obj);
- iterator       insert(const_iterator hint, const value_type& obj);
-    iterator       insert(const_iterator hint, value_type&& obj);
- template<class P> iterator insert(const_iterator hint, P&& obj);
-    template<class InputIterator> void insert(InputIterator first, InputIterator last);
     template<container-compatible-range<value_type> R>
-      void insert_range(R&& rg);
-    void insert(initializer_list<value_type>);
-    node_type extract(const_iterator position);
-    node_type extract(const key_type& x);
-    template<class K> node_type extract(K&& x);
-    insert_return_type insert(node_type&& nh);
-    iterator           insert(const_iterator hint, node_type&& nh);
     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);
     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);
-    iterator  erase(iterator position);
-    iterator  erase(const_iterator position);
-    size_type erase(const key_type& k);
-    template<class K> size_type erase(K&& x);
-    iterator  erase(const_iterator first, const_iterator last);
-    void      swap(unordered_map&)
       noexcept(allocator_traits<Allocator>::is_always_equal::value &&
-               is_nothrow_swappable_v<Hash> &&
-               is_nothrow_swappable_v<Pred>);
-    void      clear() noexcept;
     template<class H2, class P2>
-      void merge(unordered_map<Key, T, H2, P2, Allocator>& source);
     template<class H2, class P2>
-      void merge(unordered_map<Key, T, H2, P2, Allocator>&& source);
     template<class H2, class P2>
-      void merge(unordered_multimap<Key, T, H2, P2, Allocator>& source);
     template<class H2, class P2>
-      void merge(unordered_multimap<Key, T, H2, P2, Allocator>&& source);
     // observers
-    hasher hash_function() const;
-    key_equal key_eq() const;
     // map operations
-    iterator         find(const key_type& k);
-    const_iterator   find(const key_type& k) const;
     template<class K>
-      iterator       find(const K& k);
     template<class K>
-      const_iterator find(const K& k) const;
-    size_type        count(const key_type& k) const;
     template<class K>
-      size_type      count(const K& k) const;
-    bool             contains(const key_type& k) const;
     template<class K>
-      bool           contains(const K& k) const;
-    pair<iterator, iterator>               equal_range(const key_type& k);
-    pair<const_iterator, const_iterator>   equal_range(const key_type& k) const;
     template<class K>
-      pair<iterator, iterator>             equal_range(const K& k);
     template<class K>
-      pair<const_iterator, const_iterator> equal_range(const K& k) const;
     // [unord.map.elem], element access
-    mapped_type& operator[](const key_type& k);
-    mapped_type& operator[](key_type&& k);
-    mapped_type& at(const key_type& k);
- const mapped_type& at(const key_type& k) const;
     // bucket interface
-    size_type bucket_count() const noexcept;
-    size_type max_bucket_count() const noexcept;
-    size_type bucket_size(size_type n) const;
-    size_type bucket(const key_type& k) const;
- local_iterator begin(size_type n);
- const_local_iterator begin(size_type n) const;
- local_iterator end(size_type n);
- const_local_iterator end(size_type n) const;
-    const_local_iterator cbegin(size_type n) const;
-    const_local_iterator cend(size_type n) const;
     // hash policy
-    float load_factor() const noexcept;
-    float max_load_factor() const noexcept;
-    void max_load_factor(float z);
-    void rehash(size_type n);
-    void reserve(size_type n);
   };
   template<class InputIterator,
            class Hash = hash<iter-key-type<InputIterator>>,
            class Pred = equal_to<iter-key-type<InputIterator>>,
@@ -7867,13 +9279,12 @@ refers to the `size_type` member type of the type deduced by the
 deduction guide.
 #### Constructors <a id="unord.map.cnstr">[[unord.map.cnstr]]</a>
 ``` cpp
-unordered_map() : unordered_map(size_type(see below)) { }
-explicit unordered_map(size_type n,
-                       const hasher& hf = hasher(),
                                  const key_equal& eql = key_equal(),
                                  const allocator_type& a = allocator_type());
 ```
 *Effects:* Constructs an empty `unordered_map` using the specified hash
@@ -7883,24 +9294,21 @@ buckets. For the default constructor, the number of buckets is
 *Complexity:* Constant.
 ``` cpp
 template<class InputIterator>
-  unordered_map(InputIterator f, InputIterator l,
- size_type n = see below,
-                const hasher& hf = hasher(),
                           const key_equal& eql = key_equal(),
                           const allocator_type& a = allocator_type());
 template<container-compatible-range<value_type> R>
-  unordered_map(from_range_t, R&& rg,
- size_type n = see below,
-                const hasher& hf = hasher(),
                           const key_equal& eql = key_equal(),
                           const allocator_type& a = allocator_type());
-unordered_map(initializer_list<value_type> il,
- size_type n = see below,
-              const hasher& hf = hasher(),
                         const key_equal& eql = key_equal(),
                         const allocator_type& a = allocator_type());
 ```
 *Effects:* Constructs an empty `unordered_map` using the specified hash
@@ -7912,59 +9320,85 @@ buckets. If `n` is not provided, the number of buckets is
 *Complexity:* Average case linear, worst case quadratic.
 #### Element access <a id="unord.map.elem">[[unord.map.elem]]</a>
 ``` cpp
-mapped_type& operator[](const key_type& k);
 ```
 *Effects:* Equivalent to: `return try_emplace(k).first->second;`
 ``` cpp
-mapped_type& operator[](key_type&& k);
 ```
 *Effects:* Equivalent to:
 `return try_emplace(std::move(k)).first->second;`
 ``` cpp
-mapped_type& at(const key_type& k);
-const mapped_type& at(const key_type& k) const;
 ```
 *Returns:* A reference to `x.second`, where `x` is the (unique) element
 whose key is equivalent to `k`.
 *Throws:* An exception object of type `out_of_range` if no such element
 is present.
 #### Modifiers <a id="unord.map.modifiers">[[unord.map.modifiers]]</a>
 ``` cpp
 template<class P>
-  pair<iterator, bool> insert(P&& obj);
 ```
 *Constraints:* `is_constructible_v<value_type, P&&>` is `true`.
 *Effects:* Equivalent to: `return emplace(std::forward<P>(obj));`
 ``` cpp
 template<class P>
-  iterator insert(const_iterator hint, P&& obj);
 ```
 *Constraints:* `is_constructible_v<value_type, P&&>` is `true`.
 *Effects:* Equivalent to:
 `return emplace_hint(hint, std::forward<P>(obj));`
 ``` cpp
 template<class... Args>
-  pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
 template<class... Args>
-  iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args);
 ```
 *Preconditions:* `value_type` is *Cpp17EmplaceConstructible* into
 `unordered_map` from `piecewise_construct`, `forward_as_tuple(k)`,
 `forward_as_tuple(std::forward<Args>(args)...)`.
@@ -7980,13 +9414,13 @@ iterator points to the map element whose key is equivalent to `k`.
 *Complexity:* The same as `emplace` and `emplace_hint`, respectively.
 ``` cpp
 template<class... Args>
-  pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
 template<class... Args>
-  iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);
 ```
 *Preconditions:* `value_type` is *Cpp17EmplaceConstructible* into
 `unordered_map` from `piecewise_construct`,
 `forward_as_tuple(std::move(k))`,
@@ -8002,15 +9436,44 @@ type `value_type` constructed with `piecewise_construct`,
 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>
-  iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);
 ```
 *Mandates:* `is_assignable_v<mapped_type&, M&&>` is `true`.
 *Preconditions:* `value_type` is *Cpp17EmplaceConstructible* into
@@ -8027,13 +9490,13 @@ 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(key_type&& k, M&& obj);
 template<class M>
-  iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj);
 ```
 *Mandates:* `is_assignable_v<mapped_type&, M&&>` is `true`.
 *Preconditions:* `value_type` is *Cpp17EmplaceConstructible* into
@@ -8048,15 +9511,43 @@ Otherwise inserts an object of type `value_type` constructed with
 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.
 #### Erasure <a id="unord.map.erasure">[[unord.map.erasure]]</a>
 ``` cpp
 template<class K, class T, class H, class P, class A, class Predicate>
-  typename unordered_map<K, T, H, P, A>::size_type
     erase_if(unordered_map<K, T, H, P, A>& c, Predicate pred);
 ```
 *Effects:* Equivalent to:
@@ -8093,10 +9584,13 @@ the `mapped_type` is `T`, and the `value_type` is `pair<const Key, T>`.
 Subclause  [[unord.multimap]] only describes operations on
 `unordered_multimap` that are not described in one of the requirement
 tables, or for which there is additional semantic information.
 ``` cpp
 namespace std {
   template<class Key,
            class T,
            class Hash = hash<Key>,
@@ -8109,12 +9603,12 @@ namespace std {
     using mapped_type          = T;
     using value_type           = pair<const Key, T>;
     using hasher               = Hash;
     using key_equal            = Pred;
     using allocator_type       = Allocator;
-    using pointer              = typename allocator_traits<Allocator>::pointer;
-    using const_pointer        = typename allocator_traits<Allocator>::const_pointer;
     using reference            = value_type&;
     using const_reference      = const value_type&;
     using size_type            = implementation-defined  // type of unordered_multimap::size_type; // see [container.requirements]
     using difference_type      = implementation-defined  // type of unordered_multimap::difference_type; // see [container.requirements]
@@ -8123,165 +9617,163 @@ namespace std {
     using local_iterator       = implementation-defined  // type of unordered_multimap::local_iterator; // see [container.requirements]
     using const_local_iterator = implementation-defined  // type of unordered_multimap::const_local_iterator; // see [container.requirements]
     using node_type            = unspecified;
     // [unord.multimap.cnstr], construct/copy/destroy
-    unordered_multimap();
-    explicit unordered_multimap(size_type n,
-                                const hasher& hf = hasher(),
                                           const key_equal& eql = key_equal(),
                                           const allocator_type& a = allocator_type());
     template<class InputIterator>
-      unordered_multimap(InputIterator f, InputIterator l,
- size_type n = see below,
-                         const hasher& hf = hasher(),
                                    const key_equal& eql = key_equal(),
                                    const allocator_type& a = allocator_type());
     template<container-compatible-range<value_type> R>
-      unordered_multimap(from_range_t, R&& rg,
- size_type n = see below,
-                         const hasher& hf = hasher(),
                                    const key_equal& eql = key_equal(),
                                    const allocator_type& a = allocator_type());
-    unordered_multimap(const unordered_multimap&);
-    unordered_multimap(unordered_multimap&&);
-    explicit unordered_multimap(const Allocator&);
-    unordered_multimap(const unordered_multimap&, const type_identity_t<Allocator>&);
-    unordered_multimap(unordered_multimap&&, const type_identity_t<Allocator>&);
-    unordered_multimap(initializer_list<value_type> il,
- size_type n = see below,
-                       const hasher& hf = hasher(),
                                  const key_equal& eql = key_equal(),
                                  const allocator_type& a = allocator_type());
-    unordered_multimap(size_type n, const allocator_type& a)
       : unordered_multimap(n, hasher(), key_equal(), a) { }
-    unordered_multimap(size_type n, const hasher& hf, const allocator_type& a)
       : unordered_multimap(n, hf, key_equal(), a) { }
     template<class InputIterator>
-      unordered_multimap(InputIterator f, InputIterator l, size_type n, const allocator_type& a)
         : unordered_multimap(f, l, n, hasher(), key_equal(), a) { }
     template<class InputIterator>
-      unordered_multimap(InputIterator f, InputIterator l, size_type n, const hasher& hf,
- const allocator_type& a)
         : unordered_multimap(f, l, n, hf, key_equal(), a) { }
     template<container-compatible-range<value_type> R>
- unordered_multimap(from_range_t, R&& rg, size_type n, const allocator_type& a)
         : unordered_multimap(from_range, std::forward<R>(rg),
                              n, hasher(), key_equal(), a) { }
     template<container-compatible-range<value_type> R>
- unordered_multimap(from_range_t, R&& rg, size_type n, const hasher& hf,
                                    const allocator_type& a)
         : unordered_multimap(from_range, std::forward<R>(rg), n, hf, key_equal(), a) { }
-    unordered_multimap(initializer_list<value_type> il, size_type n, const allocator_type& a)
       : unordered_multimap(il, n, hasher(), key_equal(), a) { }
-    unordered_multimap(initializer_list<value_type> il, size_type n, const hasher& hf,
                                  const allocator_type& a)
       : unordered_multimap(il, n, hf, key_equal(), a) { }
-    ~unordered_multimap();
-    unordered_multimap& operator=(const unordered_multimap&);
-    unordered_multimap& operator=(unordered_multimap&&)
       noexcept(allocator_traits<Allocator>::is_always_equal::value &&
-               is_nothrow_move_assignable_v<Hash> &&
-               is_nothrow_move_assignable_v<Pred>);
- unordered_multimap& operator=(initializer_list<value_type>);
-    allocator_type get_allocator() const noexcept;
     // iterators
-    iterator       begin() noexcept;
-    const_iterator begin() const noexcept;
-    iterator       end() noexcept;
-    const_iterator end() const noexcept;
-    const_iterator cbegin() const noexcept;
-    const_iterator cend() const noexcept;
     // capacity
- [[nodiscard]] bool empty() const noexcept;
-    size_type size() const noexcept;
-    size_type max_size() const noexcept;
     // [unord.multimap.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& obj);
-    iterator insert(value_type&& obj);
- template<class P> iterator insert(P&& obj);
- iterator insert(const_iterator hint, const value_type& obj);
-    iterator insert(const_iterator hint, value_type&& obj);
- template<class P> iterator insert(const_iterator hint, P&& obj);
-    template<class InputIterator> void insert(InputIterator first, InputIterator last);
     template<container-compatible-range<value_type> R>
-      void insert_range(R&& rg);
-    void insert(initializer_list<value_type>);
-    node_type extract(const_iterator position);
-    node_type extract(const key_type& x);
-    template<class K> node_type extract(K&& x);
-    iterator insert(node_type&& nh);
-    iterator insert(const_iterator hint, node_type&& nh);
-    iterator  erase(iterator position);
-    iterator  erase(const_iterator position);
-    size_type erase(const key_type& k);
-    template<class K> size_type erase(K&& x);
-    iterator  erase(const_iterator first, const_iterator last);
-    void      swap(unordered_multimap&)
       noexcept(allocator_traits<Allocator>::is_always_equal::value &&
-               is_nothrow_swappable_v<Hash> &&
-               is_nothrow_swappable_v<Pred>);
-    void      clear() noexcept;
     template<class H2, class P2>
-      void merge(unordered_multimap<Key, T, H2, P2, Allocator>& source);
     template<class H2, class P2>
-      void merge(unordered_multimap<Key, T, H2, P2, Allocator>&& source);
     template<class H2, class P2>
-      void merge(unordered_map<Key, T, H2, P2, Allocator>& source);
     template<class H2, class P2>
-      void merge(unordered_map<Key, T, H2, P2, Allocator>&& source);
     // observers
-    hasher hash_function() const;
-    key_equal key_eq() const;
     // map operations
-    iterator         find(const key_type& k);
-    const_iterator   find(const key_type& k) const;
     template<class K>
-      iterator       find(const K& k);
     template<class K>
-      const_iterator find(const K& k) const;
-    size_type        count(const key_type& k) const;
     template<class K>
-      size_type      count(const K& k) const;
-    bool             contains(const key_type& k) const;
     template<class K>
-      bool           contains(const K& k) const;
-    pair<iterator, iterator>               equal_range(const key_type& k);
-    pair<const_iterator, const_iterator>   equal_range(const key_type& k) const;
     template<class K>
-      pair<iterator, iterator>             equal_range(const K& k);
     template<class K>
-      pair<const_iterator, const_iterator> equal_range(const K& k) const;
     // bucket interface
-    size_type bucket_count() const noexcept;
-    size_type max_bucket_count() const noexcept;
-    size_type bucket_size(size_type n) const;
-    size_type bucket(const key_type& k) const;
- local_iterator begin(size_type n);
- const_local_iterator begin(size_type n) const;
- local_iterator end(size_type n);
- const_local_iterator end(size_type n) const;
-    const_local_iterator cbegin(size_type n) const;
-    const_local_iterator cend(size_type n) const;
     // hash policy
-    float load_factor() const noexcept;
-    float max_load_factor() const noexcept;
-    void max_load_factor(float z);
-    void rehash(size_type n);
-    void reserve(size_type n);
   };
   template<class InputIterator,
            class Hash = hash<iter-key-type<InputIterator>>,
            class Pred = equal_to<iter-key-type<InputIterator>>,
@@ -8361,13 +9853,12 @@ refers to the `size_type` member type of the type deduced by the
 deduction guide.
 #### Constructors <a id="unord.multimap.cnstr">[[unord.multimap.cnstr]]</a>
 ``` cpp
-unordered_multimap() : unordered_multimap(size_type(see below)) { }
-explicit unordered_multimap(size_type n,
-                            const hasher& hf = hasher(),
                                       const key_equal& eql = key_equal(),
                                       const allocator_type& a = allocator_type());
 ```
 *Effects:* Constructs an empty `unordered_multimap` using the specified
@@ -8377,24 +9868,21 @@ hash function, key equality predicate, and allocator, and using at least
 *Complexity:* Constant.
 ``` cpp
 template<class InputIterator>
-  unordered_multimap(InputIterator f, InputIterator l,
- size_type n = see below,
-                     const hasher& hf = hasher(),
                                const key_equal& eql = key_equal(),
                                const allocator_type& a = allocator_type());
 template<container-compatible-range<value_type> R>
-  unordered_multimap(from_range_t, R&& rg,
- size_type n = see below,
-                     const hasher& hf = hasher(),
                                const key_equal& eql = key_equal(),
                                const allocator_type& a = allocator_type());
-unordered_multimap(initializer_list<value_type> il,
- size_type n = see below,
-                   const hasher& hf = hasher(),
                              const key_equal& eql = key_equal(),
                              const allocator_type& a = allocator_type());
 ```
 *Effects:* Constructs an empty `unordered_multimap` using the specified
@@ -8407,20 +9895,20 @@ hash function, key equality predicate, and allocator, and using at least
 #### Modifiers <a id="unord.multimap.modifiers">[[unord.multimap.modifiers]]</a>
 ``` cpp
 template<class P>
-  iterator insert(P&& obj);
 ```
 *Constraints:* `is_constructible_v<value_type, P&&>` is `true`.
 *Effects:* Equivalent to: `return emplace(std::forward<P>(obj));`
 ``` cpp
 template<class P>
-  iterator insert(const_iterator hint, P&& obj);
 ```
 *Constraints:* `is_constructible_v<value_type, P&&>` is `true`.
 *Effects:* Equivalent to:
@@ -8428,11 +9916,11 @@ template<class P>
 #### Erasure <a id="unord.multimap.erasure">[[unord.multimap.erasure]]</a>
 ``` cpp
 template<class K, class T, class H, class P, class A, class Predicate>
-  typename unordered_multimap<K, T, H, P, A>::size_type
     erase_if(unordered_multimap<K, T, H, P, A>& c, Predicate pred);
 ```
 *Effects:* Equivalent to:
@@ -8446,10 +9934,75 @@ for (auto i = c.begin(), last = c.end(); i != last; ) {
   }
 }
 return original_size - c.size();
 ```
 ### Class template `unordered_set` <a id="unord.set">[[unord.set]]</a>
 #### Overview <a id="unord.set.overview">[[unord.set.overview]]</a>
 An `unordered_set` is an unordered associative container that supports
@@ -8457,11 +10010,11 @@ unique keys (an `unordered_set` contains at most one of each key value)
 and in which the elements’ keys are the elements themselves. The
 `unordered_set` class supports forward iterators.
 An `unordered_set` meets all of the requirements of a container
 [[container.reqmts]], of an allocator-aware container
-[[container.alloc.reqmts]], of an unordered associative container
 [[unord.req]]. It provides the operations described in the preceding
 requirements table for unique keys; that is, an `unordered_set` supports
 the `a_uniq` operations in that table, not the `a_eq` operations. For an
 `unordered_set<Key>` the `key_type` and the `value_type` are both `Key`.
 The `iterator` and `const_iterator` types are both constant iterator
@@ -8469,10 +10022,13 @@ types. It is unspecified whether they are the same type.
 Subclause  [[unord.set]] only describes operations on `unordered_set`
 that are not described in one of the requirement tables, or for which
 there is additional semantic information.
 ``` cpp
 namespace std {
   template<class Key,
            class Hash = hash<Key>,
            class Pred = equal_to<Key>,
@@ -8483,12 +10039,12 @@ namespace std {
     using key_type             = Key;
     using value_type           = Key;
     using hasher               = Hash;
     using key_equal            = Pred;
     using allocator_type       = Allocator;
-    using pointer              = typename allocator_traits<Allocator>::pointer;
-    using const_pointer        = typename allocator_traits<Allocator>::const_pointer;
     using reference            = value_type&;
     using const_reference      = const value_type&;
     using size_type            = implementation-defined  // type of unordered_set::size_type; // see [container.requirements]
     using difference_type      = implementation-defined  // type of unordered_set::difference_type; // see [container.requirements]
@@ -8498,162 +10054,163 @@ namespace std {
     using const_local_iterator = implementation-defined  // type of unordered_set::const_local_iterator; // see [container.requirements]
     using node_type            = unspecified;
     using insert_return_type   = insert-return-type<iterator, node_type>;
     // [unord.set.cnstr], construct/copy/destroy
-    unordered_set();
-    explicit unordered_set(size_type n,
-                           const hasher& hf = hasher(),
                                      const key_equal& eql = key_equal(),
                                      const allocator_type& a = allocator_type());
     template<class InputIterator>
-      unordered_set(InputIterator f, InputIterator l,
- size_type n = see below,
-                    const hasher& hf = hasher(),
                               const key_equal& eql = key_equal(),
                               const allocator_type& a = allocator_type());
     template<container-compatible-range<value_type> R>
-      unordered_set(from_range_t, R&& rg,
- size_type n = see below,
-                    const hasher& hf = hasher(),
                               const key_equal& eql = key_equal(),
                               const allocator_type& a = allocator_type());
-    unordered_set(const unordered_set&);
-    unordered_set(unordered_set&&);
-    explicit unordered_set(const Allocator&);
-    unordered_set(const unordered_set&, const type_identity_t<Allocator>&);
-    unordered_set(unordered_set&&, const type_identity_t<Allocator>&);
-    unordered_set(initializer_list<value_type> il,
- size_type n = see below,
-                  const hasher& hf = hasher(),
                             const key_equal& eql = key_equal(),
                             const allocator_type& a = allocator_type());
-    unordered_set(size_type n, const allocator_type& a)
       : unordered_set(n, hasher(), key_equal(), a) { }
-    unordered_set(size_type n, const hasher& hf, const allocator_type& a)
       : unordered_set(n, hf, key_equal(), a) { }
     template<class InputIterator>
-      unordered_set(InputIterator f, InputIterator l, size_type n, const allocator_type& a)
         : unordered_set(f, l, n, hasher(), key_equal(), a) { }
     template<class InputIterator>
-      unordered_set(InputIterator f, InputIterator l, size_type n, const hasher& hf,
                               const allocator_type& a)
       : unordered_set(f, l, n, hf, key_equal(), a) { }
-    unordered_set(initializer_list<value_type> il, size_type n, const allocator_type& a)
       : unordered_set(il, n, hasher(), key_equal(), a) { }
     template<container-compatible-range<value_type> R>
-      unordered_set(from_range_t, R&& rg, size_type n, const allocator_type& a)
         : unordered_set(from_range, std::forward<R>(rg), n, hasher(), key_equal(), a) { }
     template<container-compatible-range<value_type> R>
-      unordered_set(from_range_t, R&& rg, size_type n, const hasher& hf, const allocator_type& a)
         : unordered_set(from_range, std::forward<R>(rg), n, hf, key_equal(), a) { }
-    unordered_set(initializer_list<value_type> il, size_type n, const hasher& hf,
                             const allocator_type& a)
       : unordered_set(il, n, hf, key_equal(), a) { }
-    ~unordered_set();
-    unordered_set& operator=(const unordered_set&);
-    unordered_set& operator=(unordered_set&&)
       noexcept(allocator_traits<Allocator>::is_always_equal::value &&
-               is_nothrow_move_assignable_v<Hash> &&
-               is_nothrow_move_assignable_v<Pred>);
- unordered_set& operator=(initializer_list<value_type>);
-    allocator_type get_allocator() const noexcept;
     // iterators
-    iterator       begin() noexcept;
-    const_iterator begin() const noexcept;
-    iterator       end() noexcept;
-    const_iterator end() const noexcept;
-    const_iterator cbegin() const noexcept;
-    const_iterator cend() const noexcept;
     // capacity
- [[nodiscard]] bool empty() const noexcept;
-    size_type size() const noexcept;
-    size_type max_size() const noexcept;
-    // 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& obj);
-    pair<iterator, bool> insert(value_type&& obj);
- iterator insert(const_iterator hint, const value_type& obj);
- iterator insert(const_iterator hint, value_type&& obj);
- template<class InputIterator> void insert(InputIterator first, InputIterator last);
     template<container-compatible-range<value_type> R>
-      void insert_range(R&& rg);
-    void insert(initializer_list<value_type>);
-    node_type extract(const_iterator position);
-    node_type extract(const key_type& x);
-    template<class K> node_type extract(K&& x);
-    insert_return_type insert(node_type&& nh);
-    iterator           insert(const_iterator hint, node_type&& nh);
-    iterator  erase(iterator position)
       requires (!same_as<iterator, const_iterator>);
-    iterator  erase(const_iterator position);
-    size_type erase(const key_type& k);
-    template<class K> size_type erase(K&& x);
-    iterator  erase(const_iterator first, const_iterator last);
-    void      swap(unordered_set&)
       noexcept(allocator_traits<Allocator>::is_always_equal::value &&
-               is_nothrow_swappable_v<Hash> &&
-               is_nothrow_swappable_v<Pred>);
-    void      clear() noexcept;
     template<class H2, class P2>
-      void merge(unordered_set<Key, H2, P2, Allocator>& source);
     template<class H2, class P2>
-      void merge(unordered_set<Key, H2, P2, Allocator>&& source);
     template<class H2, class P2>
-      void merge(unordered_multiset<Key, H2, P2, Allocator>& source);
     template<class H2, class P2>
-      void merge(unordered_multiset<Key, H2, P2, Allocator>&& source);
     // observers
-    hasher hash_function() const;
-    key_equal key_eq() const;
     // set operations
-    iterator         find(const key_type& k);
-    const_iterator   find(const key_type& k) const;
     template<class K>
-      iterator       find(const K& k);
     template<class K>
-      const_iterator find(const K& k) const;
-    size_type        count(const key_type& k) const;
     template<class K>
-      size_type      count(const K& k) const;
-    bool             contains(const key_type& k) const;
     template<class K>
-      bool           contains(const K& k) const;
-    pair<iterator, iterator>               equal_range(const key_type& k);
-    pair<const_iterator, const_iterator>   equal_range(const key_type& k) const;
     template<class K>
-      pair<iterator, iterator>             equal_range(const K& k);
     template<class K>
-      pair<const_iterator, const_iterator> equal_range(const K& k) const;
     // bucket interface
-    size_type bucket_count() const noexcept;
-    size_type max_bucket_count() const noexcept;
-    size_type bucket_size(size_type n) const;
-    size_type bucket(const key_type& k) const;
- local_iterator begin(size_type n);
- const_local_iterator begin(size_type n) const;
- local_iterator end(size_type n);
- const_local_iterator end(size_type n) const;
-    const_local_iterator cbegin(size_type n) const;
-    const_local_iterator cend(size_type n) const;
     // hash policy
-    float load_factor() const noexcept;
-    float max_load_factor() const noexcept;
-    void max_load_factor(float z);
-    void rehash(size_type n);
-    void reserve(size_type n);
   };
   template<class InputIterator,
            class Hash = hash<iter-value-type<InputIterator>>,
            class Pred = equal_to<iter-value-type<InputIterator>>,
@@ -8721,13 +10278,12 @@ refers to the `size_type` member type of the type deduced by the
 deduction guide.
 #### Constructors <a id="unord.set.cnstr">[[unord.set.cnstr]]</a>
 ``` cpp
-unordered_set() : unordered_set(size_type(see below)) { }
-explicit unordered_set(size_type n,
-                       const hasher& hf = hasher(),
                                  const key_equal& eql = key_equal(),
                                  const allocator_type& a = allocator_type());
 ```
 *Effects:* Constructs an empty `unordered_set` using the specified hash
@@ -8737,24 +10293,21 @@ buckets. For the default constructor, the number of buckets is
 *Complexity:* Constant.
 ``` cpp
 template<class InputIterator>
-  unordered_set(InputIterator f, InputIterator l,
- size_type n = see below,
-                const hasher& hf = hasher(),
                           const key_equal& eql = key_equal(),
                           const allocator_type& a = allocator_type());
 template<container-compatible-range<value_type> R>
-  unordered_multiset(from_range_t, R&& rg,
- size_type n = see below,
-                     const hasher& hf = hasher(),
                                const key_equal& eql = key_equal(),
                                const allocator_type& a = allocator_type());
-unordered_set(initializer_list<value_type> il,
- size_type n = see below,
-              const hasher& hf = hasher(),
                         const key_equal& eql = key_equal(),
                         const allocator_type& a = allocator_type());
 ```
 *Effects:* Constructs an empty `unordered_set` using the specified hash
@@ -8767,11 +10320,11 @@ buckets. If `n` is not provided, the number of buckets is
 #### Erasure <a id="unord.set.erasure">[[unord.set.erasure]]</a>
 ``` cpp
 template<class K, class H, class P, class A, class Predicate>
-  typename unordered_set<K, H, P, A>::size_type
     erase_if(unordered_set<K, H, P, A>& c, Predicate pred);
 ```
 *Effects:* Equivalent to:
@@ -8785,10 +10338,37 @@ for (auto i = c.begin(), last = c.end(); i != last; ) {
   }
 }
 return original_size - c.size();
 ```
 ### Class template `unordered_multiset` <a id="unord.multiset">[[unord.multiset]]</a>
 #### Overview <a id="unord.multiset.overview">[[unord.multiset.overview]]</a>
 An `unordered_multiset` is an unordered associative container that
@@ -8810,10 +10390,13 @@ same type.
 Subclause  [[unord.multiset]] only describes operations on
 `unordered_multiset` that are not described in one of the requirement
 tables, or for which there is additional semantic information.
 ``` cpp
 namespace std {
   template<class Key,
            class Hash = hash<Key>,
            class Pred = equal_to<Key>,
@@ -8824,12 +10407,12 @@ namespace std {
     using key_type             = Key;
     using value_type           = Key;
     using hasher               = Hash;
     using key_equal            = Pred;
     using allocator_type       = Allocator;
-    using pointer              = typename allocator_traits<Allocator>::pointer;
-    using const_pointer        = typename allocator_traits<Allocator>::const_pointer;
     using reference            = value_type&;
     using const_reference      = const value_type&;
     using size_type            = implementation-defined  // type of unordered_multiset::size_type; // see [container.requirements]
     using difference_type      = implementation-defined  // type of unordered_multiset::difference_type; // see [container.requirements]
@@ -8838,171 +10421,169 @@ namespace std {
     using local_iterator       = implementation-defined  // type of unordered_multiset::local_iterator; // see [container.requirements]
     using const_local_iterator = implementation-defined  // type of unordered_multiset::const_local_iterator; // see [container.requirements]
     using node_type            = unspecified;
     // [unord.multiset.cnstr], construct/copy/destroy
-    unordered_multiset();
-    explicit unordered_multiset(size_type n,
-                                const hasher& hf = hasher(),
                                           const key_equal& eql = key_equal(),
                                           const allocator_type& a = allocator_type());
     template<class InputIterator>
-      unordered_multiset(InputIterator f, InputIterator l,
- size_type n = see below,
-                         const hasher& hf = hasher(),
                                    const key_equal& eql = key_equal(),
                                    const allocator_type& a = allocator_type());
     template<container-compatible-range<value_type> R>
-      unordered_multiset(from_range_t, R&& rg,
- size_type n = see below,
-                         const hasher& hf = hasher(),
                                    const key_equal& eql = key_equal(),
                                    const allocator_type& a = allocator_type());
-    unordered_multiset(const unordered_multiset&);
-    unordered_multiset(unordered_multiset&&);
-    explicit unordered_multiset(const Allocator&);
-    unordered_multiset(const unordered_multiset&, const type_identity_t<Allocator>&);
-    unordered_multiset(unordered_multiset&&, const type_identity_t<Allocator>&);
-    unordered_multiset(initializer_list<value_type> il,
- size_type n = see below,
-                       const hasher& hf = hasher(),
                                  const key_equal& eql = key_equal(),
                                  const allocator_type& a = allocator_type());
-    unordered_multiset(size_type n, const allocator_type& a)
       : unordered_multiset(n, hasher(), key_equal(), a) { }
-    unordered_multiset(size_type n, const hasher& hf, const allocator_type& a)
       : unordered_multiset(n, hf, key_equal(), a) { }
     template<class InputIterator>
-      unordered_multiset(InputIterator f, InputIterator l, size_type n, const allocator_type& a)
         : unordered_multiset(f, l, n, hasher(), key_equal(), a) { }
     template<class InputIterator>
-      unordered_multiset(InputIterator f, InputIterator l, size_type n, const hasher& hf,
- const allocator_type& a)
       : unordered_multiset(f, l, n, hf, key_equal(), a) { }
     template<container-compatible-range<value_type> R>
-      unordered_multiset(from_range_t, R&& rg, size_type n, const allocator_type& a)
         : unordered_multiset(from_range, std::forward<R>(rg),
                              n, hasher(), key_equal(), a) { }
     template<container-compatible-range<value_type> R>
-      unordered_multiset(from_range_t, R&& rg, size_type n, const hasher& hf,
                                    const allocator_type& a)
         : unordered_multiset(from_range, std::forward<R>(rg), n, hf, key_equal(), a) { }
-    unordered_multiset(initializer_list<value_type> il, size_type n, const allocator_type& a)
       : unordered_multiset(il, n, hasher(), key_equal(), a) { }
-    unordered_multiset(initializer_list<value_type> il, size_type n, const hasher& hf,
                                  const allocator_type& a)
       : unordered_multiset(il, n, hf, key_equal(), a) { }
-    ~unordered_multiset();
-    unordered_multiset& operator=(const unordered_multiset&);
-    unordered_multiset& operator=(unordered_multiset&&)
       noexcept(allocator_traits<Allocator>::is_always_equal::value &&
-               is_nothrow_move_assignable_v<Hash> &&
-               is_nothrow_move_assignable_v<Pred>);
- unordered_multiset& operator=(initializer_list<value_type>);
-    allocator_type get_allocator() const noexcept;
     // iterators
-    iterator       begin() noexcept;
-    const_iterator begin() const noexcept;
-    iterator       end() noexcept;
-    const_iterator end() const noexcept;
-    const_iterator cbegin() const noexcept;
-    const_iterator cend() 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& obj);
-    iterator insert(value_type&& obj);
-    iterator insert(const_iterator hint, const value_type& obj);
-    iterator insert(const_iterator hint, value_type&& obj);
- template<class InputIterator> void insert(InputIterator first, InputIterator last);
     template<container-compatible-range<value_type> R>
-      void insert_range(R&& rg);
-    void insert(initializer_list<value_type>);
-    node_type extract(const_iterator position);
-    node_type extract(const key_type& x);
-    template<class K> node_type extract(K&& x);
-    iterator insert(node_type&& nh);
-    iterator insert(const_iterator hint, node_type&& nh);
-    iterator  erase(iterator position)
       requires (!same_as<iterator, const_iterator>);
-    iterator  erase(const_iterator position);
-    size_type erase(const key_type& k);
-    template<class K> size_type erase(K&& x);
-    iterator  erase(const_iterator first, const_iterator last);
-    void      swap(unordered_multiset&)
       noexcept(allocator_traits<Allocator>::is_always_equal::value &&
-               is_nothrow_swappable_v<Hash> &&
-               is_nothrow_swappable_v<Pred>);
-    void      clear() noexcept;
     template<class H2, class P2>
-      void merge(unordered_multiset<Key, H2, P2, Allocator>& source);
     template<class H2, class P2>
-      void merge(unordered_multiset<Key, H2, P2, Allocator>&& source);
     template<class H2, class P2>
-      void merge(unordered_set<Key, H2, P2, Allocator>& source);
     template<class H2, class P2>
-      void merge(unordered_set<Key, H2, P2, Allocator>&& source);
     // observers
-    hasher hash_function() const;
-    key_equal key_eq() const;
     // set operations
-    iterator         find(const key_type& k);
-    const_iterator   find(const key_type& k) const;
     template<class K>
-      iterator       find(const K& k);
     template<class K>
-      const_iterator find(const K& k) const;
-    size_type        count(const key_type& k) const;
     template<class K>
-      size_type      count(const K& k) const;
-    bool             contains(const key_type& k) const;
     template<class K>
-      bool           contains(const K& k) const;
-    pair<iterator, iterator>               equal_range(const key_type& k);
-    pair<const_iterator, const_iterator>   equal_range(const key_type& k) const;
     template<class K>
-      pair<iterator, iterator>             equal_range(const K& k);
     template<class K>
-      pair<const_iterator, const_iterator> equal_range(const K& k) const;
     // bucket interface
-    size_type bucket_count() const noexcept;
-    size_type max_bucket_count() const noexcept;
-    size_type bucket_size(size_type n) const;
-    size_type bucket(const key_type& k) const;
- local_iterator begin(size_type n);
- const_local_iterator begin(size_type n) const;
- local_iterator end(size_type n);
- const_local_iterator end(size_type n) const;
-    const_local_iterator cbegin(size_type n) const;
-    const_local_iterator cend(size_type n) const;
     // hash policy
-    float load_factor() const noexcept;
-    float max_load_factor() const noexcept;
-    void max_load_factor(float z);
-    void rehash(size_type n);
-    void reserve(size_type n);
   };
   template<class InputIterator,
            class Hash = hash<iter-value-type<InputIterator>>,
            class Pred = equal_to<iter-value-type<InputIterator>>,
            class Allocator = allocator<iter-value-type<InputIterator>>>
-    unordered_multiset(InputIterator, InputIterator, see below::size_type = see below,
                        Hash = Hash(), Pred = Pred(), Allocator = Allocator())
       -> unordered_multiset<iter-value-type<InputIterator>,
                             Hash, Pred, Allocator>;
   template<ranges::input_range R,
@@ -9063,13 +10644,12 @@ refers to the `size_type` member type of the type deduced by the
 deduction guide.
 #### Constructors <a id="unord.multiset.cnstr">[[unord.multiset.cnstr]]</a>
 ``` cpp
-unordered_multiset() : unordered_multiset(size_type(see below)) { }
-explicit unordered_multiset(size_type n,
-                            const hasher& hf = hasher(),
                                       const key_equal& eql = key_equal(),
                                       const allocator_type& a = allocator_type());
 ```
 *Effects:* Constructs an empty `unordered_multiset` using the specified
@@ -9079,24 +10659,21 @@ hash function, key equality predicate, and allocator, and using at least
 *Complexity:* Constant.
 ``` cpp
 template<class InputIterator>
-  unordered_multiset(InputIterator f, InputIterator l,
- size_type n = see below,
-                     const hasher& hf = hasher(),
                                const key_equal& eql = key_equal(),
                                const allocator_type& a = allocator_type());
 template<container-compatible-range<value_type> R>
-  unordered_multiset(from_range_t, R&& rg,
- size_type n = see below,
-                     const hasher& hf = hasher(),
                                const key_equal& eql = key_equal(),
                                const allocator_type& a = allocator_type());
-unordered_multiset(initializer_list<value_type> il,
- size_type n = see below,
-                   const hasher& hf = hasher(),
                              const key_equal& eql = key_equal(),
                              const allocator_type& a = allocator_type());
 ```
 *Effects:* Constructs an empty `unordered_multiset` using the specified
@@ -9109,11 +10686,11 @@ hash function, key equality predicate, and allocator, and using at least
 #### Erasure <a id="unord.multiset.erasure">[[unord.multiset.erasure]]</a>
 ``` cpp
 template<class K, class H, class P, class A, class Predicate>
-  typename unordered_multiset<K, H, P, A>::size_type
     erase_if(unordered_multiset<K, H, P, A>& c, Predicate pred);
 ```
 *Effects:* Equivalent to:
@@ -9129,11 +10706,11 @@ for (auto i = c.begin(), last = c.end(); i != last; ) {
 return original_size - c.size();
 ```
 ## 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.
@@ -9204,12 +10781,11 @@ deduction guides for container adaptors.
 The following exposition-only alias template may appear in deduction
 guides for container adaptors:
 ``` cpp
 template<class Allocator, class T>
-  using alloc-rebind = // exposition only
-    typename allocator_traits<Allocator>::template rebind_alloc<T>;
 ```
 ### Header `<queue>` synopsis <a id="queue.syn">[[queue.syn]]</a>
 ``` cpp
@@ -9219,159 +10795,49 @@ template<class Allocator, class T>
 namespace std {
   // [queue], class template queue
   template<class T, class Container = deque<T>> class queue;
   template<class T, class Container>
-    bool operator==(const queue<T, Container>& x, const queue<T, Container>& y);
   template<class T, class Container>
-    bool operator!=(const queue<T, Container>& x, const queue<T, Container>& y);
   template<class T, class Container>
-    bool operator< (const queue<T, Container>& x, const queue<T, Container>& y);
   template<class T, class Container>
-    bool operator> (const queue<T, Container>& x, const queue<T, Container>& y);
   template<class T, class Container>
-    bool operator<=(const queue<T, Container>& x, const queue<T, Container>& y);
   template<class T, class Container>
-    bool operator>=(const queue<T, Container>& x, const queue<T, Container>& y);
   template<class T, three_way_comparable Container>
-    compare_three_way_result_t<Container>
       operator<=>(const queue<T, Container>& x, const queue<T, Container>& y);
   template<class T, class Container>
-    void swap(queue<T, Container>& x, queue<T, Container>& y) noexcept(noexcept(x.swap(y)));
   template<class T, class Container, class Alloc>
     struct uses_allocator<queue<T, Container>, Alloc>;
   // [priority.queue], class template priority_queue
   template<class T, class Container = vector<T>,
            class Compare = less<typename Container::value_type>>
     class priority_queue;
   template<class T, class Container, class Compare>
-    void swap(priority_queue<T, Container, Compare>& x,
                         priority_queue<T, Container, Compare>& y) noexcept(noexcept(x.swap(y)));
   template<class T, class Container, class Compare, class Alloc>
     struct uses_allocator<priority_queue<T, Container, Compare>, Alloc>;
-}
-```
-### Header `<stack>` synopsis <a id="stack.syn">[[stack.syn]]</a>
-``` cpp
-#include <compare>              // see [compare.syn]
-#include <initializer_list>     // see [initializer.list.syn]
-namespace std {
-  // [stack], class template stack
-  template<class T, class Container = deque<T>> class stack;
-  template<class T, class Container>
-    bool operator==(const stack<T, Container>& x, const stack<T, Container>& y);
-  template<class T, class Container>
-    bool operator!=(const stack<T, Container>& x, const stack<T, Container>& y);
-  template<class T, class Container>
-    bool operator< (const stack<T, Container>& x, const stack<T, Container>& y);
-  template<class T, class Container>
-    bool operator> (const stack<T, Container>& x, const stack<T, Container>& y);
-  template<class T, class Container>
-    bool operator<=(const stack<T, Container>& x, const stack<T, Container>& y);
-  template<class T, class Container>
-    bool operator>=(const stack<T, Container>& x, const stack<T, Container>& y);
-  template<class T, three_way_comparable Container>
-    compare_three_way_result_t<Container>
-      operator<=>(const stack<T, Container>& x, const stack<T, Container>& y);
-  template<class T, class Container>
-    void swap(stack<T, Container>& x, stack<T, Container>& y) noexcept(noexcept(x.swap(y)));
-  template<class T, class Container, class Alloc>
-    struct uses_allocator<stack<T, Container>, Alloc>;
-}
-```
-### Header `<flat_map>` synopsis <a id="flat.map.syn">[[flat.map.syn]]</a>
-``` cpp
-#include <compare>              // see [compare.syn]
-#include <initializer_list>     // see [initializer.list.syn]
-namespace std {
-  // [flat.map], class template flat_map
-  template<class Key, class T, class Compare = less<Key>,
-           class KeyContainer = vector<Key>, class MappedContainer = vector<T>>
-    class flat_map;
-  struct sorted_unique_t { explicit sorted_unique_t() = default; };
-  inline constexpr sorted_unique_t sorted_unique{};
-  template<class Key, class T, class Compare, class KeyContainer, class MappedContainer,
-           class Allocator>
-    struct uses_allocator<flat_map<Key, T, Compare, KeyContainer, MappedContainer>,
-                          Allocator>;
-  // [flat.map.erasure], erasure for flat_map
-  template<class Key, class T, class Compare, class KeyContainer, class MappedContainer,
-           class Predicate>
-    typename flat_map<Key, T, Compare, KeyContainer, MappedContainer>::size_type
-      erase_if(flat_map<Key, T, Compare, KeyContainer, MappedContainer>& c, Predicate pred);
-  // [flat.multimap], class template flat_multimap
-  template<class Key, class T, class Compare = less<Key>,
-           class KeyContainer = vector<Key>, class MappedContainer = vector<T>>
-    class flat_multimap;
-  struct sorted_equivalent_t { explicit sorted_equivalent_t() = default; };
-  inline constexpr sorted_equivalent_t sorted_equivalent{};
-  template<class Key, class T, class Compare, class KeyContainer, class MappedContainer,
-           class Allocator>
-    struct uses_allocator<flat_multimap<Key, T, Compare, KeyContainer, MappedContainer>,
-                          Allocator>;
-  // [flat.multimap.erasure], erasure for flat_multimap
-  template<class Key, class T, class Compare, class KeyContainer, class MappedContainer,
-           class Predicate>
-    typename flat_multimap<Key, T, Compare, KeyContainer, MappedContainer>::size_type
-      erase_if(flat_multimap<Key, T, Compare, KeyContainer, MappedContainer>& c, Predicate pred);
-}
-```
-### Header `<flat_set>` synopsis <a id="flat.set.syn">[[flat.set.syn]]</a>
-``` cpp
-#include <compare>              // see [compare.syn]
-#include <initializer_list>     // see [initializer.list.syn]
-namespace std {
-  // [flat.set], class template flat_set
-  template<class Key, class Compare = less<Key>, class KeyContainer = vector<Key>>
-    class flat_set;
-  struct sorted_unique_t { explicit sorted_unique_t() = default; };
-  inline constexpr sorted_unique_t sorted_unique{};
-  template<class Key, class Compare, class KeyContainer, class Allocator>
-    struct uses_allocator<flat_set<Key, Compare, KeyContainer>, Allocator>;
-  // [flat.set.erasure], erasure for flat_set
-  template<class Key, class Compare, class KeyContainer, class Predicate>
-    typename flat_set<Key, Compare, KeyContainer>::size_type
-      erase_if(flat_set<Key, Compare, KeyContainer>& c, Predicate pred);
-  // [flat.multiset], class template flat_multiset
-  template<class Key, class Compare = less<Key>, class KeyContainer = vector<Key>>
-    class flat_multiset;
-  struct sorted_equivalent_t { explicit sorted_equivalent_t() = default; };
-  inline constexpr sorted_equivalent_t sorted_equivalent{};
-  template<class Key, class Compare, class KeyContainer, class Allocator>
-    struct uses_allocator<flat_multiset<Key, Compare, KeyContainer>, Allocator>;
-  // [flat.multiset.erasure], erasure for flat_multiset
-  template<class Key, class Compare, class KeyContainer, class Predicate>
-    typename flat_multiset<Key, Compare, KeyContainer>::size_type
-      erase_if(flat_multiset<Key, Compare, KeyContainer>& c, Predicate pred);
 }
 ```
 ### Class template `queue` <a id="queue">[[queue]]</a>
@@ -9384,49 +10850,49 @@ particular, `list` [[list]] and `deque` [[deque]] can be used.
 ``` cpp
 namespace std {
   template<class T, class Container = deque<T>>
   class queue {
   public:
-    using value_type      = typename Container::value_type;
-    using reference       = typename Container::reference;
-    using const_reference = typename Container::const_reference;
-    using size_type       = typename Container::size_type;
     using container_type  = Container;
   protected:
     Container c;
   public:
-    queue() : queue(Container()) {}
-    explicit queue(const Container&);
-    explicit queue(Container&&);
-    template<class InputIterator> queue(InputIterator first, InputIterator last);
-    template<container-compatible-range<T> R> queue(from_range_t, R&& rg);
-    template<class Alloc> explicit queue(const Alloc&);
-    template<class Alloc> queue(const Container&, const Alloc&);
-    template<class Alloc> queue(Container&&, const Alloc&);
-    template<class Alloc> queue(const queue&, const Alloc&);
-    template<class Alloc> queue(queue&&, const Alloc&);
     template<class InputIterator, class Alloc>
-      queue(InputIterator first, InputIterator last, const Alloc&);
     template<container-compatible-range<T> R, class Alloc>
-      queue(from_range_t, R&& rg, const Alloc&);
- [[nodiscard]] bool empty() const { return c.empty(); }
-    size_type         size()  const     { return c.size(); }
-    reference         front()           { return c.front(); }
-    const_reference   front() const     { return c.front(); }
-    reference         back()            { return c.back(); }
-    const_reference   back() const      { return c.back(); }
-    void push(const value_type& x)      { c.push_back(x); }
-    void push(value_type&& x)           { c.push_back(std::move(x)); }
-    template<container-compatible-range<T> R> void push_range(R&& rg);
     template<class... Args>
-      decltype(auto) emplace(Args&&... args)
         { return c.emplace_back(std::forward<Args>(args)...); }
-    void pop()                          { c.pop_front(); }
-    void swap(queue& q) noexcept(is_nothrow_swappable_v<Container>)
       { using std::swap; swap(c, q.c); }
   };
   template<class Container>
     queue(Container) -> queue<typename Container::value_type, Container>;
@@ -9456,32 +10922,32 @@ namespace std {
 ```
 #### Constructors <a id="queue.cons">[[queue.cons]]</a>
 ``` cpp
-explicit queue(const Container& cont);
 ```
 *Effects:* Initializes `c` with `cont`.
 ``` cpp
-explicit queue(Container&& cont);
 ```
 *Effects:* Initializes `c` with `std::move(cont)`.
 ``` cpp
 template<class InputIterator>
-  queue(InputIterator first, InputIterator last);
 ```
 *Effects:* Initializes `c` with `first` as the first argument and `last`
 as the second argument.
 ``` cpp
 template<container-compatible-range<T> R>
-  queue(from_range_t, R&& rg);
 ```
 *Effects:* Initializes `c` with
 `ranges::to<Container>(std::forward<R>(rg))`.
@@ -9489,127 +10955,127 @@ template<container-compatible-range<T> R>
 If `uses_allocator_v<container_type, Alloc>` is `false` the constructors
 in this subclause shall not participate in overload resolution.
 ``` cpp
-template<class Alloc> explicit queue(const Alloc& a);
 ```
 *Effects:* Initializes `c` with `a`.
 ``` cpp
-template<class Alloc> queue(const container_type& cont, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `cont` as the first argument and `a` as
 the second argument.
 ``` cpp
-template<class Alloc> queue(container_type&& cont, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `std::move(cont)` as the first argument
 and `a` as the second argument.
 ``` cpp
-template<class Alloc> queue(const queue& q, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `q.c` as the first argument and `a` as
 the second argument.
 ``` cpp
-template<class Alloc> queue(queue&& q, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `std::move(q.c)` as the first argument
 and `a` as the second argument.
 ``` cpp
 template<class InputIterator, class Alloc>
-  queue(InputIterator first, InputIterator last, const Alloc& alloc);
 ```
 *Effects:* Initializes `c` with `first` as the first argument, `last` as
 the second argument, and `alloc` as the third argument.
 ``` cpp
 template<container-compatible-range<T> R, class Alloc>
-  queue(from_range_t, R&& rg, const Alloc& a);
 ```
 *Effects:* Initializes `c` with
 `ranges::to<Container>(std::forward<R>(rg), a)`.
 #### Modifiers <a id="queue.mod">[[queue.mod]]</a>
 ``` cpp
 template<container-compatible-range<T> R>
-  void push_range(R&& rg);
 ```
 *Effects:* Equivalent to `c.append_range(std::forward<R>(rg))` if that
 is a valid expression, otherwise `ranges::copy(rg, back_inserter(c))`.
 #### Operators <a id="queue.ops">[[queue.ops]]</a>
 ``` cpp
 template<class T, class Container>
-  bool operator==(const queue<T, Container>& x, const queue<T, Container>& y);
 ```
 *Returns:* `x.c == y.c`.
 ``` cpp
 template<class T, class Container>
-  bool operator!=(const queue<T, Container>& x,  const queue<T, Container>& y);
 ```
 *Returns:* `x.c != y.c`.
 ``` cpp
 template<class T, class Container>
-  bool operator< (const queue<T, Container>& x, const queue<T, Container>& y);
 ```
 *Returns:* `x.c < y.c`.
 ``` cpp
 template<class T, class Container>
-  bool operator> (const queue<T, Container>& x, const queue<T, Container>& y);
 ```
 *Returns:* `x.c > y.c`.
 ``` cpp
 template<class T, class Container>
-  bool operator<=(const queue<T, Container>& x, const queue<T, Container>& y);
 ```
 *Returns:* `x.c <= y.c`.
 ``` cpp
 template<class T, class Container>
- bool operator>=(const queue<T, Container>& x,
-                    const queue<T, Container>& y);
 ```
 *Returns:* `x.c >= y.c`.
 ``` cpp
 template<class T, three_way_comparable Container>
-  compare_three_way_result_t<Container>
     operator<=>(const queue<T, Container>& x, const queue<T, Container>& y);
 ```
 *Returns:* `x.c <=> y.c`.
 #### Specialized algorithms <a id="queue.special">[[queue.special]]</a>
 ``` cpp
 template<class T, class Container>
-  void swap(queue<T, Container>& x, queue<T, Container>& y) noexcept(noexcept(x.swap(y)));
 ```
 *Constraints:* `is_swappable_v<Container>` is `true`.
 *Effects:* As if by `x.swap(y)`.
@@ -9630,67 +11096,70 @@ defines a strict weak ordering [[alg.sorting]].
 namespace std {
   template<class T, class Container = vector<T>,
            class Compare = less<typename Container::value_type>>
   class priority_queue {
   public:
-    using value_type      = typename Container::value_type;
-    using reference       = typename Container::reference;
-    using const_reference = typename Container::const_reference;
-    using size_type       = typename Container::size_type;
     using container_type  = Container;
     using value_compare   = Compare;
   protected:
     Container c;
     Compare comp;
   public:
-    priority_queue() : priority_queue(Compare()) {}
-    explicit priority_queue(const Compare& x) : priority_queue(x, Container()) {}
-    priority_queue(const Compare& x, const Container&);
-    priority_queue(const Compare& x, Container&&);
     template<class InputIterator>
-      priority_queue(InputIterator first, InputIterator last, const Compare& x = Compare());
     template<class InputIterator>
-      priority_queue(InputIterator first, InputIterator last, const Compare& x,
                                const Container&);
     template<class InputIterator>
-      priority_queue(InputIterator first, InputIterator last, const Compare& x,
                                Container&&);
     template<container-compatible-range<T> R>
-      priority_queue(from_range_t, R&& rg, const Compare& x = Compare());
-    template<class Alloc> explicit priority_queue(const Alloc&);
-    template<class Alloc> priority_queue(const Compare&, const Alloc&);
-    template<class Alloc> priority_queue(const Compare&, const Container&, const Alloc&);
-    template<class Alloc> priority_queue(const Compare&, Container&&, const Alloc&);
-    template<class Alloc> priority_queue(const priority_queue&, const Alloc&);
-    template<class Alloc> priority_queue(priority_queue&&, const Alloc&);
     template<class InputIterator, class Alloc>
-      priority_queue(InputIterator, InputIterator, const Alloc&);
     template<class InputIterator, class Alloc>
-      priority_queue(InputIterator, InputIterator, const Compare&, const Alloc&);
     template<class InputIterator, class Alloc>
-      priority_queue(InputIterator, InputIterator, const Compare&, const Container&,
                                const Alloc&);
     template<class InputIterator, class Alloc>
-      priority_queue(InputIterator, InputIterator, const Compare&, Container&&, const Alloc&);
     template<container-compatible-range<T> R, class Alloc>
-      priority_queue(from_range_t, R&& rg, const Compare&, const Alloc&);
     template<container-compatible-range<T> R, class Alloc>
-      priority_queue(from_range_t, R&& rg, const Alloc&);
- [[nodiscard]] bool empty() const { return c.empty(); }
- size_type size()  const { return c.size(); }
-    const_reference top() const { return c.front(); }
-    void push(const value_type& x);
-    void push(value_type&& x);
     template<container-compatible-range<T> R>
-      void push_range(R&& rg);
-    template<class... Args> void emplace(Args&&... args);
-    void pop();
-    void swap(priority_queue& q) noexcept(is_nothrow_swappable_v<Container> &&
- is_nothrow_swappable_v<Compare>)
       { using std::swap; swap(c, q.c); swap(comp, q.comp); }
   };
   template<class Compare, class Container>
     priority_queue(Compare, Container)
@@ -9743,36 +11212,38 @@ namespace std {
 ```
 #### Constructors <a id="priqueue.cons">[[priqueue.cons]]</a>
 ``` cpp
-priority_queue(const Compare& x, const Container& y);
-priority_queue(const Compare& x, Container&& y);
 ```
 *Preconditions:* `x` defines a strict weak ordering [[alg.sorting]].
 *Effects:* Initializes `comp` with `x` and `c` with `y` (copy
 constructing or move constructing as appropriate); calls
 `make_heap(c.begin(), c.end(), comp)`.
 ``` cpp
 template<class InputIterator>
-  priority_queue(InputIterator first, InputIterator last, const Compare& x = Compare());
 ```
 *Preconditions:* `x` defines a strict weak ordering [[alg.sorting]].
 *Effects:* Initializes `c` with `first` as the first argument and `last`
 as the second argument, and initializes `comp` with `x`; then calls
 `make_heap(c.begin(), c.end(), comp)`.
 ``` cpp
 template<class InputIterator>
-  priority_queue(InputIterator first, InputIterator last, const Compare& x, const Container& y);
 template<class InputIterator>
-  priority_queue(InputIterator first, InputIterator last, const Compare& x, Container&& y);
 ```
 *Preconditions:* `x` defines a strict weak ordering [[alg.sorting]].
 *Effects:* Initializes `comp` with `x` and `c` with `y` (copy
@@ -9780,11 +11251,11 @@ constructing or move constructing as appropriate); calls
 `c.insert(c.end(), first, last)`; and finally calls
 `make_heap(c.begin(), c.end(), comp)`.
 ``` cpp
 template<container-compatible-range<T> R>
-  priority_queue(from_range_t, R&& rg, const Compare& x = Compare());
 ```
 *Preconditions:* `x` defines a strict weak ordering [[alg.sorting]].
 *Effects:* Initializes `comp` with `x` and `c` with
@@ -9795,128 +11266,129 @@ template<container-compatible-range<T> R>
 If `uses_allocator_v<container_type, Alloc>` is `false` the constructors
 in this subclause shall not participate in overload resolution.
 ``` cpp
-template<class Alloc> explicit priority_queue(const Alloc& a);
 ```
 *Effects:* Initializes `c` with `a` and value-initializes `comp`.
 ``` cpp
-template<class Alloc> priority_queue(const Compare& compare, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `a` and initializes `comp` with
 `compare`.
 ``` cpp
 template<class Alloc>
-  priority_queue(const Compare& compare, const Container& cont, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `cont` as the first argument and `a` as
 the second argument, and initializes `comp` with `compare`; calls
 `make_heap(c.begin(), c.end(), comp)`.
 ``` cpp
 template<class Alloc>
-  priority_queue(const Compare& compare, Container&& cont, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `std::move(cont)` as the first argument
 and `a` as the second argument, and initializes `comp` with `compare`;
 calls `make_heap(c.begin(), c.end(), comp)`.
 ``` cpp
-template<class Alloc> priority_queue(const priority_queue& q, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `q.c` as the first argument and `a` as
 the second argument, and initializes `comp` with `q.comp`.
 ``` cpp
-template<class Alloc> priority_queue(priority_queue&& q, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `std::move(q.c)` as the first argument
 and `a` as the second argument, and initializes `comp` with
 `std::move(q.comp)`.
 ``` cpp
 template<class InputIterator, class Alloc>
-  priority_queue(InputIterator first, InputIterator last, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `first` as the first argument, `last` as
 the second argument, and `a` as the third argument, and
 value-initializes `comp`; calls `make_heap(c.begin(), c.end(), comp)`.
 ``` cpp
 template<class InputIterator, class Alloc>
-  priority_queue(InputIterator first, InputIterator last, const Compare& compare, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `first` as the first argument, `last` as
 the second argument, and `a` as the third argument, and initializes
 `comp` with `compare`; calls `make_heap(c.begin(), c.end(), comp)`.
 ``` cpp
 template<class InputIterator, class Alloc>
-  priority_queue(InputIterator first, InputIterator last, const Compare& compare,
                            const Container& cont, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `cont` as the first argument and `a` as
 the second argument, and initializes `comp` with `compare`; calls
 `c.insert(c.end(), first, last)`; and finally calls
 `make_heap(c.begin(), c.end(), comp)`.
 ``` cpp
 template<class InputIterator, class Alloc>
-  priority_queue(InputIterator first, InputIterator last, const Compare& compare, Container&& cont,
- const Alloc& a);
 ```
 *Effects:* Initializes `c` with `std::move(cont)` as the first argument
 and `a` as the second argument, and initializes `comp` with `compare`;
 calls `c.insert(c.end(), first, last)`; and finally calls
 `make_heap(c.begin(), c.end(), comp)`.
 ``` cpp
 template<container-compatible-range<T> R, class Alloc>
-  priority_queue(from_range_t, R&& rg, const Compare& compare, const Alloc& a);
 ```
 *Effects:* Initializes `comp` with `compare` and `c` with
 `ranges::to<Container>(std::forward<R>(rg), a)`; calls
 `make_heap(c.begin(), c.end(), comp)`.
 ``` cpp
 template<container-compatible-range<T> R, class Alloc>
-  priority_queue(from_range_t, R&& rg, const Alloc& a);
 ```
 *Effects:* Initializes `c` with
-`ranges::to<Container>(std::forward<R>(rg), a)`; calls
-`make_heap(c.begin(), c.end(), comp)`.
 #### Members <a id="priqueue.members">[[priqueue.members]]</a>
 ``` cpp
-void push(const value_type& x);
 ```
 *Effects:* As if by:
 ``` cpp
 c.push_back(x);
 push_heap(c.begin(), c.end(), comp);
 ```
 ``` cpp
-void push(value_type&& x);
 ```
 *Effects:* As if by:
 ``` cpp
@@ -9924,33 +11396,33 @@ c.push_back(std::move(x));
 push_heap(c.begin(), c.end(), comp);
 ```
 ``` cpp
 template<container-compatible-range<T> R>
-  void push_range(R&& rg);
 ```
 *Effects:* Inserts all elements of `rg` in `c` via
 `c.append_range(std::forward<R>(rg))` if that is a valid expression, or
 `ranges::copy(rg, back_inserter(c))` otherwise. Then restores the heap
 property as if by `make_heap(c.begin(), c.end(), comp)`.
 *Ensures:* `is_heap(c.begin(), c.end(), comp)` is `true`.
 ``` cpp
-template<class... Args> void emplace(Args&&... args);
 ```
 *Effects:* As if by:
 ``` cpp
 c.emplace_back(std::forward<Args>(args)...);
 push_heap(c.begin(), c.end(), comp);
 ```
 ``` cpp
-void pop();
 ```
 *Effects:* As if by:
 ``` cpp
@@ -9960,19 +11432,57 @@ c.pop_back();
 #### Specialized algorithms <a id="priqueue.special">[[priqueue.special]]</a>
 ``` cpp
 template<class T, class Container, class Compare>
-  void swap(priority_queue<T, Container, Compare>& x,
                       priority_queue<T, Container, Compare>& y) noexcept(noexcept(x.swap(y)));
 ```
 *Constraints:* `is_swappable_v<Container>` is `true` and
 `is_swappable_v<Compare>` is `true`.
 *Effects:* As if by `x.swap(y)`.
 ### Class template `stack` <a id="stack">[[stack]]</a>
 #### General <a id="stack.general">[[stack.general]]</a>
 Any sequence container supporting operations `back()`, `push_back()` and
@@ -9984,48 +11494,49 @@ Any sequence container supporting operations `back()`, `push_back()` and
 ``` cpp
 namespace std {
   template<class T, class Container = deque<T>>
   class stack {
   public:
-    using value_type      = typename Container::value_type;
-    using reference       = typename Container::reference;
-    using const_reference = typename Container::const_reference;
-    using size_type       = typename Container::size_type;
     using container_type  = Container;
   protected:
     Container c;
   public:
-    stack() : stack(Container()) {}
-    explicit stack(const Container&);
-    explicit stack(Container&&);
-    template<class InputIterator> stack(InputIterator first, InputIterator last);
-    template<container-compatible-range<T> R> stack(from_range_t, R&& rg);
-    template<class Alloc> explicit stack(const Alloc&);
-    template<class Alloc> stack(const Container&, const Alloc&);
-    template<class Alloc> stack(Container&&, const Alloc&);
-    template<class Alloc> stack(const stack&, const Alloc&);
-    template<class Alloc> stack(stack&&, const Alloc&);
     template<class InputIterator, class Alloc>
-      stack(InputIterator first, InputIterator last, const Alloc&);
     template<container-compatible-range<T> R, class Alloc>
-      stack(from_range_t, R&& rg, const Alloc&);
- [[nodiscard]] bool empty() const { return c.empty(); }
- size_type size()  const { return c.size(); }
-    reference         top()             { return c.back(); }
-    const_reference   top() const { return c.back(); }
-    void push(const value_type& x)      { c.push_back(x); }
-    void push(value_type&& x)           { c.push_back(std::move(x)); }
     template<container-compatible-range<T> R>
-      void push_range(R&& rg);
     template<class... Args>
-      decltype(auto) emplace(Args&&... args)
         { return c.emplace_back(std::forward<Args>(args)...); }
-    void pop()                          { c.pop_back(); }
-    void swap(stack& s) noexcept(is_nothrow_swappable_v<Container>)
       { using std::swap; swap(c, s.c); }
   };
   template<class Container>
     stack(Container) -> stack<typename Container::value_type, Container>;
@@ -10055,32 +11566,32 @@ namespace std {
 ```
 #### Constructors <a id="stack.cons">[[stack.cons]]</a>
 ``` cpp
-explicit stack(const Container& cont);
 ```
 *Effects:* Initializes `c` with `cont`.
 ``` cpp
-explicit stack(Container&& cont);
 ```
 *Effects:* Initializes `c` with `std::move(cont)`.
 ``` cpp
 template<class InputIterator>
-  stack(InputIterator first, InputIterator last);
 ```
 *Effects:* Initializes `c` with `first` as the first argument and `last`
 as the second argument.
 ``` cpp
 template<container-compatible-range<T> R>
-  stack(from_range_t, R&& rg);
 ```
 *Effects:* Initializes `c` with
 `ranges::to<Container>(std::forward<R>(rg))`.
@@ -10088,132 +11599,180 @@ template<container-compatible-range<T> R>
 If `uses_allocator_v<container_type, Alloc>` is `false` the constructors
 in this subclause shall not participate in overload resolution.
 ``` cpp
-template<class Alloc> explicit stack(const Alloc& a);
 ```
 *Effects:* Initializes `c` with `a`.
 ``` cpp
-template<class Alloc> stack(const container_type& cont, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `cont` as the first argument and `a` as
 the second argument.
 ``` cpp
-template<class Alloc> stack(container_type&& cont, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `std::move(cont)` as the first argument
 and `a` as the second argument.
 ``` cpp
-template<class Alloc> stack(const stack& s, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `s.c` as the first argument and `a` as
 the second argument.
 ``` cpp
-template<class Alloc> stack(stack&& s, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `std::move(s.c)` as the first argument
 and `a` as the second argument.
 ``` cpp
 template<class InputIterator, class Alloc>
-  stack(InputIterator first, InputIterator last, const Alloc& alloc);
 ```
 *Effects:* Initializes `c` with `first` as the first argument, `last` as
 the second argument, and `alloc` as the third argument.
 ``` cpp
 template<container-compatible-range<T> R, class Alloc>
-  stack(from_range_t, R&& rg, const Alloc& a);
 ```
 *Effects:* Initializes `c` with
 `ranges::to<Container>(std::forward<R>(rg), a)`.
 #### Modifiers <a id="stack.mod">[[stack.mod]]</a>
 ``` cpp
 template<container-compatible-range<T> R>
-  void push_range(R&& rg);
 ```
 *Effects:* Equivalent to `c.append_range(std::forward<R>(rg))` if that
 is a valid expression, otherwise `ranges::copy(rg, back_inserter(c))`.
 #### Operators <a id="stack.ops">[[stack.ops]]</a>
 ``` cpp
 template<class T, class Container>
-  bool operator==(const stack<T, Container>& x, const stack<T, Container>& y);
 ```
 *Returns:* `x.c == y.c`.
 ``` cpp
 template<class T, class Container>
-  bool operator!=(const stack<T, Container>& x, const stack<T, Container>& y);
 ```
 *Returns:* `x.c != y.c`.
 ``` cpp
 template<class T, class Container>
-  bool operator< (const stack<T, Container>& x, const stack<T, Container>& y);
 ```
 *Returns:* `x.c < y.c`.
 ``` cpp
 template<class T, class Container>
-  bool operator> (const stack<T, Container>& x, const stack<T, Container>& y);
 ```
 *Returns:* `x.c > y.c`.
 ``` cpp
 template<class T, class Container>
-  bool operator<=(const stack<T, Container>& x, const stack<T, Container>& y);
 ```
 *Returns:* `x.c <= y.c`.
 ``` cpp
 template<class T, class Container>
-  bool operator>=(const stack<T, Container>& x, const stack<T, Container>& y);
 ```
 *Returns:* `x.c >= y.c`.
 ``` cpp
 template<class T, three_way_comparable Container>
-  compare_three_way_result_t<Container>
     operator<=>(const stack<T, Container>& x, const stack<T, Container>& y);
 ```
 *Returns:* `x.c <=> y.c`.
 #### Specialized algorithms <a id="stack.special">[[stack.special]]</a>
 ``` cpp
 template<class T, class Container>
-  void swap(stack<T, Container>& x, stack<T, Container>& y) noexcept(noexcept(x.swap(y)));
 ```
 *Constraints:* `is_swappable_v<Container>` is `true`.
 *Effects:* As if by `x.swap(y)`.
 ### Class template `flat_map` <a id="flat.map">[[flat.map]]</a>
 #### Overview <a id="flat.map.overview">[[flat.map.overview]]</a>
 A `flat_map` is a container adaptor that provides an associative
@@ -10278,14 +11837,16 @@ The program is ill-formed if `Key` is not the same type as
 The effect of calling a constructor that takes both `key_container_type`
 and `mapped_container_type` arguments with containers of different sizes
 is undefined.
-The effect of calling a constructor or member function that takes a
-`sorted_unique_t` argument with a container, containers, or range that
-is not sorted with respect to `key_comp()`, or that contains equal
-elements, is undefined.
 #### Definition <a id="flat.map.defn">[[flat.map.defn]]</a>
 ``` cpp
 namespace std {
@@ -10310,245 +11871,259 @@ namespace std {
     using mapped_container_type  = MappedContainer;
     class value_compare {
     private:
       key_compare comp;                                         // exposition only
-      value_compare(key_compare c) : comp(c) { } // exposition only
     public:
-      bool operator()(const_reference x, const_reference y) const {
         return comp(x.first, y.first);
       }
     };
     struct containers {
       key_container_type keys;
       mapped_container_type values;
     };
-    // [flat.map.cons], construct/copy/destroy
-    flat_map() : flat_map(key_compare()) { }
-    flat_map(key_container_type key_cont, mapped_container_type mapped_cont,
-             const key_compare& comp = key_compare());
-    template<class Allocator>
-      flat_map(const key_container_type& key_cont, const mapped_container_type& mapped_cont,
-               const Allocator& a);
-    template<class Allocator>
-      flat_map(const key_container_type& key_cont, const mapped_container_type& mapped_cont,
-               const key_compare& comp, const Allocator& a);
-    flat_map(sorted_unique_t, key_container_type key_cont, mapped_container_type mapped_cont,
-             const key_compare& comp = key_compare());
-    template<class Allocator>
-      flat_map(sorted_unique_t, const key_container_type& key_cont,
-               const mapped_container_type& mapped_cont, const Allocator& a);
-    template<class Allocator>
-      flat_map(sorted_unique_t, const key_container_type& key_cont,
-               const mapped_container_type& mapped_cont,
-               const key_compare& comp, const Allocator& a);
-    explicit flat_map(const key_compare& comp)
       : c(), compare(comp) { }
-    template<class Allocator>
- flat_map(const key_compare& comp, const Allocator& a);
-    template<class Allocator>
-      explicit flat_map(const Allocator& a);
     template<class InputIterator>
-      flat_map(InputIterator first, InputIterator last, const key_compare& comp = key_compare())
         : c(), compare(comp) { insert(first, last); }
-    template<class InputIterator, class Allocator>
-      flat_map(InputIterator first, InputIterator last,
-               const key_compare& comp, const Allocator& a);
-    template<class InputIterator, class Allocator>
-      flat_map(InputIterator first, InputIterator last, const Allocator& a);
     template<container-compatible-range<value_type> R>
-      flat_map(from_range_t fr, R&& rg)
-        : flat_map(fr, std::forward<R>(rg), key_compare()) { }
-    template<container-compatible-range<value_type> R, class Allocator>
-      flat_map(from_range_t, R&& rg, const Allocator& a);
     template<container-compatible-range<value_type> R>
-      flat_map(from_range_t, R&& rg, const key_compare& comp)
         : flat_map(comp) { insert_range(std::forward<R>(rg)); }
-    template<container-compatible-range<value_type> R, class Allocator>
-      flat_map(from_range_t, R&& rg, const key_compare& comp, const Allocator& a);
- template<class InputIterator>
-      flat_map(sorted_unique_t s, InputIterator first, InputIterator last,
-               const key_compare& comp = key_compare())
-        : c(), compare(comp) { insert(s, first, last); }
-    template<class InputIterator, class Allocator>
-      flat_map(sorted_unique_t, InputIterator first, InputIterator last,
-               const key_compare& comp, const Allocator& a);
-    template<class InputIterator, class Allocator>
-      flat_map(sorted_unique_t, InputIterator first, InputIterator last, const Allocator& a);
-    flat_map(initializer_list<value_type> il, const key_compare& comp = key_compare())
         : flat_map(il.begin(), il.end(), comp) { }
-    template<class Allocator>
-      flat_map(initializer_list<value_type> il, const key_compare& comp, const Allocator& a);
-    template<class Allocator>
-      flat_map(initializer_list<value_type> il, const Allocator& a);
-    flat_map(sorted_unique_t s, initializer_list<value_type> il,
                        const key_compare& comp = key_compare())
-        : flat_map(s, il.begin(), il.end(), comp) { }
-    template<class Allocator>
-      flat_map(sorted_unique_t, initializer_list<value_type> il,
-               const key_compare& comp, const Allocator& a);
-    template<class Allocator>
-      flat_map(sorted_unique_t, initializer_list<value_type> il, const Allocator& a);
- flat_map& operator=(initializer_list<value_type> il);
     // iterators
-    iterator               begin() noexcept;
-    const_iterator         begin() const noexcept;
-    iterator               end() noexcept;
-    const_iterator         end() const noexcept;
-    reverse_iterator       rbegin() noexcept;
-    const_reverse_iterator rbegin() const noexcept;
-    reverse_iterator       rend() noexcept;
-    const_reverse_iterator rend() const noexcept;
-    const_iterator         cbegin() const noexcept;
-    const_iterator         cend() const noexcept;
-    const_reverse_iterator crbegin() const noexcept;
-    const_reverse_iterator crend() const noexcept;
     // [flat.map.capacity], capacity
- [[nodiscard]] bool empty() const noexcept;
-    size_type size() const noexcept;
-    size_type max_size() const noexcept;
     // [flat.map.access], element access
-    mapped_type& operator[](const key_type& x);
-    mapped_type& operator[](key_type&& x);
-    template<class K> mapped_type& operator[](K&& x);
-    mapped_type& at(const key_type& x);
-    const mapped_type& at(const key_type& x) const;
-    template<class K> mapped_type& at(const K& x);
-    template<class K> const mapped_type& at(const K& x) const;
     // [flat.map.modifiers], modifiers
-    template<class... Args> pair<iterator, bool> emplace(Args&&... args);
     template<class... Args>
-      iterator emplace_hint(const_iterator position, Args&&... args);
-    pair<iterator, bool> insert(const value_type& x)
       { return emplace(x); }
-    pair<iterator, bool> insert(value_type&& x)
       { return emplace(std::move(x)); }
-    iterator insert(const_iterator position, const value_type& x)
       { return emplace_hint(position, x); }
-    iterator insert(const_iterator position, value_type&& x)
       { return emplace_hint(position, std::move(x)); }
-    template<class P> pair<iterator, bool> insert(P&& x);
     template<class P>
-      iterator insert(const_iterator position, P&&);
     template<class InputIterator>
-      void insert(InputIterator first, InputIterator last);
     template<class InputIterator>
-      void insert(sorted_unique_t, InputIterator first, InputIterator last);
     template<container-compatible-range<value_type> R>
-      void insert_range(R&& rg);
-    void insert(initializer_list<value_type> il)
       { insert(il.begin(), il.end()); }
-    void insert(sorted_unique_t s, initializer_list<value_type> il)
-      { insert(s, il.begin(), il.end()); }
-    containers extract() &&;
-    void replace(key_container_type&& key_cont, mapped_container_type&& mapped_cont);
     template<class... Args>
-      pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
     template<class... Args>
-      pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
     template<class K, class... Args>
-      pair<iterator, bool> try_emplace(K&& k, Args&&... args);
     template<class... Args>
-      iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args);
     template<class... Args>
-      iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);
     template<class K, class... Args>
-      iterator try_emplace(const_iterator hint, K&& k, Args&&... args);
     template<class M>
-      pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);
     template<class M>
-      pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj);
     template<class K, class M>
-      pair<iterator, bool> insert_or_assign(K&& k, M&& obj);
     template<class M>
-      iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);
     template<class M>
-      iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj);
     template<class K, class M>
-      iterator insert_or_assign(const_iterator hint, K&& k, M&& obj);
-    iterator erase(iterator position);
-    iterator erase(const_iterator position);
-    size_type erase(const key_type& x);
-    template<class K> size_type erase(K&& x);
-    iterator erase(const_iterator first, const_iterator last);
-    void swap(flat_map& y) noexcept;
-    void clear() noexcept;
     // observers
-    key_compare key_comp() const;
-    value_compare value_comp() const;
-    const key_container_type& keys() const noexcept      { return c.keys; }
-    const mapped_container_type& values() const noexcept { return c.values; }
     // map operations
-    iterator find(const key_type& x);
-    const_iterator find(const key_type& x) const;
-    template<class K> iterator find(const K& x);
-    template<class K> const_iterator find(const K& x) const;
-    size_type count(const key_type& x) const;
-    template<class K> size_type count(const K& x) const;
-    bool contains(const key_type& x) const;
-    template<class K> bool contains(const K& x) const;
-    iterator lower_bound(const key_type& x);
-    const_iterator lower_bound(const key_type& x) const;
-    template<class K> iterator lower_bound(const K& x);
-    template<class K> const_iterator lower_bound(const K& x) const;
-    iterator upper_bound(const key_type& x);
-    const_iterator upper_bound(const key_type& x) const;
-    template<class K> iterator upper_bound(const K& x);
-    template<class K> const_iterator upper_bound(const K& x) const;
-    pair<iterator, iterator> equal_range(const key_type& x);
-    pair<const_iterator, const_iterator> equal_range(const key_type& x) const;
-    template<class K> pair<iterator, iterator> equal_range(const K& x);
-    template<class K> pair<const_iterator, const_iterator> equal_range(const K& x) const;
-    friend bool operator==(const flat_map& x, const flat_map& y);
-    friend synth-three-way-result<value_type>
       operator<=>(const flat_map& x, const flat_map& y);
-    friend void swap(flat_map& x, flat_map& y) noexcept
       { x.swap(y); }
   private:
     containers c;               // exposition only
     key_compare compare;        // exposition only
-    struct key_equiv {  // exposition only
- key_equiv(key_compare c) : comp(c) { }
-      bool operator()(const_reference x, const_reference y) const {
         return !comp(x.first, y.first) && !comp(y.first, x.first);
       }
       key_compare comp;
     };
   };
@@ -10625,162 +12200,163 @@ specified above. It has no base classes or members other than those
 specified.
 #### Constructors <a id="flat.map.cons">[[flat.map.cons]]</a>
 ``` cpp
-flat_map(key_container_type key_cont, mapped_container_type mapped_cont,
                    const key_compare& comp = key_compare());
 ```
-*Effects:* Initializes `c.keys` with `std::move(key_cont)`, `c.values`
-with `std::move(mapped_cont)`, and `compare` with `comp`; sorts the
-range \[`begin()`, `end()`) with respect to `value_comp()`; and finally
-erases the duplicate elements as if by:
 ``` cpp
-auto zv = ranges::zip_view(c.keys, c.values);
-auto it = ranges::unique(zv, key_equiv(compare)).begin();
 auto dist = distance(zv.begin(), it);
 c.keys.erase(c.keys.begin() + dist, c.keys.end());
 c.values.erase(c.values.begin() + dist, c.values.end());
 ```
 *Complexity:* Linear in N if the container arguments are already sorted
 with respect to `value_comp()` and otherwise N log N, where N is the
 value of `key_cont.size()` before this call.
 ``` cpp
-template<class Allocator>
-  flat_map(const key_container_type& key_cont, const mapped_container_type& mapped_cont,
-           const Allocator& a);
-template<class Allocator>
-  flat_map(const key_container_type& key_cont, const mapped_container_type& mapped_cont,
-           const key_compare& comp, const Allocator& a);
 ```
-*Constraints:* `uses_allocator_v<key_container_type, Allocator>` is
-`true` and `uses_allocator_v<mapped_container_type, Allocator>` is
-`true`.
 *Effects:* Equivalent to `flat_map(key_cont, mapped_cont)` and
 `flat_map(key_cont, mapped_cont, comp)`, respectively, except that
-`c.keys` and `c.values` are constructed with uses-allocator
 construction [[allocator.uses.construction]].
 *Complexity:* Same as `flat_map(key_cont, mapped_cont)` and
 `flat_map(key_cont, mapped_cont, comp)`, respectively.
 ``` cpp
-flat_map(sorted_unique_t, key_container_type key_cont, mapped_container_type mapped_cont,
- const key_compare& comp = key_compare());
-```
-*Effects:* Initializes `c.keys` with `std::move(key_cont)`, `c.values`
-with `std::move(mapped_cont)`, and `compare` with `comp`.
-*Complexity:* Constant.
-``` cpp
-template<class Allocator>
-  flat_map(sorted_unique_t s, const key_container_type& key_cont,
-           const mapped_container_type& mapped_cont, const Allocator& a);
-template<class Allocator>
-  flat_map(sorted_unique_t s, const key_container_type& key_cont,
                      const mapped_container_type& mapped_cont, const key_compare& comp,
- const Allocator& a);
 ```
-*Constraints:* `uses_allocator_v<key_container_type, Allocator>` is
-`true` and `uses_allocator_v<mapped_container_type, Allocator>` is
-`true`.
-*Effects:* Equivalent to `flat_map(s, key_cont, mapped_cont)` and
-`flat_map(s, key_cont, mapped_cont, comp)`, respectively, except that
-`c.keys` and `c.values` are constructed with uses-allocator
-construction [[allocator.uses.construction]].
 *Complexity:* Linear.
 ``` cpp
-template<class Allocator>
-  flat_map(const key_compare& comp, const Allocator& a);
-template<class Allocator>
- explicit flat_map(const Allocator& a);
-template<class InputIterator, class Allocator>
-  flat_map(InputIterator first, InputIterator last, const key_compare& comp, const Allocator& a);
-template<class InputIterator, class Allocator>
-  flat_map(InputIterator first, InputIterator last, const Allocator& a);
-template<container-compatible-range<value_type> R, class Allocator>
-  flat_map(from_range_t, R&& rg, const Allocator& a);
-template<container-compatible-range<value_type> R, class Allocator>
-  flat_map(from_range_t, R&& rg, const key_compare& comp, const Allocator& a);
-template<class InputIterator, class Allocator>
-  flat_map(sorted_unique_t, InputIterator first, InputIterator last,
-           const key_compare& comp, const Allocator& a);
-template<class InputIterator, class Allocator>
-  flat_map(sorted_unique_t, InputIterator first, InputIterator last, const Allocator& a);
-template<class Allocator>
-  flat_map(initializer_list<value_type> il, const key_compare& comp, const Allocator& a);
-template<class Allocator>
-  flat_map(initializer_list<value_type> il, const Allocator& a);
-template<class Allocator>
-  flat_map(sorted_unique_t, initializer_list<value_type> il,
-           const key_compare& comp, const Allocator& a);
-template<class Allocator>
-  flat_map(sorted_unique_t, initializer_list<value_type> il, const Allocator& a);
 ```
-*Constraints:* `uses_allocator_v<key_container_type, Allocator>` is
-`true` and `uses_allocator_v<mapped_container_type, Allocator>` is
-`true`.
 *Effects:* Equivalent to the corresponding non-allocator constructors
-except that `c.keys` and `c.values` are constructed with uses-allocator
-construction [[allocator.uses.construction]].
 #### Capacity <a id="flat.map.capacity">[[flat.map.capacity]]</a>
 ``` cpp
-size_type size() const noexcept;
 ```
-*Returns:* `c.keys.size()`.
 ``` cpp
-size_type max_size() const noexcept;
 ```
-*Returns:* `min<size_type>(c.keys.max_size(), c.values.max_size())`.
 #### Access <a id="flat.map.access">[[flat.map.access]]</a>
 ``` cpp
-mapped_type& operator[](const key_type& x);
 ```
 *Effects:* Equivalent to: `return try_emplace(x).first->second;`
 ``` cpp
-mapped_type& operator[](key_type&& x);
 ```
 *Effects:* Equivalent to:
 `return try_emplace(std::move(x)).first->second;`
 ``` cpp
-template<class K> mapped_type& operator[](K&& x);
 ```
 *Constraints:* The *qualified-id* `Compare::is_transparent` is valid and
 denotes a type.
 *Effects:* Equivalent to:
 `return try_emplace(std::forward<K>(x)).first->second;`
 ``` cpp
-mapped_type&       at(const key_type& x);
-const mapped_type& at(const key_type& x) const;
 ```
 *Returns:* A reference to the `mapped_type` corresponding to `x` in
 `*this`.
@@ -10788,12 +12364,12 @@ const mapped_type& at(const key_type& x) const;
 is present.
 *Complexity:* Logarithmic.
 ``` cpp
-template<class K> mapped_type&       at(const K& x);
-template<class K> const mapped_type& at(const K& x) const;
 ```
 *Constraints:* The *qualified-id* `Compare::is_transparent` is valid and
 denotes a type.
@@ -10809,11 +12385,11 @@ is present.
 *Complexity:* Logarithmic.
 #### Modifiers <a id="flat.map.modifiers">[[flat.map.modifiers]]</a>
 ``` cpp
-template<class... Args> pair<iterator, bool> emplace(Args&&... args);
 ```
 *Constraints:*
 `is_constructible_v<pair<key_type, mapped_type>, Args...>` is `true`.
@@ -10832,12 +12408,12 @@ c.values.insert(value_it, std::move(t.second));
 *Returns:* The `bool` component of the returned pair is `true` if and
 only if the insertion took place, and the iterator component of the pair
 points to the element with key equivalent to `t.first`.
 ``` cpp
-template<class P> pair<iterator, bool> insert(P&& x);
-template<class P> iterator insert(const_iterator position, P&& x);
 ```
 *Constraints:* `is_constructible_v<pair<key_type, mapped_type>, P>` is
 `true`.
@@ -10845,14 +12421,14 @@ template<class P> iterator insert(const_iterator position, P&& x);
 `return emplace(std::forward<P>(x));`. The second form is equivalent to
 `return emplace_hint(position, std::forward<P>(x));`.
 ``` cpp
 template<class InputIterator>
-  void insert(InputIterator first, InputIterator last);
 ```
-*Effects:* Adds elements to `c` as if by:
 ``` cpp
 for (; first != last; ++first) {
   value_type value = *first;
   c.keys.insert(c.keys.end(), std::move(value.first));
@@ -10864,12 +12440,12 @@ Then, sorts the range of newly inserted elements with respect to
 `value_comp()`; merges the resulting sorted range and the sorted range
 of pre-existing elements into a single sorted range; and finally erases
 the duplicate elements as if by:
 ``` cpp
-auto zv = ranges::zip_view(c.keys, c.values);
-auto it = ranges::unique(zv, key_equiv(compare)).begin();
 auto dist = distance(zv.begin(), it);
 c.keys.erase(c.keys.begin() + dist, c.keys.end());
 c.values.erase(c.values.begin() + dist, c.values.end());
 ```
@@ -10879,46 +12455,23 @@ M is `distance(first, last)`.
 *Remarks:* Since this operation performs an in-place merge, it may
 allocate memory.
 ``` cpp
 template<class InputIterator>
-  void insert(sorted_unique_t, InputIterator first, InputIterator last);
 ```
-*Effects:* Adds elements to `c` as if by:
-``` cpp
-for (; first != last; ++first) {
-  value_type value = *first;
-  c.keys.insert(c.keys.end(), std::move(value.first));
-  c.values.insert(c.values.end(), std::move(value.second));
-}
-```
-Then, merges the sorted range of newly added elements and the sorted
-range of pre-existing elements into a single sorted range; and finally
-erases the duplicate elements as if by:
-``` cpp
-auto zv = ranges::zip_view(c.keys, c.values);
-auto it = ranges::unique(zv, key_equiv(compare)).begin();
-auto dist = distance(zv.begin(), it);
-c.keys.erase(c.keys.begin() + dist, c.keys.end());
-c.values.erase(c.values.begin() + dist, c.values.end());
-```
 *Complexity:* Linear in N, where N is `size()` after the operation.
-*Remarks:* Since this operation performs an in-place merge, it may
-allocate memory.
 ``` cpp
 template<container-compatible-range<value_type> R>
-  void insert_range(R&& rg);
 ```
-*Effects:* Adds elements to `c` as if by:
 ``` cpp
 for (const auto& e : rg) {
   c.keys.insert(c.keys.end(), e.first);
   c.values.insert(c.values.end(), e.second);
@@ -10929,12 +12482,12 @@ Then, sorts the range of newly inserted elements with respect to
 `value_comp()`; merges the resulting sorted range and the sorted range
 of pre-existing elements into a single sorted range; and finally erases
 the duplicate elements as if by:
 ``` cpp
-auto zv = ranges::zip_view(c.keys, c.values);
-auto it = ranges::unique(zv, key_equiv(compare)).begin();
 auto dist = distance(zv.begin(), it);
 c.keys.erase(c.keys.begin() + dist, c.keys.end());
 c.values.erase(c.values.begin() + dist, c.values.end());
 ```
@@ -10944,17 +12497,17 @@ M is `ranges::distance(rg)`.
 *Remarks:* Since this operation performs an in-place merge, it may
 allocate memory.
 ``` cpp
 template<class... Args>
-  pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
 template<class... Args>
-  pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
 template<class... Args>
-  iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args);
 template<class... Args>
-  iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);
 ```
 *Constraints:* `is_constructible_v<mapped_type, Args...>` is `true`.
 *Effects:* If the map already contains an element whose key is
@@ -10976,13 +12529,13 @@ returned iterator points to the map element whose key is equivalent to
 *Complexity:* The same as `emplace` for the first two overloads, and the
 same as `emplace_hint` for the last two overloads.
 ``` cpp
 template<class K, class... Args>
-  pair<iterator, bool> try_emplace(K&& k, Args&&... args);
 template<class K, class... Args>
-  iterator try_emplace(const_iterator hint, K&& k, Args&&... args);
 ```
 *Constraints:*
 - The *qualified-id* `Compare::is_transparent` is valid and denotes a
@@ -10998,11 +12551,11 @@ object `u`, for which `find(k) == find(u)` is `true`.
 *Effects:* If the map already contains an element whose key is
 equivalent to `k`, `*this` and `args...` are unchanged. Otherwise
 equivalent to:
 ``` cpp
-auto key_it = ranges::upper_bound(c.keys, k, compare);
 auto value_it = c.values.begin() + distance(c.keys.begin(), key_it);
 c.keys.emplace(key_it, std::forward<K>(k));
 c.values.emplace(value_it, std::forward<Args>(args)...);
 ```
@@ -11012,17 +12565,17 @@ iterator points to the map element whose key is equivalent to `k`.
 *Complexity:* The same as `emplace` and `emplace_hint`, respectively.
 ``` cpp
 template<class M>
-  pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);
 template<class M>
-  pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj);
 template<class M>
-  iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);
 template<class M>
-  iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj);
 ```
 *Constraints:* `is_assignable_v<mapped_type&, M>` is `true` and
 `is_constructible_v<mapped_type, M>` is `true`.
@@ -11050,13 +12603,13 @@ returned iterator points to the map element whose key is equivalent to
 *Complexity:* The same as `emplace` for the first two overloads and the
 same as `emplace_hint` for the last two overloads.
 ``` cpp
 template<class K, class M>
-  pair<iterator, bool> insert_or_assign(K&& k, M&& obj);
 template<class K, class M>
-  iterator insert_or_assign(const_iterator hint, K&& k, M&& obj);
 ```
 *Constraints:*
 - The *qualified-id* `Compare::is_transparent` is valid and denotes a
@@ -11089,11 +12642,11 @@ pair is `true` if and only if the insertion took place. The returned
 iterator points to the map element whose key is equivalent to `k`.
 *Complexity:* The same as `emplace` and `emplace_hint`, respectively.
 ``` cpp
-void swap(flat_map& y) noexcept;
 ```
 *Effects:* Equivalent to:
 ``` cpp
@@ -11101,24 +12654,24 @@ ranges::swap(compare, y.compare);
 ranges::swap(c.keys, y.c.keys);
 ranges::swap(c.values, y.c.values);
 ```
 ``` cpp
-containers extract() &&;
 ```
 *Ensures:* `*this` is emptied, even if the function exits via an
 exception.
-*Returns:* `std::move(c)`.
 ``` cpp
-void replace(key_container_type&& key_cont, mapped_container_type&& mapped_cont);
 ```
 *Preconditions:* `key_cont.size() == mapped_cont.size()` is `true`, the
-elements of `key_cont` are sorted with respect to `compare`, and
 `key_cont` contains no equal elements.
 *Effects:* Equivalent to:
 ``` cpp
@@ -11129,11 +12682,11 @@ c.values = std::move(mapped_cont);
 #### Erasure <a id="flat.map.erasure">[[flat.map.erasure]]</a>
 ``` cpp
 template<class Key, class T, class Compare, class KeyContainer, class MappedContainer,
          class Predicate>
-  typename flat_map<Key, T, Compare, KeyContainer, MappedContainer>::size_type
     erase_if(flat_map<Key, T, Compare, KeyContainer, MappedContainer>& c, Predicate pred);
 ```
 *Preconditions:* `Key` and `T` meet the *Cpp17MoveAssignable*
 requirements.
@@ -11223,14 +12776,17 @@ The program is ill-formed if `Key` is not the same type as
 The effect of calling a constructor that takes both `key_container_type`
 and `mapped_container_type` arguments with containers of different sizes
 is undefined.
-The effect of calling a constructor or member function that takes a
 `sorted_equivalent_t` argument with a container, containers, or range
 that are not sorted with respect to `key_comp()` is undefined.
 #### Definition <a id="flat.multimap.defn">[[flat.multimap.defn]]</a>
 ``` cpp
 namespace std {
   template<class Key, class T, class Compare = less<Key>,
@@ -11254,209 +12810,219 @@ namespace std {
     using mapped_container_type  = MappedContainer;
     class value_compare {
     private:
       key_compare comp;                                         // exposition only
-      value_compare(key_compare c) : comp(c) { } // exposition only
     public:
-      bool operator()(const_reference x, const_reference y) const {
         return comp(x.first, y.first);
       }
     };
     struct containers {
       key_container_type keys;
       mapped_container_type values;
     };
-    // [flat.multimap.cons], construct/copy/destroy
-    flat_multimap() : flat_multimap(key_compare()) { }
-    flat_multimap(key_container_type key_cont, mapped_container_type mapped_cont,
                             const key_compare& comp = key_compare());
-    template<class Allocator>
-      flat_multimap(const key_container_type& key_cont, const mapped_container_type& mapped_cont,
-                    const Allocator& a);
-    template<class Allocator>
-      flat_multimap(const key_container_type& key_cont, const mapped_container_type& mapped_cont,
-                    const key_compare& comp, const Allocator& a);
-    flat_multimap(sorted_equivalent_t,
                             key_container_type key_cont, mapped_container_type mapped_cont,
                   const key_compare& comp = key_compare());
-    template<class Allocator>
-      flat_multimap(sorted_equivalent_t, const key_container_type& key_cont,
-                    const mapped_container_type& mapped_cont, const Allocator& a);
-    template<class Allocator>
-      flat_multimap(sorted_equivalent_t, const key_container_type& key_cont,
-                    const mapped_container_type& mapped_cont,
-                    const key_compare& comp, const Allocator& a);
-    explicit flat_multimap(const key_compare& comp)
-      : c(), compare(comp) { }
-    template<class Allocator>
-      flat_multimap(const key_compare& comp, const Allocator& a);
-    template<class Allocator>
-      explicit flat_multimap(const Allocator& a);
     template<class InputIterator>
-      flat_multimap(InputIterator first, InputIterator last,
                               const key_compare& comp = key_compare())
         : c(), compare(comp)
         { insert(first, last); }
-    template<class InputIterator, class Allocator>
-      flat_multimap(InputIterator first, InputIterator last,
-                    const key_compare& comp, const Allocator& a);
-    template<class InputIterator, class Allocator>
-      flat_multimap(InputIterator first, InputIterator last, const Allocator& a);
     template<container-compatible-range<value_type> R>
-      flat_multimap(from_range_t fr, R&& rg)
-        : flat_multimap(fr, std::forward<R>(rg), key_compare()) { }
-    template<container-compatible-range<value_type> R, class Allocator>
-      flat_multimap(from_range_t, R&& rg, const Allocator& a);
     template<container-compatible-range<value_type> R>
-      flat_multimap(from_range_t, R&& rg, const key_compare& comp)
         : flat_multimap(comp) { insert_range(std::forward<R>(rg)); }
-    template<container-compatible-range<value_type> R, class Allocator>
-      flat_multimap(from_range_t, R&& rg, const key_compare& comp, const Allocator& a);
- template<class InputIterator>
-      flat_multimap(sorted_equivalent_t s, InputIterator first, InputIterator last,
                             const key_compare& comp = key_compare())
-        : c(), compare(comp) { insert(s, first, last); }
-    template<class InputIterator, class Allocator>
-      flat_multimap(sorted_equivalent_t, InputIterator first, InputIterator last,
-                    const key_compare& comp, const Allocator& a);
-    template<class InputIterator, class Allocator>
-      flat_multimap(sorted_equivalent_t, InputIterator first, InputIterator last,
-                    const Allocator& a);
-    flat_multimap(initializer_list<value_type> il, const key_compare& comp = key_compare())
         : flat_multimap(il.begin(), il.end(), comp) { }
-    template<class Allocator>
-      flat_multimap(initializer_list<value_type> il, const key_compare& comp,
-                    const Allocator& a);
-    template<class Allocator>
-      flat_multimap(initializer_list<value_type> il, const Allocator& a);
-    flat_multimap(sorted_equivalent_t s, initializer_list<value_type> il,
                             const key_compare& comp = key_compare())
-        : flat_multimap(s, il.begin(), il.end(), comp) { }
-    template<class Allocator>
-      flat_multimap(sorted_equivalent_t, initializer_list<value_type> il,
-                    const key_compare& comp, const Allocator& a);
-    template<class Allocator>
-      flat_multimap(sorted_equivalent_t, initializer_list<value_type> il, const Allocator& a);
- flat_multimap& operator=(initializer_list<value_type> il);
     // iterators
-    iterator               begin() noexcept;
-    const_iterator         begin() const noexcept;
-    iterator               end() noexcept;
-    const_iterator         end() const noexcept;
-    reverse_iterator       rbegin() noexcept;
-    const_reverse_iterator rbegin() const noexcept;
-    reverse_iterator       rend() noexcept;
-    const_reverse_iterator rend() const noexcept;
-    const_iterator         cbegin() const noexcept;
-    const_iterator         cend() const noexcept;
-    const_reverse_iterator crbegin() const noexcept;
-    const_reverse_iterator crend() const noexcept;
     // capacity
- [[nodiscard]] bool empty() const noexcept;
-    size_type size() const noexcept;
-    size_type max_size() const noexcept;
     // modifiers
-    template<class... Args> iterator emplace(Args&&... args);
     template<class... Args>
-      iterator emplace_hint(const_iterator position, Args&&... args);
-    iterator insert(const value_type& x)
       { return emplace(x); }
-    iterator insert(value_type&& x)
       { return emplace(std::move(x)); }
-    iterator insert(const_iterator position, const value_type& x)
       { return emplace_hint(position, x); }
-    iterator insert(const_iterator position, value_type&& x)
       { return emplace_hint(position, std::move(x)); }
-    template<class P> iterator insert(P&& x);
     template<class P>
-      iterator insert(const_iterator position, P&&);
     template<class InputIterator>
-      void insert(InputIterator first, InputIterator last);
     template<class InputIterator>
-      void insert(sorted_equivalent_t, InputIterator first, InputIterator last);
     template<container-compatible-range<value_type> R>
-      void insert_range(R&& rg);
-    void insert(initializer_list<value_type> il)
       { insert(il.begin(), il.end()); }
-    void insert(sorted_equivalent_t s, initializer_list<value_type> il)
-      { insert(s, il.begin(), il.end()); }
-    containers extract() &&;
-    void replace(key_container_type&& key_cont, mapped_container_type&& mapped_cont);
-    iterator erase(iterator position);
-    iterator erase(const_iterator position);
-    size_type erase(const key_type& x);
-    template<class K> size_type erase(K&& x);
-    iterator erase(const_iterator first, const_iterator last);
-    void swap(flat_multimap&) noexcept;
-    void clear() noexcept;
     // observers
-    key_compare key_comp() const;
-    value_compare value_comp() const;
-    const key_container_type& keys() const noexcept { return c.keys; }
-    const mapped_container_type& values() const noexcept { return c.values; }
     // map operations
-    iterator find(const key_type& x);
-    const_iterator find(const key_type& x) const;
-    template<class K> iterator find(const K& x);
-    template<class K> const_iterator find(const K& x) const;
-    size_type count(const key_type& x) const;
-    template<class K> size_type count(const K& x) const;
-    bool contains(const key_type& x) const;
-    template<class K> bool contains(const K& x) const;
-    iterator lower_bound(const key_type& x);
-    const_iterator lower_bound(const key_type& x) const;
-    template<class K> iterator lower_bound(const K& x);
-    template<class K> const_iterator lower_bound(const K& x) const;
-    iterator upper_bound(const key_type& x);
-    const_iterator upper_bound(const key_type& x) const;
-    template<class K> iterator upper_bound(const K& x);
-    template<class K> const_iterator upper_bound(const K& x) const;
-    pair<iterator, iterator> equal_range(const key_type& x);
-    pair<const_iterator, const_iterator> equal_range(const key_type& x) const;
     template<class K>
-      pair<iterator, iterator> equal_range(const K& x);
     template<class K>
-      pair<const_iterator, const_iterator> equal_range(const K& x) const;
-    friend bool operator==(const flat_multimap& x, const flat_multimap& y);
-    friend synth-three-way-result<value_type>
       operator<=>(const flat_multimap& x, const flat_multimap& y);
-    friend void swap(flat_multimap& x, flat_multimap& y) noexcept
       { x.swap(y); }
   private:
     containers c;               // exposition only
     key_compare compare;        // exposition only
@@ -11539,119 +13105,122 @@ specified above. It has no base classes or members other than those
 specified.
 #### Constructors <a id="flat.multimap.cons">[[flat.multimap.cons]]</a>
 ``` cpp
-flat_multimap(key_container_type key_cont, mapped_container_type mapped_cont,
                         const key_compare& comp = key_compare());
 ```
-*Effects:* Initializes `c.keys` with `std::move(key_cont)`, `c.values`
-with `std::move(mapped_cont)`, and `compare` with `comp`; sorts the
-range \[`begin()`, `end()`) with respect to `value_comp()`.
 *Complexity:* Linear in N if the container arguments are already sorted
 with respect to `value_comp()` and otherwise N log N, where N is the
 value of `key_cont.size()` before this call.
 ``` cpp
-template<class Allocator>
-  flat_multimap(const key_container_type& key_cont, const mapped_container_type& mapped_cont,
- const Allocator& a);
-template<class Allocator>
-  flat_multimap(const key_container_type& key_cont, const mapped_container_type& mapped_cont,
-                const key_compare& comp, const Allocator& a);
 ```
-*Constraints:* `uses_allocator_v<key_container_type, Allocator>` is
-`true` and `uses_allocator_v<mapped_container_type, Allocator>` is
-`true`.
 *Effects:* Equivalent to `flat_multimap(key_cont, mapped_cont)` and
 `flat_multimap(key_cont, mapped_cont, comp)`, respectively, except that
-`c.keys` and `c.values` are constructed with uses-allocator
 construction [[allocator.uses.construction]].
 *Complexity:* Same as `flat_multimap(key_cont, mapped_cont)` and
 `flat_multimap(key_cont, mapped_cont, comp)`, respectively.
 ``` cpp
-flat_multimap(sorted_equivalent_t, key_container_type key_cont, mapped_container_type mapped_cont,
- const key_compare& comp = key_compare());
-```
-*Effects:* Initializes `c.keys` with `std::move(key_cont)`, `c.values`
-with `std::move(mapped_cont)`, and `compare` with `comp`.
-*Complexity:* Constant.
-``` cpp
-template<class Allocator>
-  flat_multimap(sorted_equivalent_t s, const key_container_type& key_cont,
-                const mapped_container_type& mapped_cont, const Allocator& a);
-template<class Allocator>
-  flat_multimap(sorted_equivalent_t s, const key_container_type& key_cont,
                 const mapped_container_type& mapped_cont, const key_compare& comp,
-                const Allocator& a);
 ```
-*Constraints:* `uses_allocator_v<key_container_type, Allocator>` is
-`true` and `uses_allocator_v<mapped_container_type, Allocator>` is
-`true`.
-*Effects:* Equivalent to `flat_multimap(s, key_cont, mapped_cont)` and
-`flat_multimap(s, key_cont, mapped_cont, comp)`, respectively, except
-that `c.keys` and `c.values` are constructed with uses-allocator
 construction [[allocator.uses.construction]].
 *Complexity:* Linear.
 ``` cpp
-template<class Allocator>
-  flat_multimap(const key_compare& comp, const Allocator& a);
-template<class Allocator>
- explicit flat_multimap(const Allocator& a);
-template<class InputIterator, class Allocator>
-  flat_multimap(InputIterator first, InputIterator last, const key_compare& comp,
-                const Allocator& a);
-template<class InputIterator, class Allocator>
-  flat_multimap(InputIterator first, InputIterator last, const Allocator& a);
-template<container-compatible-range<value_type> R, class Allocator>
-  flat_multimap(from_range_t, R&& rg, const Allocator& a);
-template<container-compatible-range<value_type> R, class Allocator>
-  flat_multimap(from_range_t, R&& rg, const key_compare& comp, const Allocator& a);
-template<class InputIterator, class Allocator>
-  flat_multimap(sorted_equivalent_t, InputIterator first, InputIterator last,
- const key_compare& comp, const Allocator& a);
-template<class InputIterator, class Allocator>
-  flat_multimap(sorted_equivalent_t, InputIterator first, InputIterator last,
- const Allocator& a);
-template<class Allocator>
-  flat_multimap(initializer_list<value_type> il, const key_compare& comp, const Allocator& a);
-template<class Allocator>
-  flat_multimap(initializer_list<value_type> il, const Allocator& a);
-template<class Allocator>
-  flat_multimap(sorted_equivalent_t, initializer_list<value_type> il,
-                const key_compare& comp, const Allocator& a);
-template<class Allocator>
-  flat_multimap(sorted_equivalent_t, initializer_list<value_type> il, const Allocator& a);
 ```
-*Constraints:* `uses_allocator_v<key_container_type, Allocator>` is
-`true` and `uses_allocator_v<mapped_container_type, Allocator>` is
-`true`.
 *Effects:* Equivalent to the corresponding non-allocator constructors
-except that `c.keys` and `c.values` are constructed with uses-allocator
-construction [[allocator.uses.construction]].
 #### Erasure <a id="flat.multimap.erasure">[[flat.multimap.erasure]]</a>
 ``` cpp
 template<class Key, class T, class Compare, class KeyContainer, class MappedContainer,
          class Predicate>
-  typename flat_multimap<Key, T, Compare, KeyContainer, MappedContainer>::size_type
     erase_if(flat_multimap<Key, T, Compare, KeyContainer, MappedContainer>& c, Predicate pred);
 ```
 *Preconditions:* `Key` and `T` meet the *Cpp17MoveAssignable*
 requirements.
@@ -11668,10 +13237,49 @@ exits via an exception, `c` is in a valid but unspecified
 state [[defns.valid]].
 [*Note 1*: `c` still meets its invariants, but can be
 empty. — *end note*]
 ### Class template `flat_set` <a id="flat.set">[[flat.set]]</a>
 #### Overview <a id="flat.set.overview">[[flat.set.overview]]</a>
 A `flat_set` is a container adaptor that provides an associative
@@ -11724,13 +13332,16 @@ particular, `vector` [[vector]] and `deque` [[deque]] can be used.
 [*Note 3*: `vector<bool>` is not a sequence container. — *end note*]
 The program is ill-formed if `Key` is not the same type as
 `KeyContainer::value_type`.
-The effect of calling a constructor or member function that takes a
-`sorted_unique_t` argument with a range that is not sorted with respect
-to `key_comp()`, or that contains equal elements, is undefined.
 #### Definition <a id="flat.set.defn">[[flat.set.defn]]</a>
 ``` cpp
 namespace std {
@@ -11742,192 +13353,203 @@ namespace std {
     using value_type                = Key;
     using key_compare               = Compare;
     using value_compare             = Compare;
     using reference                 = value_type&;
     using const_reference           = const value_type&;
-    using size_type                 = typename KeyContainer::size_type;
-    using difference_type           = typename KeyContainer::difference_type;
     using iterator                  = implementation-defined  // type of flat_set::iterator;  // see [container.requirements]
     using const_iterator            = implementation-defined  // type of flat_set::const_iterator;  // see [container.requirements]
     using reverse_iterator          = std::reverse_iterator<iterator>;
     using const_reverse_iterator    = std::reverse_iterator<const_iterator>;
     using container_type            = KeyContainer;
     // [flat.set.cons], constructors
-    flat_set() : flat_set(key_compare()) { }
-    explicit flat_set(container_type cont, const key_compare& comp = key_compare());
-    template<class Allocator>
-      flat_set(const container_type& cont, const Allocator& a);
-    template<class Allocator>
-      flat_set(const container_type& cont, const key_compare& comp, const Allocator& a);
-    flat_set(sorted_unique_t, container_type cont, const key_compare& comp = key_compare())
-      : c(std::move(cont)), compare(comp) { }
-    template<class Allocator>
-      flat_set(sorted_unique_t, const container_type& cont, const Allocator& a);
-    template<class Allocator>
-      flat_set(sorted_unique_t, const container_type& cont,
-               const key_compare& comp, const Allocator& a);
-    explicit flat_set(const key_compare& comp)
       : c(), compare(comp) { }
-    template<class Allocator>
- flat_set(const key_compare& comp, const Allocator& a);
-    template<class Allocator>
-      explicit flat_set(const Allocator& a);
     template<class InputIterator>
-      flat_set(InputIterator first, InputIterator last, const key_compare& comp = key_compare())
         : c(), compare(comp)
         { insert(first, last); }
-    template<class InputIterator, class Allocator>
-      flat_set(InputIterator first, InputIterator last,
-               const key_compare& comp, const Allocator& a);
-    template<class InputIterator, class Allocator>
-      flat_set(InputIterator first, InputIterator last, const Allocator& a);
     template<container-compatible-range<value_type> R>
-      flat_set(from_range_t fr, R&& rg)
-        : flat_set(fr, std::forward<R>(rg), key_compare()) { }
-    template<container-compatible-range<value_type> R, class Allocator>
-      flat_set(from_range_t, R&& rg, const Allocator& a);
     template<container-compatible-range<value_type> R>
-      flat_set(from_range_t, R&& rg, const key_compare& comp)
         : flat_set(comp)
         { insert_range(std::forward<R>(rg)); }
-    template<container-compatible-range<value_type> R, class Allocator>
-       flat_set(from_range_t, R&& rg, const key_compare& comp, const Allocator& a);
- template<class InputIterator>
-      flat_set(sorted_unique_t, InputIterator first, InputIterator last,
-               const key_compare& comp = key_compare())
-        : c(first, last), compare(comp) { }
-    template<class InputIterator, class Allocator>
-      flat_set(sorted_unique_t, InputIterator first, InputIterator last,
-               const key_compare& comp, const Allocator& a);
-    template<class InputIterator, class Allocator>
-      flat_set(sorted_unique_t, InputIterator first, InputIterator last, const Allocator& a);
-    flat_set(initializer_list<value_type> il, const key_compare& comp = key_compare())
         : flat_set(il.begin(), il.end(), comp) { }
-    template<class Allocator>
-      flat_set(initializer_list<value_type> il, const key_compare& comp, const Allocator& a);
-    template<class Allocator>
-      flat_set(initializer_list<value_type> il, const Allocator& a);
-    flat_set(sorted_unique_t s, initializer_list<value_type> il,
              const key_compare& comp = key_compare())
-        : flat_set(s, il.begin(), il.end(), comp) { }
-    template<class Allocator>
-      flat_set(sorted_unique_t, initializer_list<value_type> il,
-               const key_compare& comp, const Allocator& a);
-    template<class Allocator>
-      flat_set(sorted_unique_t, initializer_list<value_type> il, const Allocator& a);
- flat_set& operator=(initializer_list<value_type>);
     // iterators
-    iterator               begin() noexcept;
-    const_iterator         begin() const noexcept;
-    iterator               end() noexcept;
-    const_iterator         end() const noexcept;
-    reverse_iterator       rbegin() noexcept;
-    const_reverse_iterator rbegin() const noexcept;
-    reverse_iterator       rend() noexcept;
-    const_reverse_iterator rend() const noexcept;
-    const_iterator         cbegin() const noexcept;
-    const_iterator         cend() const noexcept;
-    const_reverse_iterator crbegin() const noexcept;
-    const_reverse_iterator crend() const noexcept;
     // capacity
- [[nodiscard]] bool empty() const noexcept;
-    size_type size() const noexcept;
-    size_type max_size() const noexcept;
     // [flat.set.modifiers], modifiers
-    template<class... Args> pair<iterator, bool> emplace(Args&&... args);
     template<class... Args>
-      iterator emplace_hint(const_iterator position, Args&&... args);
-    pair<iterator, bool> insert(const value_type& x)
       { return emplace(x); }
-    pair<iterator, bool> insert(value_type&& x)
       { return emplace(std::move(x)); }
-    template<class K> pair<iterator, bool> insert(K&& x);
-    iterator insert(const_iterator position, const value_type& x)
       { return emplace_hint(position, x); }
-    iterator insert(const_iterator position, value_type&& x)
       { return emplace_hint(position, std::move(x)); }
-    template<class K> iterator insert(const_iterator hint, K&& x);
     template<class InputIterator>
-      void insert(InputIterator first, InputIterator last);
     template<class InputIterator>
-      void insert(sorted_unique_t, InputIterator first, InputIterator last);
     template<container-compatible-range<value_type> R>
-      void insert_range(R&& rg);
-    void insert(initializer_list<value_type> il)
       { insert(il.begin(), il.end()); }
-    void insert(sorted_unique_t s, initializer_list<value_type> il)
-      { insert(s, il.begin(), il.end()); }
-    container_type extract() &&;
-    void replace(container_type&&);
-    iterator erase(iterator position);
-    iterator erase(const_iterator position);
-    size_type erase(const key_type& x);
-    template<class K> size_type erase(K&& x);
-    iterator erase(const_iterator first, const_iterator last);
-    void swap(flat_set& y) noexcept;
-    void clear() noexcept;
     // observers
-    key_compare key_comp() const;
-    value_compare value_comp() const;
     // set operations
-    iterator find(const key_type& x);
-    const_iterator find(const key_type& x) const;
-    template<class K> iterator find(const K& x);
-    template<class K> const_iterator find(const K& x) const;
-    size_type count(const key_type& x) const;
-    template<class K> size_type count(const K& x) const;
-    bool contains(const key_type& x) const;
-    template<class K> bool contains(const K& x) const;
-    iterator lower_bound(const key_type& x);
-    const_iterator lower_bound(const key_type& x) const;
-    template<class K> iterator lower_bound(const K& x);
-    template<class K> const_iterator lower_bound(const K& x) const;
-    iterator upper_bound(const key_type& x);
-    const_iterator upper_bound(const key_type& x) const;
-    template<class K> iterator upper_bound(const K& x);
-    template<class K> const_iterator upper_bound(const K& x) const;
-    pair<iterator, iterator> equal_range(const key_type& x);
-    pair<const_iterator, const_iterator> equal_range(const key_type& x) const;
     template<class K>
-      pair<iterator, iterator> equal_range(const K& x);
     template<class K>
-      pair<const_iterator, const_iterator> equal_range(const K& x) const;
-    friend bool operator==(const flat_set& x, const flat_set& y);
-    friend synth-three-way-result<value_type>
       operator<=>(const flat_set& x, const flat_set& y);
-    friend void swap(flat_set& x, flat_set& y) noexcept { x.swap(y); }
   private:
     container_type c;           // exposition only
     key_compare compare;        // exposition only
   };
@@ -11990,101 +13612,106 @@ namespace std {
 ```
 #### Constructors <a id="flat.set.cons">[[flat.set.cons]]</a>
 ``` cpp
-explicit flat_set(container_type cont, const key_compare& comp = key_compare());
 ```
 *Effects:* Initializes *c* with `std::move(cont)` and *compare* with
 `comp`, sorts the range \[`begin()`, `end()`) with respect to *compare*,
 and finally erases all but the first element from each group of
 consecutive equivalent elements.
-*Complexity:* Linear in N if `cont` is sorted with respect to *compare*
-and otherwise N log N, where N is the value of `cont.size()` before this
-call.
 ``` cpp
-template<class Allocator>
-  flat_set(const container_type& cont, const Allocator& a);
-template<class Allocator>
-  flat_set(const container_type& cont, const key_compare& comp, const Allocator& a);
 ```
-*Constraints:* `uses_allocator_v<container_type, Allocator>` is `true`.
 *Effects:* Equivalent to `flat_set(cont)` and `flat_set(cont, comp)`,
 respectively, except that *c* is constructed with uses-allocator
 construction [[allocator.uses.construction]].
 *Complexity:* Same as `flat_set(cont)` and `flat_set(cont, comp)`,
 respectively.
 ``` cpp
-template<class Allocator>
-  flat_set(sorted_unique_t s, const container_type& cont, const Allocator& a);
-template<class Allocator>
-  flat_set(sorted_unique_t s, const container_type& cont,
- const key_compare& comp, const Allocator& a);
 ```
-*Constraints:* `uses_allocator_v<container_type, Allocator>` is `true`.
-*Effects:* Equivalent to `flat_set(s, cont)` and
-`flat_set(s, cont, comp)`, respectively, except that *c* is constructed
-with uses-allocator construction [[allocator.uses.construction]].
 *Complexity:* Linear.
 ``` cpp
-template<class Allocator>
-  flat_set(const key_compare& comp, const Allocator& a);
-template<class Allocator>
- explicit flat_set(const Allocator& a);
-template<class InputIterator, class Allocator>
-  flat_set(InputIterator first, InputIterator last, const key_compare& comp, const Allocator& a);
-template<class InputIterator, class Allocator>
-  flat_set(InputIterator first, InputIterator last, const Allocator& a);
-template<container-compatible-range<value_type> R, class Allocator>
-  flat_set(from_range_t, R&& rg, const Allocator& a);
-template<container-compatible-range<value_type> R, class Allocator>
-  flat_set(from_range_t, R&& rg, const key_compare& comp, const Allocator& a);
-template<class InputIterator, class Allocator>
-  flat_set(sorted_unique_t, InputIterator first, InputIterator last,
-           const key_compare& comp, const Allocator& a);
-template<class InputIterator, class Allocator>
-  flat_set(sorted_unique_t, InputIterator first, InputIterator last, const Allocator& a);
-template<class Allocator>
-  flat_set(initializer_list<value_type> il, const key_compare& comp, const Allocator& a);
-template<class Allocator>
-  flat_set(initializer_list<value_type> il, const Allocator& a);
-template<class Allocator>
-  flat_set(sorted_unique_t, initializer_list<value_type> il,
-           const key_compare& comp, const Allocator& a);
-template<class Allocator>
-  flat_set(sorted_unique_t, initializer_list<value_type> il, const Allocator& a);
 ```
-*Constraints:* `uses_allocator_v<container_type, Allocator>` is `true`.
 *Effects:* Equivalent to the corresponding non-allocator constructors
 except that *c* is constructed with uses-allocator
 construction [[allocator.uses.construction]].
 #### Modifiers <a id="flat.set.modifiers">[[flat.set.modifiers]]</a>
 ``` cpp
-template<class K> pair<iterator, bool> insert(K&& x);
-template<class K> iterator insert(const_iterator hint, K&& x);
 ```
 *Constraints:* The *qualified-id* `Compare::is_transparent` is valid and
 denotes a type. `is_constructible_v<value_type, K>` is `true`.
 *Preconditions:* The conversion from `x` into `value_type` constructs an
-object `u`, for which `find(x) == find(u)` is true.
 *Effects:* If the set already contains an element equivalent to `x`,
 `*this` and `x` are unchanged. Otherwise, inserts a new element as if by
 `emplace(std::forward<K>(x))`.
@@ -12092,11 +13719,11 @@ object `u`, for which `find(x) == find(u)` is true.
 pair is `true` if and only if the insertion took place. The returned
 iterator points to the element whose key is equivalent to `x`.
 ``` cpp
 template<class InputIterator>
-  void insert(InputIterator first, InputIterator last);
 ```
 *Effects:* Adds elements to *c* as if by:
 ``` cpp
@@ -12115,20 +13742,20 @@ M is `distance(first, last)`.
 *Remarks:* Since this operation performs an in-place merge, it may
 allocate memory.
 ``` cpp
 template<class InputIterator>
-  void insert(sorted_unique_t, InputIterator first, InputIterator last);
 ```
 *Effects:* Equivalent to `insert(first, last)`.
 *Complexity:* Linear.
 ``` cpp
 template<container-compatible-range<value_type> R>
-  void insert_range(R&& rg);
 ```
 *Effects:* Adds elements to *c* as if by:
 ``` cpp
@@ -12148,31 +13775,31 @@ M is `ranges::distance(rg)`.
 *Remarks:* Since this operation performs an in-place merge, it may
 allocate memory.
 ``` cpp
-void swap(flat_set& y) noexcept;
 ```
 *Effects:* Equivalent to:
 ``` cpp
 ranges::swap(compare, y.compare);
 ranges::swap(c, y.c);
 ```
 ``` cpp
-container_type extract() &&;
 ```
 *Ensures:* `*this` is emptied, even if the function exits via an
 exception.
 *Returns:* `std::move(`*`c`*`)`.
 ``` cpp
-void replace(container_type&& cont);
 ```
 *Preconditions:* The elements of `cont` are sorted with respect to
 *compare*, and `cont` contains no equal elements.
@@ -12180,11 +13807,11 @@ void replace(container_type&& cont);
 #### Erasure <a id="flat.set.erasure">[[flat.set.erasure]]</a>
 ``` cpp
 template<class Key, class Compare, class KeyContainer, class Predicate>
-  typename flat_set<Key, Compare, KeyContainer>::size_type
     erase_if(flat_set<Key, Compare, KeyContainer>& c, Predicate pred);
 ```
 *Preconditions:* `Key` meets the *Cpp17MoveAssignable* requirements.
@@ -12257,14 +13884,17 @@ In particular, `vector` [[vector]] and `deque` [[deque]] can be used.
 [*Note 3*: `vector<bool>` is not a sequence container. — *end note*]
 The program is ill-formed if `Key` is not the same type as
 `KeyContainer::value_type`.
-The effect of calling a constructor or member function that takes a
 `sorted_equivalent_t` argument with a range that is not sorted with
 respect to `key_comp()` is undefined.
 #### Definition <a id="flat.multiset.defn">[[flat.multiset.defn]]</a>
 ``` cpp
 namespace std {
   template<class Key, class Compare = less<Key>, class KeyContainer = vector<Key>>
@@ -12275,194 +13905,205 @@ namespace std {
     using value_type                = Key;
     using key_compare               = Compare;
     using value_compare             = Compare;
     using reference                 = value_type&;
     using const_reference           = const value_type&;
-    using size_type                 = typename KeyContainer::size_type;
-    using difference_type           = typename KeyContainer::difference_type;
     using iterator                  = implementation-defined  // type of flat_multiset::iterator;  // see [container.requirements]
     using const_iterator            = implementation-defined  // type of flat_multiset::const_iterator;  // see [container.requirements]
     using reverse_iterator          = std::reverse_iterator<iterator>;
     using const_reverse_iterator    = std::reverse_iterator<const_iterator>;
     using container_type            = KeyContainer;
     // [flat.multiset.cons], constructors
-    flat_multiset() : flat_multiset(key_compare()) { }
-    explicit flat_multiset(container_type cont, const key_compare& comp = key_compare());
-    template<class Allocator>
-      flat_multiset(const container_type& cont, const Allocator& a);
-    template<class Allocator>
-      flat_multiset(const container_type& cont, const key_compare& comp, const Allocator& a);
-    flat_multiset(sorted_equivalent_t, container_type cont,
-                  const key_compare& comp = key_compare())
-      : c(std::move(cont)), compare(comp) { }
-    template<class Allocator>
-      flat_multiset(sorted_equivalent_t, const container_type&, const Allocator& a);
-    template<class Allocator>
-      flat_multiset(sorted_equivalent_t, const container_type& cont,
-                    const key_compare& comp, const Allocator& a);
-    explicit flat_multiset(const key_compare& comp)
       : c(), compare(comp) { }
-    template<class Allocator>
- flat_multiset(const key_compare& comp, const Allocator& a);
-    template<class Allocator>
-      explicit flat_multiset(const Allocator& a);
     template<class InputIterator>
-      flat_multiset(InputIterator first, InputIterator last,
                               const key_compare& comp = key_compare())
         : c(), compare(comp)
         { insert(first, last); }
-    template<class InputIterator, class Allocator>
-      flat_multiset(InputIterator first, InputIterator last,
-                    const key_compare& comp, const Allocator& a);
-    template<class InputIterator, class Allocator>
-      flat_multiset(InputIterator first, InputIterator last, const Allocator& a);
     template<container-compatible-range<value_type> R>
-      flat_multiset(from_range_t fr, R&& rg)
-        : flat_multiset(fr, std::forward<R>(rg), key_compare()) { }
-    template<container-compatible-range<value_type> R, class Allocator>
-      flat_multiset(from_range_t, R&& rg, const Allocator& a);
     template<container-compatible-range<value_type> R>
-      flat_multiset(from_range_t, R&& rg, const key_compare& comp)
         : flat_multiset(comp)
         { insert_range(std::forward<R>(rg)); }
-    template<container-compatible-range<value_type> R, class Allocator>
-      flat_multiset(from_range_t, R&& rg, const key_compare& comp, const Allocator& a);
- template<class InputIterator>
-      flat_multiset(sorted_equivalent_t, InputIterator first, InputIterator last,
                             const key_compare& comp = key_compare())
-        : c(first, last), compare(comp) { }
-    template<class InputIterator, class Allocator>
-      flat_multiset(sorted_equivalent_t, InputIterator first, InputIterator last,
-                    const key_compare& comp, const Allocator& a);
-    template<class InputIterator, class Allocator>
-      flat_multiset(sorted_equivalent_t, InputIterator first, InputIterator last,
-                    const Allocator& a);
-    flat_multiset(initializer_list<value_type> il, const key_compare& comp = key_compare())
       : flat_multiset(il.begin(), il.end(), comp) { }
-    template<class Allocator>
-      flat_multiset(initializer_list<value_type> il, const key_compare& comp,
-                    const Allocator& a);
-    template<class Allocator>
-      flat_multiset(initializer_list<value_type> il, const Allocator& a);
-    flat_multiset(sorted_equivalent_t s, initializer_list<value_type> il,
                             const key_compare& comp = key_compare())
-        : flat_multiset(s, il.begin(), il.end(), comp) { }
-    template<class Allocator>
-      flat_multiset(sorted_equivalent_t, initializer_list<value_type> il,
-                    const key_compare& comp, const Allocator& a);
-    template<class Allocator>
-      flat_multiset(sorted_equivalent_t, initializer_list<value_type> il, const Allocator& a);
- flat_multiset& operator=(initializer_list<value_type>);
     // iterators
-    iterator               begin() noexcept;
-    const_iterator         begin() const noexcept;
-    iterator               end() noexcept;
-    const_iterator         end() const noexcept;
-    reverse_iterator       rbegin() noexcept;
-    const_reverse_iterator rbegin() const noexcept;
-    reverse_iterator       rend() noexcept;
-    const_reverse_iterator rend() const noexcept;
-    const_iterator         cbegin() const noexcept;
-    const_iterator         cend() const noexcept;
-    const_reverse_iterator crbegin() const noexcept;
-    const_reverse_iterator crend() const noexcept;
     // capacity
- [[nodiscard]] bool empty() const noexcept;
-    size_type size() const noexcept;
-    size_type max_size() const noexcept;
     // [flat.multiset.modifiers], modifiers
-    template<class... Args> iterator emplace(Args&&... args);
     template<class... Args>
-      iterator emplace_hint(const_iterator position, Args&&... args);
-    iterator insert(const value_type& x)
       { return emplace(x); }
-    iterator insert(value_type&& x)
       { return emplace(std::move(x)); }
-    iterator insert(const_iterator position, const value_type& x)
       { return emplace_hint(position, x); }
-    iterator insert(const_iterator position, value_type&& x)
       { return emplace_hint(position, std::move(x)); }
     template<class InputIterator>
-      void insert(InputIterator first, InputIterator last);
     template<class InputIterator>
-      void insert(sorted_equivalent_t, InputIterator first, InputIterator last);
     template<container-compatible-range<value_type> R>
-      void insert_range(R&& rg);
-    void insert(initializer_list<value_type> il)
       { insert(il.begin(), il.end()); }
-    void insert(sorted_equivalent_t s, initializer_list<value_type> il)
-      { insert(s, il.begin(), il.end()); }
-    container_type extract() &&;
-    void replace(container_type&&);
-    iterator erase(iterator position);
-    iterator erase(const_iterator position);
-    size_type erase(const key_type& x);
-    template<class K> size_type erase(K&& x);
-    iterator erase(const_iterator first, const_iterator last);
-    void swap(flat_multiset& y) noexcept;
-    void clear() noexcept;
     // observers
-    key_compare key_comp() const;
-    value_compare value_comp() const;
     // set operations
-    iterator find(const key_type& x);
-    const_iterator find(const key_type& x) const;
-    template<class K> iterator find(const K& x);
-    template<class K> const_iterator find(const K& x) const;
-    size_type count(const key_type& x) const;
-    template<class K> size_type count(const K& x) const;
-    bool contains(const key_type& x) const;
-    template<class K> bool contains(const K& x) const;
-    iterator lower_bound(const key_type& x);
-    const_iterator lower_bound(const key_type& x) const;
-    template<class K> iterator lower_bound(const K& x);
-    template<class K> const_iterator lower_bound(const K& x) const;
-    iterator upper_bound(const key_type& x);
-    const_iterator upper_bound(const key_type& x) const;
-    template<class K> iterator upper_bound(const K& x);
-    template<class K> const_iterator upper_bound(const K& x) const;
-    pair<iterator, iterator> equal_range(const key_type& x);
-    pair<const_iterator, const_iterator> equal_range(const key_type& x) const;
     template<class K>
-      pair<iterator, iterator> equal_range(const K& x);
     template<class K>
-      pair<const_iterator, const_iterator> equal_range(const K& x) const;
-    friend bool operator==(const flat_multiset& x, const flat_multiset& y);
-    friend synth-three-way-result<value_type>
       operator<=>(const flat_multiset& x, const flat_multiset& y);
-    friend void swap(flat_multiset& x, flat_multiset& y) noexcept
       { x.swap(y); }
   private:
     container_type c;           // exposition only
     key_compare compare;        // exposition only
@@ -12490,15 +14131,15 @@ namespace std {
     flat_multiset(sorted_equivalent_t, KeyContainer, Compare, Allocator)
       -> flat_multiset<typename KeyContainer::value_type, Compare, KeyContainer>;
   template<class InputIterator, class Compare = less<iter-value-type<InputIterator>>>
     flat_multiset(InputIterator, InputIterator, Compare = Compare())
-      -> flat_multiset<iter-value-type<InputIterator>, iter-value-type<InputIterator>, Compare>;
   template<class InputIterator, class Compare = less<iter-value-type<InputIterator>>>
     flat_multiset(sorted_equivalent_t, InputIterator, InputIterator, Compare = Compare())
-      -> flat_multiset<iter-value-type<InputIterator>, iter-value-type<InputIterator>, Compare>;
   template<ranges::input_range R, class Compare = less<ranges::range_value_t<R>>,
            class Allocator = allocator<ranges::range_value_t<R>>>
     flat_multiset(from_range_t, R&&, Compare = Compare(), Allocator = Allocator())
       -> flat_multiset<ranges::range_value_t<R>, Compare,
@@ -12526,95 +14167,100 @@ namespace std {
 ```
 #### Constructors <a id="flat.multiset.cons">[[flat.multiset.cons]]</a>
 ``` cpp
-explicit flat_multiset(container_type cont, const key_compare& comp = key_compare());
 ```
 *Effects:* Initializes *c* with `std::move(cont)` and *compare* with
 `comp`, and sorts the range \[`begin()`, `end()`) with respect to
 *compare*.
-*Complexity:* Linear in N if `cont` is sorted with respect to *compare*
-and otherwise N log N, where N is the value of `cont.size()` before this
-call.
 ``` cpp
-template<class Allocator>
-  flat_multiset(const container_type& cont, const Allocator& a);
-template<class Allocator>
-  flat_multiset(const container_type& cont, const key_compare& comp, const Allocator& a);
 ```
-*Constraints:* `uses_allocator_v<container_type, Allocator>` is `true`.
 *Effects:* Equivalent to `flat_multiset(cont)` and
 `flat_multiset(cont, comp)`, respectively, except that *c* is
 constructed with uses-allocator
 construction [[allocator.uses.construction]].
 *Complexity:* Same as `flat_multiset(cont)` and
 `flat_multiset(cont, comp)`, respectively.
 ``` cpp
-template<class Allocator>
-  flat_multiset(sorted_equivalent_t s, const container_type& cont, const Allocator& a);
-template<class Allocator>
-  flat_multiset(sorted_equivalent_t s, const container_type& cont,
- const key_compare& comp, const Allocator& a);
 ```
-*Constraints:* `uses_allocator_v<container_type, Allocator>` is `true`.
-*Effects:* Equivalent to `flat_multiset(s, cont)` and
-`flat_multiset(s, cont, comp)`, respectively, except that *c* is
-constructed with uses-allocator
 construction [[allocator.uses.construction]].
 *Complexity:* Linear.
 ``` cpp
-template<class Allocator>
-  flat_multiset(const key_compare& comp, const Allocator& a);
-template<class Allocator>
- explicit flat_multiset(const Allocator& a);
-template<class InputIterator, class Allocator>
-  flat_multiset(InputIterator first, InputIterator last,
-                const key_compare& comp, const Allocator& a);
-template<class InputIterator, class Allocator>
-  flat_multiset(InputIterator first, InputIterator last, const Allocator& a);
-template<container-compatible-range<value_type> R, class Allocator>
-  flat_multiset(from_range_t, R&& rg, const Allocator& a);
-template<container-compatible-range<value_type> R, class Allocator>
-  flat_multiset(from_range_t, R&& rg, const key_compare& comp, const Allocator& a);
-template<class InputIterator, class Allocator>
-  flat_multiset(sorted_equivalent_t, InputIterator first, InputIterator last,
- const key_compare& comp, const Allocator& a);
-template<class InputIterator, class Allocator>
-  flat_multiset(sorted_equivalent_t, InputIterator first, InputIterator last, const Allocator& a);
-template<class Allocator>
-  flat_multiset(initializer_list<value_type> il, const key_compare& comp, const Allocator& a);
-template<class Allocator>
-  flat_multiset(initializer_list<value_type> il, const Allocator& a);
-template<class Allocator>
-  flat_multiset(sorted_equivalent_t, initializer_list<value_type> il,
-                const key_compare& comp, const Allocator& a);
-template<class Allocator>
-  flat_multiset(sorted_equivalent_t, initializer_list<value_type> il, const Allocator& a);
 ```
-*Constraints:* `uses_allocator_v<container_type, Allocator>` is `true`.
 *Effects:* Equivalent to the corresponding non-allocator constructors
 except that *c* is constructed with uses-allocator
 construction [[allocator.uses.construction]].
 #### Modifiers <a id="flat.multiset.modifiers">[[flat.multiset.modifiers]]</a>
 ``` cpp
-template<class... Args> iterator emplace(Args&&... args);
 ```
 *Constraints:* `is_constructible_v<value_type, Args...>` is `true`.
 *Effects:* First, initializes an object `t` of type `value_type` with
@@ -12627,11 +14273,11 @@ c.insert(it, std::move(t));
 *Returns:* An iterator that points to the inserted element.
 ``` cpp
 template<class InputIterator>
-  void insert(InputIterator first, InputIterator last);
 ```
 *Effects:* Adds elements to *c* as if by:
 ``` cpp
@@ -12648,51 +14294,51 @@ M is `distance(first, last)`.
 *Remarks:* Since this operation performs an in-place merge, it may
 allocate memory.
 ``` cpp
 template<class InputIterator>
-  void insert(sorted_equivalent_t, InputIterator first, InputIterator last);
 ```
 *Effects:* Equivalent to `insert(first, last)`.
 *Complexity:* Linear.
 ``` cpp
-void swap(flat_multiset& y) noexcept;
 ```
 *Effects:* Equivalent to:
 ``` cpp
 ranges::swap(compare, y.compare);
 ranges::swap(c, y.c);
 ```
 ``` cpp
-container_type extract() &&;
 ```
 *Ensures:* `*this` is emptied, even if the function exits via an
 exception.
-*Returns:* `std::move(c)`.
 ``` cpp
-void replace(container_type&& cont);
 ```
 *Preconditions:* The elements of `cont` are sorted with respect to
 *compare*.
-*Effects:* Equivalent to: `c = std::move(cont);`
 #### Erasure <a id="flat.multiset.erasure">[[flat.multiset.erasure]]</a>
 ``` cpp
 template<class Key, class Compare, class KeyContainer, class Predicate>
-  typename flat_multiset<Key, Compare, KeyContainer>::size_type
     erase_if(flat_multiset<Key, Compare, KeyContainer>& c, Predicate pred);
 ```
 *Preconditions:* `Key` meets the *Cpp17MoveAssignable* requirements.
@@ -12767,22 +14413,39 @@ with these multidimensional views.
 ### Contiguous access <a id="views.contiguous">[[views.contiguous]]</a>
 #### Header `<span>` synopsis <a id="span.syn">[[span.syn]]</a>
 ``` cpp
 namespace std {
   // constants
   inline constexpr size_t dynamic_extent = numeric_limits<size_t>::max();
   // [views.span], class template span
   template<class ElementType, size_t Extent = dynamic_extent>
-    class span;
   template<class ElementType, size_t Extent>
-    constexpr bool ranges::enable_view<span<ElementType, Extent>> = true;
   template<class ElementType, size_t Extent>
-    constexpr bool ranges::enable_borrowed_range<span<ElementType, Extent>> = true;
   // [span.objectrep], views of object representation
   template<class ElementType, size_t Extent>
     span<const byte, Extent == dynamic_extent ? dynamic_extent : sizeof(ElementType) * Extent>
       as_bytes(span<ElementType, Extent> s) noexcept;
@@ -12834,16 +14497,15 @@ namespace std {
       constexpr span(array<T, N>& arr) noexcept;
     template<class T, size_t N>
       constexpr span(const array<T, N>& arr) noexcept;
     template<class R>
       constexpr explicit(extent != dynamic_extent) span(R&& r);
     constexpr span(const span& other) noexcept = default;
     template<class OtherElementType, size_t OtherExtent>
       constexpr explicit(see below) span(const span<OtherElementType, OtherExtent>& s) noexcept;
-    ~span() noexcept = default;
     constexpr span& operator=(const span& other) noexcept = default;
     // [span.sub], subviews
     template<size_t Count>
       constexpr span<element_type, Count> first() const;
@@ -12858,14 +14520,15 @@ namespace std {
       size_type offset, size_type count = dynamic_extent) const;
     // [span.obs], observers
     constexpr size_type size() const noexcept;
     constexpr size_type size_bytes() const noexcept;
- [[nodiscard]] constexpr bool empty() const noexcept;
     // [span.elem], element access
     constexpr reference operator[](size_type idx) const;
     constexpr reference front() const;
     constexpr reference back() const;
     constexpr pointer data() const noexcept;
     // [span.iterators], iterator support
@@ -12882,11 +14545,12 @@ namespace std {
     pointer data_;              // exposition only
     size_type size_;            // exposition only
   };
   template<class It, class EndOrSize>
-    span(It, EndOrSize) -> span<remove_reference_t<iter_reference_t<It>>>;
   template<class T, size_t N>
     span(T (&)[N]) -> span<T, N>;
   template<class T, size_t N>
     span(array<T, N>&) -> span<T, N>;
   template<class T, size_t N>
@@ -12900,10 +14564,14 @@ namespace std {
 [[term.trivially.copyable.type]].
 `ElementType` is required to be a complete object type that is not an
 abstract class type.
 ##### Constructors, copy, and assignment <a id="span.cons">[[span.cons]]</a>
 ``` cpp
 constexpr span() noexcept;
 ```
@@ -12926,14 +14594,15 @@ template<class It>
 *Preconditions:*
 - \[`first`, `first + count`) is a valid range.
 - `It` models `contiguous_iterator`.
-- If `extent` is not equal to `dynamic_extent`, then `count` is equal to
-  `extent`.
-*Effects:* Initializes *`data_`* with `to_address(first)` and *`size_`*
 with `count`.
 *Throws:* Nothing.
 ``` cpp
@@ -12950,28 +14619,29 @@ template<class It, class End>
 - `End` satisfies `sized_sentinel_for<It>`.
 - `is_convertible_v<End, size_t>` is `false`.
 *Preconditions:*
-- If `extent` is not equal to `dynamic_extent`, then `last - first` is
-  equal to `extent`.
 - \[`first`, `last`) is a valid range.
 - `It` models `contiguous_iterator`.
 - `End` models `sized_sentinel_for<It>`.
-*Effects:* Initializes *`data_`* with `to_address(first)` and *`size_`*
 with `last - first`.
 *Throws:* When and what `last - first` throws.
 ``` cpp
 template<size_t N> constexpr span(type_identity_t<element_type> (&arr)[N]) noexcept;
 template<class T, size_t N> constexpr span(array<T, N>& arr) noexcept;
 template<class T, size_t N> constexpr span(const array<T, N>& arr) noexcept;
 ```
-*Constraints:* Let `U` be `remove_pointer_t<decltype(data(arr))>`.
 - `extent == dynamic_extent || N == extent` is `true`, and
 - `is_convertible_v<U(*)[], element_type(*)[]>` is `true`.
   \[*Note 3*: The intent is to allow only qualification conversions of
   the array element type to `element_type`. — *end note*]
@@ -12979,11 +14649,11 @@ template<class T, size_t N> constexpr span(const array<T, N>& arr) noexcept;
 *Effects:* Constructs a `span` that is a view over the supplied array.
 [*Note 1*: `type_identity_t` affects class template argument
 deduction. — *end note*]
-*Ensures:* `size() == N && data() == data(arr)` is `true`.
 ``` cpp
 template<class R> constexpr explicit(extent != dynamic_extent) span(R&& r);
 ```
@@ -13000,21 +14670,34 @@ template<class R> constexpr explicit(extent != dynamic_extent) span(R&& r);
   \[*Note 4*: The intent is to allow only qualification conversions of
   the range reference type to `element_type`. — *end note*]
 *Preconditions:*
-- If `extent` is not equal to `dynamic_extent`, then `ranges::size(r)`
-  is equal to `extent`.
 - `R` models `ranges::contiguous_range` and `ranges::sized_range`.
 - If `is_const_v<element_type>` is `false`, `R` models
   `ranges::borrowed_range`.
-*Effects:* Initializes *`data_`* with `ranges::data(r)` and *`size_`*
-with `ranges::size(r)`.
 *Throws:* What and when `ranges::data(r)` and `ranges::size(r)` throw.
 ``` cpp
 constexpr span(const span& other) noexcept = default;
 ```
 *Ensures:* `other.size() == size() && other.data() == data()`.
@@ -13031,12 +14714,12 @@ template<class OtherElementType, size_t OtherExtent>
 - `is_convertible_v<OtherElementType(*)[], element_type(*)[]>` is
   `true`. \[*Note 5*: The intent is to allow only qualification
   conversions of the `OtherElementType` to
   `element_type`. — *end note*]
-*Preconditions:* If `extent` is not equal to `dynamic_extent`, then
-`s.size()` is equal to `extent`.
 *Effects:* Constructs a `span` that is a view over the range
 \[`s.data()`, `s.data() + s.size()`).
 *Ensures:* `size() == s.size() && data() == s.data()`.
@@ -13055,11 +14738,12 @@ constexpr span& operator=(const span& other) noexcept = default;
 ##### Deduction guides <a id="span.deduct">[[span.deduct]]</a>
 ``` cpp
 template<class It, class EndOrSize>
-  span(It, EndOrSize) -> span<remove_reference_t<iter_reference_t<It>>>;
 ```
 *Constraints:* `It` satisfies `contiguous_iterator`.
 ``` cpp
@@ -13075,22 +14759,22 @@ template<class R>
 template<size_t Count> constexpr span<element_type, Count> first() const;
 ```
 *Mandates:* `Count <= Extent` is `true`.
-*Preconditions:* `Count <= size()` is `true`.
 *Effects:* Equivalent to: `return R{data(), Count};` where `R` is the
 return type.
 ``` cpp
 template<size_t Count> constexpr span<element_type, Count> last() const;
 ```
 *Mandates:* `Count <= Extent` is `true`.
-*Preconditions:* `Count <= size()` is `true`.
 *Effects:* Equivalent to: `return R{data() + (size() - Count), Count};`
 where `R` is the return type.
 ``` cpp
@@ -13104,12 +14788,10 @@ template<size_t Offset, size_t Count = dynamic_extent>
 Offset <= Extent && (Count == dynamic_extent || Count <= Extent - Offset)
 ```
 is `true`.
-*Preconditions:*
 ``` cpp
 Offset <= size() && (Count == dynamic_extent || Count <= size() - Offset)
 ```
 is `true`.
@@ -13131,29 +14813,27 @@ Count != dynamic_extent ? Count
 ``` cpp
 constexpr span<element_type, dynamic_extent> first(size_type count) const;
 ```
-*Preconditions:* `count <= size()` is `true`.
 *Effects:* Equivalent to: `return {data(), count};`
 ``` cpp
 constexpr span<element_type, dynamic_extent> last(size_type count) const;
 ```
-*Preconditions:* `count <= size()` is `true`.
 *Effects:* Equivalent to: `return {data() + (size() - count), count};`
 ``` cpp
 constexpr span<element_type, dynamic_extent> subspan(
   size_type offset, size_type count = dynamic_extent) const;
 ```
-*Preconditions:*
 ``` cpp
 offset <= size() && (count == dynamic_extent || count <= size() - offset)
 ```
 is `true`.
@@ -13177,46 +14857,60 @@ constexpr size_type size_bytes() const noexcept;
 ```
 *Effects:* Equivalent to: `return size() * sizeof(element_type);`
 ``` cpp
-[[nodiscard]] constexpr bool empty() const noexcept;
 ```
 *Effects:* Equivalent to: `return size() == 0;`
 ##### Element access <a id="span.elem">[[span.elem]]</a>
 ``` cpp
 constexpr reference operator[](size_type idx) const;
 ```
-*Preconditions:* `idx < size()` is `true`.
-*Effects:* Equivalent to: `return *(data() + idx);`
 ``` cpp
 constexpr reference front() const;
 ```
-*Preconditions:* `empty()` is `false`.
-*Effects:* Equivalent to: `return *data();`
 ``` cpp
 constexpr reference back() const;
 ```
-*Preconditions:* `empty()` is `false`.
-*Effects:* Equivalent to: `return *(data() + (size() - 1));`
 ``` cpp
 constexpr pointer data() const noexcept;
 ```
-*Effects:* Equivalent to: `return `*`data_`*`;`
 ##### Iterator support <a id="span.iterators">[[span.iterators]]</a>
 ``` cpp
 using iterator = implementation-defined  // type of span::iterator;
@@ -13304,42 +14998,81 @@ the following are true:
   the interval [Lᵢ, Uᵢ) of S.
 #### Header `<mdspan>` synopsis <a id="mdspan.syn">[[mdspan.syn]]</a>
 ``` cpp
 namespace std {
   // [mdspan.extents], class template extents
   template<class IndexType, size_t... Extents>
     class extents;
   // [mdspan.extents.dextents], alias template dextents
   template<class IndexType, size_t Rank>
     using dextents = see below;
   // [mdspan.layout], layout mapping
   struct layout_left;
   struct layout_right;
   struct layout_stride;
   // [mdspan.accessor.default], class template default_accessor
   template<class ElementType>
     class default_accessor;
   // [mdspan.mdspan], class template mdspan
   template<class ElementType, class Extents, class LayoutPolicy = layout_right,
            class AccessorPolicy = default_accessor<ElementType>>
-    class mdspan;
 }
 ```
 #### Class template `extents` <a id="mdspan.extents">[[mdspan.extents]]</a>
 ##### Overview <a id="mdspan.extents.overview">[[mdspan.extents.overview]]</a>
 The class template `extents` represents a multidimensional index space
-of rank equal to `sizeof...(Extents)`. In subclause [[views]], `extents`
-is used synonymously with multidimensional index space.
 ``` cpp
 namespace std {
   template<class IndexType, size_t... Extents>
   class extents {
@@ -13519,12 +15252,12 @@ Let `N` be `sizeof...(OtherIndexTypes)`, and let `exts_arr` be
 - If `N != rank_dynamic()` is `true`, `exts_arr[`r`]` equals Eᵣ for each
   r for which Eᵣ is a static extent, and
 - either
   - `sizeof...(exts) == 0` is `true`, or
-  - each element of `exts` is nonnegative and is representable as a
- value of type `index_type`.
 *Ensures:* `*this == extents(exts_arr)` is `true`.
 ``` cpp
 template<class OtherIndexType, size_t N>
@@ -13546,16 +15279,16 @@ template<class OtherIndexType, size_t N>
 - If `N != rank_dynamic()` is `true`, `exts[`r`]` equals Eᵣ for each r
   for which Eᵣ is a static extent, and
 - either
   - `N` is zero, or
-  - `exts[`r`]` is nonnegative and is representable as a value of type
     `index_type` for every rank index r.
 *Effects:*
-- If `N` equals `dynamic_rank()`, for all d in the range
   [0, `rank_dynamic()`), direct-non-list-initializes
   *`dynamic-extents`*`[`d`]` with `as_const(exts[`d`])`.
 - Otherwise, for all d in the range [0, `rank_dynamic()`),
   direct-non-list-initializes *`dynamic-extents`*`[`d`]` with
   `as_const(exts[`*`dynamic-index-inv`*`(`d`)])`.
@@ -13565,11 +15298,12 @@ template<class... Integrals>
   explicit extents(Integrals...) -> see below;
 ```
 *Constraints:* `(is_convertible_v<Integrals, size_t> && ...)` is `true`.
-*Remarks:* The deduced type is `dextents<size_t, sizeof...(Integrals)>`.
 ##### Observers of the multidimensional index space <a id="mdspan.extents.obs">[[mdspan.extents.obs]]</a>
 ``` cpp
 static constexpr size_t static_extent(rank_type i) noexcept;
@@ -13608,16 +15342,26 @@ template<class IndexType, size_t Rank>
 *Result:* A type `E` that is a specialization of `extents` such that
 `E::rank() == Rank && E::rank() == E::rank_dynamic()` is `true`, and
 `E::index_type` denotes `IndexType`.
 #### Layout mapping <a id="mdspan.layout">[[mdspan.layout]]</a>
 ##### General <a id="mdspan.layout.general">[[mdspan.layout.general]]</a>
-In subclauses [[mdspan.layout.reqmts]] and
-[[mdspan.layout.policy.reqmts]]:
 - `M` denotes a layout mapping class.
 - `m` denotes a (possibly const) value of type `M`.
 - `i` and `j` are packs of (possibly const) integers that are
   multidimensional indices in `m.extents()` [[mdspan.overview]].
@@ -13626,19 +15370,44 @@ In subclauses [[mdspan.layout.reqmts]] and
 - `r` is a (possibly const) rank index of `typename M::extents_type`.
 - `dᵣ` is a pack of (possibly const) integers for which
   `sizeof...(dᵣ) == M::extents_type::rank()` is `true`, the rᵗʰ element
   is equal to 1, and all other elements are equal to 0.
-In subclauses [[mdspan.layout.reqmts]] through [[mdspan.layout.stride]],
-let *`is-mapping-of`* be the exposition-only variable template defined
   as follows:
   ``` cpp
   template<class Layout, class Mapping>
   constexpr bool is-mapping-of =  // exposition only
     is_same_v<typename Layout::template mapping<typename Mapping::extents_type>, Mapping>;
   ```
 ##### Requirements <a id="mdspan.layout.reqmts">[[mdspan.layout.reqmts]]</a>
 A type `M` meets the *layout mapping* requirements if
@@ -13762,20 +15531,24 @@ m.stride(r)
 *Result:* `typename M::index_type`
 *Returns:* sᵣ as defined in `m.is_strided()` above.
 ``` cpp
 M::is_always_unique()
 ```
 *Result:* A constant expression [[expr.const]] of type `bool`.
 *Returns:* `true` only if `m.is_unique()` is `true` for all possible
 objects `m` of type `M`.
-[*Note 5*: A mapping can return `false` even if the above condition is
 met. For certain layout mappings, it is possibly not feasible to
 determine whether every instance is unique. — *end note*]
 ``` cpp
 M::is_always_exhaustive()
@@ -13784,11 +15557,11 @@ M::is_always_exhaustive()
 *Result:* A constant expression [[expr.const]] of type `bool`.
 *Returns:* `true` only if `m.is_exhaustive()` is `true` for all possible
 objects `m` of type `M`.
-[*Note 6*: A mapping can return `false` even if the above condition is
 met. For certain layout mappings, it is possibly not feasible to
 determine whether every instance is exhaustive. — *end note*]
 ``` cpp
 M::is_always_strided()
@@ -13797,11 +15570,11 @@ M::is_always_strided()
 *Result:* A constant expression [[expr.const]] of type `bool`.
 *Returns:* `true` only if `m.is_strided()` is `true` for all possible
 objects `m` of type `M`.
-[*Note 7*: A mapping can return `false` even if the above condition is
 met. For certain layout mappings, it is possibly not feasible to
 determine whether every instance is strided. — *end note*]
 ##### Layout mapping policy requirements <a id="mdspan.layout.policy.reqmts">[[mdspan.layout.policy.reqmts]]</a>
@@ -13826,15 +15599,27 @@ namespace std {
   };
   struct layout_stride {
     template<class Extents>
       class mapping;
   };
 }
 ```
-Each of `layout_left`, `layout_right`, and `layout_stride` meets the
-layout mapping policy requirements and is a trivial type.
 ##### Class template `layout_left::mapping` <a id="mdspan.layout.left">[[mdspan.layout.left]]</a>
 ###### Overview <a id="mdspan.layout.left.overview">[[mdspan.layout.left.overview]]</a>
@@ -13845,13 +15630,13 @@ stride 1, and strides increase left-to-right as the product of extents.
 namespace std {
   template<class Extents>
   class layout_left::mapping {
   public:
     using extents_type = Extents;
-    using index_type = typename extents_type::index_type;
-    using size_type = typename extents_type::size_type;
-    using rank_type = typename extents_type::rank_type;
     using layout_type = layout_left;
     // [mdspan.layout.left.cons], constructors
     constexpr mapping() noexcept = default;
     constexpr mapping(const mapping&) noexcept = default;
@@ -13860,10 +15645,14 @@ namespace std {
       constexpr explicit(!is_convertible_v<OtherExtents, extents_type>)
         mapping(const mapping<OtherExtents>&) noexcept;
     template<class OtherExtents>
       constexpr explicit(!is_convertible_v<OtherExtents, extents_type>)
         mapping(const layout_right::mapping<OtherExtents>&) noexcept;
     template<class OtherExtents>
       constexpr explicit(extents_type::rank() > 0)
         mapping(const layout_stride::mapping<OtherExtents>&);
     constexpr mapping& operator=(const mapping&) noexcept = default;
@@ -13889,10 +15678,21 @@ namespace std {
     template<class OtherExtents>
       friend constexpr bool operator==(const mapping&, const mapping<OtherExtents>&) noexcept;
   private:
     extents_type extents_{};                                               // exposition only
   };
 }
 ```
 If `Extents` is not a specialization of `extents`, then the program is
@@ -13930,11 +15730,11 @@ value of type `index_type` [[basic.fundamental]].
 *Effects:* Direct-non-list-initializes *extents\_* with
 `other.extents()`.
 ``` cpp
-template<class OtherExents>
   constexpr explicit(!is_convertible_v<OtherExtents, extents_type>)
     mapping(const layout_right::mapping<OtherExtents>& other) noexcept;
 ```
 *Constraints:*
@@ -13946,10 +15746,44 @@ template<class OtherExents>
 value of type `index_type` [[basic.fundamental]].
 *Effects:* Direct-non-list-initializes *extents\_* with
 `other.extents()`.
 ``` cpp
 template<class OtherExtents>
   constexpr explicit(extents_type::rank() > 0)
     mapping(const layout_stride::mapping<OtherExtents>& other);
 ```
@@ -14001,11 +15835,11 @@ is `true`. Equivalent to:
 ``` cpp
 return ((static_cast<index_type>(i) * stride(P)) + ... + 0);
 ```
 ``` cpp
-constexpr index_type stride(rank_type i) const;
 ```
 *Constraints:* `extents_type::rank() > 0` is `true`.
 *Preconditions:* `i < extents_type::rank()` is `true`.
@@ -14032,13 +15866,13 @@ stride 1, and strides increase right-to-left as the product of extents.
 namespace std {
   template<class Extents>
   class layout_right::mapping {
   public:
     using extents_type = Extents;
-    using index_type = typename extents_type::index_type;
-    using size_type = typename extents_type::size_type;
-    using rank_type = typename extents_type::rank_type;
     using layout_type = layout_right;
     // [mdspan.layout.right.cons], constructors
     constexpr mapping() noexcept = default;
     constexpr mapping(const mapping&) noexcept = default;
@@ -14047,10 +15881,14 @@ namespace std {
       constexpr explicit(!is_convertible_v<OtherExtents, extents_type>)
         mapping(const mapping<OtherExtents>&) noexcept;
     template<class OtherExtents>
       constexpr explicit(!is_convertible_v<OtherExtents, extents_type>)
         mapping(const layout_left::mapping<OtherExtents>&) noexcept;
     template<class OtherExtents>
       constexpr explicit(extents_type::rank() > 0)
         mapping(const layout_stride::mapping<OtherExtents>&) noexcept;
     constexpr mapping& operator=(const mapping&) noexcept = default;
@@ -14076,10 +15914,21 @@ namespace std {
     template<class OtherExtents>
       friend constexpr bool operator==(const mapping&, const mapping<OtherExtents>&) noexcept;
   private:
     extents_type extents_{};    // exposition only
   };
 }
 ```
 If `Extents` is not a specialization of `extents`, then the program is
@@ -14133,10 +15982,46 @@ template<class OtherExtents>
 value of type `index_type` [[basic.fundamental]].
 *Effects:* Direct-non-list-initializes *extents\_* with
 `other.extents()`.
 ``` cpp
 template<class OtherExtents>
  constexpr explicit(extents_type::rank() > 0)
     mapping(const layout_stride::mapping<OtherExtents>& other) noexcept;
 ```
@@ -14156,11 +16041,11 @@ template<class OtherExtents>
 `other.extents()`.
 ###### Observers <a id="mdspan.layout.right.obs">[[mdspan.layout.right.obs]]</a>
 ``` cpp
-index_type required_span_size() const noexcept;
 ```
 *Returns:* `extents().`*`fwd-prod-of-extents`*`(extents_type::rank())`.
 ``` cpp
@@ -14219,13 +16104,13 @@ user-defined.
 namespace std {
   template<class Extents>
   class layout_stride::mapping {
   public:
     using extents_type = Extents;
-    using index_type = typename extents_type::index_type;
-    using size_type = typename extents_type::size_type;
-    using rank_type = typename extents_type::rank_type;
     using layout_type = layout_stride;
   private:
     static constexpr rank_type rank_ = extents_type::rank();    // exposition only
@@ -14266,10 +16151,21 @@ namespace std {
       friend constexpr bool operator==(const mapping&, const OtherMapping&) noexcept;
   private:
     extents_type extents_{};                    // exposition only
     array<index_type, rank_> strides_{};        // exposition only
   };
 }
 ```
 If `Extents` is not a specialization of `extents`, then the program is
@@ -14288,11 +16184,15 @@ Let `REQUIRED-SPAN-SIZE(e, strides)` be:
 - `1`, if `e.rank() == 0` is `true`,
 - otherwise `0`, if the size of the multidimensional index space `e` is
   0,
 - otherwise `1` plus the sum of products of `(e.extent(r) - 1)` and
-  `strides[r]` for all r in the range [0, `e.rank()`).
 Let `OFFSET(m)` be:
 - `m()`, if `e.rank() == 0` is `true`,
 - otherwise `0`, if the size of the multidimensional index space `e` is
@@ -14360,11 +16260,12 @@ template<class OtherIndexType>
 - `is_nothrow_constructible_v<index_type, const OtherIndexType&>` is
   `true`.
 *Preconditions:*
-- `s[`i`] > 0` is `true` for all i in the range [0, rank_).
 - *`REQUIRED-SPAN-SIZE`*`(e, s)` is representable as a value of type
   `index_type` [[basic.fundamental]].
 - If *rank\_* is greater than 0, then there exists a permutation P of
   the integers in the range [0, rank_), such that
   `s[`pᵢ`] >= s[`pᵢ₋₁`] * e.extent(p`ᵢ₋₁`)` is `true` for all i in the
@@ -14392,11 +16293,11 @@ template<class StridedLayoutMapping>
 - `StridedLayoutMapping::is_always_strided()` is `true`.
 *Preconditions:*
 - `StridedLayoutMapping` meets the layout mapping
-  requirements [[mdspan.layout.policy.reqmts]],
 - `other.stride(`r`) > 0` is `true` for every rank index r of
   `extents()`,
 - `other.required_span_size()` is representable as a value of type
   `index_type` [[basic.fundamental]], and
 - *`OFFSET`*`(other) == 0` is `true`.
@@ -14408,13 +16309,15 @@ direct-non-list-initializes *`strides_`*`[`d`]` with
 Remarks: The expression inside `explicit` is equivalent to:
 ``` cpp
 !(is_convertible_v<typename StridedLayoutMapping::extents_type, extents_type> &&
-  (is-mapping-of<layout_left, LayoutStrideMapping> ||
-   is-mapping-of<layout_right, LayoutStrideMapping> ||
-   is-mapping-of<layout_stride, LayoutStrideMapping>))
 ```
 ###### Observers <a id="mdspan.layout.stride.obs">[[mdspan.layout.stride.obs]]</a>
 ``` cpp
@@ -14479,10 +16382,898 @@ requirements [[mdspan.layout.policy.reqmts]].
 *Returns:* `true` if `x.extents() == y.extents()` is `true`,
 *`OFFSET`*`(y) == 0` is `true`, and each of
 `x.stride(`r`) == y.stride(`r`)` is `true` for r in the range
 [0, `x.extents().rank()`). Otherwise, `false`.
 #### Accessor policy <a id="mdspan.accessor">[[mdspan.accessor]]</a>
 ##### General <a id="mdspan.accessor.general">[[mdspan.accessor.general]]</a>
 An *accessor policy* defines types and operations by which a reference
@@ -14491,11 +17282,11 @@ of such objects and an index.
 A range of indices [0, N) is an *accessible range* of a given data
 handle and an accessor if, for each i in the range, the accessor
 policy’s `access` function produces a valid reference to an object.
-In subclause [[mdspan.accessor.reqmts]],
 - `A` denotes an accessor policy.
 - `a` denotes a value of type `A` or `const A`.
 - `p` denotes a value of type `A::data_handle_type` or
   `const A::data_handle_type`. \[*Note 1*: The type
@@ -14635,10 +17426,155 @@ constexpr reference access(data_handle_type p, size_t i) const noexcept;
 constexpr data_handle_type offset(data_handle_type p, size_t i) const noexcept;
 ```
 *Effects:* Equivalent to: `return p + i;`
 #### Class template `mdspan` <a id="mdspan.mdspan">[[mdspan.mdspan]]</a>
 ##### Overview <a id="mdspan.mdspan.overview">[[mdspan.mdspan.overview]]</a>
 `mdspan` is a view of a multidimensional array of elements.
@@ -14650,18 +17586,18 @@ namespace std {
   class mdspan {
   public:
     using extents_type = Extents;
     using layout_type = LayoutPolicy;
     using accessor_type = AccessorPolicy;
-    using mapping_type = typename layout_type::template mapping<extents_type>;
     using element_type = ElementType;
     using value_type = remove_cv_t<element_type>;
-    using index_type = typename extents_type::index_type;
-    using size_type = typename extents_type::size_type;
-    using rank_type = typename extents_type::rank_type;
-    using data_handle_type = typename accessor_type::data_handle_type;
-    using reference = typename accessor_type::reference;
     static constexpr rank_type rank() noexcept { return extents_type::rank(); }
     static constexpr rank_type rank_dynamic() noexcept { return extents_type::rank_dynamic(); }
     static constexpr size_t static_extent(rank_type r) noexcept
       { return extents_type::static_extent(r); }
@@ -14699,12 +17635,22 @@ namespace std {
     template<class OtherIndexType>
       constexpr reference operator[](span<OtherIndexType, rank()> indices) const;
     template<class OtherIndexType>
       constexpr reference operator[](const array<OtherIndexType, rank()>& indices) const;
     constexpr size_type size() const noexcept;
- [[nodiscard]] constexpr bool empty() const noexcept;
     friend constexpr void swap(mdspan& x, mdspan& y) noexcept;
     constexpr const extents_type& extents() const noexcept { return map_.extents(); }
     constexpr const data_handle_type& data_handle() const noexcept { return ptr_; }
@@ -14744,11 +17690,11 @@ namespace std {
       -> mdspan<remove_pointer_t<remove_reference_t<Pointer>>, extents<size_t>>;
   template<class ElementType, class... Integrals>
     requires ((is_convertible_v<Integrals, size_t> && ...) && sizeof...(Integrals) > 0)
     explicit mdspan(ElementType*, Integrals...)
-      -> mdspan<ElementType, dextents<size_t, sizeof...(Integrals)>>;
   template<class ElementType, class OtherIndexType, size_t N>
     mdspan(ElementType*, span<OtherIndexType, N>)
       -> mdspan<ElementType, dextents<size_t, N>>;
@@ -14851,12 +17797,12 @@ template<class OtherIndexType, size_t N>
 ```
 *Constraints:*
 - `is_convertible_v<const OtherIndexType&, index_type>` is `true`,
-- `(is_nothrow_constructible<index_type, const OtherIndexType&> && ...)`
- is `true`,
 - `N == rank() || N == rank_dynamic()` is `true`,
 - `is_constructible_v<mapping_type, extents_type>` is `true`, and
 - `is_default_constructible_v<accessor_type>` is `true`.
 *Preconditions:* $[0, \texttt{\textit{map_}.required_span_size()})$ is
@@ -14935,18 +17881,17 @@ template<class OtherElementType, class OtherExtents,
 - `is_constructible_v<data_handle_type, const OtherAccessor::data_handle_type&>`
   is `true`, and
 - `is_constructible_v<extents_type, OtherExtents>` is `true`.
-*Preconditions:*
-- For each rank index `r` of `extents_type`,
 `static_extent(r) == dynamic_extent || static_extent(r) == other.extent(r)`
 is `true`.
-- $[0, \texttt{\textit{map_}.required_span_size()})$ is an accessible
-  range of *ptr\_* and *acc\_* for values of *ptr\_*, *map\_*, and
-  *acc\_* after the invocation of this constructor.
 *Effects:*
 - Direct-non-list-initializes *ptr\_* with `other.`*`ptr_`*,
 - direct-non-list-initializes *map\_* with `other.`*`map_`*, and
@@ -14973,11 +17918,11 @@ template<class... OtherIndexTypes>
   `true`, and
 - `sizeof...(OtherIndexTypes) == rank()` is `true`.
 Let `I` be `extents_type::`*`index-cast`*`(std::move(indices))`.
-*Preconditions:* `I` is a multidimensional index in `extents()`.
 [*Note 1*: This implies that
 *`map_`*`(I) < `*`map_`*`.required_span_size()` is
 `true`. — *end note*]
@@ -15007,11 +17952,55 @@ is_same_v<make_index_sequence<rank()>, index_sequence<P...>>
 ```
 is `true`. Equivalent to:
 ``` cpp
-return operator[](as_const(indices[P])...);
 ```
 ``` cpp
 constexpr size_type size() const noexcept;
 ```
@@ -15021,11 +18010,11 @@ constexpr size_type size() const noexcept;
 [[basic.fundamental]].
 *Returns:* `extents().`*`fwd-prod-of-extents`*`(rank())`.
 ``` cpp
-[[nodiscard]] constexpr bool empty() const noexcept;
 ```
 *Returns:* `true` if the size of the multidimensional index space
 `extents()` is 0, otherwise `false`.
@@ -15039,10 +18028,599 @@ friend constexpr void swap(mdspan& x, mdspan& y) noexcept;
 swap(x.ptr_, y.ptr_);
 swap(x.map_, y.map_);
 swap(x.acc_, y.acc_);
 ```
 <!-- Link reference definitions -->
 [alg.equal]: algorithms.md#alg.equal
 [alg.sorting]: algorithms.md#alg.sorting
 [algorithm.stable]: library.md#algorithm.stable
 [algorithms]: algorithms.md#algorithms
@@ -15066,20 +18644,21 @@ swap(x.acc_, y.acc_);
 [associative.reqmts]: #associative.reqmts
 [associative.reqmts.except]: #associative.reqmts.except
 [associative.reqmts.general]: #associative.reqmts.general
 [associative.set.syn]: #associative.set.syn
 [basic.fundamental]: basic.md#basic.fundamental
 [basic.string]: strings.md#basic.string
 [class.copy.ctor]: class.md#class.copy.ctor
 [class.default.ctor]: class.md#class.default.ctor
 [class.dtor]: class.md#class.dtor
 [container.adaptors]: #container.adaptors
 [container.adaptors.format]: #container.adaptors.format
 [container.adaptors.general]: #container.adaptors.general
 [container.alloc.reqmts]: #container.alloc.reqmts
-[container.gen.reqmts]: #container.gen.reqmts
 [container.insert.return]: #container.insert.return
 [container.node]: #container.node
 [container.node.compat]: #container.node.compat
 [container.node.cons]: #container.node.cons
 [container.node.dtor]: #container.node.dtor
 [container.node.modifiers]: #container.node.modifiers
@@ -15107,28 +18686,32 @@ swap(x.acc_, y.acc_);
 [expr.const]: expr.md#expr.const
 [flat.map]: #flat.map
 [flat.map.access]: #flat.map.access
 [flat.map.capacity]: #flat.map.capacity
 [flat.map.cons]: #flat.map.cons
 [flat.map.defn]: #flat.map.defn
 [flat.map.erasure]: #flat.map.erasure
 [flat.map.modifiers]: #flat.map.modifiers
 [flat.map.overview]: #flat.map.overview
 [flat.map.syn]: #flat.map.syn
 [flat.multimap]: #flat.multimap
 [flat.multimap.cons]: #flat.multimap.cons
 [flat.multimap.defn]: #flat.multimap.defn
 [flat.multimap.erasure]: #flat.multimap.erasure
 [flat.multimap.overview]: #flat.multimap.overview
 [flat.multiset]: #flat.multiset
 [flat.multiset.cons]: #flat.multiset.cons
 [flat.multiset.defn]: #flat.multiset.defn
 [flat.multiset.erasure]: #flat.multiset.erasure
 [flat.multiset.modifiers]: #flat.multiset.modifiers
 [flat.multiset.overview]: #flat.multiset.overview
 [flat.set]: #flat.set
 [flat.set.cons]: #flat.set.cons
 [flat.set.defn]: #flat.set.defn
 [flat.set.erasure]: #flat.set.erasure
 [flat.set.modifiers]: #flat.set.modifiers
 [flat.set.overview]: #flat.set.overview
 [flat.set.syn]: #flat.set.syn
@@ -15141,10 +18724,26 @@ swap(x.acc_, y.acc_);
 [forward.list.modifiers]: #forward.list.modifiers
 [forward.list.ops]: #forward.list.ops
 [forward.list.overview]: #forward.list.overview
 [forward.list.syn]: #forward.list.syn
 [hash.requirements]: library.md#hash.requirements
 [iterator.concept.contiguous]: iterators.md#iterator.concept.contiguous
 [iterator.concept.random.access]: iterators.md#iterator.concept.random.access
 [iterator.requirements]: iterators.md#iterator.requirements
 [iterator.requirements.general]: iterators.md#iterator.requirements.general
 [list]: #list
@@ -15160,45 +18759,73 @@ swap(x.acc_, y.acc_);
 [map.cons]: #map.cons
 [map.erasure]: #map.erasure
 [map.modifiers]: #map.modifiers
 [map.overview]: #map.overview
 [mdspan.accessor]: #mdspan.accessor
 [mdspan.accessor.default]: #mdspan.accessor.default
 [mdspan.accessor.default.members]: #mdspan.accessor.default.members
 [mdspan.accessor.default.overview]: #mdspan.accessor.default.overview
 [mdspan.accessor.general]: #mdspan.accessor.general
 [mdspan.accessor.reqmts]: #mdspan.accessor.reqmts
 [mdspan.extents]: #mdspan.extents
 [mdspan.extents.cmp]: #mdspan.extents.cmp
 [mdspan.extents.cons]: #mdspan.extents.cons
 [mdspan.extents.dextents]: #mdspan.extents.dextents
 [mdspan.extents.expo]: #mdspan.extents.expo
 [mdspan.extents.obs]: #mdspan.extents.obs
 [mdspan.extents.overview]: #mdspan.extents.overview
 [mdspan.layout]: #mdspan.layout
 [mdspan.layout.general]: #mdspan.layout.general
 [mdspan.layout.left]: #mdspan.layout.left
 [mdspan.layout.left.cons]: #mdspan.layout.left.cons
 [mdspan.layout.left.obs]: #mdspan.layout.left.obs
 [mdspan.layout.left.overview]: #mdspan.layout.left.overview
 [mdspan.layout.policy.overview]: #mdspan.layout.policy.overview
 [mdspan.layout.policy.reqmts]: #mdspan.layout.policy.reqmts
 [mdspan.layout.reqmts]: #mdspan.layout.reqmts
 [mdspan.layout.right]: #mdspan.layout.right
 [mdspan.layout.right.cons]: #mdspan.layout.right.cons
 [mdspan.layout.right.obs]: #mdspan.layout.right.obs
 [mdspan.layout.right.overview]: #mdspan.layout.right.overview
 [mdspan.layout.stride]: #mdspan.layout.stride
 [mdspan.layout.stride.cons]: #mdspan.layout.stride.cons
 [mdspan.layout.stride.expo]: #mdspan.layout.stride.expo
 [mdspan.layout.stride.obs]: #mdspan.layout.stride.obs
 [mdspan.layout.stride.overview]: #mdspan.layout.stride.overview
 [mdspan.mdspan]: #mdspan.mdspan
 [mdspan.mdspan.cons]: #mdspan.mdspan.cons
 [mdspan.mdspan.members]: #mdspan.mdspan.members
 [mdspan.mdspan.overview]: #mdspan.mdspan.overview
 [mdspan.overview]: #mdspan.overview
 [mdspan.syn]: #mdspan.syn
 [multimap]: #multimap
 [multimap.cons]: #multimap.cons
 [multimap.erasure]: #multimap.erasure
 [multimap.modifiers]: #multimap.modifiers
@@ -15220,17 +18847,19 @@ swap(x.acc_, y.acc_);
 [queue.mod]: #queue.mod
 [queue.ops]: #queue.ops
 [queue.special]: #queue.special
 [queue.syn]: #queue.syn
 [random.access.iterators]: iterators.md#random.access.iterators
 [res.on.data.races]: library.md#res.on.data.races
 [sequence.reqmts]: #sequence.reqmts
 [sequences]: #sequences
 [sequences.general]: #sequences.general
 [set]: #set
 [set.cons]: #set.cons
 [set.erasure]: #set.erasure
 [set.overview]: #set.overview
 [span.cons]: #span.cons
 [span.deduct]: #span.deduct
 [span.elem]: #span.elem
 [span.iterators]: #span.iterators
@@ -15246,15 +18875,16 @@ swap(x.acc_, y.acc_);
 [stack.general]: #stack.general
 [stack.mod]: #stack.mod
 [stack.ops]: #stack.ops
 [stack.special]: #stack.special
 [stack.syn]: #stack.syn
 [strings]: strings.md#strings
 [swappable.requirements]: library.md#swappable.requirements
 [temp.deduct]: temp.md#temp.deduct
-[temp.param]: temp.md#temp.param
 [temp.type]: temp.md#temp.type
 [term.trivially.copyable.type]: basic.md#term.trivially.copyable.type
 [unord]: #unord
 [unord.general]: #unord.general
 [unord.hash]: utilities.md#unord.hash
 [unord.map]: #unord.map
@@ -15277,10 +18907,11 @@ swap(x.acc_, y.acc_);
 [unord.req.except]: #unord.req.except
 [unord.req.general]: #unord.req.general
 [unord.set]: #unord.set
 [unord.set.cnstr]: #unord.set.cnstr
 [unord.set.erasure]: #unord.set.erasure
 [unord.set.overview]: #unord.set.overview
 [unord.set.syn]: #unord.set.syn
 [vector]: #vector
 [vector.bool]: #vector.bool
 [vector.bool.fmt]: #vector.bool.fmt

 [[containers.summary]].
 **Table: Containers library summary** <a id="containers.summary">[containers.summary]</a>
 | Subclause                  |                                  | Header                                           |
+| -------------------------- | -------------------------------- | ------------------------------------------------ |
 | [[container.requirements]] | Requirements                     |                                                  |
+| [[sequences]]              | Sequence containers              | `<array>`, `<deque>`, `<forward_list>`, `<hive>`,  |     | `<inplace_vector>`, `<list>`, `<vector>` |
 | [[associative]]            | Associative containers           | `<map>`, `<set>`                                 |
 | [[unord]]                  | Unordered associative containers | `<unordered_map>`, `<unordered_set>`             |
 | [[container.adaptors]]     | Container adaptors               | `<queue>`, `<stack>`, `<flat_map>`, `<flat_set>` |
 | [[views]]                  | Views                            | `<span>`, `<mdspan>`                             |
 [*Note 1*: This means, for example, that a node-based container would
 need to construct nodes containing aligned buffers and call `construct`
 to place the element into the buffer. — *end note*]
+### General containers <a id="container.requirements.general">[[container.requirements.general]]</a>
+#### Introduction <a id="container.intro.reqmts">[[container.intro.reqmts]]</a>
+In [[container.requirements.general]],
 - `X` denotes a container class containing objects of type `T`,
 - `a` denotes a value of type `X`,
 - `b` and `c` denote values of type (possibly const) `X`,
 - `i` and `j` denote values of type (possibly const) `X::iterator`,
 template<class R, class T>
 concept container-compatible-range =    // exposition only
   ranges::input_range<R> && convertible_to<ranges::range_reference_t<R>, T>;
 ```
+#### Container requirements <a id="container.reqmts">[[container.reqmts]]</a>
 A type `X` meets the *container* requirements if the following types,
 statements, and expressions are well-formed and have the specified
 semantics.
 ```
 *Ensures:* `u` is equal to the value that `rv` had before this
 construction.
+*Complexity:* Linear for `array` and `inplace_vector` and constant for
+all other standard containers.
 ``` cpp
+t = v
 ```
 *Result:* `X&`.
 *Ensures:* `t == v`.
 *Result:* `void`.
 *Effects:* Exchanges the contents of `t` and `s`.
+*Complexity:* Linear for `array` and `inplace_vector`, and constant for
+all other standard containers.
 ``` cpp
 swap(t, s)
 ```
 [*Note 2*: If an invocation of a constructor uses the default value of
 an optional allocator argument, then the allocator type must support
 value-initialization. — *end note*]
 A copy of this allocator is used for any memory allocation and element
+construction performed, by these constructors and by all other member
 functions, during the lifetime of each container object or until the
 allocator is replaced. The allocator may be replaced only via assignment
 or `swap()`. Allocator replacement is performed by copy assignment, move
 assignment, or swapping of the allocator only if
 `get_allocator()` returns a copy of the allocator used to construct the
 container or, if that allocator has been replaced, a copy of the most
 recent replacement.
 The expression `a.swap(b)`, for containers `a` and `b` of a standard
+container type other than `array` and `inplace_vector`, shall exchange
+the values of `a` and `b` without invoking any move, copy, or swap
+operations on the individual container elements. Any `Compare`, `Pred`,
+or `Hash` types belonging to `a` and `b` shall meet the *Cpp17Swappable*
+requirements and shall be exchanged by calling `swap` as described in
 [[swappable.requirements]]. If
 `allocator_traits<allocator_type>::propagate_on_container_swap::value`
 is `true`, then `allocator_type` shall meet the *Cpp17Swappable*
 requirements and the allocators of `a` and `b` shall also be exchanged
 by calling `swap` as described in  [[swappable.requirements]].
 refer to the same element in the other container after the swap. It is
 unspecified whether an iterator with value `a.end()` before the swap
 will have value `b.end()` after the swap.
 Unless otherwise specified (see  [[associative.reqmts.except]],
+[[unord.req.except]], [[deque.modifiers]], [[inplace.vector.modifiers]],
+and [[vector.modifiers]]) all container types defined in this Clause
+meet the following additional requirements:
 - If an exception is thrown by an `insert()` or `emplace()` function
   while inserting a single element, that function has no effects.
 - If an exception is thrown by a `push_back()`, `push_front()`,
   `emplace_back()`, or `emplace_front()` function, that function has no
 a <=> b
 ```
 *Result:* *`synth-three-way-result`*`<X::value_type>`.
+*Preconditions:* Either `T` models `three_way_comparable`, or `<` is
+defined for values of type (possibly const) `T` and `<` is a total
+ordering relationship.
 *Returns:*
 `lexicographical_compare_three_way(a.begin(), a.end(), b.begin(), b.end(), `*`synth-three-way`*`)`
 [*Note 1*: The algorithm `lexicographical_compare_three_way` is defined
 *Complexity:* Linear.
 #### Allocator-aware containers <a id="container.alloc.reqmts">[[container.alloc.reqmts]]</a>
+Except for `array` and `inplace_vector`, all of the containers defined
+in [[containers]], [[stacktrace.basic]], [[basic.string]], and
+[[re.results]] meet the additional requirements of an
 *allocator-aware container*, as described below.
 Given an allocator type `A` and given a container type `X` having a
 `value_type` identical to `T` and an `allocator_type` identical to
 `allocator_traits<A>::rebind_alloc<T>` and given an lvalue `m` of type
+`A`, a pointer `p` of type `T*`, an expression `v` that denotes an
+lvalue of type `T` or `const T` or an rvalue of type `const T`, and an
+rvalue `rv` of type `T`, the following terms are defined. If `X` is not
+allocator-aware or is a specialization of `basic_string`, the terms
+below are defined as if `A` were `allocator<T>` — no allocator object
+needs to be created and user specializations of `allocator<T>` are not
+instantiated:
 - `T` is **Cpp17DefaultInsertable* into `X`* means that the following
   expression is well-formed:
   ``` cpp
   allocator_traits<A>::construct(m, p)
   and its evaluation causes the following postcondition to hold: The
   value of `*p` is equivalent to the value of `rv` before the
   evaluation.
   \[*Note 1*: `rv` remains a valid object. Its state is
+  unspecified. — *end note*]
 - `T` is **Cpp17CopyInsertable* into `X`* means that, in addition to `T`
   being *Cpp17MoveInsertable* into `X`, the following expression is
   well-formed:
   ``` cpp
   allocator_traits<A>::construct(m, p, v)
 X u(t, m);
 ```
 *Preconditions:* `T` is *Cpp17CopyInsertable* into `X`.
+*Ensures:* `u == t`, `u.get_allocator() == m`.
 *Complexity:* Linear.
 ``` cpp
 X u(rv);
 `y[1] = true`. — *end note*]
 ### Sequence containers <a id="sequence.reqmts">[[sequence.reqmts]]</a>
 A sequence container organizes a finite set of objects, all of the same
+type, into a strictly linear arrangement. The library provides the
+following basic kinds of sequence containers: `vector`,
+`inplace_vector`, `forward_list`, `list`, and `deque`. In addition,
+`array` and `hive` are provided as sequence containers which provide
+limited sequence operations, in `array`’s case because it has a fixed
+number of elements, and in `hive`’s case because insertion order is
+unspecified. The library also provides container adaptors that make it
 easy to construct abstract data types, such as `stack`s, `queue`s,
 `flat_map`s, `flat_multimap`s, `flat_set`s, or `flat_multiset`s, out of
 the basic sequence container kinds (or out of other program-defined
 sequence containers).
 In this subclause,
 - `X` denotes a sequence container class,
 - `a` denotes a value of type `X` containing elements of type `T`,
 - `u` denotes the name of a variable being declared,
   `X::allocator_type` is valid and denotes a type [[temp.deduct]] and
   `allocator<T>` if it doesn’t,
 - `i` and `j` denote iterators that meet the *Cpp17InputIterator*
   requirements and refer to elements implicitly convertible to
   `value_type`,
+- \[`i`, `j`) denotes a valid range,
 - `rg` denotes a value of a type `R` that models
   `container-compatible-range<T>`,
 - `il` designates an object of type `initializer_list<value_type>`,
 - `n` denotes a value of type `X::size_type`,
 - `p` denotes a valid constant iterator to `a`,
 - `q` denotes a valid dereferenceable constant iterator to `a`,
+- \[`q1`, `q2`) denotes a valid range of constant iterators in `a`,
 - `t` denotes an lvalue or a const rvalue of `X::value_type`, and
 - `rv` denotes a non-const rvalue of `X::value_type`.
 - `Args` denotes a template parameter pack;
 - `args` denotes a function parameter pack with the pattern `Args&&`.
 *Preconditions:* `T` is *Cpp17EmplaceConstructible* into `X` from `*i`.
 For `vector`, if the iterator does not meet the *Cpp17ForwardIterator*
 requirements [[forward.iterators]], `T` is also *Cpp17MoveInsertable*
 into `X`.
+*Effects:* Constructs a sequence container equal to the range \[`i`,
+`j`). Each iterator in the range \[`i`, `j`) is dereferenced exactly
+once.
 *Ensures:* `distance(u.begin(), u.end()) == distance(i, j)` is `true`.
 ``` cpp
 X(from_range, rg)
 ```
 *Preconditions:* `T` is *Cpp17EmplaceConstructible* into `X` from
+`*ranges::begin(rg)`. For `vector`, if `R` models
+`ranges::approximately_sized_range` but not `ranges::sized_range` or
+models `ranges::input_range` but not `ranges::forward_range`, `T` is
+also *Cpp17MoveInsertable* into `X`.
 *Effects:* Constructs a sequence container equal to the range `rg`. Each
 iterator in the range `rg` is dereferenced exactly once.
+*Recommended practice:* If `R` models
+`ranges::approximately_sized_range` and
+`ranges::distance(rg) <= ranges::reserve_hint(rg)` is `true`, an
+implementation should not perform more than a single reallocation.
 *Ensures:* `distance(begin(), end()) == ranges::distance(rg)` is `true`.
 ``` cpp
 X(il)
 ```
 ```
 *Result:* `iterator`.
 *Preconditions:* `T` is *Cpp17EmplaceConstructible* into `X` from
+`args`. For `vector`, `inplace_vector`, and `deque`, `T` is also
+*Cpp17MoveInsertable* into `X` and *Cpp17MoveAssignable*.
 *Effects:* Inserts an object of type `T` constructed with
 `std::forward<Args>(args)...` before `p`.
 [*Note 1*: `args` can directly or indirectly refer to a value in
 `a`. — *end note*]
+*Returns:* An iterator that points to the new element.
 ``` cpp
 a.insert(p, t)
 ```
 *Result:* `iterator`.
+*Preconditions:* `T` is *Cpp17CopyInsertable* into `X`. For `vector`,
+`inplace_vector`, and `deque`, `T` is also *Cpp17CopyAssignable*.
 *Effects:* Inserts a copy of `t` before `p`.
 *Returns:* An iterator that points to the copy of `t` inserted into `a`.
 a.insert(p, rv)
 ```
 *Result:* `iterator`.
+*Preconditions:* `T` is *Cpp17MoveInsertable* into `X`. For `vector`,
+`inplace_vector`, and `deque`, `T` is also *Cpp17MoveAssignable*.
 *Effects:* Inserts a copy of `rv` before `p`.
 *Returns:* An iterator that points to the copy of `rv` inserted into
 `a`.
 ```
 *Result:* `iterator`.
 *Preconditions:* `T` is *Cpp17EmplaceConstructible* into `X` from `*i`.
+For `vector`, `inplace_vector`, and `deque`, `T` is also
+*Cpp17MoveInsertable* into `X`, and `T` meets the
+*Cpp17MoveConstructible*, *Cpp17MoveAssignable*, and
 *Cpp17Swappable*[[swappable.requirements]] requirements. Neither `i` nor
 `j` are iterators into `a`.
+*Effects:* Inserts copies of elements in \[`i`, `j`) before `p`. Each
 iterator in the range \[`i`, `j`) shall be dereferenced exactly once.
 *Returns:* An iterator that points to the copy of the first element
 inserted into `a`, or `p` if `i == j`.
 ```
 *Result:* `iterator`.
 *Preconditions:* `T` is *Cpp17EmplaceConstructible* into `X` from
+`*ranges::begin(rg)`. For `vector`, `inplace_vector`, and `deque`, `T`
+is also *Cpp17MoveInsertable* into `X`, and `T` meets the
 *Cpp17MoveConstructible*, *Cpp17MoveAssignable*, and
 *Cpp17Swappable*[[swappable.requirements]] requirements. `rg` and `a` do
 not overlap.
 *Effects:* Inserts copies of elements in `rg` before `p`. Each iterator
 a.erase(q)
 ```
 *Result:* `iterator`.
+*Preconditions:* For `vector`, `inplace_vector`, and `deque`, `T` is
+*Cpp17MoveAssignable*.
 *Effects:* Erases the element pointed to by `q`.
 *Returns:* An iterator that points to the element immediately following
 `q` prior to the element being erased. If no such element exists,
 a.erase(q1, q2)
 ```
 *Result:* `iterator`.
+*Preconditions:* For `vector`, `inplace_vector`, and `deque`, `T` is
+*Cpp17MoveAssignable*.
+*Effects:* Erases the elements in the range \[`q1`, `q2`).
 *Returns:* An iterator that points to the element pointed to by `q2`
 prior to any elements being erased. If no such element exists, `a.end()`
 is returned.
 and assignable from `*i`. For `vector`, if the iterator does not meet
 the forward iterator requirements [[forward.iterators]], `T` is also
 *Cpp17MoveInsertable* into `X`. Neither `i` nor `j` are iterators into
 `a`.
+*Effects:* Replaces elements in `a` with a copy of \[`i`, `j`).
+Invalidates all references, pointers and iterators referring to the
+elements of `a`. For `vector` and `deque`, also invalidates the
+past-the-end iterator. Each iterator in the range \[`i`, `j`) is
+dereferenced exactly once.
 ``` cpp
 a.assign_range(rg)
 ```
 *Mandates:* `assignable_from<T&, ranges::range_reference_t<R>>` is
 modeled.
 *Preconditions:* `T` is *Cpp17EmplaceConstructible* into `X` from
+`*ranges::begin(rg)`. For `vector`, if `R` models
+`ranges::approximately_sized_range` but not `ranges::sized_range` or
+models `ranges::input_range` but not `ranges::forward_range`, `T` is
+also *Cpp17MoveInsertable* into `X`. `rg` and `a` do not overlap.
 *Effects:* Replaces elements in `a` with a copy of each element in `rg`.
 Invalidates all references, pointers, and iterators referring to the
 elements of `a`. For `vector` and `deque`, also invalidates the
 past-the-end iterator. Each iterator in the range `rg` is dereferenced
 exactly once.
+*Recommended practice:* If `R` models
+`ranges::approximately_sized_range` and
+`ranges::distance(rg) <= ranges::reserve_hint(rg)` is `true`, an
+implementation should not perform any reallocation.
 ``` cpp
 a.assign(il)
 ```
 *Effects:* Equivalent to `a.assign(il.begin(), il.end())`.
 a.front()
 ```
 *Result:* `reference; const_reference` for constant `a`.
+`a.empty()` is `false`.
 *Returns:* `*a.begin()`
 *Remarks:* Required for `basic_string`, `array`, `deque`,
+`forward_list`, `inplace_vector`, `list`, and `vector`.
 ``` cpp
 a.back()
 ```
 *Result:* `reference; const_reference` for constant `a`.
+`a.empty()` is `false`.
 *Effects:* Equivalent to:
 ``` cpp
 auto tmp = a.end();
 --tmp;
 return *tmp;
 ```
+*Remarks:* Required for `basic_string`, `array`, `deque`,
+`inplace_vector`, `list`, and `vector`.
 ``` cpp
 a.emplace_front(args)
 ```
 *Effects:* Appends an object of type `T` constructed with
 `std::forward<Args>(args)...`.
 *Returns:* `a.back()`.
+*Remarks:* Required for `deque`, `inplace_vector`, `list`, and `vector`.
 ``` cpp
 a.push_front(t)
 ```
 *Preconditions:* `T` is *Cpp17CopyInsertable* into `X`.
 *Effects:* Appends a copy of `t`.
+*Remarks:* Required for `basic_string`, `deque`, `inplace_vector`,
+`list`, and `vector`.
 ``` cpp
 a.push_back(rv)
 ```
 *Preconditions:* `T` is *Cpp17MoveInsertable* into `X`.
 *Effects:* Appends a copy of `rv`.
+*Remarks:* Required for `basic_string`, `deque`, `inplace_vector`,
+`list`, and `vector`.
 ``` cpp
 a.append_range(rg)
 ```
 into `X`.
 *Effects:* Inserts copies of elements in `rg` before `end()`. Each
 iterator in the range `rg` is dereferenced exactly once.
+*Remarks:* Required for `deque`, `inplace_vector`, `list`, and `vector`.
 ``` cpp
 a.pop_front()
 ```
 *Result:* `void`
+`a.empty()` is `false`.
 *Effects:* Destroys the first element.
 *Remarks:* Required for `deque`, `forward_list`, and `list`.
 a.pop_back()
 ```
 *Result:* `void`
+`a.empty()` is `false`.
 *Effects:* Destroys the last element.
+*Remarks:* Required for `basic_string`, `deque`, `inplace_vector`,
+`list`, and `vector`.
 ``` cpp
 a[n]
 ```
+*Result:* `reference; const_reference` for constant `a`.
+`n < a.size()` is `true`.
+*Effects:* Equivalent to: `return *(a.begin() + n);`
+*Remarks:* Required for `basic_string`, `array`, `deque`,
+`inplace_vector`, and `vector`.
 ``` cpp
 a.at(n)
 ```
+*Result:* `reference; const_reference` for constant `a`.
 *Returns:* `*(a.begin() + n)`
 *Throws:* `out_of_range` if `n >= a.size()`.
+*Remarks:* Required for `basic_string`, `array`, `deque`,
+`inplace_vector`, and `vector`.
 ### Node handles <a id="container.node">[[container.node]]</a>
 #### Overview <a id="container.node.overview">[[container.node.overview]]</a>
   using key_type       = see below;     // not present for set containers
   using mapped_type    = see below;     // not present for set containers
   using allocator_type = see below;
 private:
+  using container-node-type = unspecified;                  // exposition only
+  using ator-traits = allocator_traits<allocator_type>;     // exposition only
+  typename ator-traits::template
+    rebind_traits<container-node-type>::pointer ptr_;       // exposition only
   optional<allocator_type> alloc_;                          // exposition only
 public:
   // [container.node.cons], constructors, copy, and assignment
   constexpr node-handle() noexcept : ptr_(), alloc_() {}
+ constexpr node-handle(node-handle&&) noexcept;
+ constexpr node-handle& operator=(node-handle&&);
   // [container.node.dtor], destructor
+ constexpr ~node-handle();
   // [container.node.observers], observers
+ constexpr value_type& value() const; // not present for map containers
   key_type& key() const;                        // not present for set containers
+ constexpr mapped_type& mapped() const; // not present for set containers
+ constexpr allocator_type get_allocator() const;
+ constexpr explicit operator bool() const noexcept;
+ constexpr bool empty() const noexcept;
   // [container.node.modifiers], modifiers
+ constexpr void swap(node-handle&)
+    noexcept(ator-traits::propagate_on_container_swap::value ||
+ ator-traits::is_always_equal::value);
+  friend constexpr void swap(node-handle& x, node-handle& y) noexcept(noexcept(x.swap(y))) {
     x.swap(y);
   }
 };
 ```
 #### Constructors, copy, and assignment <a id="container.node.cons">[[container.node.cons]]</a>
 ``` cpp
+constexpr node-handle(node-handle&& nh) noexcept;
 ```
+*Effects:* Constructs a *node-handle* object initializing *ptr\_* with
+`nh.`*`ptr_`*. Move constructs *alloc\_* with `nh.`*`alloc_`*. Assigns
+`nullptr` to `nh.`*`ptr_`* and assigns `nullopt` to `nh.`*`alloc_`*.
 ``` cpp
+constexpr node-handle& operator=(node-handle&& nh);
 ```
+*Preconditions:* Either `!`*`alloc_`* is `true`, or
+*`ator-traits`*`::propagate_on_container_move_assignment::value` is
+`true`, or *`alloc_`*` == nh.`*`alloc_`* is `true`.
 *Effects:*
+- If *`ptr_`*` != nullptr` is `true`, destroys the `value_type`
+ subobject in the *container-node-type* object pointed to by *ptr\_* by
+ calling *`ator-traits`*`::destroy`, then deallocates *ptr\_* by
+ calling
+  *`ator-traits`*`::template rebind_traits<`*`container-node-type`*`>::deallocate`.
+- Assigns `nh.`*`ptr_`* to *ptr\_*.
+- If `!`*`alloc_`* is `true` or
+ *`ator-traits`*`::propagate_on_container_move_assignment::value` is
+ `true`, move assigns `nh.`*`alloc_`* to *alloc\_*.
+- Assigns `nullptr` to `nh.`*`ptr_`* and assigns `nullopt` to
+  `nh.`*`alloc_`*.
 *Returns:* `*this`.
 *Throws:* Nothing.
 #### Destructor <a id="container.node.dtor">[[container.node.dtor]]</a>
 ``` cpp
+constexpr ~node-handle();
 ```
+*Effects:* If *`ptr_`*` != nullptr` is `true`, destroys the `value_type`
+subobject in the *container-node-type* object pointed to by *ptr\_* by
+calling *`ator-traits`*`::destroy`, then deallocates *ptr\_* by calling
+*`ator-traits`*`::template rebind_traits<`*`container-node-type`*`>::deallocate`.
 #### Observers <a id="container.node.observers">[[container.node.observers]]</a>
 ``` cpp
+constexpr value_type& value() const;
 ```
 *Preconditions:* `empty() == false`.
 *Returns:* A reference to the `value_type` subobject in the
+*container-node-type* object pointed to by *ptr\_*.
 *Throws:* Nothing.
 ``` cpp
 key_type& key() const;
 ```
 *Preconditions:* `empty() == false`.
 *Returns:* A non-const reference to the `key_type` member of the
+`value_type` subobject in the *container-node-type* object pointed to by
+*ptr\_*.
 *Throws:* Nothing.
 *Remarks:* Modifying the key through the returned reference is
 permitted.
 ``` cpp
+constexpr mapped_type& mapped() const;
 ```
 *Preconditions:* `empty() == false`.
 *Returns:* A reference to the `mapped_type` member of the `value_type`
+subobject in the *container-node-type* object pointed to by *ptr\_*.
 *Throws:* Nothing.
 ``` cpp
+constexpr allocator_type get_allocator() const;
 ```
 *Preconditions:* `empty() == false`.
+*Returns:* `*`*`alloc_`*.
 *Throws:* Nothing.
 ``` cpp
+constexpr explicit operator bool() const noexcept;
 ```
+*Returns:* *`ptr_`*` != nullptr`.
 ``` cpp
+constexpr bool empty() const noexcept;
 ```
+*Returns:* *`ptr_`*` == nullptr`.
 #### Modifiers <a id="container.node.modifiers">[[container.node.modifiers]]</a>
 ``` cpp
+constexpr void swap(node-handle& nh)
+  noexcept(ator-traits::propagate_on_container_swap::value ||
+ ator-traits::is_always_equal::value);
 ```
+*Preconditions:* `!`*`alloc_`* is `true`, or `!nh.`*`alloc_`*, or
+*`ator-traits`*`::propagate_on_container_swap::value` is `true`, or
+*`alloc_`*` == nh.`*`alloc_`* is `true`.
+*Effects:* Calls `swap(`*`ptr_`*`, nh.`*`ptr_`*`)`. If `!`*`alloc_`* is
+`true`, or `!nh.`*`alloc_`* is `true`, or
+*`ator-traits`*`::propagate_on_container_swap::value` is `true` calls
+`swap(`*`alloc_`*`, nh.`*`alloc_`*`)`.
 ### Insert return type <a id="container.insert.return">[[container.insert.return]]</a>
 The associative containers with unique keys and the unordered containers
 with unique keys have a member function `insert` that returns a nested
   bool     inserted;
   NodeType node;
 };
 ```
+The name *`insert-return-type`* is for exposition only.
 *`insert-return-type`* has the template parameters, data members, and
 special members specified above. It has no base classes or members other
 than those specified.
 ### Associative containers <a id="associative.reqmts">[[associative.reqmts]]</a>
 - `X` denotes an associative container class,
 - `a` denotes a value of type `X`,
 - `a2` denotes a value of a type with nodes compatible with type `X` (
   [[container.node.compat]]),
+- `b` denotes a value of type `X` or `const X`,
 - `u` denotes the name of a variable being declared,
 - `a_uniq` denotes a value of type `X` when `X` supports unique keys,
+- `a_eq` denotes a value of type `X` when `X` supports equivalent keys,
 - `a_tran` denotes a value of type `X` or `const X` when the
   *qualified-id* `X::key_compare::is_transparent` is valid and denotes a
   type [[temp.deduct]],
 - `i` and `j` meet the *Cpp17InputIterator* requirements and refer to
   elements implicitly convertible to `value_type`,
 - `rg` denotes a value of a type `R` that models
   `container-compatible-range<value_type>`,
 - `p` denotes a valid constant iterator to `a`,
 - `q` denotes a valid dereferenceable constant iterator to `a`,
 - `r` denotes a valid dereferenceable iterator to `a`,
+- \[`q1`, `q2`) denotes a valid range of constant iterators in `a`,
 - `il` designates an object of type `initializer_list<value_type>`,
 - `t` denotes a value of type `X::value_type`,
 - `k` denotes a value of type `X::key_type`, and
 - `c` denotes a value of type `X::key_compare` or
   `const X::key_compare`;
 - `m` denotes an allocator of a type convertible to `A`, and `nh`
   denotes a non-const rvalue of type `X::node_type`.
 A type `X` meets the *associative container* requirements if `X` meets
 all the requirements of an allocator-aware container
+[[container.alloc.reqmts]] and the following types, statements, and
+expressions are well-formed and have the specified semantics, except
 that for `map` and `multimap`, the requirements placed on `value_type`
+in [[container.reqmts]] apply instead to `key_type` and `mapped_type`.
+[*Note 3*: For example, in some cases `key_type` and `mapped_type` need
+to be *Cpp17CopyAssignable* even though the associated `value_type`,
+`pair<const key_type, mapped_type>`, is not
 *Cpp17CopyAssignable*. — *end note*]
 ``` cpp
 typename X::key_type
 ```
 *Effects:* Equivalent to `a.emplace(std::forward<Args>(args)...)`,
 except that the element is inserted as close as possible to the position
 just prior to `p`.
+*Returns:* The iterator returned by `emplace`.
 *Complexity:* Logarithmic in general, but amortized constant if the
 element is inserted right before `p`.
 ``` cpp
 a.merge(a2)
 ```
 *Result:* `void`
+*Preconditions:* `a.get_allocator() == a2.get_allocator()` is `true`.
 *Effects:* Attempts to extract each element in `a2` and insert it into
 `a` using the comparison object of `a`. In containers with unique keys,
 if there is an element in `a` with key equivalent to the key of an
 element from `a2`, then that element is not extracted from `a2`.
 *Ensures:* Pointers and references to the transferred elements of `a2`
+refer to those same elements but as members of `a`. If `a.begin()` and
+`a2.begin()` have the same type, iterators referring to the transferred
+elements will continue to refer to their elements, but they now behave
+as iterators into `a`, not into `a2`.
 *Throws:* Nothing unless the comparison object throws.
 *Complexity:* N log(`a.size()+` N), where N has the value `a2.size()`.
 *Result:* `iterator`; `const_iterator` for constant `b`.
 *Returns:* An iterator pointing to the first element with key greater
 than `k`, or `b.end()` if such an element is not found.
+*Complexity:* Logarithmic.
 ``` cpp
 a_tran.upper_bound(ku)
 ```
 - `a_tran` denotes a value of type `X` or `const X` when the
   *qualified-id*s `X::key_equal::is_transparent` and
   `X::hasher::is_transparent` are both valid and denote types
   [[temp.deduct]],
 - `i` and `j` denote input iterators that refer to `value_type`,
+- \[`i`, `j`) denotes a valid range,
 - `rg` denotes a value of a type `R` that models
   `container-compatible-range<value_type>`,
 - `p` and `q2` denote valid constant iterators to `a`,
 - `q` and `q1` denote valid dereferenceable constant iterators to `a`,
 - `r` denotes a valid dereferenceable iterator to `a`,
+- \[`q1`, `q2`) denotes a valid range in `a`,
 - `il` denotes a value of type `initializer_list<value_type>`,
 - `t` denotes a value of type `X::value_type`,
 - `k` denotes a value of type `key_type`,
 - `hf` denotes a value of type `hasher` or `const hasher`,
 - `eq` denotes a value of type `key_equal` or `const key_equal`,
 - `z` denotes a value of type `float`, and
 - `nh` denotes an rvalue of type `X::node_type`.
 A type `X` meets the *unordered associative container* requirements if
 `X` meets all the requirements of an allocator-aware container
+[[container.alloc.reqmts]] and the following types, statements, and
+expressions are well-formed and have the specified semantics, except
 that for `unordered_map` and `unordered_multimap`, the requirements
+placed on `value_type` in [[container.reqmts]] apply instead to
 `key_type` and `mapped_type`.
+[*Note 3*: For example, `key_type` and `mapped_type` sometimes need to
+be *Cpp17CopyAssignable* even though the associated `value_type`,
+`pair<const key_type, mapped_type>`, is not
 *Cpp17CopyAssignable*. — *end note*]
 ``` cpp
 typename X::key_type
 ```
 ``` cpp
 X(b)
 ```
 *Effects:* In addition to the container
+requirements [[container.reqmts]], copies the hash function, predicate,
+and maximum load factor.
 *Complexity:* Average case linear in `b.size()`, worst case quadratic.
 ``` cpp
 a = b
 a.emplace_hint(p, args)
 ```
 *Result:* `iterator`
+*Effects:* Equivalent to `a.emplace(std::forward<Args>(args)...)`,
+except that the `const_iterator` `p` is a hint pointing to where the
+search should start. Implementations are permitted to ignore the hint.
+*Returns:* The iterator returned by `emplace`.
 ``` cpp
 a_uniq.insert(t)
 ```
 *Result:* `void`
 *Preconditions:* `value_type` is *Cpp17EmplaceConstructible* into `X`
 from `*i`. Neither `i` nor `j` are iterators into `a`.
+*Effects:* Equivalent to `a.insert(t)` for each element in \[`i`, `j`).
 *Complexity:* Average case 𝑂(N), where N is `distance(i, j)`, worst case
 𝑂(N(`a.size()` + 1)).
 ``` cpp
 a.erase(q1, q2)
 ```
 *Result:* `iterator`
+*Effects:* Erases all elements in the range \[`q1`, `q2`).
 *Returns:* The iterator immediately following the erased elements prior
 to the erasure.
 *Complexity:* Average case linear in `distance(q1, q2)`, worst case
 *Preconditions:* `b.bucket_count() > 0`.
 *Returns:* The index of the bucket in which elements with keys
 equivalent to `k` would be found, if any such element existed. The
+return value is in the range \[`0`, `b.bucket_count()`).
+*Complexity:* Constant.
+``` cpp
+a_tran.bucket(ke)
+```
+*Result:* `size_type`
+*Preconditions:* `a_tran.bucket_count() > 0`.
+*Ensures:* The return value is in the range \[`0`,
+`a_tran.bucket_count()`).
+*Returns:* The index of the bucket in which elements with keys
+equivalent to `ke` would be found, if any such element existed.
 *Complexity:* Constant.
 ``` cpp
 b.bucket_size(n)
 ```
 *Result:* `size_type`
+*Preconditions:* `n` shall be in the range \[`0`, `b.bucket_count()`).
 *Returns:* The number of elements in the `n`ᵗʰ bucket.
 *Complexity:* 𝑂(`b.bucket_size(n)`)
 b.begin(n)
 ```
 *Result:* `local_iterator`; `const_local_iterator` for constant `b`.
+*Preconditions:* `n` is in the range \[`0`, `b.bucket_count()`).
 *Returns:* An iterator referring to the first element in the bucket. If
 the bucket is empty, then `b.begin(n) == b.end(n)`.
 *Complexity:* Constant.
 b.end(n)
 ```
 *Result:* `local_iterator`; `const_local_iterator` for constant `b`.
+*Preconditions:* `n` is in the range \[`0`, `b.bucket_count()`).
 *Returns:* An iterator which is the past-the-end value for the bucket.
 *Complexity:* Constant.
 b.cbegin(n)
 ```
 *Result:* `const_local_iterator`
+*Preconditions:* `n` shall be in the range \[`0`, `b.bucket_count()`).
 *Returns:* An iterator referring to the first element in the bucket. If
 the bucket is empty, then `b.cbegin(n) == b.cend(n)`.
 *Complexity:* Constant.
 b.cend(n)
 ```
 *Result:* `const_local_iterator`
+*Preconditions:* `n` is in the range \[`0`, `b.bucket_count()`).
 *Returns:* An iterator which is the past-the-end value for the bucket.
 *Complexity:* Constant.
 element is owned by a `node_type` is undefined behavior. References and
 pointers to an element obtained while it is owned by a `node_type` are
 invalidated if the element is successfully inserted.
 The member function templates `find`, `count`, `equal_range`,
+`contains`, `extract`, `erase`, and `bucket` shall not participate in
+overload resolution unless the *qualified-id*s `Pred::is_transparent`
+and `Hash::is_transparent` are both valid and denote types
+[[temp.deduct]]. Additionally, the member function templates `extract`
+and `erase` shall not participate in overload resolution if
 `is_convertible_v<K&&, iterator> || is_convertible_v<K&&, const_iterator>`
 is `true`, where `K` is the type substituted as the first template
 argument.
 A deduction guide for an unordered associative container shall not
 within a `rehash()` function other than by the container’s hash function
 or comparison function, the `rehash()` function has no effect.
 ## Sequence containers <a id="sequences">[[sequences]]</a>
+### General <a id="sequences.general">[[sequences.general]]</a>
+The headers `<array>`, `<deque>`, `<forward_list>`, `<hive>`,
+`<inplace_vector>`, `<list>`, and `<vector>` define class templates that
+meet the requirements for sequence containers.
 The following exposition-only alias template may appear in deduction
 guides for sequence containers:
 ``` cpp
 template<class InputIterator>
+  using iter-value-type = iterator_traits<InputIterator>::value_type;  // exposition only
 ```
 ### Header `<array>` synopsis <a id="array.syn">[[array.syn]]</a>
 ``` cpp
+// mostly freestanding
 #include <compare>              // see [compare.syn]
 #include <initializer_list>     // see [initializer.list.syn]
 namespace std {
   // [array], class template array
+  template<class T, size_t N> struct array;                             // partially freestanding
   template<class T, size_t N>
     constexpr bool operator==(const array<T, N>& x, const array<T, N>& y);
   template<class T, size_t N>
     constexpr synth-three-way-result<T>
   template<size_t I, class T, size_t N>
     constexpr const T&& get(const array<T, N>&&) noexcept;
 }
 ```
 ### Class template `array` <a id="array">[[array]]</a>
 #### Overview <a id="array.overview">[[array.overview]]</a>
 The header `<array>` defines a class template for storing fixed-size
 requirements of a sequence container [[sequence.reqmts]]. Descriptions
 are provided here only for operations on `array` that are not described
 in one of these tables and for operations where there is additional
 semantic information.
+`array<T, N>` is a structural type [[term.structural.type]] if `T` is a
+structural type. Two values `a1` and `a2` of type `array<T, N>` are
 template-argument-equivalent [[temp.type]] if and only if each pair of
 corresponding elements in `a1` and `a2` are
 template-argument-equivalent.
 The types `iterator` and `const_iterator` meet the constexpr iterator
     constexpr const_iterator         cend() const noexcept;
     constexpr const_reverse_iterator crbegin() const noexcept;
     constexpr const_reverse_iterator crend() const noexcept;
     // capacity
+    constexpr bool empty() const noexcept;
     constexpr size_type size() const noexcept;
     constexpr size_type max_size() const noexcept;
     // element access
     constexpr reference       operator[](size_type n);
     constexpr const_reference operator[](size_type n) const;
+    constexpr reference       at(size_type n);                          // freestanding-deleted
+    constexpr const_reference at(size_type n) const;                    // freestanding-deleted
     constexpr reference       front();
     constexpr const_reference front() const;
     constexpr reference       back();
     constexpr const_reference back() const;
 }
 ```
 #### Constructors, copy, and assignment <a id="array.cons">[[array.cons]]</a>
+An `array` relies on the implicitly-declared special member functions
 [[class.default.ctor]], [[class.dtor]], [[class.copy.ctor]] to conform
 to the container requirements table in  [[container.requirements]]. In
 addition to the requirements specified in the container requirements
+table, the implicitly-declared move constructor and move assignment
+operator for `array` require that `T` be *Cpp17MoveConstructible* or
 *Cpp17MoveAssignable*, respectively.
 ``` cpp
 template<class T, class... U>
   array(T, U...) -> array<T, 1 + sizeof...(U)>;
 constexpr T* data() noexcept;
 constexpr const T* data() const noexcept;
 ```
 *Returns:* A pointer such that \[`data()`, `data() + size()`) is a valid
+range. For a non-empty array, `data() == addressof(front())` is `true`.
 ``` cpp
 constexpr void fill(const T& u);
 ```
 ``` cpp
 template<class T, size_t N>
   constexpr array<remove_cv_t<T>, N> to_array(T (&a)[N]);
 ```
+*Mandates:* `is_array_v<T>` is `false` and
+`is_constructible_v<remove_cv_t<T>, T&>` is `true`.
 *Preconditions:* `T` meets the *Cpp17CopyConstructible* requirements.
 *Returns:* `{{ a[0], `…`, a[N - 1] }}`.
 ``` cpp
 template<class T, size_t N>
   constexpr array<remove_cv_t<T>, N> to_array(T (&&a)[N]);
 ```
+*Mandates:* `is_array_v<T>` is `false` and
+`is_constructible_v<remove_cv_t<T>, T>` is `true`.
 *Preconditions:* `T` meets the *Cpp17MoveConstructible* requirements.
 *Returns:* `{{ std::move(a[0]), `…`, std::move(a[N - 1]) }}`.
 *Mandates:* `I < N` is `true`.
 *Returns:* A reference to the `I`ᵗʰ element of `a`, where indexing is
 zero-based.
+### Header `<deque>` synopsis <a id="deque.syn">[[deque.syn]]</a>
+``` cpp
+#include <compare>              // see [compare.syn]
+#include <initializer_list>     // see [initializer.list.syn]
+namespace std {
+  // [deque], class template deque
+  template<class T, class Allocator = allocator<T>> class deque;
+  template<class T, class Allocator>
+    constexpr bool operator==(const deque<T, Allocator>& x, const deque<T, Allocator>& y);
+  template<class T, class Allocator>
+    constexpr synth-three-way-result<T>
+      operator<=>(const deque<T, Allocator>& x, const deque<T, Allocator>& y);
+  template<class T, class Allocator>
+    constexpr void swap(deque<T, Allocator>& x, deque<T, Allocator>& y)
+      noexcept(noexcept(x.swap(y)));
+  // [deque.erasure], erasure
+  template<class T, class Allocator, class U = T>
+    constexpr typename deque<T, Allocator>::size_type
+      erase(deque<T, Allocator>& c, const U& value);
+  template<class T, class Allocator, class Predicate>
+    constexpr typename deque<T, Allocator>::size_type
+      erase_if(deque<T, Allocator>& c, Predicate pred);
+  namespace pmr {
+    template<class T>
+      using deque = std::deque<T, polymorphic_allocator<T>>;
+  }
+}
+```
 ### Class template `deque` <a id="deque">[[deque]]</a>
 #### Overview <a id="deque.overview">[[deque.overview]]</a>
 A `deque` is a sequence container that supports random access iterators
 optional sequence container requirements [[sequence.reqmts]].
 Descriptions are provided here only for operations on `deque` that are
 not described in one of these tables or for operations where there is
 additional semantic information.
+The types `iterator` and `const_iterator` meet the constexpr iterator
+requirements [[iterator.requirements.general]].
 ``` cpp
 namespace std {
   template<class T, class Allocator = allocator<T>>
   class deque {
   public:
     // types
     using value_type             = T;
     using allocator_type         = Allocator;
+    using pointer                = allocator_traits<Allocator>::pointer;
+    using const_pointer          = allocator_traits<Allocator>::const_pointer;
     using reference              = value_type&;
     using const_reference        = const value_type&;
     using size_type              = implementation-defined  // type of deque::size_type; // see [container.requirements]
     using difference_type        = implementation-defined  // type of deque::difference_type; // see [container.requirements]
     using iterator               = implementation-defined  // type of deque::iterator; // see [container.requirements]
     using const_iterator         = implementation-defined  // type of deque::const_iterator; // see [container.requirements]
     using reverse_iterator       = std::reverse_iterator<iterator>;
     using const_reverse_iterator = std::reverse_iterator<const_iterator>;
     // [deque.cons], construct/copy/destroy
+ constexpr deque() : deque(Allocator()) { }
+ constexpr explicit deque(const Allocator&);
+ constexpr explicit deque(size_type n, const Allocator& = Allocator());
+ constexpr deque(size_type n, const T& value, const Allocator& = Allocator());
     template<class InputIterator>
+ constexpr deque(InputIterator first, InputIterator last, const Allocator& = Allocator());
     template<container-compatible-range<T> R>
+ constexpr deque(from_range_t, R&& rg, const Allocator& = Allocator());
+ constexpr deque(const deque& x);
+ constexpr deque(deque&&);
+ constexpr deque(const deque&, const type_identity_t<Allocator>&);
+ constexpr deque(deque&&, const type_identity_t<Allocator>&);
+ constexpr deque(initializer_list<T>, const Allocator& = Allocator());
+ constexpr ~deque();
+ constexpr deque& operator=(const deque& x);
+ constexpr deque& operator=(deque&& x)
       noexcept(allocator_traits<Allocator>::is_always_equal::value);
+ constexpr deque& operator=(initializer_list<T>);
     template<class InputIterator>
+ constexpr void assign(InputIterator first, InputIterator last);
     template<container-compatible-range<T> R>
+ constexpr void assign_range(R&& rg);
+ constexpr void assign(size_type n, const T& t);
+ constexpr void assign(initializer_list<T>);
+ constexpr allocator_type get_allocator() const noexcept;
     // iterators
+ constexpr iterator               begin() noexcept;
+ constexpr const_iterator         begin() const noexcept;
+ constexpr iterator               end() noexcept;
+ constexpr const_iterator         end() const noexcept;
+ constexpr reverse_iterator       rbegin() noexcept;
+ constexpr const_reverse_iterator rbegin() const noexcept;
+ constexpr reverse_iterator       rend() noexcept;
+ constexpr const_reverse_iterator rend() const noexcept;
+ constexpr const_iterator         cbegin() const noexcept;
+ constexpr const_iterator         cend() const noexcept;
+ constexpr const_reverse_iterator crbegin() const noexcept;
+ constexpr const_reverse_iterator crend() const noexcept;
     // [deque.capacity], capacity
+ constexpr bool empty() const noexcept;
+ constexpr size_type size() const noexcept;
+ constexpr size_type max_size() const noexcept;
+ constexpr void      resize(size_type sz);
+ constexpr void      resize(size_type sz, const T& c);
+ constexpr void      shrink_to_fit();
     // element access
+ constexpr reference       operator[](size_type n);
+ constexpr const_reference operator[](size_type n) const;
+ constexpr reference       at(size_type n);
+ constexpr const_reference at(size_type n) const;
+ constexpr reference       front();
+ constexpr const_reference front() const;
+ constexpr reference       back();
+ constexpr const_reference back() const;
     // [deque.modifiers], modifiers
+    template<class... Args> constexpr reference emplace_front(Args&&... args);
+    template<class... Args> constexpr reference emplace_back(Args&&... args);
+    template<class... Args> constexpr iterator emplace(const_iterator position, Args&&... args);
+ constexpr void push_front(const T& x);
+ constexpr void push_front(T&& x);
     template<container-compatible-range<T> R>
+ constexpr void prepend_range(R&& rg);
+ constexpr void push_back(const T& x);
+ constexpr void push_back(T&& x);
     template<container-compatible-range<T> R>
+ constexpr void append_range(R&& rg);
+ constexpr iterator insert(const_iterator position, const T& x);
+ constexpr iterator insert(const_iterator position, T&& x);
+ constexpr iterator insert(const_iterator position, size_type n, const T& x);
     template<class InputIterator>
+ constexpr iterator insert(const_iterator position,
+                                InputIterator first, InputIterator last);
     template<container-compatible-range<T> R>
+ constexpr iterator insert_range(const_iterator position, R&& rg);
+ constexpr iterator insert(const_iterator position, initializer_list<T>);
+ constexpr void pop_front();
+ constexpr void pop_back();
+ constexpr iterator erase(const_iterator position);
+ constexpr iterator erase(const_iterator first, const_iterator last);
+ constexpr void     swap(deque&)
       noexcept(allocator_traits<Allocator>::is_always_equal::value);
+ constexpr void     clear() noexcept;
   };
   template<class InputIterator, class Allocator = allocator<iter-value-type<InputIterator>>>
     deque(InputIterator, InputIterator, Allocator = Allocator())
       -> deque<iter-value-type<InputIterator>, Allocator>;
 ```
 #### Constructors, copy, and assignment <a id="deque.cons">[[deque.cons]]</a>
 ``` cpp
+constexpr explicit deque(const Allocator&);
 ```
 *Effects:* Constructs an empty `deque`, using the specified allocator.
 *Complexity:* Constant.
 ``` cpp
+constexpr explicit deque(size_type n, const Allocator& = Allocator());
 ```
+*Preconditions:* `T` is *Cpp17DefaultInsertable* into `deque`.
 *Effects:* Constructs a `deque` with `n` default-inserted elements using
 the specified allocator.
 *Complexity:* Linear in `n`.
 ``` cpp
+constexpr deque(size_type n, const T& value, const Allocator& = Allocator());
 ```
+*Preconditions:* `T` is *Cpp17CopyInsertable* into `deque`.
 *Effects:* Constructs a `deque` with `n` copies of `value`, using the
 specified allocator.
 *Complexity:* Linear in `n`.
 ``` cpp
 template<class InputIterator>
+ constexpr deque(InputIterator first, InputIterator last, const Allocator& = Allocator());
 ```
 *Effects:* Constructs a `deque` equal to the range \[`first`, `last`),
 using the specified allocator.
 *Complexity:* Linear in `distance(first, last)`.
 ``` cpp
 template<container-compatible-range<T> R>
+ constexpr deque(from_range_t, R&& rg, const Allocator& = Allocator());
 ```
 *Effects:* Constructs a `deque` with the elements of the range `rg`,
 using the specified allocator.
 *Complexity:* Linear in `ranges::distance(rg)`.
 #### Capacity <a id="deque.capacity">[[deque.capacity]]</a>
 ``` cpp
+constexpr void resize(size_type sz);
 ```
 *Preconditions:* `T` is *Cpp17MoveInsertable* and
+*Cpp17DefaultInsertable* into `deque`.
 *Effects:* If `sz < size()`, erases the last `size() - sz` elements from
 the sequence. Otherwise, appends `sz - size()` default-inserted elements
 to the sequence.
 ``` cpp
+constexpr void resize(size_type sz, const T& c);
 ```
+*Preconditions:* `T` is *Cpp17CopyInsertable* into `deque`.
 *Effects:* If `sz < size()`, erases the last `size() - sz` elements from
 the sequence. Otherwise, appends `sz - size()` copies of `c` to the
 sequence.
 ``` cpp
+constexpr void shrink_to_fit();
 ```
+*Preconditions:* `T` is *Cpp17MoveInsertable* into `deque`.
 *Effects:* `shrink_to_fit` is a non-binding request to reduce memory use
 but does not change the size of the sequence.
 [*Note 1*: The request is non-binding to allow latitude for
 elements in the sequence, as well as the past-the-end iterator.
 #### Modifiers <a id="deque.modifiers">[[deque.modifiers]]</a>
 ``` cpp
+constexpr iterator insert(const_iterator position, const T& x);
+constexpr iterator insert(const_iterator position, T&& x);
+constexpr iterator insert(const_iterator position, size_type n, const T& x);
 template<class InputIterator>
+ constexpr iterator insert(const_iterator position,
                             InputIterator first, InputIterator last);
 template<container-compatible-range<T> R>
+ constexpr iterator insert_range(const_iterator position, R&& rg);
+constexpr iterator insert(const_iterator position, initializer_list<T>);
+template<class... Args> constexpr reference emplace_front(Args&&... args);
+template<class... Args> constexpr reference emplace_back(Args&&... args);
+template<class... Args> constexpr iterator emplace(const_iterator position, Args&&... args);
+constexpr void push_front(const T& x);
+constexpr void push_front(T&& x);
 template<container-compatible-range<T> R>
+ constexpr void prepend_range(R&& rg);
+constexpr void push_back(const T& x);
+constexpr void push_back(T&& x);
 template<container-compatible-range<T> R>
+ constexpr void append_range(R&& rg);
 ```
 *Effects:* An insertion in the middle of the deque invalidates all the
 iterators and references to elements of the deque. An insertion at
 either end of the deque invalidates all the iterators to the deque, but
 a deque always takes constant time and causes a single call to a
 constructor of `T`.
 *Remarks:* If an exception is thrown other than by the copy constructor,
 move constructor, assignment operator, or move assignment operator of
+`T`, there are no effects. If an exception is thrown while inserting a
 single element at either end, there are no effects. Otherwise, if an
 exception is thrown by the move constructor of a
 non-*Cpp17CopyInsertable* `T`, the effects are unspecified.
 ``` cpp
+constexpr iterator erase(const_iterator position);
+constexpr iterator erase(const_iterator first, const_iterator last);
+constexpr void pop_front();
+constexpr void pop_back();
 ```
 *Effects:* An erase operation that erases the last element of a deque
 invalidates only the past-the-end iterator and all iterators and
 references to the erased elements. An erase operation that erases the
 erased elements.
 #### Erasure <a id="deque.erasure">[[deque.erasure]]</a>
 ``` cpp
+template<class T, class Allocator, class U = T>
+ constexpr typename deque<T, Allocator>::size_type
     erase(deque<T, Allocator>& c, const U& value);
 ```
 *Effects:* Equivalent to:
 return r;
 ```
 ``` cpp
 template<class T, class Allocator, class Predicate>
+ constexpr typename deque<T, Allocator>::size_type
     erase_if(deque<T, Allocator>& c, Predicate pred);
 ```
 *Effects:* Equivalent to:
 auto r = distance(it, c.end());
 c.erase(it, c.end());
 return r;
 ```
+### Header `<forward_list>` synopsis <a id="forward.list.syn">[[forward.list.syn]]</a>
+``` cpp
+#include <compare>              // see [compare.syn]
+#include <initializer_list>     // see [initializer.list.syn]
+namespace std {
+  // [forward.list], class template forward_list
+  template<class T, class Allocator = allocator<T>> class forward_list;
+  template<class T, class Allocator>
+    constexpr bool operator==(const forward_list<T, Allocator>& x,
+                              const forward_list<T, Allocator>& y);
+  template<class T, class Allocator>
+    constexpr synth-three-way-result<T>
+      operator<=>(const forward_list<T, Allocator>& x,
+                  const forward_list<T, Allocator>& y);
+  template<class T, class Allocator>
+    constexpr void swap(forward_list<T, Allocator>& x, forward_list<T, Allocator>& y)
+      noexcept(noexcept(x.swap(y)));
+  // [forward.list.erasure], erasure
+  template<class T, class Allocator, class U = T>
+    constexpr typename forward_list<T, Allocator>::size_type
+      erase(forward_list<T, Allocator>& c, const U& value);
+  template<class T, class Allocator, class Predicate>
+    constexpr typename forward_list<T, Allocator>::size_type
+      erase_if(forward_list<T, Allocator>& c, Predicate pred);
+  namespace pmr {
+    template<class T>
+      using forward_list = std::forward_list<T, polymorphic_allocator<T>>;
+  }
+}
+```
 ### Class template `forward_list` <a id="forward.list">[[forward.list]]</a>
 #### Overview <a id="forward.list.overview">[[forward.list.overview]]</a>
 A `forward_list` is a container that supports forward iterators and
 overhead relative to a hand-written C-style singly linked list. Features
 that would conflict with that goal have been omitted. — *end note*]
 A `forward_list` meets all of the requirements of a container
 [[container.reqmts]], except that the `size()` member function is not
+provided and `operator==` has linear complexity. A `forward_list` also
 meets all of the requirements for an allocator-aware container
 [[container.alloc.reqmts]]. In addition, a `forward_list` provides the
 `assign` member functions and several of the optional sequence container
 requirements [[sequence.reqmts]]. Descriptions are provided here only
 for operations on `forward_list` that are not described in that table or
 the first element of interest, but in a `forward_list` there is no
 constant-time way to access a preceding element. For this reason,
 `erase_after` and `splice_after` take fully-open ranges, not semi-open
 ranges. — *end note*]
+The types `iterator` and `const_iterator` meet the constexpr iterator
+requirements [[iterator.requirements.general]].
 ``` cpp
 namespace std {
   template<class T, class Allocator = allocator<T>>
   class forward_list {
   public:
     // types
     using value_type      = T;
     using allocator_type  = Allocator;
+    using pointer         = allocator_traits<Allocator>::pointer;
+    using const_pointer   = allocator_traits<Allocator>::const_pointer;
     using reference       = value_type&;
     using const_reference = const value_type&;
     using size_type       = implementation-defined  // type of forward_list::size_type; // see [container.requirements]
     using difference_type = implementation-defined  // type of forward_list::difference_type; // see [container.requirements]
     using iterator        = implementation-defined  // type of forward_list::iterator; // see [container.requirements]
     using const_iterator  = implementation-defined  // type of forward_list::const_iterator; // see [container.requirements]
     // [forward.list.cons], construct/copy/destroy
+ constexpr forward_list() : forward_list(Allocator()) { }
+ constexpr explicit forward_list(const Allocator&);
+ constexpr explicit forward_list(size_type n, const Allocator& = Allocator());
+ constexpr forward_list(size_type n, const T& value, const Allocator& = Allocator());
     template<class InputIterator>
+ constexpr forward_list(InputIterator first, InputIterator last,
+                             const Allocator& = Allocator());
     template<container-compatible-range<T> R>
+ constexpr forward_list(from_range_t, R&& rg, const Allocator& = Allocator());
+ constexpr forward_list(const forward_list& x);
+ constexpr forward_list(forward_list&& x);
+ constexpr forward_list(const forward_list& x, const type_identity_t<Allocator>&);
+ constexpr forward_list(forward_list&& x, const type_identity_t<Allocator>&);
+ constexpr forward_list(initializer_list<T>, const Allocator& = Allocator());
+ constexpr ~forward_list();
+ constexpr forward_list& operator=(const forward_list& x);
+ constexpr forward_list& operator=(forward_list&& x)
       noexcept(allocator_traits<Allocator>::is_always_equal::value);
+ constexpr forward_list& operator=(initializer_list<T>);
     template<class InputIterator>
+ constexpr void assign(InputIterator first, InputIterator last);
     template<container-compatible-range<T> R>
+ constexpr void assign_range(R&& rg);
+ constexpr void assign(size_type n, const T& t);
+ constexpr void assign(initializer_list<T>);
+ constexpr allocator_type get_allocator() const noexcept;
     // [forward.list.iter], iterators
+ constexpr iterator before_begin() noexcept;
+ constexpr const_iterator before_begin() const noexcept;
+ constexpr iterator begin() noexcept;
+ constexpr const_iterator begin() const noexcept;
+ constexpr iterator end() noexcept;
+ constexpr const_iterator end() const noexcept;
+ constexpr const_iterator cbegin() const noexcept;
+ constexpr const_iterator cbefore_begin() const noexcept;
+ constexpr const_iterator cend() const noexcept;
     // capacity
+ constexpr bool empty() const noexcept;
+ constexpr size_type max_size() const noexcept;
     // [forward.list.access], element access
+ constexpr reference front();
+ constexpr const_reference front() const;
     // [forward.list.modifiers], modifiers
+    template<class... Args> constexpr reference emplace_front(Args&&... args);
+ constexpr void push_front(const T& x);
+ constexpr void push_front(T&& x);
     template<container-compatible-range<T> R>
+ constexpr void prepend_range(R&& rg);
+ constexpr void pop_front();
+    template<class... Args>
+      constexpr iterator emplace_after(const_iterator position, Args&&... args);
+ constexpr iterator insert_after(const_iterator position, const T& x);
+    constexpr iterator insert_after(const_iterator position, T&& x);
+ constexpr iterator insert_after(const_iterator position, size_type n, const T& x);
     template<class InputIterator>
+ constexpr iterator insert_after(const_iterator position,
+                                      InputIterator first, InputIterator last);
+    constexpr iterator insert_after(const_iterator position, initializer_list<T> il);
     template<container-compatible-range<T> R>
+ constexpr iterator insert_range_after(const_iterator position, R&& rg);
+ constexpr iterator erase_after(const_iterator position);
+ constexpr iterator erase_after(const_iterator position, const_iterator last);
+ constexpr void swap(forward_list&)
       noexcept(allocator_traits<Allocator>::is_always_equal::value);
+ constexpr void resize(size_type sz);
+ constexpr void resize(size_type sz, const value_type& c);
+ constexpr void clear() noexcept;
     // [forward.list.ops], forward_list operations
+ constexpr void splice_after(const_iterator position, forward_list& x);
+ constexpr void splice_after(const_iterator position, forward_list&& x);
+ constexpr void splice_after(const_iterator position, forward_list& x, const_iterator i);
+ constexpr void splice_after(const_iterator position, forward_list&& x, const_iterator i);
+ constexpr void splice_after(const_iterator position, forward_list& x,
                                 const_iterator first, const_iterator last);
+ constexpr void splice_after(const_iterator position, forward_list&& x,
                                 const_iterator first, const_iterator last);
+ constexpr size_type remove(const T& value);
+    template<class Predicate> constexpr size_type remove_if(Predicate pred);
     size_type unique();
+    template<class BinaryPredicate> constexpr size_type unique(BinaryPredicate binary_pred);
+ constexpr void merge(forward_list& x);
+ constexpr void merge(forward_list&& x);
+    template<class Compare> constexpr void merge(forward_list& x, Compare comp);
+    template<class Compare> constexpr void merge(forward_list&& x, Compare comp);
+ constexpr void sort();
+    template<class Compare> constexpr void sort(Compare comp);
+ constexpr void reverse() noexcept;
   };
   template<class InputIterator, class Allocator = allocator<iter-value-type<InputIterator>>>
     forward_list(InputIterator, InputIterator, Allocator = Allocator())
       -> forward_list<iter-value-type<InputIterator>, Allocator>;
 referenced.
 #### Constructors, copy, and assignment <a id="forward.list.cons">[[forward.list.cons]]</a>
 ``` cpp
+constexpr explicit forward_list(const Allocator&);
 ```
 *Effects:* Constructs an empty `forward_list` object using the specified
 allocator.
 *Complexity:* Constant.
 ``` cpp
+constexpr explicit forward_list(size_type n, const Allocator& = Allocator());
 ```
+*Preconditions:* `T` is *Cpp17DefaultInsertable* into `forward_list`.
 *Effects:* Constructs a `forward_list` object with `n` default-inserted
 elements using the specified allocator.
 *Complexity:* Linear in `n`.
 ``` cpp
+constexpr forward_list(size_type n, const T& value, const Allocator& = Allocator());
 ```
+*Preconditions:* `T` is *Cpp17CopyInsertable* into `forward_list`.
 *Effects:* Constructs a `forward_list` object with `n` copies of `value`
 using the specified allocator.
 *Complexity:* Linear in `n`.
 ``` cpp
 template<class InputIterator>
+ constexpr forward_list(InputIterator first, InputIterator last, const Allocator& = Allocator());
 ```
 *Effects:* Constructs a `forward_list` object equal to the range
 \[`first`, `last`).
 *Complexity:* Linear in `distance(first, last)`.
 ``` cpp
 template<container-compatible-range<T> R>
+ constexpr forward_list(from_range_t, R&& rg, const Allocator& = Allocator());
 ```
 *Effects:* Constructs a `forward_list` object with the elements of the
 range `rg`.
 *Complexity:* Linear in `ranges::distance(rg)`.
 #### Iterators <a id="forward.list.iter">[[forward.list.iter]]</a>
 ``` cpp
+constexpr iterator before_begin() noexcept;
+constexpr const_iterator before_begin() const noexcept;
+constexpr const_iterator cbefore_begin() const noexcept;
 ```
 *Effects:* `cbefore_begin()` is equivalent to
 `const_cast<forward_list const&>(*this).before_begin()`.
 *Remarks:* `before_begin() == end()` shall equal `false`.
 #### Element access <a id="forward.list.access">[[forward.list.access]]</a>
 ``` cpp
+constexpr reference front();
+constexpr const_reference front() const;
 ```
 *Returns:* `*begin()`
 #### Modifiers <a id="forward.list.modifiers">[[forward.list.modifiers]]</a>
+The member functions in this subclause do not affect the validity of
+iterators and references when inserting elements, and when erasing
+elements invalidate iterators and references to the erased elements
+only. If an exception is thrown by any of these member functions there
+is no effect on the container. Inserting `n` elements into a
+`forward_list` is linear in `n`, and the number of calls to the copy or
+move constructor of `T` is exactly equal to `n`. Erasing `n` elements
+from a `forward_list` is linear in `n` and the number of calls to the
+destructor of type `T` is exactly equal to `n`.
 ``` cpp
+template<class... Args> constexpr reference emplace_front(Args&&... args);
 ```
 *Effects:* Inserts an object of type `value_type` constructed with
 `value_type(std::forward<Args>(args)...)` at the beginning of the list.
 ``` cpp
+constexpr void push_front(const T& x);
+constexpr void push_front(T&& x);
 ```
 *Effects:* Inserts a copy of `x` at the beginning of the list.
 ``` cpp
 template<container-compatible-range<T> R>
+ constexpr void prepend_range(R&& rg);
 ```
 *Effects:* Inserts a copy of each element of `rg` at the beginning of
 the list.
 [*Note 1*: The order of elements is not reversed. — *end note*]
 ``` cpp
+constexpr void pop_front();
 ```
 *Effects:* As if by `erase_after(before_begin())`.
 ``` cpp
+constexpr iterator insert_after(const_iterator position, const T& x);
 ```
 *Preconditions:* `T` is *Cpp17CopyInsertable* into `forward_list`.
 `position` is `before_begin()` or is a dereferenceable iterator in the
 range \[`begin()`, `end()`).
 *Effects:* Inserts a copy of `x` after `position`.
 *Returns:* An iterator pointing to the copy of `x`.
 ``` cpp
+constexpr iterator insert_after(const_iterator position, T&& x);
 ```
 *Preconditions:* `T` is *Cpp17MoveInsertable* into `forward_list`.
 `position` is `before_begin()` or is a dereferenceable iterator in the
 range \[`begin()`, `end()`).
 *Effects:* Inserts a copy of `x` after `position`.
 *Returns:* An iterator pointing to the copy of `x`.
 ``` cpp
+constexpr iterator insert_after(const_iterator position, size_type n, const T& x);
 ```
 *Preconditions:* `T` is *Cpp17CopyInsertable* into `forward_list`.
 `position` is `before_begin()` or is a dereferenceable iterator in the
 range \[`begin()`, `end()`).
 *Returns:* An iterator pointing to the last inserted copy of `x`, or
 `position` if `n == 0` is `true`.
 ``` cpp
 template<class InputIterator>
+ constexpr iterator insert_after(const_iterator position,
+                                  InputIterator first, InputIterator last);
 ```
 *Preconditions:* `T` is *Cpp17EmplaceConstructible* into `forward_list`
 from `*first`. `position` is `before_begin()` or is a dereferenceable
 iterator in the range \[`begin()`, `end()`). Neither `first` nor `last`
 *Returns:* An iterator pointing to the last inserted element, or
 `position` if `first == last` is `true`.
 ``` cpp
 template<container-compatible-range<T> R>
+ constexpr iterator insert_range_after(const_iterator position, R&& rg);
 ```
 *Preconditions:* `T` is *Cpp17EmplaceConstructible* into `forward_list`
 from `*ranges::begin(rg)`. `position` is `before_begin()` or is a
 dereferenceable iterator in the range \[`begin()`, `end()`). `rg` and
 *Returns:* An iterator pointing to the last inserted element, or
 `position` if `rg` is empty.
 ``` cpp
+constexpr iterator insert_after(const_iterator position, initializer_list<T> il);
 ```
 *Effects:* Equivalent to:
 `return insert_after(position, il.begin(), il.end());`
 ``` cpp
 template<class... Args>
+ constexpr iterator emplace_after(const_iterator position, Args&&... args);
 ```
 *Preconditions:* `T` is *Cpp17EmplaceConstructible* into `forward_list`
 from `std::forward<Args>(args)...`. `position` is `before_begin()` or is
 a dereferenceable iterator in the range \[`begin()`, `end()`).
 `position`.
 *Returns:* An iterator pointing to the new object.
 ``` cpp
+constexpr iterator erase_after(const_iterator position);
 ```
 *Preconditions:* The iterator following `position` is dereferenceable.
 *Effects:* Erases the element pointed to by the iterator following
 was erased, or `end()` if no such element exists.
 *Throws:* Nothing.
 ``` cpp
+constexpr iterator erase_after(const_iterator position, const_iterator last);
 ```
 *Preconditions:* All iterators in the range (`position`, `last`) are
 dereferenceable.
 *Returns:* `last`.
 *Throws:* Nothing.
 ``` cpp
+constexpr void resize(size_type sz);
 ```
+*Preconditions:* `T` is *Cpp17DefaultInsertable* into `forward_list`.
 *Effects:* If `sz < distance(begin(), end())`, erases the last
 `distance(begin(), end()) - sz` elements from the list. Otherwise,
 inserts `sz - distance(begin(), end())` default-inserted elements at the
 end of the list.
 ``` cpp
+constexpr void resize(size_type sz, const value_type& c);
 ```
+*Preconditions:* `T` is *Cpp17CopyInsertable* into `forward_list`.
 *Effects:* If `sz < distance(begin(), end())`, erases the last
 `distance(begin(), end()) - sz` elements from the list. Otherwise,
 inserts `sz - distance(begin(), end())` copies of `c` at the end of the
 list.
 ``` cpp
+constexpr void clear() noexcept;
 ```
 *Effects:* Erases all elements in the range \[`begin()`, `end()`).
 *Remarks:* Does not invalidate past-the-end iterators.
 list and `n` is an integer, means an iterator `j` such that `j + n == i`
 is `true`. For `merge` and `sort`, the definitions and requirements in
 [[alg.sorting]] apply.
 ``` cpp
+constexpr void splice_after(const_iterator position, forward_list& x);
+constexpr void splice_after(const_iterator position, forward_list&& x);
 ```
 *Preconditions:* `position` is `before_begin()` or is a dereferenceable
 iterator in the range \[`begin()`, `end()`).
 `get_allocator() == x.get_allocator()` is `true`. `addressof(x) != this`
 *Throws:* Nothing.
 *Complexity:* 𝑂(`distance(x.begin(), x.end())`)
 ``` cpp
+constexpr void splice_after(const_iterator position, forward_list& x, const_iterator i);
+constexpr void splice_after(const_iterator position, forward_list&& x, const_iterator i);
 ```
 *Preconditions:* `position` is `before_begin()` or is a dereferenceable
 iterator in the range \[`begin()`, `end()`). The iterator following `i`
 is a dereferenceable iterator in `x`.
 *Throws:* Nothing.
 *Complexity:* 𝑂(1)
 ``` cpp
+constexpr void splice_after(const_iterator position, forward_list& x,
                             const_iterator first, const_iterator last);
+constexpr void splice_after(const_iterator position, forward_list&& x,
                             const_iterator first, const_iterator last);
 ```
 *Preconditions:* `position` is `before_begin()` or is a dereferenceable
 iterator in the range \[`begin()`, `end()`). (`first`, `last`) is a
 into `*this`, not into `x`.
 *Complexity:* 𝑂(`distance(first, last)`)
 ``` cpp
+constexpr size_type remove(const T& value);
+template<class Predicate> constexpr size_type remove_if(Predicate pred);
 ```
 *Effects:* Erases all the elements in the list referred to by a list
 iterator `i` for which the following conditions hold: `*i == value` (for
 `remove()`), `pred(*i)` is `true` (for `remove_if()`). Invalidates only
 corresponding predicate.
 *Remarks:* Stable [[algorithm.stable]].
 ``` cpp
+constexpr size_type unique();
+template<class BinaryPredicate> constexpr size_type unique(BinaryPredicate binary_pred);
 ```
 Let `binary_pred` be `equal_to<>{}` for the first overload.
 *Preconditions:* `binary_pred` is an equivalence relation.
 *Complexity:* If `empty()` is `false`, exactly
 `distance(begin(), end()) - 1` applications of the corresponding
 predicate, otherwise no applications of the predicate.
 ``` cpp
+constexpr void merge(forward_list& x);
+constexpr void merge(forward_list&& x);
+template<class Compare> constexpr void merge(forward_list& x, Compare comp);
+template<class Compare> constexpr void merge(forward_list&& x, Compare comp);
 ```
 Let `comp` be `less<>` for the first two overloads.
 *Preconditions:* `*this` and `x` are both sorted with respect to the
 *Remarks:* Stable [[algorithm.stable]]. If `addressof(x) != this`, `x`
 is empty after the merge. No elements are copied by this operation. If
 an exception is thrown other than by a comparison, there are no effects.
 ``` cpp
+constexpr void sort();
+template<class Compare> constexpr void sort(Compare comp);
 ```
 *Effects:* Sorts the list according to the `operator<` or the `comp`
 function object. If an exception is thrown, the order of the elements in
 `*this` is unspecified. Does not affect the validity of iterators and
 `distance(begin(), end())`.
 *Remarks:* Stable [[algorithm.stable]].
 ``` cpp
+constexpr void reverse() noexcept;
 ```
 *Effects:* Reverses the order of the elements in the list. Does not
 affect the validity of iterators and references.
 *Complexity:* Linear time.
 #### Erasure <a id="forward.list.erasure">[[forward.list.erasure]]</a>
 ``` cpp
+template<class T, class Allocator, class U = T>
+ constexpr typename forward_list<T, Allocator>::size_type
     erase(forward_list<T, Allocator>& c, const U& value);
 ```
 *Effects:* Equivalent to:
+``` cpp
+return erase_if(c, [&](const auto& elem) -> bool { return elem == value; });
+```
 ``` cpp
 template<class T, class Allocator, class Predicate>
+ constexpr typename forward_list<T, Allocator>::size_type
     erase_if(forward_list<T, Allocator>& c, Predicate pred);
 ```
 *Effects:* Equivalent to: `return c.remove_if(pred);`
+### Header `<hive>` synopsis <a id="hive.syn">[[hive.syn]]</a>
+``` cpp
+#include <initializer_list>     // see [initializer.list.syn]
+#include <compare>              // see [compare.syn]
+namespace std {
+  struct hive_limits {
+    size_t min;
+    size_t max;
+    constexpr hive_limits(size_t minimum, size_t maximum) noexcept
+      : min(minimum), max(maximum) {}
+  };
+  // \ref {hive}, class template hive
+  template<class T, class Allocator = allocator<T>> class hive;
+  template<class T, class Allocator>
+    void swap(hive<T, Allocator>& x, hive<T, Allocator>& y)
+      noexcept(noexcept(x.swap(y)));
+  template<class T, class Allocator, class U = T>
+    typename hive<T, Allocator>::size_type
+      erase(hive<T, Allocator>& c, const U& value);
+  template<class T, class Allocator, class Predicate>
+    typename hive<T, Allocator>::size_type
+      erase_if(hive<T, Allocator>& c, Predicate pred);
+  namespace pmr {
+    template<class T>
+      using hive = std::hive<T, polymorphic_allocator<T>>;
+  }
+}
+```
+### Class template `hive` <a id="hive">[[hive]]</a>
+#### Overview <a id="hive.overview">[[hive.overview]]</a>
+A `hive` is a type of sequence container that provides constant-time
+insertion and erasure operations. Storage is automatically managed in
+multiple memory blocks, referred to as *element blocks*. Insertion
+position is determined by the container, and insertion may re-use the
+memory locations of erased elements.
+Element blocks which contain elements are referred to as *active
+blocks*, those which do not are referred to as *reserved blocks*. Active
+blocks which become empty of elements are either deallocated or become
+reserved blocks. Reserved blocks become active blocks when they are used
+to store elements. A user can create additional reserved blocks by
+calling `reserve`.
+Erasures use unspecified techniques of constant time complexity to
+identify the memory locations of erased elements, which are subsequently
+skipped during iteration, as opposed to relocating subsequent elements
+during erasure.
+Active block capacities have an *implementation-defined* growth factor
+(which need not be integral), for example a new active block’s capacity
+could be equal to the summed capacities of the pre-existing active
+blocks.
+Limits can be placed on both the minimum and maximum element capacities
+of element blocks, both by users and implementations.
+- The minimum limit shall be no larger than the maximum limit.
+- When limits are not specified by a user during construction, the
+  implementation’s default limits are used.
+- The default limits of an implementation are not guaranteed to be the
+  same as the minimum and maximum possible capacities for an
+  implementation’s element blocks. \[*Note 1*: To allow latitude for
+  both implementation-specific and user-directed
+  optimization. — *end note*] The latter are defined as hard limits.
+  The maximum hard limit shall be no larger than
+  `std::allocator_traits<Allocator>::max_size()`.
+- If user-specified limits are not within hard limits, or if the
+  specified minimum limit is greater than the specified maximum limit,
+  the behavior is undefined.
+- An element block is said to be *within the bounds* of a pair of
+  minimum/maximum limits when its capacity is greater-or-equal-to the
+  minimum limit and less-than-or-equal-to the maximum limit.
+A `hive` conforms to the requirements for containers
+[[container.reqmts]], with the exception of operators `==` and `!=`. A
+`hive` also meets the requirements of a reversible container
+[[container.rev.reqmts]], of an allocator-aware container
+[[container.alloc.reqmts]], and some of the requirements of a sequence
+container [[sequence.reqmts]]. Descriptions are provided here only for
+operations on `hive` that are not described in that table or for
+operations where there is additional semantic information.
+The iterators of `hive` meet the *Cpp17BidirectionalIterator*
+requirements but also model `three_way_comparable<strong_ordering>`.
+``` cpp
+namespace std {
+  template<class T, class Allocator = allocator<T>>
+  class hive {
+  public:
+    // types
+    using value_type = T;
+    using allocator_type = Allocator;
+    using pointer = allocator_traits<Allocator>::pointer;
+    using const_pointer = allocator_traits<Allocator>::const_pointer;
+    using reference = value_type&;
+    using const_reference = const value_type&;
+    using size_type = implementation-defined;                               // see [container.requirements]
+    using difference_type = implementation-defined;                         // see [container.requirements]
+    using iterator = implementation-defined;                                // see [container.requirements]
+    using const_iterator = implementation-defined;                          // see [container.requirements]
+    using reverse_iterator = std::reverse_iterator<iterator>;               // see [container.requirements]
+    using const_reverse_iterator = std::reverse_iterator<const_iterator>;   // see [container.requirements]
+    // [hive.cons], construct/copy/destroy
+    constexpr hive() noexcept(noexcept(Allocator())) : hive(Allocator()) {}
+    constexpr explicit hive(const Allocator&) noexcept;
+    constexpr explicit hive(hive_limits block_limits) : hive(block_limits, Allocator()) {}
+    constexpr hive(hive_limits block_limits, const Allocator&);
+    explicit hive(size_type n, const Allocator& = Allocator());
+    hive(size_type n, hive_limits block_limits, const Allocator& = Allocator());
+    hive(size_type n, const T& value, const Allocator& = Allocator());
+    hive(size_type n, const T& value, hive_limits block_limits, const Allocator& = Allocator());
+    template<class InputIterator>
+      hive(InputIterator first, InputIterator last, const Allocator& = Allocator());
+    template<class InputIterator>
+      hive(InputIterator first, InputIterator last, hive_limits block_limits,
+           const Allocator& = Allocator());
+    template<container-compatible-range<T> R>
+      hive(from_range_t, R&& rg, const Allocator& = Allocator());
+    template<container-compatible-range<T> R>
+      hive(from_range_t, R&& rg, hive_limits block_limits, const Allocator& = Allocator());
+    hive(const hive& x);
+    hive(hive&&) noexcept;
+    hive(const hive& x, const type_identity_t<Allocator>& alloc);
+    hive(hive&&, const type_identity_t<Allocator>& alloc);
+    hive(initializer_list<T> il, const Allocator& = Allocator());
+    hive(initializer_list<T> il, hive_limits block_limits, const Allocator& = Allocator());
+    ~hive();
+    hive& operator=(const hive& x);
+    hive& operator=(hive&& x) noexcept(see below);
+    hive& operator=(initializer_list<T>);
+    template<class InputIterator>
+      void assign(InputIterator first, InputIterator last);
+    template<container-compatible-range<T> R>
+      void assign_range(R&& rg);
+    void assign(size_type n, const T& t);
+    void assign(initializer_list<T>);
+    allocator_type get_allocator() const noexcept;
+    // 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;
+    // [hive.capacity], capacity
+    bool empty() const noexcept;
+    size_type size() const noexcept;
+    size_type max_size() const noexcept;
+    size_type capacity() const noexcept;
+    void reserve(size_type n);
+    void shrink_to_fit();
+    void trim_capacity() noexcept;
+    void trim_capacity(size_type n) noexcept;
+    constexpr hive_limits block_capacity_limits() const noexcept;
+    static constexpr hive_limits block_capacity_default_limits() noexcept;
+    static constexpr hive_limits block_capacity_hard_limits() noexcept;
+    void reshape(hive_limits block_limits);
+    // [hive.modifiers], modifiers
+    template<class... Args> iterator emplace(Args&&... args);
+    template<class... Args> iterator emplace_hint(const_iterator hint, Args&&... args);
+    iterator insert(const T& x);
+    iterator insert(T&& x);
+    iterator insert(const_iterator hint, const T& x);
+    iterator insert(const_iterator hint, T&& x);
+    void insert(initializer_list<T> il);
+    template<container-compatible-range<T> R>
+      void insert_range(R&& rg);
+    template<class InputIterator>
+      void insert(InputIterator first, InputIterator last);
+    void insert(size_type n, const T& x);
+    iterator erase(const_iterator position);
+    iterator erase(const_iterator first, const_iterator last);
+    void swap(hive&) noexcept(see below);
+    void clear() noexcept;
+    // [hive.operations], hive operations
+    void splice(hive& x);
+    void splice(hive&& x);
+    template<class BinaryPredicate = equal_to<T>>
+      size_type unique(BinaryPredicate binary_pred = BinaryPredicate());
+    template<class Compare = less<T>>
+      void sort(Compare comp = Compare());
+    iterator get_iterator(const_pointer p) noexcept;
+    const_iterator get_iterator(const_pointer p) const noexcept;
+  private:
+    hive_limits current-limits = implementation-defined;     // exposition only
+  };
+  template<class InputIterator, class Allocator = allocator<iter-value-type<InputIterator>>>
+    hive(InputIterator, InputIterator, Allocator = Allocator())
+      -> hive<iter-value-type<InputIterator>, Allocator>;
+  template<class InputIterator, class Allocator = allocator<iter-value-type<InputIterator>>>
+    hive(InputIterator, InputIterator, hive_limits, Allocator = Allocator())
+      -> hive<iter-value-type<InputIterator>, Allocator>;
+  template<ranges::input_range R, class Allocator = allocator<ranges::range_value_t<R>>>
+    hive(from_range_t, R&&, Allocator = Allocator())
+      -> hive<ranges::range_value_t<R>, Allocator>;
+  template<ranges::input_range R, class Allocator = allocator<ranges::range_value_t<R>>>
+    hive(from_range_t, R&&, hive_limits, Allocator = Allocator())
+      -> hive<ranges::range_value_t<R>, Allocator>;
+}
+```
+#### Constructors, copy, and assignment <a id="hive.cons">[[hive.cons]]</a>
+``` cpp
+constexpr explicit hive(const Allocator&) noexcept;
+```
+*Effects:* Constructs an empty `hive`, using the specified allocator.
+*Complexity:* Constant.
+``` cpp
+constexpr hive(hive_limits block_limits, const Allocator&);
+```
+*Effects:* Constructs an empty `hive`, using the specified allocator.
+Initializes *current-limits* with `block_limits`.
+*Complexity:* Constant.
+``` cpp
+explicit hive(size_type n, const Allocator& = Allocator());
+hive(size_type n, hive_limits block_limits, const Allocator& = Allocator());
+```
+*Preconditions:* `T` is *Cpp17DefaultInsertable* into `hive`.
+*Effects:* Constructs a `hive` with `n` default-inserted elements, using
+the specified allocator. If the second overload is called, also
+initializes *current-limits* with `block_limits`.
+*Complexity:* Linear in `n`.
+``` cpp
+hive(size_type n, const T& value, const Allocator& = Allocator());
+hive(size_type n, const T& value, hive_limits block_limits, const Allocator& = Allocator());
+```
+*Preconditions:* `T` is *Cpp17CopyInsertable* into `hive`.
+*Effects:* Constructs a `hive` with `n` copies of `value`, using the
+specified allocator. If the second overload is called, also initializes
+*current-limits* with `block_limits`.
+*Complexity:* Linear in `n`.
+``` cpp
+template<class InputIterator>
+  hive(InputIterator first, InputIterator last, const Allocator& = Allocator());
+template<class InputIterator>
+  hive(InputIterator first, InputIterator last, hive_limits block_limits,
+       const Allocator& = Allocator());
+```
+*Effects:* Constructs a `hive` equal to the range \[`first`, `last`),
+using the specified allocator. If the second overload is called, also
+initializes *current-limits* with `block_limits`.
+*Complexity:* Linear in `distance(first, last)`.
+``` cpp
+template<container-compatible-range<T> R>
+  hive(from_range_t, R&& rg, const Allocator& = Allocator());
+template<container-compatible-range<T> R>
+  hive(from_range_t, R&& rg, hive_limits block_limits, const Allocator& = Allocator());
+```
+*Effects:* Constructs a `hive` object with the elements of the range
+`rg`, using the specified allocator. If the second overload is called,
+also initializes *current-limits* with `block_limits`.
+*Complexity:* Linear in `ranges::distance(rg)`.
+``` cpp
+hive(const hive& x);
+hive(const hive& x, const type_identity_t<Allocator>& alloc);
+```
+*Preconditions:* `T` is *Cpp17CopyInsertable* into `hive`.
+*Effects:* Constructs a `hive` object with the elements of `x`. If the
+second overload is called, uses `alloc`. Initializes *current-limits*
+with `x.`*`current-limits`*.
+*Complexity:* Linear in `x.size()`.
+``` cpp
+hive(hive&& x) noexcept;
+hive(hive&& x, const type_identity_t<Allocator>& alloc);
+```
+*Preconditions:* For the second overload, when
+`allocator_traits<alloc>::is_always_equal::value` is `false`, `T` meets
+the *Cpp17MoveInsertable* requirements.
+*Effects:* When the first overload is called, or the second overload is
+called and `alloc == x.get_allocator()` is `true`, *current-limits* is
+set to `x.`*`current-limits`* and each element block is moved from `x`
+into `*this`. Pointers and references to the elements of `x` now refer
+to those same elements but as members of `*this`. Iterators referring to
+the elements of `x` will continue to refer to their elements, but they
+now behave as iterators into `*this`.
+If the second overload is called and `alloc == x.get_allocator()` is
+`false`, each element in `x` is moved into `*this`. References, pointers
+and iterators referring to the elements of `x`, as well as the
+past-the-end iterator of `x`, are invalidated.
+*Ensures:* `x.empty()` is `true`.
+*Complexity:* If the second overload is called and
+`alloc == x.get_allocator()` is `false`, linear in `x.size()`. Otherwise
+constant.
+``` cpp
+hive(initializer_list<T> il, const Allocator& = Allocator());
+hive(initializer_list<T> il, hive_limits block_limits, const Allocator& = Allocator());
+```
+*Preconditions:* `T` is *Cpp17CopyInsertable* into `hive`.
+*Effects:* Constructs a `hive` object with the elements of `il`, using
+the specified allocator. If the second overload is called, also
+initializes *current-limits* with `block_limits`.
+*Complexity:* Linear in `il.size()`.
+``` cpp
+hive& operator=(const hive& x);
+```
+*Preconditions:* `T` is *Cpp17CopyInsertable* into `hive` and
+*Cpp17CopyAssignable*.
+*Effects:* All elements in `*this` are either copy-assigned to, or
+destroyed. All elements in `x` are copied into `*this`.
+[*Note 1*: *current-limits* is unchanged. — *end note*]
+*Complexity:* Linear in `size() + x.size()`.
+``` cpp
+hive& operator=(hive&& x)
+  noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
+           allocator_traits<Allocator>::is_always_equal::value);
+```
+*Preconditions:* When
+``` cpp
+(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
+ allocator_traits<Allocator>::is_always_equal::value)
+```
+is `false`, `T` is *Cpp17MoveInsertable* into `hive` and
+*Cpp17MoveAssignable*.
+*Effects:* Each element in `*this` is either move-assigned to, or
+destroyed. When
+``` cpp
+(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
+ get_allocator() == x.get_allocator())
+```
+is `true`, *current-limits* is set to `x.`*`current-limits`* and each
+element block is moved from `x` into `*this`. Pointers and references to
+the elements of `x` now refer to those same elements but as members of
+`*this`. Iterators referring to the elements of `x` will continue to
+refer to their elements, but they now behave as iterators into `*this`,
+not into `x`.
+When
+``` cpp
+(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
+ get_allocator() == x.get_allocator())
+```
+is `false`, each element in `x` is moved into `*this`. References,
+pointers and iterators referring to the elements of `x`, as well as the
+past-the-end iterator of `x`, are invalidated.
+*Ensures:* `x.empty()` is `true`.
+*Complexity:* Linear in `size()`. If
+``` cpp
+(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
+ get_allocator() == x.get_allocator())
+```
+is `false`, also linear in `x.size()`.
+#### Capacity <a id="hive.capacity">[[hive.capacity]]</a>
+``` cpp
+size_type capacity() const noexcept;
+```
+*Returns:* The total number of elements that `*this` can hold without
+requiring allocation of more element blocks.
+*Complexity:* Constant.
+``` cpp
+void reserve(size_type n);
+```
+*Effects:* If `n <= capacity()` is `true`, there are no effects.
+Otherwise increases `capacity()` by allocating reserved blocks.
+*Ensures:* `capacity() >= n` is `true`.
+*Throws:* `length_error` if `n > max_size()`, as well as any exceptions
+thrown by the allocator.
+*Complexity:* Linear in the number of reserved blocks allocated.
+*Remarks:* The size of the sequence is not changed. All references,
+pointers, and iterators referring to elements in `*this`, as well as the
+past-the-end iterator, remain valid.
+``` cpp
+void shrink_to_fit();
+```
+*Preconditions:* `T` is *Cpp17MoveInsertable* into `hive`.
+*Effects:* `shrink_to_fit` is a non-binding request to reduce
+`capacity()` to be closer to `size()`.
+[*Note 1*: The request is non-binding to allow latitude for
+implementation-specific optimizations. — *end note*]
+It does not increase `capacity()`, but may reduce `capacity()`. It may
+reallocate elements. If `capacity()` is already equal to `size()`, there
+are no effects. If an exception is thrown during allocation of a new
+element block, `capacity()` may be reduced and reallocation may occur.
+Otherwise if an exception is thrown, the effects are unspecified.
+*Complexity:* If reallocation happens, linear in the size of the
+sequence.
+*Remarks:* If reallocation happens, the order of the elements in `*this`
+may change and all references, pointers, and iterators referring to the
+elements in `*this`, as well as the past-the-end iterator, are
+invalidated.
+``` cpp
+void trim_capacity() noexcept;
+void trim_capacity(size_type n) noexcept;
+```
+*Effects:* For the first overload, all reserved blocks are deallocated,
+and `capacity()` is reduced accordingly. For the second overload,
+`capacity()` is reduced to no less than `n`.
+*Complexity:* Linear in the number of reserved blocks deallocated.
+*Remarks:* All references, pointers, and iterators referring to elements
+in `*this`, as well as the past-the-end iterator, remain valid.
+``` cpp
+constexpr hive_limits block_capacity_limits() const noexcept;
+```
+*Returns:* *current-limits*.
+*Complexity:* Constant.
+``` cpp
+static constexpr hive_limits block_capacity_default_limits() noexcept;
+```
+*Returns:* A `hive_limits` struct with the `min` and `max` members set
+to the implementation’s default limits.
+*Complexity:* Constant.
+``` cpp
+static constexpr hive_limits block_capacity_hard_limits() noexcept;
+```
+*Returns:* A `hive_limits` struct with the `min` and `max` members set
+to the implementation’s hard limits.
+*Complexity:* Constant.
+``` cpp
+void reshape(hive_limits block_limits);
+```
+*Preconditions:* `T` is *Cpp17MoveInsertable* into `hive`.
+*Effects:* For any active blocks not within the bounds of
+`block_limits`, the elements within those active blocks are reallocated
+to new or existing element blocks which are within the bounds. Any
+element blocks not within the bounds of `block_limits` are deallocated.
+If an exception is thrown during allocation of a new element block,
+`capacity()` may be reduced, reallocation may occur, and
+*current-limits* may be assigned a value other than `block_limits`.
+Otherwise `block_limits` is assigned to *current-limits*. If any other
+exception is thrown the effects are unspecified.
+*Ensures:* `size()` is unchanged.
+*Complexity:* Linear in the number of element blocks in `*this`. If
+reallocation happens, also linear in the number of elements reallocated.
+*Remarks:* This operation may change `capacity()`. If reallocation
+happens, the order of the elements in `*this` may change. Reallocation
+invalidates all references, pointers, and iterators referring to the
+elements in `*this`, as well as the past-the-end iterator.
+[*Note 2*: If no reallocation happens, they remain
+valid. — *end note*]
+#### Modifiers <a id="hive.modifiers">[[hive.modifiers]]</a>
+``` cpp
+template<class... Args> iterator emplace(Args&&... args);
+template<class... Args> iterator emplace_hint(const_iterator hint, Args&&... args);
+```
+*Preconditions:* `T` is *Cpp17EmplaceConstructible* into `hive` from
+`args`.
+*Effects:* Inserts an object of type `T` constructed with
+`std::forward<Args>(args)...`. The `hint` parameter is ignored. If an
+exception is thrown, there are no effects.
+[*Note 1*: `args` can directly or indirectly refer to a value in
+`*this`. — *end note*]
+*Returns:* An iterator that points to the new element.
+*Complexity:* Constant. Exactly one object of type `T` is constructed.
+*Remarks:* Invalidates the past-the-end iterator.
+``` cpp
+iterator insert(const T& x);
+iterator insert(const_iterator hint, const T& x);
+iterator insert(T&& x);
+iterator insert(const_iterator hint, T&& x);
+```
+*Effects:* Equivalent to:
+`return emplace(std::forward<decltype(x)>(x));`
+[*Note 2*: The `hint` parameter is ignored. — *end note*]
+``` cpp
+void insert(initializer_list<T> rg);
+template<container-compatible-range<T> R>
+  void insert_range(R&& rg);
+```
+*Preconditions:* `T` is *Cpp17EmplaceInsertable* into `hive` from
+`*ranges::begin(rg)`. `rg` and `*this` do not overlap.
+*Effects:* Inserts copies of elements in `rg`. Each iterator in the
+range `rg` is dereferenced exactly once.
+*Complexity:* Linear in the number of elements inserted. Exactly one
+object of type `T` is constructed for each element inserted.
+*Remarks:* If an element is inserted, invalidates the past-the-end
+iterator.
+``` cpp
+void insert(size_type n, const T& x);
+```
+*Preconditions:* `T` is *Cpp17CopyInsertable* into `hive`.
+*Effects:* Inserts `n` copies of `x`.
+*Complexity:* Linear in `n`. Exactly one object of type `T` is
+constructed for each element inserted.
+*Remarks:* If an element is inserted, invalidates the past-the-end
+iterator.
+``` cpp
+template<class InputIterator>
+  void insert(InputIterator first, InputIterator last);
+```
+*Effects:* Equivalent to `insert_range(ranges::subrange(first, last))`.
+``` cpp
+iterator erase(const_iterator position);
+iterator erase(const_iterator first, const_iterator last);
+```
+*Complexity:* Linear in the number of elements erased. Additionally, if
+any active blocks become empty of elements as a result of the function
+call, at worst linear in the number of element blocks.
+*Remarks:* Invalidates references, pointers and iterators referring to
+the erased elements. An erase operation that erases the last element in
+`*this` also invalidates the past-the-end iterator.
+``` cpp
+void swap(hive& x)
+  noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value ||
+           allocator_traits<Allocator>::is_always_equal::value);
+```
+*Effects:* Exchanges the contents, `capacity()`, and *current-limits* of
+`*this` with that of `x`.
+*Complexity:* Constant.
+#### Operations <a id="hive.operations">[[hive.operations]]</a>
+In this subclause, arguments for a template parameter named `Predicate`
+or `BinaryPredicate` shall meet the corresponding requirements in
+[[algorithms.requirements]]. The semantics of `i + n` and `i - n`, where
+`i` is an iterator into the `hive` and `n` is an integer, are the same
+as those of `next(i, n)` and `prev(i, n)`, respectively. For `sort`, the
+definitions and requirements in [[alg.sorting]] apply.
+``` cpp
+void splice(hive& x);
+void splice(hive&& x);
+```
+*Preconditions:* `get_allocator() == x.get_allocator()` is `true`.
+*Effects:* If `addressof(x) == this` is `true`, the behavior is
+erroneous and there are no effects. Otherwise, inserts the contents of
+`x` into `*this` and `x` becomes empty. Pointers and references to the
+moved elements of `x` now refer to those same elements but as members of
+`*this`. Iterators referring to the moved elements continue to refer to
+their elements, but they now behave as iterators into `*this`, not into
+`x`.
+*Throws:* `length_error` if any of `x`’s active blocks are not within
+the bounds of *current-limits*.
+*Complexity:* Linear in the sum of all element blocks in `x` plus all
+element blocks in `*this`.
+*Remarks:* Reserved blocks in `x` are not transferred into `*this`. If
+`addressof(x) == this` is `false`, invalidates the past-the-end iterator
+for both `x` and `*this`.
+``` cpp
+template<class BinaryPredicate = equal_to<T>>
+  size_type unique(BinaryPredicate binary_pred = BinaryPredicate());
+```
+*Preconditions:* `binary_pred` is an equivalence relation.
+*Effects:* Erases all but the first element from every consecutive group
+of equivalent elements. That is, for a nonempty `hive`, erases all
+elements referred to by the iterator `i` in the range \[`begin() + 1`,
+`end()`) for which `binary_pred(*i, *(i - 1))` is `true`.
+*Returns:* The number of elements erased.
+*Throws:* Nothing unless an exception is thrown by the predicate.
+*Complexity:* If `empty()` is `false`, exactly `size() - 1` applications
+of the corresponding predicate, otherwise no applications of the
+predicate.
+*Remarks:* Invalidates references, pointers, and iterators referring to
+the erased elements. If the last element in `*this` is erased, also
+invalidates the past-the-end iterator.
+``` cpp
+template<class Compare = less<T>>
+  void sort(Compare comp = Compare());
+```
+*Preconditions:* `T` is *Cpp17MoveInsertable* into `hive`,
+*Cpp17MoveAssignable*, and *Cpp17Swappable*.
+*Effects:* Sorts `*this` according to the `comp` function object. If an
+exception is thrown, the order of the elements in `*this` is
+unspecified.
+*Complexity:* 𝑂(N log N) comparisons, where N is `size()`.
+*Remarks:* May allocate. References, pointers, and iterators referring
+to elements in `*this`, as well as the past-the-end iterator, may be
+invalidated.
+[*Note 1*: Not required to be
+stable [[algorithm.stable]]. — *end note*]
+``` cpp
+iterator get_iterator(const_pointer p) noexcept;
+const_iterator get_iterator(const_pointer p) const noexcept;
+```
+*Preconditions:* `p` points to an element in `*this`.
+*Returns:* An `iterator` or `const_iterator` pointing to the same
+element as `p`.
+*Complexity:* Linear in the number of active blocks in `*this`.
+#### Erasure <a id="hive.erasure">[[hive.erasure]]</a>
+``` cpp
+template<class T, class Allocator, class U = T>
+  typename hive<T, Allocator>::size_type
+    erase(hive<T, Allocator>& c, const U& value);
+```
+*Effects:* Equivalent to:
+``` cpp
+return erase_if(c, [&](const auto& elem) -> bool { return elem == value; });
+```
+``` cpp
+template<class T, class Allocator, class Predicate>
+  typename hive<T, Allocator>::size_type
+    erase_if(hive<T, Allocator>& c, Predicate pred);
+```
+*Effects:* Equivalent to:
+``` cpp
+auto original_size = c.size();
+for (auto i = c.begin(), last = c.end(); i != last; ) {
+  if (pred(*i)) {
+    i = c.erase(i);
+  } else {
+    ++i;
+  }
+}
+return original_size - c.size();
+```
+### Header `<list>` synopsis <a id="list.syn">[[list.syn]]</a>
+``` cpp
+#include <compare>              // see [compare.syn]
+#include <initializer_list>     // see [initializer.list.syn]
+namespace std {
+  // [list], class template list
+  template<class T, class Allocator = allocator<T>> class list;
+  template<class T, class Allocator>
+    constexpr bool operator==(const list<T, Allocator>& x, const list<T, Allocator>& y);
+  template<class T, class Allocator>
+    constexpr synth-three-way-result<T>
+      operator<=>(const list<T, Allocator>& x, const list<T, Allocator>& y);
+  template<class T, class Allocator>
+    constexpr void swap(list<T, Allocator>& x, list<T, Allocator>& y)
+      noexcept(noexcept(x.swap(y)));
+  // [list.erasure], erasure
+  template<class T, class Allocator, class U = T>
+    constexpr typename list<T, Allocator>::size_type
+      erase(list<T, Allocator>& c, const U& value);
+  template<class T, class Allocator, class Predicate>
+    constexpr typename list<T, Allocator>::size_type
+      erase_if(list<T, Allocator>& c, Predicate pred);
+  namespace pmr {
+    template<class T>
+      using list = std::list<T, polymorphic_allocator<T>>;
+  }
+}
+```
 ### Class template `list` <a id="list">[[list]]</a>
 #### Overview <a id="list.overview">[[list.overview]]</a>
 A `list` is a sequence container that supports bidirectional iterators
 Descriptions are provided here only for operations on `list` that are
 not described in one of these tables or for operations where there is
 additional semantic information.
+The types `iterator` and `const_iterator` meet the constexpr iterator
+requirements [[iterator.requirements.general]].
 ``` cpp
 namespace std {
   template<class T, class Allocator = allocator<T>>
   class list {
   public:
     // types
     using value_type             = T;
     using allocator_type         = Allocator;
+    using pointer                = allocator_traits<Allocator>::pointer;
+    using const_pointer          = allocator_traits<Allocator>::const_pointer;
     using reference              = value_type&;
     using const_reference        = const value_type&;
     using size_type              = implementation-defined  // type of list::size_type; // see [container.requirements]
     using difference_type        = implementation-defined  // type of list::difference_type; // see [container.requirements]
     using iterator               = implementation-defined  // type of list::iterator; // see [container.requirements]
     using const_iterator         = implementation-defined  // type of list::const_iterator; // see [container.requirements]
     using reverse_iterator       = std::reverse_iterator<iterator>;
     using const_reverse_iterator = std::reverse_iterator<const_iterator>;
     // [list.cons], construct/copy/destroy
+ constexpr list() : list(Allocator()) { }
+ constexpr explicit list(const Allocator&);
+ constexpr explicit list(size_type n, const Allocator& = Allocator());
+ constexpr list(size_type n, const T& value, const Allocator& = Allocator());
     template<class InputIterator>
+ constexpr list(InputIterator first, InputIterator last, const Allocator& = Allocator());
     template<container-compatible-range<T> R>
+ constexpr list(from_range_t, R&& rg, const Allocator& = Allocator());
+ constexpr list(const list& x);
+ constexpr list(list&& x);
+ constexpr list(const list&, const type_identity_t<Allocator>&);
+ constexpr list(list&&, const type_identity_t<Allocator>&);
+ constexpr list(initializer_list<T>, const Allocator& = Allocator());
+ constexpr ~list();
+ constexpr list& operator=(const list& x);
+ constexpr list& operator=(list&& x)
       noexcept(allocator_traits<Allocator>::is_always_equal::value);
+ constexpr list& operator=(initializer_list<T>);
     template<class InputIterator>
+ constexpr void assign(InputIterator first, InputIterator last);
     template<container-compatible-range<T> R>
+ constexpr void assign_range(R&& rg);
+ constexpr void assign(size_type n, const T& t);
+ constexpr void assign(initializer_list<T>);
+ constexpr allocator_type get_allocator() const noexcept;
     // iterators
+ constexpr iterator               begin() noexcept;
+ constexpr const_iterator         begin() const noexcept;
+ constexpr iterator               end() noexcept;
+ constexpr const_iterator         end() const noexcept;
+ constexpr reverse_iterator       rbegin() noexcept;
+ constexpr const_reverse_iterator rbegin() const noexcept;
+ constexpr reverse_iterator       rend() noexcept;
+ constexpr const_reverse_iterator rend() const noexcept;
+ constexpr const_iterator         cbegin() const noexcept;
+ constexpr const_iterator         cend() const noexcept;
+ constexpr const_reverse_iterator crbegin() const noexcept;
+ constexpr const_reverse_iterator crend() const noexcept;
     // [list.capacity], capacity
+ constexpr bool empty() const noexcept;
+ constexpr size_type size() const noexcept;
+ constexpr size_type max_size() const noexcept;
+ constexpr void      resize(size_type sz);
+ constexpr void      resize(size_type sz, const T& c);
     // element access
+ constexpr reference       front();
+ constexpr const_reference front() const;
+ constexpr reference       back();
+ constexpr const_reference back() const;
     // [list.modifiers], modifiers
+    template<class... Args> constexpr reference emplace_front(Args&&... args);
+    template<class... Args> constexpr reference emplace_back(Args&&... args);
+ constexpr void push_front(const T& x);
+ constexpr void push_front(T&& x);
     template<container-compatible-range<T> R>
+ constexpr void prepend_range(R&& rg);
+ constexpr void pop_front();
+ constexpr void push_back(const T& x);
+ constexpr void push_back(T&& x);
     template<container-compatible-range<T> R>
+ constexpr void append_range(R&& rg);
+ constexpr void pop_back();
+    template<class... Args> constexpr iterator emplace(const_iterator position, Args&&... args);
+ constexpr iterator insert(const_iterator position, const T& x);
+ constexpr iterator insert(const_iterator position, T&& x);
+ constexpr iterator insert(const_iterator position, size_type n, const T& x);
     template<class InputIterator>
+ constexpr iterator insert(const_iterator position,
+                                InputIterator first, InputIterator last);
     template<container-compatible-range<T> R>
+ constexpr iterator insert_range(const_iterator position, R&& rg);
+ constexpr iterator insert(const_iterator position, initializer_list<T> il);
+ constexpr iterator erase(const_iterator position);
+ constexpr iterator erase(const_iterator position, const_iterator last);
+ constexpr void     swap(list&) noexcept(allocator_traits<Allocator>::is_always_equal::value);
+ constexpr void     clear() noexcept;
     // [list.ops], list operations
+ constexpr void splice(const_iterator position, list& x);
+ constexpr void splice(const_iterator position, list&& x);
+ constexpr void splice(const_iterator position, list& x, const_iterator i);
+ constexpr void splice(const_iterator position, list&& x, const_iterator i);
+ constexpr void splice(const_iterator position, list& x,
+ const_iterator first, const_iterator last);
+    constexpr void splice(const_iterator position, list&& x,
+                          const_iterator first, const_iterator last);
+ constexpr size_type remove(const T& value);
+    template<class Predicate> constexpr size_type remove_if(Predicate pred);
+ constexpr size_type unique();
     template<class BinaryPredicate>
+ constexpr size_type unique(BinaryPredicate binary_pred);
+ constexpr void merge(list& x);
+ constexpr void merge(list&& x);
+    template<class Compare> constexpr void merge(list& x, Compare comp);
+    template<class Compare> constexpr void merge(list&& x, Compare comp);
+ constexpr void sort();
+    template<class Compare> constexpr void sort(Compare comp);
+ constexpr void reverse() noexcept;
   };
   template<class InputIterator, class Allocator = allocator<iter-value-type<InputIterator>>>
     list(InputIterator, InputIterator, Allocator = Allocator())
       -> list<iter-value-type<InputIterator>, Allocator>;
 any member of the resulting specialization of `list` is referenced.
 #### Constructors, copy, and assignment <a id="list.cons">[[list.cons]]</a>
 ``` cpp
+constexpr explicit list(const Allocator&);
 ```
 *Effects:* Constructs an empty list, using the specified allocator.
 *Complexity:* Constant.
 ``` cpp
+constexpr explicit list(size_type n, const Allocator& = Allocator());
 ```
+*Preconditions:* `T` is *Cpp17DefaultInsertable* into `list`.
 *Effects:* Constructs a `list` with `n` default-inserted elements using
 the specified allocator.
 *Complexity:* Linear in `n`.
 ``` cpp
+constexpr list(size_type n, const T& value, const Allocator& = Allocator());
 ```
+*Preconditions:* `T` is *Cpp17CopyInsertable* into `list`.
 *Effects:* Constructs a `list` with `n` copies of `value`, using the
 specified allocator.
 *Complexity:* Linear in `n`.
 ``` cpp
 template<class InputIterator>
+ constexpr list(InputIterator first, InputIterator last, const Allocator& = Allocator());
 ```
 *Effects:* Constructs a `list` equal to the range \[`first`, `last`).
 *Complexity:* Linear in `distance(first, last)`.
 ``` cpp
 template<container-compatible-range<T> R>
+ constexpr list(from_range_t, R&& rg, const Allocator& = Allocator());
 ```
 *Effects:* Constructs a `list` object with the elements of the range
 `rg`.
 *Complexity:* Linear in `ranges::distance(rg)`.
 #### Capacity <a id="list.capacity">[[list.capacity]]</a>
 ``` cpp
+constexpr void resize(size_type sz);
 ```
+*Preconditions:* `T` is *Cpp17DefaultInsertable* into `list`.
 *Effects:* If `size() < sz`, appends `sz - size()` default-inserted
 elements to the sequence. If `sz <= size()`, equivalent to:
 ``` cpp
 advance(it, sz);
 erase(it, end());
 ```
 ``` cpp
+constexpr void resize(size_type sz, const T& c);
 ```
+*Preconditions:* `T` is *Cpp17CopyInsertable* into `list`.
 *Effects:* As if by:
 ``` cpp
 if (sz > size())
 ```
 #### Modifiers <a id="list.modifiers">[[list.modifiers]]</a>
 ``` cpp
+constexpr iterator insert(const_iterator position, const T& x);
+constexpr iterator insert(const_iterator position, T&& x);
+constexpr iterator insert(const_iterator position, size_type n, const T& x);
 template<class InputIterator>
+ constexpr iterator insert(const_iterator position,
+ InputIterator first, InputIterator last);
 template<container-compatible-range<T> R>
+ constexpr iterator insert_range(const_iterator position, R&& rg);
+constexpr iterator insert(const_iterator position, initializer_list<T>);
+template<class... Args> constexpr reference emplace_front(Args&&... args);
+template<class... Args> constexpr reference emplace_back(Args&&... args);
+template<class... Args> constexpr iterator emplace(const_iterator position, Args&&... args);
+constexpr void push_front(const T& x);
+constexpr void push_front(T&& x);
 template<container-compatible-range<T> R>
+ constexpr void prepend_range(R&& rg);
+constexpr void push_back(const T& x);
+constexpr void push_back(T&& x);
 template<container-compatible-range<T> R>
+ constexpr void append_range(R&& rg);
 ```
 *Complexity:* Insertion of a single element into a list takes constant
 time and exactly one call to a constructor of `T`. Insertion of multiple
 elements into a list is linear in the number of elements inserted, and
 the number of calls to the copy constructor or move constructor of `T`
 is exactly equal to the number of elements inserted.
 *Remarks:* Does not affect the validity of iterators and references. If
+an exception is thrown, there are no effects.
 ``` cpp
+constexpr iterator erase(const_iterator position);
+constexpr iterator erase(const_iterator first, const_iterator last);
+constexpr void pop_front();
+constexpr void pop_back();
+constexpr void clear() noexcept;
 ```
 *Effects:* Invalidates only the iterators and references to the erased
 elements.
 from one list to another. The behavior of splice operations is undefined
 if `get_allocator() !=
 x.get_allocator()`.
 ``` cpp
+constexpr void splice(const_iterator position, list& x);
+constexpr void splice(const_iterator position, list&& x);
 ```
 *Preconditions:* `addressof(x) != this` is `true`.
 *Effects:* Inserts the contents of `x` before `position` and `x` becomes
 *Throws:* Nothing.
 *Complexity:* Constant time.
 ``` cpp
+constexpr void splice(const_iterator position, list& x, const_iterator i);
+constexpr void splice(const_iterator position, list&& x, const_iterator i);
 ```
 *Preconditions:* `i` is a valid dereferenceable iterator of `x`.
 *Effects:* Inserts an element pointed to by `i` from list `x` before
 *Throws:* Nothing.
 *Complexity:* Constant time.
 ``` cpp
+constexpr void splice(const_iterator position, list& x,
+ const_iterator first, const_iterator last);
+constexpr void splice(const_iterator position, list&& x,
+ const_iterator first, const_iterator last);
 ```
+*Preconditions:* \[`first`, `last`) is a valid range in `x`. `position`
+is not an iterator in the range \[`first`, `last`).
 *Effects:* Inserts elements in the range \[`first`, `last`) before
 `position` and removes the elements from `x`. Pointers and references to
 the moved elements of `x` now refer to those same elements but as
 members of `*this`. Iterators referring to the moved elements will
 *Complexity:* Constant time if `addressof(x) == this`; otherwise, linear
 time.
 ``` cpp
+constexpr size_type remove(const T& value);
+template<class Predicate> constexpr size_type remove_if(Predicate pred);
 ```
 *Effects:* Erases all the elements in the list referred to by a list
 iterator `i` for which the following conditions hold: `*i == value`,
 `pred(*i) != false`. Invalidates only the iterators and references to
 predicate.
 *Remarks:* Stable [[algorithm.stable]].
 ``` cpp
+constexpr size_type unique();
+template<class BinaryPredicate> constexpr size_type unique(BinaryPredicate binary_pred);
 ```
 Let `binary_pred` be `equal_to<>{}` for the first overload.
 *Preconditions:* `binary_pred` is an equivalence relation.
 *Complexity:* If `empty()` is `false`, exactly `size() - 1` applications
 of the corresponding predicate, otherwise no applications of the
 predicate.
 ``` cpp
+constexpr void merge(list& x);
+constexpr void merge(list&& x);
+template<class Compare> constexpr void merge(list& x, Compare comp);
+template<class Compare> constexpr void merge(list&& x, Compare comp);
 ```
 Let `comp` be `less<>` for the first two overloads.
 *Preconditions:* `*this` and `x` are both sorted with respect to the
 *Complexity:* At most `size() + x.size() - 1` comparisons if
 `addressof(x) != this`; otherwise, no comparisons are performed.
 *Remarks:* Stable [[algorithm.stable]]. If `addressof(x) != this`, `x`
 is empty after the merge. No elements are copied by this operation. If
+an exception is thrown other than by a comparison, there are no effects.
 ``` cpp
+constexpr void reverse() noexcept;
 ```
 *Effects:* Reverses the order of the elements in the list. Does not
 affect the validity of iterators and references.
 *Effects:* Sorts the list according to the `operator<` or a `Compare`
 function object. If an exception is thrown, the order of the elements in
 `*this` is unspecified. Does not affect the validity of iterators and
 references.
+*Complexity:* Approximately N log N comparisons, where N is `size()`.
 *Remarks:* Stable [[algorithm.stable]].
 #### Erasure <a id="list.erasure">[[list.erasure]]</a>
 ``` cpp
+template<class T, class Allocator, class U = T>
   typename list<T, Allocator>::size_type
+ constexpr erase(list<T, Allocator>& c, const U& value);
 ```
 *Effects:* Equivalent to:
+``` cpp
+return erase_if(c, [&](const auto& elem) -> bool { return elem == value; });
+```
 ``` cpp
 template<class T, class Allocator, class Predicate>
   typename list<T, Allocator>::size_type
+ constexpr erase_if(list<T, Allocator>& c, Predicate pred);
 ```
 *Effects:* Equivalent to: `return c.remove_if(pred);`
+### Header `<vector>` synopsis <a id="vector.syn">[[vector.syn]]</a>
+``` cpp
+#include <compare>              // see [compare.syn]
+#include <initializer_list>     // see [initializer.list.syn]
+namespace std {
+  // [vector], class template vector
+  template<class T, class Allocator = allocator<T>> class vector;
+  template<class T, class Allocator>
+    constexpr bool operator==(const vector<T, Allocator>& x, const vector<T, Allocator>& y);
+  template<class T, class Allocator>
+    constexpr synth-three-way-result<T>
+      operator<=>(const vector<T, Allocator>& x, const vector<T, Allocator>& y);
+  template<class T, class Allocator>
+    constexpr void swap(vector<T, Allocator>& x, vector<T, Allocator>& y)
+      noexcept(noexcept(x.swap(y)));
+  // [vector.erasure], erasure
+  template<class T, class Allocator, class U = T>
+    constexpr typename vector<T, Allocator>::size_type
+      erase(vector<T, Allocator>& c, const U& value);
+  template<class T, class Allocator, class Predicate>
+    constexpr typename vector<T, Allocator>::size_type
+      erase_if(vector<T, Allocator>& c, Predicate pred);
+  namespace pmr {
+    template<class T>
+      using vector = std::vector<T, polymorphic_allocator<T>>;
+  }
+  // [vector.bool], specialization of vector for bool
+  // [vector.bool.pspc], partial class template specialization vector<bool, Allocator>
+  template<class Allocator>
+    class vector<bool, Allocator>;
+  template<class T>
+    constexpr bool is-vector-bool-reference = see below;          // exposition only
+  // hash support
+  template<class T> struct hash;
+  template<class Allocator> struct hash<vector<bool, Allocator>>;
+  // [vector.bool.fmt], formatter specialization for vector<bool>
+  template<class T, class charT> requires is-vector-bool-reference<T>
+    struct formatter<T, charT>;
+}
+```
 ### Class template `vector` <a id="vector">[[vector]]</a>
 #### Overview <a id="vector.overview">[[vector.overview]]</a>
 A `vector` is a sequence container that supports (amortized) constant
   class vector {
   public:
     // types
     using value_type             = T;
     using allocator_type         = Allocator;
+    using pointer                = allocator_traits<Allocator>::pointer;
+    using const_pointer          = allocator_traits<Allocator>::const_pointer;
     using reference              = value_type&;
     using const_reference        = const value_type&;
     using size_type              = implementation-defined  // type of vector::size_type; // see [container.requirements]
     using difference_type        = implementation-defined  // type of vector::difference_type; // see [container.requirements]
     using iterator               = implementation-defined  // type of vector::iterator; // see [container.requirements]
     constexpr const_iterator         cend() const noexcept;
     constexpr const_reverse_iterator crbegin() const noexcept;
     constexpr const_reverse_iterator crend() const noexcept;
     // [vector.capacity], capacity
+    constexpr bool empty() const noexcept;
     constexpr size_type size() const noexcept;
     constexpr size_type max_size() const noexcept;
     constexpr size_type capacity() const noexcept;
     constexpr void      resize(size_type sz);
     constexpr void      resize(size_type sz, const T& c);
     constexpr void      shrink_to_fit();
     // element access
     constexpr reference       operator[](size_type n);
     constexpr const_reference operator[](size_type n) const;
     constexpr reference       at(size_type n);
+    constexpr const_reference at(size_type n) const;
     constexpr reference       front();
     constexpr const_reference front() const;
     constexpr reference       back();
     constexpr const_reference back() const;
 ``` cpp
 constexpr explicit vector(size_type n, const Allocator& = Allocator());
 ```
+*Preconditions:* `T` is *Cpp17DefaultInsertable* into `vector`.
 *Effects:* Constructs a `vector` with `n` default-inserted elements
 using the specified allocator.
 *Complexity:* Linear in `n`.
 ``` cpp
 constexpr vector(size_type n, const T& value,
                  const Allocator& = Allocator());
 ```
+*Preconditions:* `T` is *Cpp17CopyInsertable* into `vector`.
 *Effects:* Constructs a `vector` with `n` copies of `value`, using the
 specified allocator.
 *Complexity:* Linear in `n`.
 *Effects:* Constructs a `vector` equal to the range \[`first`, `last`),
 using the specified allocator.
 *Complexity:* Makes only N calls to the copy constructor of `T` (where N
 is the distance between `first` and `last`) and no reallocations if
+`InputIterator` meets the *Cpp17ForwardIterator* requirements. It makes
+order N calls to the copy constructor of `T` and order log N
+reallocations if they are just input iterators.
 ``` cpp
 template<container-compatible-range<T> R>
   constexpr vector(from_range_t, R&& rg, const Allocator& = Allocator());
 ```
 *Effects:* Constructs a `vector` object with the elements of the range
 `rg`, using the specified allocator.
 *Complexity:* Initializes exactly N elements from the results of
 dereferencing successive iterators of `rg`, where N is
+`ranges::distance(rg)`.
+Performs no reallocations if:
+- `R` models `ranges::approximately_sized_range`, and
+  `ranges::distance(rg) <= ranges::reserve_hint(rg)` is `true`, or
+- `R` models `ranges::forward_range` and `R` does not model
+  `ranges::approximately_sized_range`.
+Otherwise, performs order log N reallocations and order N calls to the
+copy or move constructor of `T`.
 #### Capacity <a id="vector.capacity">[[vector.capacity]]</a>
 ``` cpp
 constexpr size_type capacity() const noexcept;
 ``` cpp
 constexpr void reserve(size_type n);
 ```
+*Preconditions:* `T` is *Cpp17MoveInsertable* into `vector`.
 *Effects:* A directive that informs a `vector` of a planned change in
 size, so that it can manage the storage allocation accordingly. After
 `reserve()`, `capacity()` is greater or equal to the argument of
 `reserve` if reallocation happens; and equal to the previous value of
 exception is thrown other than by the move constructor of a
 non-*Cpp17CopyInsertable* type, there are no effects.
 *Throws:* `length_error` if `n > max_size()`.[^4]
+*Complexity:* Linear in the size of the sequence.
+*Remarks:* The size of the sequence is not changed. Reallocation
+invalidates all the references, pointers, and iterators referring to the
+elements in the sequence, as well as the past-the-end iterator.
 [*Note 1*: If no reallocation happens, they remain
 valid. — *end note*]
 No reallocation shall take place during insertions that happen after a
 ``` cpp
 constexpr void shrink_to_fit();
 ```
+*Preconditions:* `T` is *Cpp17MoveInsertable* into `vector`.
 *Effects:* `shrink_to_fit` is a non-binding request to reduce
 `capacity()` to `size()`.
 [*Note 2*: The request is non-binding to allow latitude for
 implementation-specific optimizations. — *end note*]
 It does not increase `capacity()`, but may reduce `capacity()` by
 causing reallocation. If an exception is thrown other than by the move
+constructor of a non-*Cpp17CopyInsertable* `T`, there are no effects.
 *Complexity:* If reallocation happens, linear in the size of the
 sequence.
 *Remarks:* Reallocation invalidates all the references, pointers, and
 ``` cpp
 constexpr void resize(size_type sz);
 ```
 *Preconditions:* `T` is *Cpp17MoveInsertable* and
+*Cpp17DefaultInsertable* into `vector`.
 *Effects:* If `sz < size()`, erases the last `size() - sz` elements from
 the sequence. Otherwise, appends `sz - size()` default-inserted elements
 to the sequence.
 *Remarks:* If an exception is thrown other than by the move constructor
+of a non-*Cpp17CopyInsertable* `T`, there are no effects.
 ``` cpp
 constexpr void resize(size_type sz, const T& c);
 ```
+*Preconditions:* `T` is *Cpp17CopyInsertable* into `vector`.
 *Effects:* If `sz < size()`, erases the last `size() - sz` elements from
 the sequence. Otherwise, appends `sz - size()` copies of `c` to the
 sequence.
+*Remarks:* If an exception is thrown, there are no effects.
 #### Data <a id="vector.data">[[vector.data]]</a>
 ``` cpp
 constexpr T*       data() noexcept;
 constexpr const T* data() const noexcept;
 ```
 *Returns:* A pointer such that \[`data()`, `data() + size()`) is a valid
+range. For a non-empty vector, `data() == addressof(front())` is `true`.
 *Complexity:* Constant time.
 #### Modifiers <a id="vector.modifiers">[[vector.modifiers]]</a>
 past-the-end iterator. If no reallocation happens, then references,
 pointers, and iterators before the insertion point remain valid but
 those at or after the insertion point, including the past-the-end
 iterator, are invalidated. If an exception is thrown other than by the
 copy constructor, move constructor, assignment operator, or move
+assignment operator of `T` or by any `InputIterator` operation, there
+are no effects. If an exception is thrown while inserting a single
+element at the end and `T` is *Cpp17CopyInsertable* or
 `is_nothrow_move_constructible_v<T>` is `true`, there are no effects.
 Otherwise, if an exception is thrown by the move constructor of a
 non-*Cpp17CopyInsertable* `T`, the effects are unspecified.
+For the declarations taking a range `R`, performs at most one
+reallocation if:
+- `R` models `ranges::approximately_sized_range` and
+  `ranges::distance(rg) <= ranges::reserve_hint(rg)` is `true`, or
+- `R` models `ranges::forward_range` and `R` does not model
+  `ranges::approximately_sized_range`.
+For the declarations taking a pair of `InputIterator`, performs at most
+one reallocation if `InputIterator` meets the *Cpp17ForwardIterator*
+requirements.
 ``` cpp
 constexpr iterator erase(const_iterator position);
 constexpr iterator erase(const_iterator first, const_iterator last);
 constexpr void pop_back();
 ```
 vector after the erased elements.
 #### Erasure <a id="vector.erasure">[[vector.erasure]]</a>
 ``` cpp
+template<class T, class Allocator, class U = T>
   constexpr typename vector<T, Allocator>::size_type
     erase(vector<T, Allocator>& c, const U& value);
 ```
 *Effects:* Equivalent to:
     using reverse_iterator       = std::reverse_iterator<iterator>;
     using const_reverse_iterator = std::reverse_iterator<const_iterator>;
     // bit reference
     class reference {
     public:
       constexpr reference(const reference&) = default;
       constexpr ~reference();
       constexpr operator bool() const noexcept;
       constexpr reference& operator=(bool x) noexcept;
     constexpr const_iterator         cend() const noexcept;
     constexpr const_reverse_iterator crbegin() const noexcept;
     constexpr const_reverse_iterator crend() const noexcept;
     // capacity
+    constexpr bool empty() const noexcept;
     constexpr size_type size() const noexcept;
     constexpr size_type max_size() const noexcept;
     constexpr size_type capacity() const noexcept;
     constexpr void      resize(size_type sz, bool c = false);
     constexpr void      reserve(size_type n);
     constexpr void      shrink_to_fit();
     // element access
     constexpr reference       operator[](size_type n);
     constexpr const_reference operator[](size_type n) const;
     constexpr reference       at(size_type n);
+    constexpr const_reference at(size_type n) const;
     constexpr reference       front();
     constexpr const_reference front() const;
     constexpr reference       back();
     constexpr const_reference back() const;
   };
 }
 ```
 Unless described below, all operations have the same requirements and
+semantics as the `vector` primary template, except that operations
 dealing with the `bool` value type map to bit values in the container
 storage and `allocator_traits::construct` [[allocator.traits.members]]
 is not used to construct these values.
 There is no requirement that the data be stored as a contiguous
     format(const T& ref, FormatContext& ctx) const;
 ```
 Equivalent to: `return `*`underlying_`*`.format(ref, ctx);`
+### Header `<inplace_vector>` synopsis <a id="inplace.vector.syn">[[inplace.vector.syn]]</a>
+``` cpp
+// mostly freestanding
+#include <compare>              // see [compare.syn]
+#include <initializer_list>     // see [initializer.list.syn]
+namespace std {
+  // [inplace.vector], class template inplace_vector
+  template<class T, size_t N> class inplace_vector;             // partially freestanding
+  // [inplace.vector.erasure], erasure
+  template<class T, size_t N, class U = T>
+    constexpr typename inplace_vector<T, N>::size_type
+      erase(inplace_vector<T, N>& c, const U& value);
+  template<class T, size_t N, class Predicate>
+    constexpr typename inplace_vector<T, N>::size_type
+      erase_if(inplace_vector<T, N>& c, Predicate pred);
+}
+```
+### Class template `inplace_vector` <a id="inplace.vector">[[inplace.vector]]</a>
+#### Overview <a id="inplace.vector.overview">[[inplace.vector.overview]]</a>
+An `inplace_vector` is a contiguous container. Its capacity is fixed and
+its elements are stored within the `inplace_vector` object itself.
+An `inplace_vector` meets all of the requirements of a container
+[[container.reqmts]], of a reversible container
+[[container.rev.reqmts]], of a contiguous container, and of a sequence
+container, including most of the optional sequence container
+requirements [[sequence.reqmts]]. The exceptions are the `push_front`,
+`prepend_range`, `pop_front`, and `emplace_front` member functions,
+which are not provided. Descriptions are provided here only for
+operations on `inplace_vector` that are not described in one of these
+tables or for operations where there is additional semantic information.
+For any `N`, `inplace_vector<T, N>::iterator` and
+`inplace_vector<T, N>::const_iterator` meet the constexpr iterator
+requirements.
+Any member function of `inplace_vector<T, N>` that would cause the size
+to exceed `N` throws an exception of type `bad_alloc`.
+Let `IV` denote a specialization of `inplace_vector<T, N>`. If `N` is
+zero, then `IV` is trivially copyable and empty, and
+`std::is_trivially_default_constructible_v<IV>` is `true`. Otherwise:
+- If `is_trivially_copy_constructible_v<T>` is `true`, then `IV` has a
+  trivial copy constructor.
+- If `is_trivially_move_constructible_v<T>` is `true`, then `IV` has a
+  trivial move constructor.
+- If `is_trivially_destructible_v<T>` is `true`, then:
+  - `IV` has a trivial destructor.
+  - If
+    ``` cpp
+    is_trivially_copy_constructible_v<T> && is_trivially_copy_assignable_v<T>
+    ```
+    is `true`, then `IV` has a trivial copy assignment operator.
+  - If
+    ``` cpp
+    is_trivially_move_constructible_v<T> && is_trivially_move_assignable_v<T>
+    ```
+    is `true`, then `IV` has a trivial move assignment operator.
+``` cpp
+namespace std {
+  template<class T, size_t N>
+  class inplace_vector {
+  public:
+    // types:
+    using value_type             = T;
+    using pointer                = T*;
+    using const_pointer          = const T*;
+    using reference              = value_type&;
+    using const_reference        = const value_type&;
+    using size_type              = size_t;
+    using difference_type        = ptrdiff_t;
+    using iterator               = implementation-defined  // type of inplace_vector::iterator; // see [container.requirements]
+    using const_iterator         = implementation-defined  // type of inplace_vector::const_iterator; // see [container.requirements]
+    using reverse_iterator       = std::reverse_iterator<iterator>;
+    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+    // [inplace.vector.cons], construct/copy/destroy
+    constexpr inplace_vector() noexcept;
+    constexpr explicit inplace_vector(size_type n);                         // freestanding-deleted
+    constexpr inplace_vector(size_type n, const T& value);                  // freestanding-deleted
+    template<class InputIterator>
+      constexpr inplace_vector(InputIterator first, InputIterator last);    // freestanding-deleted
+    template<container-compatible-range<T> R>
+      constexpr inplace_vector(from_range_t, R&& rg);                       // freestanding-deleted
+    constexpr inplace_vector(const inplace_vector&);
+    constexpr inplace_vector(inplace_vector&&)
+      noexcept(N == 0 || is_nothrow_move_constructible_v<T>);
+    constexpr inplace_vector(initializer_list<T> il);                       // freestanding-deleted
+    constexpr ~inplace_vector();
+    constexpr inplace_vector& operator=(const inplace_vector& other);
+    constexpr inplace_vector& operator=(inplace_vector&& other)
+      noexcept(N == 0 || (is_nothrow_move_assignable_v<T> &&
+                          is_nothrow_move_constructible_v<T>));
+    constexpr inplace_vector& operator=(initializer_list<T>);               // freestanding-deleted
+    template<class InputIterator>
+      constexpr void assign(InputIterator first, InputIterator last);       // freestanding-deleted
+    template<container-compatible-range<T> R>
+      constexpr void assign_range(R&& rg);                                  // freestanding-deleted
+    constexpr void assign(size_type n, const T& u);                         // freestanding-deleted
+    constexpr void assign(initializer_list<T> il);                          // freestanding-deleted
+    // iterators
+    constexpr iterator               begin()         noexcept;
+    constexpr const_iterator         begin()   const noexcept;
+    constexpr iterator               end()           noexcept;
+    constexpr const_iterator         end()     const noexcept;
+    constexpr reverse_iterator       rbegin()        noexcept;
+    constexpr const_reverse_iterator rbegin()  const noexcept;
+    constexpr reverse_iterator       rend()          noexcept;
+    constexpr const_reverse_iterator rend()    const noexcept;
+    constexpr const_iterator         cbegin()  const noexcept;
+    constexpr const_iterator         cend()    const noexcept;
+    constexpr const_reverse_iterator crbegin() const noexcept;
+    constexpr const_reverse_iterator crend()   const noexcept;
+    // [inplace.vector.capacity], capacity
+    constexpr bool empty() const noexcept;
+    constexpr size_type size() const noexcept;
+    static constexpr size_type max_size() noexcept;
+    static constexpr size_type capacity() noexcept;
+    constexpr void resize(size_type sz);                                    // freestanding-deleted
+    constexpr void resize(size_type sz, const T& c);                        // freestanding-deleted
+    static constexpr void reserve(size_type n);                             // freestanding-deleted
+    static constexpr void shrink_to_fit() noexcept;
+    // element access
+    constexpr reference       operator[](size_type n);
+    constexpr const_reference operator[](size_type n) const;
+    constexpr reference       at(size_type n);                              // freestanding-deleted
+    constexpr const_reference at(size_type n) const;                        // freestanding-deleted
+    constexpr reference       front();
+    constexpr const_reference front() const;
+    constexpr reference       back();
+    constexpr const_reference back() const;
+    // [inplace.vector.data], data access
+    constexpr       T* data()       noexcept;
+    constexpr const T* data() const noexcept;
+    // [inplace.vector.modifiers], modifiers
+    template<class... Args>
+      constexpr reference emplace_back(Args&&... args);                     // freestanding-deleted
+    constexpr reference push_back(const T& x);                              // freestanding-deleted
+    constexpr reference push_back(T&& x);                                   // freestanding-deleted
+    template<container-compatible-range<T> R>
+      constexpr void append_range(R&& rg);                                  // freestanding-deleted
+    constexpr void pop_back();
+    template<class... Args>
+      constexpr pointer try_emplace_back(Args&&... args);
+    constexpr pointer try_push_back(const T& x);
+    constexpr pointer try_push_back(T&& x);
+    template<container-compatible-range<T> R>
+      constexpr ranges::borrowed_iterator_t<R> try_append_range(R&& rg);
+    template<class... Args>
+      constexpr reference unchecked_emplace_back(Args&&... args);
+    constexpr reference unchecked_push_back(const T& x);
+    constexpr reference unchecked_push_back(T&& x);
+    template<class... Args>
+      constexpr iterator emplace(const_iterator position, Args&&... args);  // freestanding-deleted
+    constexpr iterator insert(const_iterator position, const T& x);         // freestanding-deleted
+    constexpr iterator insert(const_iterator position, T&& x);              // freestanding-deleted
+    constexpr iterator insert(const_iterator position, size_type n,         // freestanding-deleted
+                              const T& x);
+    template<class InputIterator>
+      constexpr iterator insert(const_iterator position,                    // freestanding-deleted
+                                InputIterator first, InputIterator last);
+    template<container-compatible-range<T> R>
+      constexpr iterator insert_range(const_iterator position, R&& rg);     // freestanding-deleted
+    constexpr iterator insert(const_iterator position,                      // freestanding-deleted
+                              initializer_list<T> il);
+    constexpr iterator erase(const_iterator position);
+    constexpr iterator erase(const_iterator first, const_iterator last);
+    constexpr void swap(inplace_vector& x)
+      noexcept(N == 0 || (is_nothrow_swappable_v<T> &&
+                          is_nothrow_move_constructible_v<T>));
+    constexpr void clear() noexcept;
+    friend constexpr bool operator==(const inplace_vector& x,
+                                     const inplace_vector& y);
+    friend constexpr synth-three-way-result<T>
+      operator<=>(const inplace_vector& x, const inplace_vector& y);
+    friend constexpr void swap(inplace_vector& x, inplace_vector& y)
+      noexcept(N == 0 || (is_nothrow_swappable_v<T> &&
+                          is_nothrow_move_constructible_v<T>))
+      { x.swap(y); }
+  };
+}
+```
+#### Constructors <a id="inplace.vector.cons">[[inplace.vector.cons]]</a>
+``` cpp
+constexpr explicit inplace_vector(size_type n);
+```
+*Preconditions:* `T` is *Cpp17DefaultInsertable* into `inplace_vector`.
+*Effects:* Constructs an `inplace_vector` with `n` default-inserted
+elements.
+*Complexity:* Linear in `n`.
+``` cpp
+constexpr inplace_vector(size_type n, const T& value);
+```
+*Preconditions:* `T` is *Cpp17CopyInsertable* into `inplace_vector`.
+*Effects:* Constructs an `inplace_vector` with `n` copies of `value`.
+*Complexity:* Linear in `n`.
+``` cpp
+template<class InputIterator>
+  constexpr inplace_vector(InputIterator first, InputIterator last);
+```
+*Effects:* Constructs an `inplace_vector` equal to the range \[`first`,
+`last`).
+*Complexity:* Linear in `distance(first, last)`.
+``` cpp
+template<container-compatible-range<T> R>
+  constexpr inplace_vector(from_range_t, R&& rg);
+```
+*Effects:* Constructs an `inplace_vector` with the elements of the range
+`rg`.
+*Complexity:* Linear in `ranges::distance(rg)`.
+#### Capacity <a id="inplace.vector.capacity">[[inplace.vector.capacity]]</a>
+``` cpp
+static constexpr size_type capacity() noexcept;
+static constexpr size_type max_size() noexcept;
+```
+*Returns:* `N`.
+``` cpp
+constexpr void resize(size_type sz);
+```
+*Preconditions:* `T` is *Cpp17DefaultInsertable* into `inplace_vector`.
+*Effects:* If `sz < size()`, erases the last `size() - sz` elements from
+the sequence. Otherwise, appends `sz - size()` default-inserted elements
+to the sequence.
+*Remarks:* If an exception is thrown, there are no effects on `*this`.
+``` cpp
+constexpr void resize(size_type sz, const T& c);
+```
+*Preconditions:* `T` is *Cpp17CopyInsertable* into `inplace_vector`.
+*Effects:* If `sz < size()`, erases the last `size() - sz` elements from
+the sequence. Otherwise, appends `sz - size()` copies of `c` to the
+sequence.
+*Remarks:* If an exception is thrown, there are no effects on `*this`.
+``` cpp
+static constexpr void reserve(size_type n);
+```
+*Effects:* None.
+*Throws:* `bad_alloc` if `n > capacity()` is `true`.
+``` cpp
+static constexpr void shrink_to_fit() noexcept;
+```
+*Effects:* None.
+#### Data <a id="inplace.vector.data">[[inplace.vector.data]]</a>
+``` cpp
+constexpr       T* data()       noexcept;
+constexpr const T* data() const noexcept;
+```
+*Returns:* A pointer such that \[`data()`, `data() + size()`) is a valid
+range. For a non-empty `inplace_vector`, `data() == addressof(front())`
+is `true`.
+*Complexity:* Constant time.
+#### Modifiers <a id="inplace.vector.modifiers">[[inplace.vector.modifiers]]</a>
+``` cpp
+constexpr iterator insert(const_iterator position, const T& x);
+constexpr iterator insert(const_iterator position, T&& x);
+constexpr iterator insert(const_iterator position, size_type n, const T& x);
+template<class InputIterator>
+  constexpr iterator insert(const_iterator position, InputIterator first, InputIterator last);
+template<container-compatible-range<T> R>
+  constexpr iterator insert_range(const_iterator position, R&& rg);
+constexpr iterator insert(const_iterator position, initializer_list<T> il);
+template<class... Args>
+  constexpr iterator emplace(const_iterator position, Args&&... args);
+template<container-compatible-range<T> R>
+  constexpr void append_range(R&& rg);
+```
+Let n be the value of `size()` before this call for the `append_range`
+overload, and `distance(begin, position)` otherwise.
+*Complexity:* Linear in the number of elements inserted plus the
+distance to the end of the vector.
+*Remarks:* If an exception is thrown other than by the copy constructor,
+move constructor, assignment operator, or move assignment operator of
+`T` or by any `InputIterator` operation, there are no effects.
+Otherwise, if an exception is thrown, then `size()` ≥ n and elements in
+the range `begin() + ``[``0, `n`)` are not modified.
+``` cpp
+constexpr reference push_back(const T& x);
+constexpr reference push_back(T&& x);
+template<class... Args>
+  constexpr reference emplace_back(Args&&... args);
+```
+*Returns:* `back()`.
+*Throws:* `bad_alloc` or any exception thrown by the initialization of
+the inserted element.
+*Complexity:* Constant.
+*Remarks:* If an exception is thrown, there are no effects on `*this`.
+``` cpp
+template<class... Args>
+  constexpr pointer try_emplace_back(Args&&... args);
+constexpr pointer try_push_back(const T& x);
+constexpr pointer try_push_back(T&& x);
+```
+Let `vals` denote a pack:
+- `std::forward<Args>(args)...` for the first overload,
+- `x` for the second overload,
+- `std::move(x)` for the third overload.
+*Preconditions:* `value_type` is *Cpp17EmplaceConstructible* into
+`inplace_vector` from `vals...`.
+*Effects:* If `size() < capacity()` is `true`, appends an object of type
+`T` direct-non-list-initialized with `vals...`. Otherwise, there are no
+effects.
+*Returns:* `nullptr` if `size() == capacity()` is `true`, otherwise
+`addressof(back())`.
+*Throws:* Nothing unless an exception is thrown by the initialization of
+the inserted element.
+*Complexity:* Constant.
+*Remarks:* If an exception is thrown, there are no effects on `*this`.
+``` cpp
+template<container-compatible-range<T> R>
+  constexpr ranges::borrowed_iterator_t<R> try_append_range(R&& rg);
+```
+*Preconditions:* `value_type` is *Cpp17EmplaceConstructible* into
+`inplace_vector` from
+`*ranges::begin(rg)`.
+*Effects:* Appends copies of initial elements in `rg` before `end()`,
+until all elements are inserted or `size() == capacity()` is `true`.
+Each iterator in the range `rg` is dereferenced at most once.
+*Returns:* The first iterator in the range `ranges::begin(rg)`+\[0, `n`)
+that was not inserted into `*this`, where `n` is the number of elements
+in `rg`.
+*Complexity:* Linear in the number of elements inserted.
+*Remarks:* Let n be the value of `size()` prior to this call. If an
+exception is thrown after the insertion of k elements, then `size()`
+equals n + k, elements in the range `begin() + ``[``0, `n`)` are not
+modified, and elements in the range `begin() + ``[`n`, `n + k`)`
+correspond to the inserted elements.
+``` cpp
+template<class... Args>
+  constexpr reference unchecked_emplace_back(Args&&... args);
+```
+*Preconditions:* `size() < capacity()` is `true`.
+*Effects:* Equivalent to:
+`return *try_emplace_back(std::forward<Args>(args)...);`
+``` cpp
+constexpr reference unchecked_push_back(const T& x);
+constexpr reference unchecked_push_back(T&& x);
+```
+*Preconditions:* `size() < capacity()` is `true`.
+*Effects:* Equivalent to:
+`return *try_push_back(std::forward<decltype(x)>(x));`
+``` cpp
+constexpr iterator erase(const_iterator position);
+constexpr iterator erase(const_iterator first, const_iterator last);
+constexpr void pop_back();
+```
+*Effects:* Invalidates iterators and references at or after the point of
+the erase.
+*Throws:* Nothing unless an exception is thrown by the assignment
+operator or move assignment operator of `T`.
+*Complexity:* The destructor of `T` is called the number of times equal
+to the number of the elements erased, but the assignment operator of `T`
+is called the number of times equal to the number of elements after the
+erased elements.
+#### Erasure <a id="inplace.vector.erasure">[[inplace.vector.erasure]]</a>
+``` cpp
+template<class T, size_t N, class U = T>
+  constexpr size_t erase(inplace_vector<T, N>& c, const U& value);
+```
+*Effects:* Equivalent to:
+``` cpp
+auto it = remove(c.begin(), c.end(), value);
+auto r = distance(it, c.end());
+c.erase(it, c.end());
+return r;
+```
+``` cpp
+template<class T, size_t N, class Predicate>
+  constexpr size_t erase_if(inplace_vector<T, N>& c, Predicate pred);
+```
+*Effects:* Equivalent to:
+``` cpp
+auto it = remove_if(c.begin(), c.end(), pred);
+auto r = distance(it, c.end());
+c.erase(it, c.end());
+return r;
+```
 ## Associative containers <a id="associative">[[associative]]</a>
+### General <a id="associative.general">[[associative.general]]</a>
 The header `<map>` defines the class templates `map` and `multimap`; the
 header `<set>` defines the class templates `set` and `multiset`.
 The following exposition-only alias templates may appear in deduction
 guides for associative containers:
 ``` cpp
 template<class InputIterator>
+  using iter-value-type = iterator_traits<InputIterator>::value_type;   // exposition only
 template<class InputIterator>
   using iter-key-type = remove_const_t<
     tuple_element_t<0, iter-value-type<InputIterator>>>;                // exposition only
 template<class InputIterator>
   using iter-mapped-type =
     tuple_element_t<1, iter-value-type<InputIterator>>;                 // exposition only
 template<class InputIterator>
   using iter-to-alloc-type = pair<
+ const tuple_element_t<0, iter-value-type<InputIterator>>,
     tuple_element_t<1, iter-value-type<InputIterator>>>;                // exposition only
 template<ranges::input_range Range>
   using range-key-type =
     remove_const_t<typename ranges::range_value_t<Range>::first_type>;  // exposition only
 template<ranges::input_range Range>
+  using range-mapped-type = ranges::range_value_t<Range>::second_type; // exposition only
 template<ranges::input_range Range>
   using range-to-alloc-type =
+    pair<const typename ranges::range_value_t<Range>::first_type,
          typename ranges::range_value_t<Range>::second_type>;           // exposition only
 ```
 ### Header `<map>` synopsis <a id="associative.map.syn">[[associative.map.syn]]</a>
   template<class Key, class T, class Compare = less<Key>,
            class Allocator = allocator<pair<const Key, T>>>
     class map;
   template<class Key, class T, class Compare, class Allocator>
+ constexpr bool operator==(const map<Key, T, Compare, Allocator>& x,
                               const map<Key, T, Compare, Allocator>& y);
   template<class Key, class T, class Compare, class Allocator>
+ constexpr synth-three-way-result<pair<const Key, T>>
       operator<=>(const map<Key, T, Compare, Allocator>& x,
                   const map<Key, T, Compare, Allocator>& y);
   template<class Key, class T, class Compare, class Allocator>
+ constexpr void swap(map<Key, T, Compare, Allocator>& x,
                         map<Key, T, Compare, Allocator>& y)
       noexcept(noexcept(x.swap(y)));
   // [map.erasure], erasure for map
   template<class Key, class T, class Compare, class Allocator, class Predicate>
+ constexpr typename map<Key, T, Compare, Allocator>::size_type
       erase_if(map<Key, T, Compare, Allocator>& c, Predicate pred);
   // [multimap], class template multimap
   template<class Key, class T, class Compare = less<Key>,
            class Allocator = allocator<pair<const Key, T>>>
     class multimap;
   template<class Key, class T, class Compare, class Allocator>
+ constexpr bool operator==(const multimap<Key, T, Compare, Allocator>& x,
                               const multimap<Key, T, Compare, Allocator>& y);
   template<class Key, class T, class Compare, class Allocator>
+ constexpr synth-three-way-result<pair<const Key, T>>
       operator<=>(const multimap<Key, T, Compare, Allocator>& x,
                   const multimap<Key, T, Compare, Allocator>& y);
   template<class Key, class T, class Compare, class Allocator>
+ constexpr void swap(multimap<Key, T, Compare, Allocator>& x,
               multimap<Key, T, Compare, Allocator>& y)
       noexcept(noexcept(x.swap(y)));
   // [multimap.erasure], erasure for multimap
   template<class Key, class T, class Compare, class Allocator, class Predicate>
+ constexpr typename multimap<Key, T, Compare, Allocator>::size_type
       erase_if(multimap<Key, T, Compare, Allocator>& c, Predicate pred);
   namespace pmr {
     template<class Key, class T, class Compare = less<Key>>
       using map = std::map<Key, T, Compare,
                                      polymorphic_allocator<pair<const Key, T>>>;
   }
 }
 ```
 ### Class template `map` <a id="map">[[map]]</a>
 #### Overview <a id="map.overview">[[map.overview]]</a>
 A `map` is an associative container that supports unique keys (i.e.,
 supports bidirectional iterators.
 A `map` meets all of the requirements of a container
 [[container.reqmts]], of a reversible container
 [[container.rev.reqmts]], of an allocator-aware container
+[[container.alloc.reqmts]], and of an associative container
 [[associative.reqmts]]. A `map` also provides most operations described
 in  [[associative.reqmts]] for unique keys. This means that a `map`
 supports the `a_uniq` operations in  [[associative.reqmts]] but not the
 `a_eq` operations. For a `map<Key,T>` the `key_type` is `Key` and the
 `value_type` is `pair<const Key,T>`. Descriptions are provided here only
 for operations on `map` that are not described in one of those tables or
 for operations where there is additional semantic information.
+The types `iterator` and `const_iterator` meet the constexpr iterator
+requirements [[iterator.requirements.general]].
 ``` cpp
 namespace std {
   template<class Key, class T, class Compare = less<Key>,
            class Allocator = allocator<pair<const Key, T>>>
   class map {
     using key_type               = Key;
     using mapped_type            = T;
     using value_type             = pair<const Key, T>;
     using key_compare            = Compare;
     using allocator_type         = Allocator;
+    using pointer                = allocator_traits<Allocator>::pointer;
+    using const_pointer          = allocator_traits<Allocator>::const_pointer;
     using reference              = value_type&;
     using const_reference        = const value_type&;
     using size_type              = implementation-defined  // type of map::size_type; // see [container.requirements]
     using difference_type        = implementation-defined  // type of map::difference_type; // see [container.requirements]
     using iterator               = implementation-defined  // type of map::iterator; // see [container.requirements]
     using const_reverse_iterator = std::reverse_iterator<const_iterator>;
     using node_type              = unspecified;
     using insert_return_type     = insert-return-type<iterator, node_type>;
     class value_compare {
     protected:
       Compare comp;
+ constexpr value_compare(Compare c) : comp(c) {}
     public:
+ constexpr bool operator()(const value_type& x, const value_type& y) const {
         return comp(x.first, y.first);
       }
     };
     // [map.cons], construct/copy/destroy
+ constexpr map() : map(Compare()) { }
+ constexpr explicit map(const Compare& comp, const Allocator& = Allocator());
     template<class InputIterator>
+ constexpr map(InputIterator first, InputIterator last,
                     const Compare& comp = Compare(), const Allocator& = Allocator());
     template<container-compatible-range<value_type> R>
+ constexpr map(from_range_t, R&& rg, const Compare& comp = Compare(),
+ const Allocator& = Allocator());
+ constexpr map(const map& x);
+    constexpr map(map&& x);
     explicit map(const Allocator&);
+ constexpr map(const map&, const type_identity_t<Allocator>&);
+ constexpr map(map&&, const type_identity_t<Allocator>&);
+ constexpr map(initializer_list<value_type>, const Compare& = Compare(),
                   const Allocator& = Allocator());
     template<class InputIterator>
+ constexpr map(InputIterator first, InputIterator last, const Allocator& a)
         : map(first, last, Compare(), a) { }
     template<container-compatible-range<value_type> R>
+ constexpr map(from_range_t, R&& rg, const Allocator& a)
         : map(from_range, std::forward<R>(rg), Compare(), a) { }
+ constexpr map(initializer_list<value_type> il, const Allocator& a)
       : map(il, Compare(), a) { }
+ constexpr ~map();
+ constexpr map& operator=(const map& x);
+ constexpr map& operator=(map&& x)
       noexcept(allocator_traits<Allocator>::is_always_equal::value &&
                is_nothrow_move_assignable_v<Compare>);
+ constexpr map& operator=(initializer_list<value_type>);
+ constexpr allocator_type get_allocator() const noexcept;
     // iterators
+ constexpr iterator               begin() noexcept;
+ constexpr const_iterator         begin() const noexcept;
+ constexpr iterator               end() noexcept;
+ constexpr const_iterator         end() const noexcept;
+ constexpr reverse_iterator       rbegin() noexcept;
+ constexpr const_reverse_iterator rbegin() const noexcept;
+ constexpr reverse_iterator       rend() noexcept;
+ constexpr const_reverse_iterator rend() const noexcept;
+ constexpr const_iterator         cbegin() const noexcept;
+ constexpr const_iterator         cend() const noexcept;
+ constexpr const_reverse_iterator crbegin() const noexcept;
+ constexpr const_reverse_iterator crend() const noexcept;
     // capacity
+ constexpr bool empty() const noexcept;
+ constexpr size_type size() const noexcept;
+ constexpr size_type max_size() const noexcept;
     // [map.access], element access
+ constexpr mapped_type& operator[](const key_type& x);
+ constexpr mapped_type& operator[](key_type&& x);
+ template<class K> constexpr mapped_type& operator[](K&& x);
+ constexpr mapped_type& at(const key_type& x);
+    constexpr const mapped_type& at(const key_type& x) const;
+    template<class K> constexpr mapped_type&       at(const K& x);
+    template<class K> constexpr const mapped_type& at(const K& x) const;
     // [map.modifiers], modifiers
+    template<class... Args> constexpr pair<iterator, bool> emplace(Args&&... args);
+    template<class... Args>
+      constexpr iterator emplace_hint(const_iterator position, Args&&... args);
+ constexpr pair<iterator, bool> insert(const value_type& x);
+ constexpr pair<iterator, bool> insert(value_type&& x);
+ template<class P> constexpr pair<iterator, bool> insert(P&& x);
+ constexpr iterator insert(const_iterator position, const value_type& x);
+    constexpr iterator insert(const_iterator position, value_type&& x);
     template<class P>
+ constexpr iterator insert(const_iterator position, P&&);
     template<class InputIterator>
+ constexpr void insert(InputIterator first, InputIterator last);
     template<container-compatible-range<value_type> R>
+ constexpr void insert_range(R&& rg);
+ constexpr void insert(initializer_list<value_type>);
+ constexpr node_type extract(const_iterator position);
+ constexpr node_type extract(const key_type& x);
+    template<class K> constexpr node_type extract(K&& x);
+ constexpr insert_return_type insert(node_type&& nh);
+ constexpr iterator           insert(const_iterator hint, node_type&& nh);
     template<class... Args>
+ constexpr pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
     template<class... Args>
+ constexpr pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
+    template<class K, class... Args>
+      constexpr pair<iterator, bool> try_emplace(K&& k, Args&&... args);
     template<class... Args>
+ constexpr iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args);
     template<class... Args>
+ constexpr iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);
+    template<class K, class... Args>
+      constexpr iterator try_emplace(const_iterator hint, K&& k, Args&&... args);
     template<class M>
+ constexpr pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);
     template<class M>
+ constexpr pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj);
+    template<class K, class M>
+      constexpr pair<iterator, bool> insert_or_assign(K&& k, M&& obj);
     template<class M>
+ constexpr iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);
     template<class M>
+ constexpr iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj);
+    template<class K, class M>
+      constexpr iterator insert_or_assign(const_iterator hint, K&& k, M&& obj);
+ constexpr iterator  erase(iterator position);
+ constexpr iterator  erase(const_iterator position);
+ constexpr size_type erase(const key_type& x);
+    template<class K> constexpr size_type erase(K&& x);
+ constexpr iterator  erase(const_iterator first, const_iterator last);
+ constexpr void      swap(map&)
       noexcept(allocator_traits<Allocator>::is_always_equal::value &&
                is_nothrow_swappable_v<Compare>);
+ constexpr void      clear() noexcept;
     template<class C2>
+ constexpr void merge(map<Key, T, C2, Allocator>& source);
     template<class C2>
+ constexpr void merge(map<Key, T, C2, Allocator>&& source);
     template<class C2>
+ constexpr void merge(multimap<Key, T, C2, Allocator>& source);
     template<class C2>
+ constexpr void merge(multimap<Key, T, C2, Allocator>&& source);
     // observers
+ constexpr key_compare key_comp() const;
+ constexpr value_compare value_comp() const;
     // map operations
+ constexpr iterator       find(const key_type& x);
+ constexpr const_iterator find(const key_type& x) const;
+    template<class K> constexpr iterator       find(const K& x);
+    template<class K> constexpr const_iterator find(const K& x) const;
+ constexpr size_type      count(const key_type& x) const;
+    template<class K> constexpr size_type count(const K& x) const;
+ constexpr bool           contains(const key_type& x) const;
+    template<class K> constexpr bool contains(const K& x) const;
+ constexpr iterator       lower_bound(const key_type& x);
+ constexpr const_iterator lower_bound(const key_type& x) const;
+    template<class K> constexpr iterator       lower_bound(const K& x);
+    template<class K> constexpr const_iterator lower_bound(const K& x) const;
+ constexpr iterator       upper_bound(const key_type& x);
+ constexpr const_iterator upper_bound(const key_type& x) const;
+    template<class K> constexpr iterator       upper_bound(const K& x);
+    template<class K> constexpr const_iterator upper_bound(const K& x) const;
+ constexpr pair<iterator, iterator>               equal_range(const key_type& x);
+ constexpr pair<const_iterator, const_iterator>   equal_range(const key_type& x) const;
     template<class K>
+ constexpr pair<iterator, iterator>             equal_range(const K& x);
     template<class K>
+ constexpr pair<const_iterator, const_iterator> equal_range(const K& x) const;
   };
   template<class InputIterator, class Compare = less<iter-key-type<InputIterator>>,
            class Allocator = allocator<iter-to-alloc-type<InputIterator>>>
     map(InputIterator, InputIterator, Compare = Compare(), Allocator = Allocator())
 ```
 #### Constructors, copy, and assignment <a id="map.cons">[[map.cons]]</a>
 ``` cpp
+constexpr explicit map(const Compare& comp, const Allocator& = Allocator());
 ```
 *Effects:* Constructs an empty `map` using the specified comparison
 object and allocator.
 *Complexity:* Constant.
 ``` cpp
 template<class InputIterator>
+ constexpr map(InputIterator first, InputIterator last,
                 const Compare& comp = Compare(), const Allocator& = Allocator());
 ```
 *Effects:* Constructs an empty `map` using the specified comparison
 object and allocator, and inserts elements from the range \[`first`,
 sorted with respect to `comp` and otherwise N log N, where N is
 `last - first`.
 ``` cpp
 template<container-compatible-range<value_type> R>
+ constexpr map(from_range_t, R&& rg, const Compare& comp = Compare(),
+                const Allocator& = Allocator());
 ```
 *Effects:* Constructs an empty `map` using the specified comparison
 object and allocator, and inserts elements from the range `rg`.
 `comp` and otherwise N log N, where N is `ranges::distance(rg)`.
 #### Element access <a id="map.access">[[map.access]]</a>
 ``` cpp
+constexpr mapped_type& operator[](const key_type& x);
 ```
 *Effects:* Equivalent to: `return try_emplace(x).first->second;`
 ``` cpp
+constexpr mapped_type& operator[](key_type&& x);
 ```
 *Effects:* Equivalent to:
 `return try_emplace(std::move(x)).first->second;`
 ``` cpp
+template<class K> constexpr mapped_type& operator[](K&& x);
+```
+*Constraints:* The *qualified-id* `Compare::is_transparent` is valid and
+denotes a type.
+*Effects:* Equivalent to:
+`return try_emplace(std::forward<K>(x)).first->second;`
+``` cpp
+constexpr mapped_type&       at(const key_type& x);
+constexpr const mapped_type& at(const key_type& x) const;
 ```
 *Returns:* A reference to the `mapped_type` corresponding to `x` in
 `*this`.
 *Throws:* An exception object of type `out_of_range` if no such element
 is present.
 *Complexity:* Logarithmic.
+``` cpp
+template<class K> constexpr mapped_type&       at(const K& x);
+template<class K> constexpr const mapped_type& at(const K& x) const;
+```
+*Constraints:* The *qualified-id* `Compare::is_transparent` is valid and
+denotes a type.
+*Preconditions:* The expression `find(x)` is well-formed and has
+well-defined behavior.
+*Returns:* A reference to `find(x)->second`.
+*Throws:* An exception object of type `out_of_range` if
+`find(x) == end()` is `true`.
+*Complexity:* Logarithmic.
 #### Modifiers <a id="map.modifiers">[[map.modifiers]]</a>
 ``` cpp
 template<class P>
+ constexpr pair<iterator, bool> insert(P&& x);
 template<class P>
+ constexpr iterator insert(const_iterator position, P&& x);
 ```
 *Constraints:* `is_constructible_v<value_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... Args>
+ constexpr pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
 template<class... Args>
+ constexpr iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args);
 ```
 *Preconditions:* `value_type` is *Cpp17EmplaceConstructible* into `map`
 from `piecewise_construct`, `forward_as_tuple(k)`,
 `forward_as_tuple(std::forward<Args>(args)...)`.
 *Complexity:* The same as `emplace` and `emplace_hint`, respectively.
 ``` cpp
 template<class... Args>
+ constexpr pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
 template<class... Args>
+ constexpr iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);
 ```
 *Preconditions:* `value_type` is *Cpp17EmplaceConstructible* into `map`
 from `piecewise_construct`, `forward_as_tuple(std::move(k))`,
 `forward_as_tuple(std::forward<Args>(args)...)`.
 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 K, class... Args>
+  constexpr pair<iterator, bool> try_emplace(K&& k, Args&&... args);
+template<class K, class... Args>
+  constexpr iterator try_emplace(const_iterator hint, K&& k, Args&&... args);
+```
+*Constraints:* The *qualified-id* `Compare::is_transparent` is valid and
+denotes a type. For the first overload,
+`is_convertible_v<K&&, const_iterator>` and
+`is_convertible_v<K&&, iterator>` are both `false`.
+*Preconditions:* `value_type` is *Cpp17EmplaceConstructible* into `map`
+from
+`piecewise_construct, forward_as_tuple(std::forward<K>(k)), forward_as_tuple(std::forward<Args>(args)...)`.
+*Effects:* If the map already contains an element whose key is
+equivalent to `k`, there is no effect. Otherwise, let `r` be
+`equal_range(k)`. Constructs an object `u` of type `value_type` with
+`piecewise_construct, forward_as_tuple(std::forward<K>(k)), forward_as_tuple(std::forward<Args>(args)...)`.
+If `equal_range(u.first) == r` is `false`, the behavior is undefined.
+Inserts `u` into `*this`.
+*Returns:* For 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>
+ constexpr pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);
 template<class M>
+ constexpr iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);
 ```
 *Mandates:* `is_assignable_v<mapped_type&, M&&>` is `true`.
 *Preconditions:* `value_type` is *Cpp17EmplaceConstructible* into `map`
 *Complexity:* The same as `emplace` and `emplace_hint`, respectively.
 ``` cpp
 template<class M>
+ constexpr pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj);
 template<class M>
+ constexpr iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj);
 ```
 *Mandates:* `is_assignable_v<mapped_type&, M&&>` is `true`.
 *Preconditions:* `value_type` is *Cpp17EmplaceConstructible* into `map`
 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 K, class M>
+  constexpr pair<iterator, bool> insert_or_assign(K&& k, M&& obj);
+template<class K, class M>
+  constexpr iterator insert_or_assign(const_iterator hint, K&& k, M&& obj);
+```
+*Constraints:* The *qualified-id* `Compare::is_transparent` is valid and
+denotes a type.
+*Mandates:* `is_assignable_v<mapped_type&, M&&>` is `true`.
+*Preconditions:* `value_type` is *Cpp17EmplaceConstructible* into `map`
+from `std::forward<K>(k), std:: forward<M>(obj)`.
+*Effects:* If the map already contains an element `e` whose key is
+equivalent to `k`, assigns `std::forward<M> (obj)` to `e.second`.
+Otherwise, let `r` be `equal_range(k)`. Constructs an object `u` of type
+`value_type` with `std::forward<K>(k), std::forward<M>(obj)`. If
+`equal_range(u.first) == r` is `false`, the behavior is undefined.
+Inserts `u` into `*this`.
+*Returns:* For 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.
 #### Erasure <a id="map.erasure">[[map.erasure]]</a>
 ``` cpp
 template<class Key, class T, class Compare, class Allocator, class Predicate>
   typename map<Key, T, Compare, Allocator>::size_type
+ constexpr erase_if(map<Key, T, Compare, Allocator>& c, Predicate pred);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 `Key` and the `value_type` is `pair<const Key,T>`. Descriptions are
 provided here only for operations on `multimap` that are not described
 in one of those tables or for operations where there is additional
 semantic information.
+The types `iterator` and `const_iterator` meet the constexpr iterator
+requirements [[iterator.requirements.general]].
 ``` cpp
 namespace std {
   template<class Key, class T, class Compare = less<Key>,
            class Allocator = allocator<pair<const Key, T>>>
   class multimap {
     using key_type               = Key;
     using mapped_type            = T;
     using value_type             = pair<const Key, T>;
     using key_compare            = Compare;
     using allocator_type         = Allocator;
+    using pointer                = allocator_traits<Allocator>::pointer;
+    using const_pointer          = allocator_traits<Allocator>::const_pointer;
     using reference              = value_type&;
     using const_reference        = const value_type&;
     using size_type              = implementation-defined  // type of multimap::size_type; // see [container.requirements]
     using difference_type        = implementation-defined  // type of multimap::difference_type; // see [container.requirements]
     using iterator               = implementation-defined  // type of multimap::iterator; // see [container.requirements]
     using reverse_iterator       = std::reverse_iterator<iterator>;
     using const_reverse_iterator = std::reverse_iterator<const_iterator>;
     using node_type              = unspecified;
     class value_compare {
     protected:
       Compare comp;
+ constexpr value_compare(Compare c) : comp(c) { }
     public:
+ constexpr bool operator()(const value_type& x, const value_type& y) const {
         return comp(x.first, y.first);
       }
     };
     // [multimap.cons], construct/copy/destroy
+ constexpr multimap() : multimap(Compare()) { }
+ constexpr explicit multimap(const Compare& comp, const Allocator& = Allocator());
     template<class InputIterator>
+ constexpr multimap(InputIterator first, InputIterator last,
+ const Compare& comp = Compare(), const Allocator& = Allocator());
     template<container-compatible-range<value_type> R>
+ constexpr multimap(from_range_t, R&& rg,
                          const Compare& comp = Compare(), const Allocator& = Allocator());
+ constexpr multimap(const multimap& x);
+ constexpr multimap(multimap&& x);
+ constexpr explicit multimap(const Allocator&);
+ constexpr multimap(const multimap&, const type_identity_t<Allocator>&);
+ constexpr multimap(multimap&&, const type_identity_t<Allocator>&);
+ constexpr multimap(initializer_list<value_type>,
+ const Compare& = Compare(), const Allocator& = Allocator());
     template<class InputIterator>
+ constexpr multimap(InputIterator first, InputIterator last, const Allocator& a)
         : multimap(first, last, Compare(), a) { }
     template<container-compatible-range<value_type> R>
+ constexpr multimap(from_range_t, R&& rg, const Allocator& a)
         : multimap(from_range, std::forward<R>(rg), Compare(), a) { }
+ constexpr multimap(initializer_list<value_type> il, const Allocator& a)
       : multimap(il, Compare(), a) { }
+ constexpr ~multimap();
+ constexpr multimap& operator=(const multimap& x);
+ constexpr multimap& operator=(multimap&& x)
       noexcept(allocator_traits<Allocator>::is_always_equal::value &&
                is_nothrow_move_assignable_v<Compare>);
+ constexpr multimap& operator=(initializer_list<value_type>);
+ constexpr allocator_type get_allocator() const noexcept;
     // iterators
+ constexpr iterator               begin() noexcept;
+ constexpr const_iterator         begin() const noexcept;
+ constexpr iterator               end() noexcept;
+ constexpr const_iterator         end() const noexcept;
+ constexpr reverse_iterator       rbegin() noexcept;
+ constexpr const_reverse_iterator rbegin() const noexcept;
+ constexpr reverse_iterator       rend() noexcept;
+ constexpr const_reverse_iterator rend() const noexcept;
+ constexpr const_iterator         cbegin() const noexcept;
+ constexpr const_iterator         cend() const noexcept;
+ constexpr const_reverse_iterator crbegin() const noexcept;
+ constexpr const_reverse_iterator crend() const noexcept;
     // capacity
+ constexpr bool empty() const noexcept;
+ constexpr size_type size() const noexcept;
+ constexpr size_type max_size() const noexcept;
     // [multimap.modifiers], modifiers
+    template<class... Args> constexpr iterator emplace(Args&&... args);
+    template<class... Args>
+      constexpr iterator emplace_hint(const_iterator position, Args&&... args);
+ constexpr iterator insert(const value_type& x);
+ constexpr iterator insert(value_type&& x);
+ template<class P> constexpr iterator insert(P&& x);
+ constexpr iterator insert(const_iterator position, const value_type& x);
+ constexpr iterator insert(const_iterator position, value_type&& x);
+    template<class P> constexpr iterator insert(const_iterator position, P&& x);
     template<class InputIterator>
+ constexpr void insert(InputIterator first, InputIterator last);
     template<container-compatible-range<value_type> R>
+ constexpr void insert_range(R&& rg);
+ constexpr void insert(initializer_list<value_type>);
+ constexpr node_type extract(const_iterator position);
+ constexpr node_type extract(const key_type& x);
     template<class K> node_type extract(K&& x);
+ constexpr iterator insert(node_type&& nh);
+ constexpr iterator insert(const_iterator hint, node_type&& nh);
+ constexpr iterator  erase(iterator position);
+ constexpr iterator  erase(const_iterator position);
+ constexpr size_type erase(const key_type& x);
+    template<class K> constexpr size_type erase(K&& x);
+ constexpr iterator  erase(const_iterator first, const_iterator last);
+ constexpr void      swap(multimap&)
       noexcept(allocator_traits<Allocator>::is_always_equal::value &&
                is_nothrow_swappable_v<Compare>);
+ constexpr void      clear() noexcept;
     template<class C2>
+ constexpr void merge(multimap<Key, T, C2, Allocator>& source);
     template<class C2>
+ constexpr void merge(multimap<Key, T, C2, Allocator>&& source);
     template<class C2>
+ constexpr void merge(map<Key, T, C2, Allocator>& source);
     template<class C2>
+ constexpr void merge(map<Key, T, C2, Allocator>&& source);
     // observers
+ constexpr key_compare key_comp() const;
+ constexpr value_compare value_comp() const;
     // map operations
+ constexpr iterator       find(const key_type& x);
+ constexpr const_iterator find(const key_type& x) const;
+    template<class K> constexpr iterator       find(const K& x);
+    template<class K> constexpr const_iterator find(const K& x) const;
+ constexpr size_type      count(const key_type& x) const;
+    template<class K> constexpr size_type count(const K& x) const;
+ constexpr bool           contains(const key_type& x) const;
+    template<class K> constexpr bool contains(const K& x) const;
+ constexpr iterator       lower_bound(const key_type& x);
+ constexpr const_iterator lower_bound(const key_type& x) const;
+    template<class K> constexpr iterator       lower_bound(const K& x);
+    template<class K> constexpr const_iterator lower_bound(const K& x) const;
+ constexpr iterator       upper_bound(const key_type& x);
+ constexpr const_iterator upper_bound(const key_type& x) const;
+    template<class K> constexpr iterator       upper_bound(const K& x);
+    template<class K> constexpr const_iterator upper_bound(const K& x) const;
+ constexpr pair<iterator, iterator>               equal_range(const key_type& x);
+ constexpr pair<const_iterator, const_iterator>   equal_range(const key_type& x) const;
     template<class K>
+ constexpr pair<iterator, iterator>             equal_range(const K& x);
     template<class K>
+ constexpr pair<const_iterator, const_iterator> equal_range(const K& x) const;
   };
   template<class InputIterator, class Compare = less<iter-key-type<InputIterator>>,
            class Allocator = allocator<iter-to-alloc-type<InputIterator>>>
     multimap(InputIterator, InputIterator, Compare = Compare(), Allocator = Allocator())
 ```
 #### Constructors <a id="multimap.cons">[[multimap.cons]]</a>
 ``` cpp
+constexpr explicit multimap(const Compare& comp, const Allocator& = Allocator());
 ```
 *Effects:* Constructs an empty `multimap` using the specified comparison
 object and allocator.
 *Complexity:* Constant.
 ``` cpp
 template<class InputIterator>
+ constexpr multimap(InputIterator first, InputIterator last,
+ const Compare& comp = Compare(), const Allocator& = Allocator());
 ```
 *Effects:* Constructs an empty `multimap` using the specified comparison
 object and allocator, and inserts elements from the range \[`first`,
 `last`).
 sorted with respect to `comp` and otherwise N log N, where N is
 `last - first`.
 ``` cpp
 template<container-compatible-range<value_type> R>
+ constexpr multimap(from_range_t, R&& rg,
+                     const Compare& comp = Compare(), const Allocator& = Allocator());
 ```
 *Effects:* Constructs an empty `multimap` using the specified comparison
 object and allocator, and inserts elements from the range `rg`.
 `comp` and otherwise N log N, where N is `ranges::distance(rg)`.
 #### Modifiers <a id="multimap.modifiers">[[multimap.modifiers]]</a>
 ``` cpp
+template<class P> constexpr iterator insert(P&& x);
+template<class P> constexpr iterator insert(const_iterator position, P&& x);
 ```
 *Constraints:* `is_constructible_v<value_type, P&&>` is `true`.
 *Effects:* The first form is equivalent to
 #### Erasure <a id="multimap.erasure">[[multimap.erasure]]</a>
 ``` cpp
 template<class Key, class T, class Compare, class Allocator, class Predicate>
   typename multimap<Key, T, Compare, Allocator>::size_type
+ constexpr erase_if(multimap<Key, T, Compare, Allocator>& c, Predicate pred);
 ```
 *Effects:* Equivalent to:
 ``` cpp
   }
 }
 return original_size - c.size();
 ```
+### Header `<set>` synopsis <a id="associative.set.syn">[[associative.set.syn]]</a>
+``` cpp
+#include <compare>              // see [compare.syn]
+#include <initializer_list>     // see [initializer.list.syn]
+namespace std {
+  // [set], class template set
+  template<class Key, class Compare = less<Key>, class Allocator = allocator<Key>>
+    class set;
+  template<class Key, class Compare, class Allocator>
+    constexpr bool operator==(const set<Key, Compare, Allocator>& x,
+                              const set<Key, Compare, Allocator>& y);
+  template<class Key, class Compare, class Allocator>
+    constexpr synth-three-way-result<Key>
+      operator<=>(const set<Key, Compare, Allocator>& x,
+                  const set<Key, Compare, Allocator>& y);
+  template<class Key, class Compare, class Allocator>
+    constexpr void swap(set<Key, Compare, Allocator>& x,
+                        set<Key, Compare, Allocator>& y)
+      noexcept(noexcept(x.swap(y)));
+  // [set.erasure], erasure for set
+  template<class Key, class Compare, class Allocator, class Predicate>
+    constexpr typename set<Key, Compare, Allocator>::size_type
+      erase_if(set<Key, Compare, Allocator>& c, Predicate pred);
+  // [multiset], class template multiset
+  template<class Key, class Compare = less<Key>, class Allocator = allocator<Key>>
+    class multiset;
+  template<class Key, class Compare, class Allocator>
+    constexpr bool operator==(const multiset<Key, Compare, Allocator>& x,
+                              const multiset<Key, Compare, Allocator>& y);
+  template<class Key, class Compare, class Allocator>
+    constexpr synth-three-way-result<Key>
+      operator<=>(const multiset<Key, Compare, Allocator>& x,
+                  const multiset<Key, Compare, Allocator>& y);
+  template<class Key, class Compare, class Allocator>
+    constexpr void swap(multiset<Key, Compare, Allocator>& x,
+                        multiset<Key, Compare, Allocator>& y)
+      noexcept(noexcept(x.swap(y)));
+  // [multiset.erasure], erasure for multiset
+  template<class Key, class Compare, class Allocator, class Predicate>
+    constexpr typename multiset<Key, Compare, Allocator>::size_type
+      erase_if(multiset<Key, Compare, Allocator>& c, Predicate pred);
+  namespace pmr {
+    template<class Key, class Compare = less<Key>>
+      using set = std::set<Key, Compare, polymorphic_allocator<Key>>;
+    template<class Key, class Compare = less<Key>>
+      using multiset = std::multiset<Key, Compare, polymorphic_allocator<Key>>;
+  }
+}
+```
 ### Class template `set` <a id="set">[[set]]</a>
 #### Overview <a id="set.overview">[[set.overview]]</a>
 A `set` is an associative container that supports unique keys (i.e.,
 iterators.
 A `set` meets all of the requirements of a container
 [[container.reqmts]], of a reversible container
 [[container.rev.reqmts]], of an allocator-aware container
+[[container.alloc.reqmts]], and of an associative container
 [[associative.reqmts]]. A `set` also provides most operations described
 in  [[associative.reqmts]] for unique keys. This means that a `set`
 supports the `a_uniq` operations in  [[associative.reqmts]] but not the
 `a_eq` operations. For a `set<Key>` both the `key_type` and `value_type`
 are `Key`. Descriptions are provided here only for operations on `set`
 that are not described in one of these tables and for operations where
 there is additional semantic information.
+The types `iterator` and `const_iterator` meet the constexpr iterator
+requirements [[iterator.requirements.general]].
 ``` cpp
 namespace std {
   template<class Key, class Compare = less<Key>,
            class Allocator = allocator<Key>>
   class set {
     using key_type               = Key;
     using key_compare            = Compare;
     using value_type             = Key;
     using value_compare          = Compare;
     using allocator_type         = Allocator;
+    using pointer                = allocator_traits<Allocator>::pointer;
+    using const_pointer          = allocator_traits<Allocator>::const_pointer;
     using reference              = value_type&;
     using const_reference        = const value_type&;
     using size_type              = implementation-defined  // type of set::size_type; // see [container.requirements]
     using difference_type        = implementation-defined  // type of set::difference_type; // see [container.requirements]
     using iterator               = implementation-defined  // type of set::iterator; // see [container.requirements]
     using const_reverse_iterator = std::reverse_iterator<const_iterator>;
     using node_type              = unspecified;
     using insert_return_type     = insert-return-type<iterator, node_type>;
     // [set.cons], construct/copy/destroy
+ constexpr set() : set(Compare()) { }
+ constexpr explicit set(const Compare& comp, const Allocator& = Allocator());
     template<class InputIterator>
+ constexpr set(InputIterator first, InputIterator last,
                     const Compare& comp = Compare(), const Allocator& = Allocator());
     template<container-compatible-range<value_type> R>
+ constexpr set(from_range_t, R&& rg,
+                    const Compare& comp = Compare(), const Allocator& = Allocator());
+ constexpr set(const set& x);
+ constexpr set(set&& x);
+ constexpr explicit set(const Allocator&);
+ constexpr set(const set&, const type_identity_t<Allocator>&);
+ constexpr set(set&&, const type_identity_t<Allocator>&);
+    constexpr set(initializer_list<value_type>,
+                  const Compare& = Compare(), const Allocator& = Allocator());
     template<class InputIterator>
+ constexpr set(InputIterator first, InputIterator last, const Allocator& a)
         : set(first, last, Compare(), a) { }
     template<container-compatible-range<value_type> R>
+ constexpr set(from_range_t, R&& rg, const Allocator& a)
         : set(from_range, std::forward<R>(rg), Compare(), a) { }
+ constexpr set(initializer_list<value_type> il, const Allocator& a)
       : set(il, Compare(), a) { }
+ constexpr ~set();
+ constexpr set& operator=(const set& x);
+ constexpr set& operator=(set&& x)
       noexcept(allocator_traits<Allocator>::is_always_equal::value &&
                is_nothrow_move_assignable_v<Compare>);
+ constexpr set& operator=(initializer_list<value_type>);
+ constexpr allocator_type get_allocator() const noexcept;
     // iterators
+ constexpr iterator               begin() noexcept;
+ constexpr const_iterator         begin() const noexcept;
+ constexpr iterator               end() noexcept;
+ constexpr const_iterator         end() const noexcept;
+ constexpr reverse_iterator       rbegin() noexcept;
+ constexpr const_reverse_iterator rbegin() const noexcept;
+ constexpr reverse_iterator       rend() noexcept;
+ constexpr const_reverse_iterator rend() const noexcept;
+ constexpr const_iterator         cbegin() const noexcept;
+ constexpr const_iterator         cend() const noexcept;
+ constexpr const_reverse_iterator crbegin() const noexcept;
+ constexpr const_reverse_iterator crend() const noexcept;
     // capacity
+ constexpr bool empty() const noexcept;
+ constexpr size_type size() const noexcept;
+ constexpr size_type max_size() const noexcept;
+    // [set.modifiers], modifiers
+    template<class... Args> constexpr pair<iterator, bool> emplace(Args&&... args);
+    template<class... Args>
+      constexpr iterator emplace_hint(const_iterator position, Args&&... args);
+ constexpr pair<iterator,bool> insert(const value_type& x);
+ constexpr pair<iterator,bool> insert(value_type&& x);
+ template<class K> constexpr pair<iterator, bool> insert(K&& x);
+    constexpr iterator insert(const_iterator position, const value_type& x);
+    constexpr iterator insert(const_iterator position, value_type&& x);
+    template<class K> constexpr iterator insert(const_iterator position, K&& x);
     template<class InputIterator>
+ constexpr void insert(InputIterator first, InputIterator last);
     template<container-compatible-range<value_type> R>
+ constexpr void insert_range(R&& rg);
+ constexpr void insert(initializer_list<value_type>);
+ constexpr node_type extract(const_iterator position);
+ constexpr node_type extract(const key_type& x);
+    template<class K> constexpr node_type extract(K&& x);
+ constexpr insert_return_type insert(node_type&& nh);
+ constexpr iterator           insert(const_iterator hint, node_type&& nh);
+ constexpr iterator  erase(iterator position)
       requires (!same_as<iterator, const_iterator>);
+ constexpr iterator  erase(const_iterator position);
+ constexpr size_type erase(const key_type& x);
+    template<class K> constexpr size_type erase(K&& x);
+ constexpr iterator  erase(const_iterator first, const_iterator last);
+ constexpr void      swap(set&)
       noexcept(allocator_traits<Allocator>::is_always_equal::value &&
                is_nothrow_swappable_v<Compare>);
+ constexpr void      clear() noexcept;
     template<class C2>
+ constexpr void merge(set<Key, C2, Allocator>& source);
     template<class C2>
+ constexpr void merge(set<Key, C2, Allocator>&& source);
     template<class C2>
+ constexpr void merge(multiset<Key, C2, Allocator>& source);
     template<class C2>
+ constexpr void merge(multiset<Key, C2, Allocator>&& source);
     // observers
+ constexpr key_compare key_comp() const;
+ constexpr value_compare value_comp() const;
     // set operations
+ constexpr iterator       find(const key_type& x);
+ constexpr const_iterator find(const key_type& x) const;
+    template<class K> constexpr iterator       find(const K& x);
+    template<class K> constexpr const_iterator find(const K& x) const;
+ constexpr size_type      count(const key_type& x) const;
+    template<class K> constexpr size_type count(const K& x) const;
+ constexpr bool           contains(const key_type& x) const;
+    template<class K> constexpr bool contains(const K& x) const;
+ constexpr iterator       lower_bound(const key_type& x);
+ constexpr const_iterator lower_bound(const key_type& x) const;
+    template<class K> constexpr iterator       lower_bound(const K& x);
+    template<class K> constexpr const_iterator lower_bound(const K& x) const;
+ constexpr iterator       upper_bound(const key_type& x);
+ constexpr const_iterator upper_bound(const key_type& x) const;
+    template<class K> constexpr iterator       upper_bound(const K& x);
+    template<class K> constexpr const_iterator upper_bound(const K& x) const;
+ constexpr pair<iterator, iterator>               equal_range(const key_type& x);
+ constexpr pair<const_iterator, const_iterator>   equal_range(const key_type& x) const;
     template<class K>
+ constexpr pair<iterator, iterator>             equal_range(const K& x);
     template<class K>
+ constexpr pair<const_iterator, const_iterator> equal_range(const K& x) const;
   };
   template<class InputIterator,
            class Compare = less<iter-value-type<InputIterator>>,
            class Allocator = allocator<iter-value-type<InputIterator>>>
 ```
 #### Constructors, copy, and assignment <a id="set.cons">[[set.cons]]</a>
 ``` cpp
+constexpr explicit set(const Compare& comp, const Allocator& = Allocator());
 ```
 *Effects:* Constructs an empty `set` using the specified comparison
 object and allocator.
 *Complexity:* Constant.
 ``` cpp
 template<class InputIterator>
+ constexpr set(InputIterator first, InputIterator last,
                 const Compare& comp = Compare(), const Allocator& = Allocator());
 ```
 *Effects:* Constructs an empty `set` using the specified comparison
 object and allocator, and inserts elements from the range \[`first`,
 sorted with respect to `comp` and otherwise N log N, where N is
 `last - first`.
 ``` cpp
 template<container-compatible-range<value_type> R>
+ constexpr set(from_range_t, R&& rg, const Compare& comp = Compare(),
+                const Allocator& = Allocator());
 ```
 *Effects:* Constructs an empty `set` using the specified comparison
 object and allocator, and inserts elements from the range `rg`.
 #### Erasure <a id="set.erasure">[[set.erasure]]</a>
 ``` cpp
 template<class Key, class Compare, class Allocator, class Predicate>
+ constexpr typename set<Key, Compare, Allocator>::size_type
     erase_if(set<Key, Compare, Allocator>& c, Predicate pred);
 ```
 *Effects:* Equivalent to:
   }
 }
 return original_size - c.size();
 ```
+#### Modifiers <a id="set.modifiers">[[set.modifiers]]</a>
+``` cpp
+template<class K> constexpr pair<iterator, bool> insert(K&& x);
+template<class K> constexpr iterator insert(const_iterator hint, K&& x);
+```
+*Constraints:* The *qualified-id* `Compare::is_transparent` is valid and
+denotes a type. For the second overload,
+`is_convertible_v<K&&, const_iterator>` and
+`is_convertible_v<K&&, iterator>` are both `false`.
+*Preconditions:* `value_type` is *Cpp17EmplaceConstructible* into `set`
+from `std::forward<K>(x)`.
+*Effects:* If the set already contains an element that is equivalent to
+`x`, there is no effect. Otherwise, let `r` be `equal_range(x)`.
+Constructs an object `u` of type `value_type` with `std::forward<K>(x)`.
+If `equal_range(u) == r` is `false`, the behavior is undefined. Inserts
+`u` into `*this`.
+*Returns:* For 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 set element that is equivalent to `x`.
+*Complexity:* Logarithmic.
 ### Class template `multiset` <a id="multiset">[[multiset]]</a>
 #### Overview <a id="multiset.overview">[[multiset.overview]]</a>
 A `multiset` is an associative container that supports equivalent keys
 supports bidirectional iterators.
 A `multiset` meets all of the requirements of a container
 [[container.reqmts]], of a reversible container
 [[container.rev.reqmts]], of an allocator-aware container
+[[container.alloc.reqmts]], and of an associative container
 [[associative.reqmts]]. `multiset` also provides most operations
 described in  [[associative.reqmts]] for duplicate keys. This means that
 a `multiset` supports the `a_eq` operations in  [[associative.reqmts]]
 but not the `a_uniq` operations. For a `multiset<Key>` both the
 `key_type` and `value_type` are `Key`. Descriptions are provided here
 only for operations on `multiset` that are not described in one of these
 tables and for operations where there is additional semantic
 information.
+The types `iterator` and `const_iterator` meet the constexpr iterator
+requirements [[iterator.requirements.general]].
 ``` cpp
 namespace std {
   template<class Key, class Compare = less<Key>,
            class Allocator = allocator<Key>>
   class multiset {
     using key_type               = Key;
     using key_compare            = Compare;
     using value_type             = Key;
     using value_compare          = Compare;
     using allocator_type         = Allocator;
+    using pointer                = allocator_traits<Allocator>::pointer;
+    using const_pointer          = allocator_traits<Allocator>::const_pointer;
     using reference              = value_type&;
     using const_reference        = const value_type&;
     using size_type              = implementation-defined  // type of multiset::size_type; // see [container.requirements]
     using difference_type        = implementation-defined  // type of multiset::difference_type; // see [container.requirements]
     using iterator               = implementation-defined  // type of multiset::iterator; // see [container.requirements]
     using reverse_iterator       = std::reverse_iterator<iterator>;
     using const_reverse_iterator = std::reverse_iterator<const_iterator>;
     using node_type              = unspecified;
     // [multiset.cons], construct/copy/destroy
+ constexpr multiset() : multiset(Compare()) { }
+ constexpr explicit multiset(const Compare& comp, const Allocator& = Allocator());
     template<class InputIterator>
+ constexpr multiset(InputIterator first, InputIterator last,
                          const Compare& comp = Compare(), const Allocator& = Allocator());
     template<container-compatible-range<value_type> R>
+ constexpr multiset(from_range_t, R&& rg,
                          const Compare& comp = Compare(), const Allocator& = Allocator());
+ constexpr multiset(const multiset& x);
+ constexpr multiset(multiset&& x);
+ constexpr explicit multiset(const Allocator&);
+ constexpr multiset(const multiset&, const type_identity_t<Allocator>&);
+ constexpr multiset(multiset&&, const type_identity_t<Allocator>&);
+ constexpr multiset(initializer_list<value_type>, const Compare& = Compare(),
                        const Allocator& = Allocator());
     template<class InputIterator>
+ constexpr multiset(InputIterator first, InputIterator last, const Allocator& a)
         : multiset(first, last, Compare(), a) { }
     template<container-compatible-range<value_type> R>
+ constexpr multiset(from_range_t, R&& rg, const Allocator& a)
         : multiset(from_range, std::forward<R>(rg), Compare(), a) { }
+ constexpr multiset(initializer_list<value_type> il, const Allocator& a)
       : multiset(il, Compare(), a) { }
+ constexpr ~multiset();
+ constexpr multiset& operator=(const multiset& x);
+ constexpr multiset& operator=(multiset&& x)
       noexcept(allocator_traits<Allocator>::is_always_equal::value &&
                is_nothrow_move_assignable_v<Compare>);
+ constexpr multiset& operator=(initializer_list<value_type>);
+ constexpr allocator_type get_allocator() const noexcept;
     // iterators
+ constexpr iterator               begin() noexcept;
+ constexpr const_iterator         begin() const noexcept;
+ constexpr iterator               end() noexcept;
+ constexpr const_iterator         end() const noexcept;
+ constexpr reverse_iterator       rbegin() noexcept;
+ constexpr const_reverse_iterator rbegin() const noexcept;
+ constexpr reverse_iterator       rend() noexcept;
+ constexpr const_reverse_iterator rend() const noexcept;
+ constexpr const_iterator         cbegin() const noexcept;
+ constexpr const_iterator         cend() const noexcept;
+ constexpr const_reverse_iterator crbegin() const noexcept;
+ constexpr const_reverse_iterator crend() const noexcept;
     // capacity
+ constexpr bool empty() const noexcept;
+ constexpr size_type size() const noexcept;
+ constexpr size_type max_size() const noexcept;
     // modifiers
+    template<class... Args> constexpr iterator emplace(Args&&... args);
+    template<class... Args>
+      constexpr iterator emplace_hint(const_iterator position, Args&&... args);
+ constexpr iterator insert(const value_type& x);
+ constexpr iterator insert(value_type&& x);
+ constexpr iterator insert(const_iterator position, const value_type& x);
+    constexpr iterator insert(const_iterator position, value_type&& x);
     template<class InputIterator>
+ constexpr void insert(InputIterator first, InputIterator last);
     template<container-compatible-range<value_type> R>
+ constexpr void insert_range(R&& rg);
+ constexpr void insert(initializer_list<value_type>);
+ constexpr node_type extract(const_iterator position);
+ constexpr node_type extract(const key_type& x);
+    template<class K> constexpr node_type extract(K&& x);
+ constexpr iterator insert(node_type&& nh);
+ constexpr iterator insert(const_iterator hint, node_type&& nh);
+ constexpr iterator  erase(iterator position)
       requires (!same_as<iterator, const_iterator>);
+ constexpr iterator  erase(const_iterator position);
+ constexpr size_type erase(const key_type& x);
+    template<class K> constexpr size_type erase(K&& x);
+ constexpr iterator  erase(const_iterator first, const_iterator last);
+ constexpr void      swap(multiset&)
       noexcept(allocator_traits<Allocator>::is_always_equal::value &&
                is_nothrow_swappable_v<Compare>);
+ constexpr void      clear() noexcept;
     template<class C2>
+ constexpr void merge(multiset<Key, C2, Allocator>& source);
     template<class C2>
+ constexpr void merge(multiset<Key, C2, Allocator>&& source);
     template<class C2>
+ constexpr void merge(set<Key, C2, Allocator>& source);
     template<class C2>
+ constexpr void merge(set<Key, C2, Allocator>&& source);
     // observers
+ constexpr key_compare key_comp() const;
+ constexpr value_compare value_comp() const;
     // set operations
+ constexpr iterator       find(const key_type& x);
+ constexpr const_iterator find(const key_type& x) const;
+    template<class K> constexpr iterator       find(const K& x);
+    template<class K> constexpr const_iterator find(const K& x) const;
+ constexpr size_type      count(const key_type& x) const;
+    template<class K> constexpr size_type count(const K& x) const;
+ constexpr bool           contains(const key_type& x) const;
+    template<class K> constexpr bool contains(const K& x) const;
+ constexpr iterator       lower_bound(const key_type& x);
+ constexpr const_iterator lower_bound(const key_type& x) const;
+    template<class K> constexpr iterator       lower_bound(const K& x);
+    template<class K> constexpr const_iterator lower_bound(const K& x) const;
+ constexpr iterator       upper_bound(const key_type& x);
+ constexpr const_iterator upper_bound(const key_type& x) const;
+    template<class K> constexpr iterator       upper_bound(const K& x);
+    template<class K> constexpr const_iterator upper_bound(const K& x) const;
+ constexpr pair<iterator, iterator>               equal_range(const key_type& x);
+ constexpr pair<const_iterator, const_iterator>   equal_range(const key_type& x) const;
     template<class K>
+ constexpr pair<iterator, iterator>             equal_range(const K& x);
     template<class K>
+ constexpr pair<const_iterator, const_iterator> equal_range(const K& x) const;
   };
   template<class InputIterator,
            class Compare = less<iter-value-type<InputIterator>>,
            class Allocator = allocator<iter-value-type<InputIterator>>>
 ```
 #### Constructors <a id="multiset.cons">[[multiset.cons]]</a>
 ``` cpp
+constexpr explicit multiset(const Compare& comp, const Allocator& = Allocator());
 ```
 *Effects:* Constructs an empty `multiset` using the specified comparison
 object and allocator.
 *Complexity:* Constant.
 ``` cpp
 template<class InputIterator>
+ constexpr multiset(InputIterator first, InputIterator last,
                      const Compare& comp = Compare(), const Allocator& = Allocator());
 ```
 *Effects:* Constructs an empty `multiset` using the specified comparison
 object and allocator, and inserts elements from the range \[`first`,
 sorted with respect to `comp` and otherwise N log N, where N is
 `last - first`.
 ``` cpp
 template<container-compatible-range<value_type> R>
+ constexpr multiset(from_range_t, R&& rg, const Compare& comp = Compare(),
+                     const Allocator& = Allocator());
 ```
 *Effects:* Constructs an empty `multiset` using the specified comparison
 object and allocator, and inserts elements from the range `rg`.
 #### Erasure <a id="multiset.erasure">[[multiset.erasure]]</a>
 ``` cpp
 template<class Key, class Compare, class Allocator, class Predicate>
+ constexpr typename multiset<Key, Compare, Allocator>::size_type
     erase_if(multiset<Key, Compare, Allocator>& c, Predicate pred);
 ```
 *Effects:* Equivalent to:
 return original_size - c.size();
 ```
 ## Unordered associative containers <a id="unord">[[unord]]</a>
+### General <a id="unord.general">[[unord.general]]</a>
 The header `<unordered_map>` defines the class templates `unordered_map`
 and `unordered_multimap`; the header `<unordered_set>` defines the class
 templates `unordered_set` and `unordered_multiset`.
            class Pred = equal_to<Key>,
            class Alloc = allocator<pair<const Key, T>>>
     class unordered_multimap;
   template<class Key, class T, class Hash, class Pred, class Alloc>
+ constexpr bool operator==(const unordered_map<Key, T, Hash, Pred, Alloc>& a,
                               const unordered_map<Key, T, Hash, Pred, Alloc>& b);
   template<class Key, class T, class Hash, class Pred, class Alloc>
+ constexpr bool operator==(const unordered_multimap<Key, T, Hash, Pred, Alloc>& a,
                               const unordered_multimap<Key, T, Hash, Pred, Alloc>& b);
   template<class Key, class T, class Hash, class Pred, class Alloc>
+ constexpr void swap(unordered_map<Key, T, Hash, Pred, Alloc>& x,
                         unordered_map<Key, T, Hash, Pred, Alloc>& y)
       noexcept(noexcept(x.swap(y)));
   template<class Key, class T, class Hash, class Pred, class Alloc>
+ constexpr void swap(unordered_multimap<Key, T, Hash, Pred, Alloc>& x,
                         unordered_multimap<Key, T, Hash, Pred, Alloc>& y)
       noexcept(noexcept(x.swap(y)));
   // [unord.map.erasure], erasure for unordered_map
   template<class K, class T, class H, class P, class A, class Predicate>
+ constexpr typename unordered_map<K, T, H, P, A>::size_type
       erase_if(unordered_map<K, T, H, P, A>& c, Predicate pred);
   // [unord.multimap.erasure], erasure for unordered_multimap
   template<class K, class T, class H, class P, class A, class Predicate>
+ constexpr typename unordered_multimap<K, T, H, P, A>::size_type
       erase_if(unordered_multimap<K, T, H, P, A>& c, Predicate pred);
   namespace pmr {
     template<class Key,
              class T,
   }
 }
 ```
 ### Class template `unordered_map` <a id="unord.map">[[unord.map]]</a>
 #### Overview <a id="unord.map.overview">[[unord.map.overview]]</a>
 An `unordered_map` is an unordered associative container that supports
 Subclause  [[unord.map]] only describes operations on `unordered_map`
 that are not described in one of the requirement tables, or for which
 there is additional semantic information.
+The types `iterator` and `const_iterator` meet the constexpr iterator
+requirements [[iterator.requirements.general]].
 ``` cpp
 namespace std {
   template<class Key,
            class T,
            class Hash = hash<Key>,
     using mapped_type          = T;
     using value_type           = pair<const Key, T>;
     using hasher               = Hash;
     using key_equal            = Pred;
     using allocator_type       = Allocator;
+    using pointer              = allocator_traits<Allocator>::pointer;
+    using const_pointer        = allocator_traits<Allocator>::const_pointer;
     using reference            = value_type&;
     using const_reference      = const value_type&;
     using size_type            = implementation-defined  // type of unordered_map::size_type; // see [container.requirements]
     using difference_type      = implementation-defined  // type of unordered_map::difference_type; // see [container.requirements]
     using const_local_iterator = implementation-defined  // type of unordered_map::const_local_iterator; // see [container.requirements]
     using node_type            = unspecified;
     using insert_return_type   = insert-return-type<iterator, node_type>;
     // [unord.map.cnstr], construct/copy/destroy
+ constexpr unordered_map();
+ constexpr explicit unordered_map(size_type n, const hasher& hf = hasher(),
                                      const key_equal& eql = key_equal(),
                                      const allocator_type& a = allocator_type());
     template<class InputIterator>
+ constexpr unordered_map(InputIterator f, InputIterator l,
+ size_type n = see below, const hasher& hf = hasher(),
                               const key_equal& eql = key_equal(),
                               const allocator_type& a = allocator_type());
     template<container-compatible-range<value_type> R>
+ constexpr unordered_map(from_range_t, R&& rg, size_type n = see below,
                               const hasher& hf = hasher(), const key_equal& eql = key_equal(),
                               const allocator_type& a = allocator_type());
+ constexpr unordered_map(const unordered_map&);
+ constexpr unordered_map(unordered_map&&);
+ constexpr explicit unordered_map(const Allocator&);
+ constexpr unordered_map(const unordered_map&, const type_identity_t<Allocator>&);
+ constexpr unordered_map(unordered_map&&, const type_identity_t<Allocator>&);
+ constexpr unordered_map(initializer_list<value_type> il, size_type n = see below,
                             const hasher& hf = hasher(),
                             const key_equal& eql = key_equal(),
                             const allocator_type& a = allocator_type());
+ constexpr unordered_map(size_type n, const allocator_type& a)
       : unordered_map(n, hasher(), key_equal(), a) { }
+ constexpr unordered_map(size_type n, const hasher& hf, const allocator_type& a)
       : unordered_map(n, hf, key_equal(), a) { }
     template<class InputIterator>
+ constexpr unordered_map(InputIterator f, InputIterator l, size_type n,
+                              const allocator_type& a)
         : unordered_map(f, l, n, hasher(), key_equal(), a) { }
     template<class InputIterator>
+ constexpr unordered_map(InputIterator f, InputIterator l, size_type n, const hasher& hf,
                               const allocator_type& a)
         : unordered_map(f, l, n, hf, key_equal(), a) { }
     template<container-compatible-range<value_type> R>
+ constexpr unordered_map(from_range_t, R&& rg, size_type n, const allocator_type& a)
         : unordered_map(from_range, std::forward<R>(rg), n, hasher(), key_equal(), a) { }
     template<container-compatible-range<value_type> R>
+ constexpr unordered_map(from_range_t, R&& rg, size_type n, const hasher& hf,
+                              const allocator_type& a)
         : unordered_map(from_range, std::forward<R>(rg), n, hf, key_equal(), a) { }
+ constexpr unordered_map(initializer_list<value_type> il, size_type n,
+                            const allocator_type& a)
       : unordered_map(il, n, hasher(), key_equal(), a) { }
+ constexpr unordered_map(initializer_list<value_type> il, size_type n, const hasher& hf,
                             const allocator_type& a)
       : unordered_map(il, n, hf, key_equal(), a) { }
+ constexpr ~unordered_map();
+ constexpr unordered_map& operator=(const unordered_map&);
+ constexpr unordered_map& operator=(unordered_map&&)
       noexcept(allocator_traits<Allocator>::is_always_equal::value &&
                is_nothrow_move_assignable_v<Hash> &&
                is_nothrow_move_assignable_v<Pred>);
+ constexpr unordered_map& operator=(initializer_list<value_type>);
+ constexpr allocator_type get_allocator() const noexcept;
     // iterators
+ constexpr iterator       begin() noexcept;
+ constexpr const_iterator begin() const noexcept;
+ constexpr iterator       end() noexcept;
+ constexpr const_iterator end() const noexcept;
+ constexpr const_iterator cbegin() const noexcept;
+ constexpr const_iterator cend() const noexcept;
     // capacity
+ constexpr bool empty() const noexcept;
+ constexpr size_type size() const noexcept;
+ constexpr size_type max_size() const noexcept;
     // [unord.map.modifiers], modifiers
+    template<class... Args> constexpr pair<iterator, bool> emplace(Args&&... args);
+    template<class... Args>
+      constexpr iterator emplace_hint(const_iterator position, Args&&... args);
+ constexpr pair<iterator, bool> insert(const value_type& obj);
+ constexpr pair<iterator, bool> insert(value_type&& obj);
+ template<class P> constexpr pair<iterator, bool> insert(P&& obj);
+ constexpr iterator       insert(const_iterator hint, const value_type& obj);
+ constexpr iterator insert(const_iterator hint, value_type&& obj);
+    template<class P> constexpr iterator insert(const_iterator hint, P&& obj);
+    template<class InputIterator> constexpr void insert(InputIterator first, InputIterator last);
     template<container-compatible-range<value_type> R>
+ constexpr void insert_range(R&& rg);
+ constexpr void insert(initializer_list<value_type>);
+ constexpr node_type extract(const_iterator position);
+ constexpr node_type extract(const key_type& x);
+    template<class K> constexpr node_type extract(K&& x);
+ constexpr insert_return_type insert(node_type&& nh);
+ constexpr iterator           insert(const_iterator hint, node_type&& nh);
     template<class... Args>
+ constexpr pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
     template<class... Args>
+ constexpr pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
+    template<class K, class... Args>
+      constexpr pair<iterator, bool> try_emplace(K&& k, Args&&... args);
     template<class... Args>
+ constexpr iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args);
     template<class... Args>
+ constexpr iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);
+    template<class K, class... Args>
+      constexpr iterator try_emplace(const_iterator hint, K&& k, Args&&... args);
     template<class M>
+ constexpr pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);
     template<class M>
+ constexpr pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj);
+    template<class K, class M>
+      constexpr pair<iterator, bool> insert_or_assign(K&& k, M&& obj);
     template<class M>
+ constexpr iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);
     template<class M>
+ constexpr iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj);
+    template<class K, class M>
+      constexpr iterator insert_or_assign(const_iterator hint, K&& k, M&& obj);
+ constexpr iterator  erase(iterator position);
+ constexpr iterator  erase(const_iterator position);
+ constexpr size_type erase(const key_type& k);
+    template<class K> constexpr size_type erase(K&& x);
+ constexpr iterator  erase(const_iterator first, const_iterator last);
+ constexpr void      swap(unordered_map&)
       noexcept(allocator_traits<Allocator>::is_always_equal::value &&
+               is_nothrow_swappable_v<Hash> && is_nothrow_swappable_v<Pred>);
+    constexpr void      clear() noexcept;
     template<class H2, class P2>
+ constexpr void merge(unordered_map<Key, T, H2, P2, Allocator>& source);
     template<class H2, class P2>
+ constexpr void merge(unordered_map<Key, T, H2, P2, Allocator>&& source);
     template<class H2, class P2>
+ constexpr void merge(unordered_multimap<Key, T, H2, P2, Allocator>& source);
     template<class H2, class P2>
+ constexpr void merge(unordered_multimap<Key, T, H2, P2, Allocator>&& source);
     // observers
+ constexpr hasher hash_function() const;
+ constexpr key_equal key_eq() const;
     // map operations
+ constexpr iterator         find(const key_type& k);
+ constexpr const_iterator   find(const key_type& k) const;
     template<class K>
+ constexpr iterator       find(const K& k);
     template<class K>
+ constexpr const_iterator find(const K& k) const;
+ constexpr size_type        count(const key_type& k) const;
     template<class K>
+ constexpr size_type      count(const K& k) const;
+ constexpr bool             contains(const key_type& k) const;
     template<class K>
+ constexpr bool           contains(const K& k) const;
+ constexpr pair<iterator, iterator>               equal_range(const key_type& k);
+ constexpr pair<const_iterator, const_iterator>   equal_range(const key_type& k) const;
     template<class K>
+ constexpr pair<iterator, iterator>             equal_range(const K& k);
     template<class K>
+ constexpr pair<const_iterator, const_iterator> equal_range(const K& k) const;
     // [unord.map.elem], element access
+ constexpr mapped_type& operator[](const key_type& k);
+ constexpr mapped_type& operator[](key_type&& k);
+ template<class K> constexpr mapped_type& operator[](K&& k);
+ constexpr mapped_type& at(const key_type& k);
+    constexpr const mapped_type& at(const key_type& k) const;
+    template<class K> constexpr mapped_type& at(const K& k);
+    template<class K> constexpr const mapped_type& at(const K& k) const;
     // bucket interface
+ constexpr size_type bucket_count() const noexcept;
+ constexpr size_type max_bucket_count() const noexcept;
+ constexpr size_type bucket_size(size_type n) const;
+ constexpr size_type bucket(const key_type& k) const;
+ template<class K> constexpr size_type bucket(const K& k) const;
+ constexpr local_iterator begin(size_type n);
+ constexpr const_local_iterator begin(size_type n) const;
+ constexpr local_iterator end(size_type n);
+ constexpr const_local_iterator end(size_type n) const;
+ constexpr const_local_iterator cbegin(size_type n) const;
+    constexpr const_local_iterator cend(size_type n) const;
     // hash policy
+ constexpr float load_factor() const noexcept;
+ constexpr float max_load_factor() const noexcept;
+ constexpr void max_load_factor(float z);
+ constexpr void rehash(size_type n);
+ constexpr void reserve(size_type n);
   };
   template<class InputIterator,
            class Hash = hash<iter-key-type<InputIterator>>,
            class Pred = equal_to<iter-key-type<InputIterator>>,
 deduction guide.
 #### Constructors <a id="unord.map.cnstr">[[unord.map.cnstr]]</a>
 ``` cpp
+constexpr unordered_map() : unordered_map(size_type(see below)) { }
+constexpr explicit unordered_map(size_type n, const hasher& hf = hasher(),
                                  const key_equal& eql = key_equal(),
                                  const allocator_type& a = allocator_type());
 ```
 *Effects:* Constructs an empty `unordered_map` using the specified hash
 *Complexity:* Constant.
 ``` cpp
 template<class InputIterator>
+ constexpr unordered_map(InputIterator f, InputIterator l,
+ size_type n = see below, const hasher& hf = hasher(),
                           const key_equal& eql = key_equal(),
                           const allocator_type& a = allocator_type());
 template<container-compatible-range<value_type> R>
+ constexpr unordered_map(from_range_t, R&& rg,
+ size_type n = see below, const hasher& hf = hasher(),
                           const key_equal& eql = key_equal(),
                           const allocator_type& a = allocator_type());
+constexpr unordered_map(initializer_list<value_type> il,
+ size_type n = see below, const hasher& hf = hasher(),
                         const key_equal& eql = key_equal(),
                         const allocator_type& a = allocator_type());
 ```
 *Effects:* Constructs an empty `unordered_map` using the specified hash
 *Complexity:* Average case linear, worst case quadratic.
 #### Element access <a id="unord.map.elem">[[unord.map.elem]]</a>
 ``` cpp
+constexpr mapped_type& operator[](const key_type& k);
 ```
 *Effects:* Equivalent to: `return try_emplace(k).first->second;`
 ``` cpp
+constexpr mapped_type& operator[](key_type&& k);
 ```
 *Effects:* Equivalent to:
 `return try_emplace(std::move(k)).first->second;`
 ``` cpp
+template<class K> constexpr mapped_type& operator[](K&& k);
+```
+*Constraints:* The *qualified-id*s `Hash::is_transparent` and
+`Pred::is_transparent` are valid and denote types.
+*Effects:* Equivalent to:
+`return try_emplace(std::forward<K>(k)).first->second;`
+``` cpp
+constexpr mapped_type& at(const key_type& k);
+constexpr const mapped_type& at(const key_type& k) const;
 ```
 *Returns:* A reference to `x.second`, where `x` is the (unique) element
 whose key is equivalent to `k`.
 *Throws:* An exception object of type `out_of_range` if no such element
 is present.
+``` cpp
+template<class K> constexpr mapped_type&       at(const K& k);
+template<class K> constexpr const mapped_type& at(const K& k) const;
+```
+*Constraints:* The *qualified-id*s `Hash::is_transparent` and
+`Pred::is_transparent` are valid and denote types.
+*Preconditions:* The expression `find(k)` is well-formed and has
+well-defined behavior.
+*Returns:* A reference to `find(k)->second`.
+*Throws:* An exception object of type `out_of_range` if
+`find(k) == end()` is `true`.
 #### Modifiers <a id="unord.map.modifiers">[[unord.map.modifiers]]</a>
 ``` cpp
 template<class P>
+ constexpr pair<iterator, bool> insert(P&& obj);
 ```
 *Constraints:* `is_constructible_v<value_type, P&&>` is `true`.
 *Effects:* Equivalent to: `return emplace(std::forward<P>(obj));`
 ``` cpp
 template<class P>
+ constexpr iterator insert(const_iterator hint, P&& obj);
 ```
 *Constraints:* `is_constructible_v<value_type, P&&>` is `true`.
 *Effects:* Equivalent to:
 `return emplace_hint(hint, std::forward<P>(obj));`
 ``` cpp
 template<class... Args>
+ constexpr pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
 template<class... Args>
+ constexpr iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args);
 ```
 *Preconditions:* `value_type` is *Cpp17EmplaceConstructible* into
 `unordered_map` from `piecewise_construct`, `forward_as_tuple(k)`,
 `forward_as_tuple(std::forward<Args>(args)...)`.
 *Complexity:* The same as `emplace` and `emplace_hint`, respectively.
 ``` cpp
 template<class... Args>
+ constexpr pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
 template<class... Args>
+ constexpr iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);
 ```
 *Preconditions:* `value_type` is *Cpp17EmplaceConstructible* into
 `unordered_map` from `piecewise_construct`,
 `forward_as_tuple(std::move(k))`,
 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 K, class... Args>
+  constexpr pair<iterator, bool> try_emplace(K&& k, Args&&... args);
+template<class K, class... Args>
+  constexpr iterator try_emplace(const_iterator hint, K&& k, Args&&... args);
+```
+*Constraints:* The *qualified-id*s `Hash::is_transparent` and
+`Pred::is_transparent` are valid and denote types. For the first
+overload, `is_convertible_v<K&&, const_iterator>` and
+`is_convertible_v<K&&, iterator>` are both `false`.
+*Preconditions:* `value_type` is *Cpp17EmplaceConstructible* into
+`unordered_map` from
+`piecewise_construct, forward_as_tuple(std::forward<K>(k)), forward_as_tuple(std::forward<Args> (args)...)`.
+*Effects:* If the map already contains an element whose key is
+equivalent to `k`, there is no effect. Otherwise, let `h` be
+`hash_function()(k)`. Constructs an object `u` of type `value_type` with
+`piecewise_construct, forward_as_tuple(std::forward<K>(k)), forward_as_tuple(std::forward<Args>(args)...)`.
+If `hash_function()(u.first) != h || contains(u.first)` is `true`, the
+behavior is undefined. Inserts `u` into `*this`.
+*Returns:* For 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>
+ constexpr pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);
 template<class M>
+ constexpr iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);
 ```
 *Mandates:* `is_assignable_v<mapped_type&, M&&>` is `true`.
 *Preconditions:* `value_type` is *Cpp17EmplaceConstructible* into
 *Complexity:* The same as `emplace` and `emplace_hint`, respectively.
 ``` cpp
 template<class M>
+ constexpr pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj);
 template<class M>
+ constexpr iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj);
 ```
 *Mandates:* `is_assignable_v<mapped_type&, M&&>` is `true`.
 *Preconditions:* `value_type` is *Cpp17EmplaceConstructible* into
 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 K, class M>
+  constexpr pair<iterator, bool> insert_or_assign(K&& k, M&& obj);
+template<class K, class M>
+  constexpr iterator insert_or_assign(const_iterator hint, K&& k, M&& obj);
+```
+*Constraints:* The *qualified-id*s `Hash::is_transparent` and
+`Pred::is_transparent` are valid and denote types.
+*Mandates:* `is_assignable_v<mapped_type&, M&&>` is `true`.
+*Preconditions:* `value_type` is *Cpp17EmplaceConstructible* into
+`unordered_map` from `std::forward<K> (k), std::forward<M>(obj)`.
+*Effects:* If the map already contains an element `e` whose key is
+equivalent to `k`, assigns `std::forward<M> (obj)` to `e.second`.
+Otherwise, let `h` be `hash_function()(k)`. Constructs an object `u` of
+type `value_type` with `std::forward<K>(k), std::forward<M>(obj)`. If
+`hash_function()(u.first) != h || contains(u.first)` is `true`, the
+behavior is undefined. Inserts `u` into `*this`.
+*Returns:* For 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.
 #### Erasure <a id="unord.map.erasure">[[unord.map.erasure]]</a>
 ``` cpp
 template<class K, class T, class H, class P, class A, class Predicate>
+ constexpr typename unordered_map<K, T, H, P, A>::size_type
     erase_if(unordered_map<K, T, H, P, A>& c, Predicate pred);
 ```
 *Effects:* Equivalent to:
 Subclause  [[unord.multimap]] only describes operations on
 `unordered_multimap` that are not described in one of the requirement
 tables, or for which there is additional semantic information.
+The types `iterator` and `const_iterator` meet the constexpr iterator
+requirements [[iterator.requirements.general]].
 ``` cpp
 namespace std {
   template<class Key,
            class T,
            class Hash = hash<Key>,
     using mapped_type          = T;
     using value_type           = pair<const Key, T>;
     using hasher               = Hash;
     using key_equal            = Pred;
     using allocator_type       = Allocator;
+    using pointer              = allocator_traits<Allocator>::pointer;
+    using const_pointer        = allocator_traits<Allocator>::const_pointer;
     using reference            = value_type&;
     using const_reference      = const value_type&;
     using size_type            = implementation-defined  // type of unordered_multimap::size_type; // see [container.requirements]
     using difference_type      = implementation-defined  // type of unordered_multimap::difference_type; // see [container.requirements]
     using local_iterator       = implementation-defined  // type of unordered_multimap::local_iterator; // see [container.requirements]
     using const_local_iterator = implementation-defined  // type of unordered_multimap::const_local_iterator; // see [container.requirements]
     using node_type            = unspecified;
     // [unord.multimap.cnstr], construct/copy/destroy
+ constexpr unordered_multimap();
+ constexpr explicit unordered_multimap(size_type n, const hasher& hf = hasher(),
                                           const key_equal& eql = key_equal(),
                                           const allocator_type& a = allocator_type());
     template<class InputIterator>
+ constexpr unordered_multimap(InputIterator f, InputIterator l,
+ size_type n = see below, const hasher& hf = hasher(),
                                    const key_equal& eql = key_equal(),
                                    const allocator_type& a = allocator_type());
     template<container-compatible-range<value_type> R>
+ constexpr unordered_multimap(from_range_t, R&& rg,
+ size_type n = see below, const hasher& hf = hasher(),
                                    const key_equal& eql = key_equal(),
                                    const allocator_type& a = allocator_type());
+ constexpr unordered_multimap(const unordered_multimap&);
+ constexpr unordered_multimap(unordered_multimap&&);
+ constexpr explicit unordered_multimap(const Allocator&);
+ constexpr unordered_multimap(const unordered_multimap&, const type_identity_t<Allocator>&);
+ constexpr unordered_multimap(unordered_multimap&&, const type_identity_t<Allocator>&);
+ constexpr unordered_multimap(initializer_list<value_type> il,
+ size_type n = see below, const hasher& hf = hasher(),
                                  const key_equal& eql = key_equal(),
                                  const allocator_type& a = allocator_type());
+ constexpr unordered_multimap(size_type n, const allocator_type& a)
       : unordered_multimap(n, hasher(), key_equal(), a) { }
+ constexpr unordered_multimap(size_type n, const hasher& hf, const allocator_type& a)
       : unordered_multimap(n, hf, key_equal(), a) { }
     template<class InputIterator>
+ constexpr unordered_multimap(InputIterator f, InputIterator l, size_type n,
+                                   const allocator_type& a)
         : unordered_multimap(f, l, n, hasher(), key_equal(), a) { }
     template<class InputIterator>
+ constexpr unordered_multimap(InputIterator f, InputIterator l, size_type n,
+ const hasher& hf, const allocator_type& a)
         : unordered_multimap(f, l, n, hf, key_equal(), a) { }
     template<container-compatible-range<value_type> R>
+      constexpr unordered_multimap(from_range_t, R&& rg, size_type n, const allocator_type& a)
         : unordered_multimap(from_range, std::forward<R>(rg),
                              n, hasher(), key_equal(), a) { }
     template<container-compatible-range<value_type> R>
+      constexpr unordered_multimap(from_range_t, R&& rg, size_type n, const hasher& hf,
                                    const allocator_type& a)
         : unordered_multimap(from_range, std::forward<R>(rg), n, hf, key_equal(), a) { }
+ constexpr unordered_multimap(initializer_list<value_type> il, size_type n,
+                                 const allocator_type& a)
       : unordered_multimap(il, n, hasher(), key_equal(), a) { }
+ constexpr unordered_multimap(initializer_list<value_type> il, size_type n, const hasher& hf,
                                  const allocator_type& a)
       : unordered_multimap(il, n, hf, key_equal(), a) { }
+ constexpr ~unordered_multimap();
+ constexpr unordered_multimap& operator=(const unordered_multimap&);
+ constexpr unordered_multimap& operator=(unordered_multimap&&)
       noexcept(allocator_traits<Allocator>::is_always_equal::value &&
+               is_nothrow_move_assignable_v<Hash> && is_nothrow_move_assignable_v<Pred>);
+    constexpr unordered_multimap& operator=(initializer_list<value_type>);
+ constexpr allocator_type get_allocator() const noexcept;
     // iterators
+ constexpr iterator       begin() noexcept;
+ constexpr const_iterator begin() const noexcept;
+ constexpr iterator       end() noexcept;
+ constexpr const_iterator end() const noexcept;
+ constexpr const_iterator cbegin() const noexcept;
+ constexpr const_iterator cend() const noexcept;
     // capacity
+ constexpr bool empty() const noexcept;
+ constexpr size_type size() const noexcept;
+ constexpr size_type max_size() const noexcept;
     // [unord.multimap.modifiers], modifiers
+    template<class... Args> constexpr iterator emplace(Args&&... args);
+    template<class... Args>
+      constexpr iterator emplace_hint(const_iterator position, Args&&... args);
+ constexpr iterator insert(const value_type& obj);
+ constexpr iterator insert(value_type&& obj);
+ template<class P> constexpr iterator insert(P&& obj);
+ constexpr iterator insert(const_iterator hint, const value_type& obj);
+ constexpr iterator insert(const_iterator hint, value_type&& obj);
+    template<class P> constexpr iterator insert(const_iterator hint, P&& obj);
+    template<class InputIterator> constexpr void insert(InputIterator first, InputIterator last);
     template<container-compatible-range<value_type> R>
+ constexpr void insert_range(R&& rg);
+ constexpr void insert(initializer_list<value_type>);
+ constexpr node_type extract(const_iterator position);
+ constexpr node_type extract(const key_type& x);
+    template<class K> constexpr node_type extract(K&& x);
+ constexpr iterator insert(node_type&& nh);
+ constexpr iterator insert(const_iterator hint, node_type&& nh);
+ constexpr iterator  erase(iterator position);
+ constexpr iterator  erase(const_iterator position);
+ constexpr size_type erase(const key_type& k);
+    template<class K> constexpr size_type erase(K&& x);
+ constexpr iterator  erase(const_iterator first, const_iterator last);
+ constexpr void      swap(unordered_multimap&)
       noexcept(allocator_traits<Allocator>::is_always_equal::value &&
+               is_nothrow_swappable_v<Hash> && is_nothrow_swappable_v<Pred>);
+    constexpr void      clear() noexcept;
     template<class H2, class P2>
+ constexpr void merge(unordered_multimap<Key, T, H2, P2, Allocator>& source);
     template<class H2, class P2>
+ constexpr void merge(unordered_multimap<Key, T, H2, P2, Allocator>&& source);
     template<class H2, class P2>
+ constexpr void merge(unordered_map<Key, T, H2, P2, Allocator>& source);
     template<class H2, class P2>
+ constexpr void merge(unordered_map<Key, T, H2, P2, Allocator>&& source);
     // observers
+ constexpr hasher hash_function() const;
+ constexpr key_equal key_eq() const;
     // map operations
+ constexpr iterator         find(const key_type& k);
+ constexpr const_iterator   find(const key_type& k) const;
     template<class K>
+ constexpr iterator       find(const K& k);
     template<class K>
+ constexpr const_iterator find(const K& k) const;
+ constexpr size_type        count(const key_type& k) const;
     template<class K>
+ constexpr size_type      count(const K& k) const;
+ constexpr bool             contains(const key_type& k) const;
     template<class K>
+ constexpr bool           contains(const K& k) const;
+ constexpr pair<iterator, iterator>               equal_range(const key_type& k);
+ constexpr pair<const_iterator, const_iterator>   equal_range(const key_type& k) const;
     template<class K>
+ constexpr pair<iterator, iterator>             equal_range(const K& k);
     template<class K>
+ constexpr pair<const_iterator, const_iterator> equal_range(const K& k) const;
     // bucket interface
+ constexpr size_type bucket_count() const noexcept;
+ constexpr size_type max_bucket_count() const noexcept;
+ constexpr size_type bucket_size(size_type n) const;
+ constexpr size_type bucket(const key_type& k) const;
+ template<class K> constexpr size_type bucket(const K& k) const;
+ constexpr local_iterator begin(size_type n);
+ constexpr const_local_iterator begin(size_type n) const;
+ constexpr local_iterator end(size_type n);
+ constexpr const_local_iterator end(size_type n) const;
+ constexpr const_local_iterator cbegin(size_type n) const;
+    constexpr const_local_iterator cend(size_type n) const;
     // hash policy
+ constexpr float load_factor() const noexcept;
+ constexpr float max_load_factor() const noexcept;
+ constexpr void max_load_factor(float z);
+ constexpr void rehash(size_type n);
+ constexpr void reserve(size_type n);
   };
   template<class InputIterator,
            class Hash = hash<iter-key-type<InputIterator>>,
            class Pred = equal_to<iter-key-type<InputIterator>>,
 deduction guide.
 #### Constructors <a id="unord.multimap.cnstr">[[unord.multimap.cnstr]]</a>
 ``` cpp
+constexpr unordered_multimap() : unordered_multimap(size_type(see below)) { }
+constexpr explicit unordered_multimap(size_type n, const hasher& hf = hasher(),
                                       const key_equal& eql = key_equal(),
                                       const allocator_type& a = allocator_type());
 ```
 *Effects:* Constructs an empty `unordered_multimap` using the specified
 *Complexity:* Constant.
 ``` cpp
 template<class InputIterator>
+ constexpr unordered_multimap(InputIterator f, InputIterator l,
+ size_type n = see below, const hasher& hf = hasher(),
                                const key_equal& eql = key_equal(),
                                const allocator_type& a = allocator_type());
 template<container-compatible-range<value_type> R>
+ constexpr unordered_multimap(from_range_t, R&& rg,
+ size_type n = see below, const hasher& hf = hasher(),
                                const key_equal& eql = key_equal(),
                                const allocator_type& a = allocator_type());
+constexpr unordered_multimap(initializer_list<value_type> il,
+ size_type n = see below, const hasher& hf = hasher(),
                              const key_equal& eql = key_equal(),
                              const allocator_type& a = allocator_type());
 ```
 *Effects:* Constructs an empty `unordered_multimap` using the specified
 #### Modifiers <a id="unord.multimap.modifiers">[[unord.multimap.modifiers]]</a>
 ``` cpp
 template<class P>
+ constexpr iterator insert(P&& obj);
 ```
 *Constraints:* `is_constructible_v<value_type, P&&>` is `true`.
 *Effects:* Equivalent to: `return emplace(std::forward<P>(obj));`
 ``` cpp
 template<class P>
+ constexpr iterator insert(const_iterator hint, P&& obj);
 ```
 *Constraints:* `is_constructible_v<value_type, P&&>` is `true`.
 *Effects:* Equivalent to:
 #### Erasure <a id="unord.multimap.erasure">[[unord.multimap.erasure]]</a>
 ``` cpp
 template<class K, class T, class H, class P, class A, class Predicate>
+ constexpr typename unordered_multimap<K, T, H, P, A>::size_type
     erase_if(unordered_multimap<K, T, H, P, A>& c, Predicate pred);
 ```
 *Effects:* Equivalent to:
   }
 }
 return original_size - c.size();
 ```
+### Header `<unordered_set>` synopsis <a id="unord.set.syn">[[unord.set.syn]]</a>
+``` cpp
+#include <compare>              // see [compare.syn]
+#include <initializer_list>     // see [initializer.list.syn]
+namespace std {
+  // [unord.set], class template unordered_set
+  template<class Key,
+           class Hash = hash<Key>,
+           class Pred = equal_to<Key>,
+           class Alloc = allocator<Key>>
+    class unordered_set;
+  // [unord.multiset], class template unordered_multiset
+  template<class Key,
+           class Hash = hash<Key>,
+           class Pred = equal_to<Key>,
+           class Alloc = allocator<Key>>
+    class unordered_multiset;
+  template<class Key, class Hash, class Pred, class Alloc>
+    constexpr bool operator==(const unordered_set<Key, Hash, Pred, Alloc>& a,
+                              const unordered_set<Key, Hash, Pred, Alloc>& b);
+  template<class Key, class Hash, class Pred, class Alloc>
+    constexpr bool operator==(const unordered_multiset<Key, Hash, Pred, Alloc>& a,
+                              const unordered_multiset<Key, Hash, Pred, Alloc>& b);
+  template<class Key, class Hash, class Pred, class Alloc>
+    constexpr void swap(unordered_set<Key, Hash, Pred, Alloc>& x,
+                        unordered_set<Key, Hash, Pred, Alloc>& y)
+      noexcept(noexcept(x.swap(y)));
+  template<class Key, class Hash, class Pred, class Alloc>
+    constexpr void swap(unordered_multiset<Key, Hash, Pred, Alloc>& x,
+                        unordered_multiset<Key, Hash, Pred, Alloc>& y)
+      noexcept(noexcept(x.swap(y)));
+  // [unord.set.erasure], erasure for unordered_set
+  template<class K, class H, class P, class A, class Predicate>
+    constexpr typename unordered_set<K, H, P, A>::size_type
+      erase_if(unordered_set<K, H, P, A>& c, Predicate pred);
+  // [unord.multiset.erasure], erasure for unordered_multiset
+  template<class K, class H, class P, class A, class Predicate>
+    constexpr typename unordered_multiset<K, H, P, A>::size_type
+      erase_if(unordered_multiset<K, H, P, A>& c, Predicate pred);
+  namespace pmr {
+    template<class Key,
+             class Hash = hash<Key>,
+             class Pred = equal_to<Key>>
+      using unordered_set = std::unordered_set<Key, Hash, Pred,
+                                               polymorphic_allocator<Key>>;
+    template<class Key,
+             class Hash = hash<Key>,
+             class Pred = equal_to<Key>>
+      using unordered_multiset = std::unordered_multiset<Key, Hash, Pred,
+                                                         polymorphic_allocator<Key>>;
+  }
+}
+```
 ### Class template `unordered_set` <a id="unord.set">[[unord.set]]</a>
 #### Overview <a id="unord.set.overview">[[unord.set.overview]]</a>
 An `unordered_set` is an unordered associative container that supports
 and in which the elements’ keys are the elements themselves. The
 `unordered_set` class supports forward iterators.
 An `unordered_set` meets all of the requirements of a container
 [[container.reqmts]], of an allocator-aware container
+[[container.alloc.reqmts]], and of an unordered associative container
 [[unord.req]]. It provides the operations described in the preceding
 requirements table for unique keys; that is, an `unordered_set` supports
 the `a_uniq` operations in that table, not the `a_eq` operations. For an
 `unordered_set<Key>` the `key_type` and the `value_type` are both `Key`.
 The `iterator` and `const_iterator` types are both constant iterator
 Subclause  [[unord.set]] only describes operations on `unordered_set`
 that are not described in one of the requirement tables, or for which
 there is additional semantic information.
+The types `iterator` and `const_iterator` meet the constexpr iterator
+requirements [[iterator.requirements.general]].
 ``` cpp
 namespace std {
   template<class Key,
            class Hash = hash<Key>,
            class Pred = equal_to<Key>,
     using key_type             = Key;
     using value_type           = Key;
     using hasher               = Hash;
     using key_equal            = Pred;
     using allocator_type       = Allocator;
+    using pointer              = allocator_traits<Allocator>::pointer;
+    using const_pointer        = allocator_traits<Allocator>::const_pointer;
     using reference            = value_type&;
     using const_reference      = const value_type&;
     using size_type            = implementation-defined  // type of unordered_set::size_type; // see [container.requirements]
     using difference_type      = implementation-defined  // type of unordered_set::difference_type; // see [container.requirements]
     using const_local_iterator = implementation-defined  // type of unordered_set::const_local_iterator; // see [container.requirements]
     using node_type            = unspecified;
     using insert_return_type   = insert-return-type<iterator, node_type>;
     // [unord.set.cnstr], construct/copy/destroy
+ constexpr unordered_set();
+ constexpr explicit unordered_set(size_type n, const hasher& hf = hasher(),
                                      const key_equal& eql = key_equal(),
                                      const allocator_type& a = allocator_type());
     template<class InputIterator>
+ constexpr unordered_set(InputIterator f, InputIterator l,
+ size_type n = see below, const hasher& hf = hasher(),
                               const key_equal& eql = key_equal(),
                               const allocator_type& a = allocator_type());
     template<container-compatible-range<value_type> R>
+ constexpr unordered_set(from_range_t, R&& rg,
+ size_type n = see below, const hasher& hf = hasher(),
                               const key_equal& eql = key_equal(),
                               const allocator_type& a = allocator_type());
+ constexpr unordered_set(const unordered_set&);
+ constexpr unordered_set(unordered_set&&);
+ constexpr explicit unordered_set(const Allocator&);
+ constexpr unordered_set(const unordered_set&, const type_identity_t<Allocator>&);
+ constexpr unordered_set(unordered_set&&, const type_identity_t<Allocator>&);
+ constexpr unordered_set(initializer_list<value_type> il,
+ size_type n = see below, const hasher& hf = hasher(),
                             const key_equal& eql = key_equal(),
                             const allocator_type& a = allocator_type());
+ constexpr unordered_set(size_type n, const allocator_type& a)
       : unordered_set(n, hasher(), key_equal(), a) { }
+ constexpr unordered_set(size_type n, const hasher& hf, const allocator_type& a)
       : unordered_set(n, hf, key_equal(), a) { }
     template<class InputIterator>
+ constexpr unordered_set(InputIterator f, InputIterator l, size_type n,
+                              const allocator_type& a)
         : unordered_set(f, l, n, hasher(), key_equal(), a) { }
     template<class InputIterator>
+ constexpr unordered_set(InputIterator f, InputIterator l, size_type n, const hasher& hf,
                               const allocator_type& a)
       : unordered_set(f, l, n, hf, key_equal(), a) { }
+ constexpr unordered_set(initializer_list<value_type> il, size_type n,
+                            const allocator_type& a)
       : unordered_set(il, n, hasher(), key_equal(), a) { }
     template<container-compatible-range<value_type> R>
+ constexpr unordered_set(from_range_t, R&& rg, size_type n, const allocator_type& a)
         : unordered_set(from_range, std::forward<R>(rg), n, hasher(), key_equal(), a) { }
     template<container-compatible-range<value_type> R>
+ constexpr unordered_set(from_range_t, R&& rg, size_type n, const hasher& hf,
+                              const allocator_type& a)
         : unordered_set(from_range, std::forward<R>(rg), n, hf, key_equal(), a) { }
+ constexpr unordered_set(initializer_list<value_type> il, size_type n, const hasher& hf,
                             const allocator_type& a)
       : unordered_set(il, n, hf, key_equal(), a) { }
+ constexpr ~unordered_set();
+ constexpr unordered_set& operator=(const unordered_set&);
+ constexpr unordered_set& operator=(unordered_set&&)
       noexcept(allocator_traits<Allocator>::is_always_equal::value &&
+               is_nothrow_move_assignable_v<Hash> && is_nothrow_move_assignable_v<Pred>);
+    constexpr unordered_set& operator=(initializer_list<value_type>);
+ constexpr allocator_type get_allocator() const noexcept;
     // iterators
+ constexpr iterator       begin() noexcept;
+ constexpr const_iterator begin() const noexcept;
+ constexpr iterator       end() noexcept;
+ constexpr const_iterator end() const noexcept;
+ constexpr const_iterator cbegin() const noexcept;
+ constexpr const_iterator cend() const noexcept;
     // capacity
+ constexpr bool empty() const noexcept;
+ constexpr size_type size() const noexcept;
+ constexpr size_type max_size() const noexcept;
+    // [unord.set.modifiers], modifiers
+    template<class... Args> constexpr pair<iterator, bool> emplace(Args&&... args);
+    template<class... Args>
+      constexpr iterator emplace_hint(const_iterator position, Args&&... args);
+ constexpr pair<iterator, bool> insert(const value_type& obj);
+ constexpr pair<iterator, bool> insert(value_type&& obj);
+ template<class K> constexpr pair<iterator, bool> insert(K&& obj);
+ constexpr iterator insert(const_iterator hint, const value_type& obj);
+    constexpr iterator insert(const_iterator hint, value_type&& obj);
+    template<class K> constexpr iterator insert(const_iterator hint, K&& obj);
+    template<class InputIterator> constexpr void insert(InputIterator first, InputIterator last);
     template<container-compatible-range<value_type> R>
+ constexpr void insert_range(R&& rg);
+ constexpr void insert(initializer_list<value_type>);
+ constexpr node_type extract(const_iterator position);
+ constexpr node_type extract(const key_type& x);
+    template<class K> constexpr node_type extract(K&& x);
+ constexpr insert_return_type insert(node_type&& nh);
+ constexpr iterator           insert(const_iterator hint, node_type&& nh);
+ constexpr iterator  erase(iterator position)
       requires (!same_as<iterator, const_iterator>);
+ constexpr iterator  erase(const_iterator position);
+ constexpr size_type erase(const key_type& k);
+    template<class K> constexpr size_type erase(K&& x);
+ constexpr iterator  erase(const_iterator first, const_iterator last);
+ constexpr void      swap(unordered_set&)
       noexcept(allocator_traits<Allocator>::is_always_equal::value &&
+               is_nothrow_swappable_v<Hash> && is_nothrow_swappable_v<Pred>);
+    constexpr void      clear() noexcept;
     template<class H2, class P2>
+ constexpr void merge(unordered_set<Key, H2, P2, Allocator>& source);
     template<class H2, class P2>
+ constexpr void merge(unordered_set<Key, H2, P2, Allocator>&& source);
     template<class H2, class P2>
+ constexpr void merge(unordered_multiset<Key, H2, P2, Allocator>& source);
     template<class H2, class P2>
+ constexpr void merge(unordered_multiset<Key, H2, P2, Allocator>&& source);
     // observers
+ constexpr hasher hash_function() const;
+ constexpr key_equal key_eq() const;
     // set operations
+ constexpr iterator         find(const key_type& k);
+ constexpr const_iterator   find(const key_type& k) const;
     template<class K>
+ constexpr iterator       find(const K& k);
     template<class K>
+ constexpr const_iterator find(const K& k) const;
+ constexpr size_type        count(const key_type& k) const;
     template<class K>
+ constexpr size_type      count(const K& k) const;
+ constexpr bool             contains(const key_type& k) const;
     template<class K>
+ constexpr bool           contains(const K& k) const;
+ constexpr pair<iterator, iterator>               equal_range(const key_type& k);
+ constexpr pair<const_iterator, const_iterator>   equal_range(const key_type& k) const;
     template<class K>
+ constexpr pair<iterator, iterator>             equal_range(const K& k);
     template<class K>
+ constexpr pair<const_iterator, const_iterator> equal_range(const K& k) const;
     // bucket interface
+ constexpr size_type bucket_count() const noexcept;
+ constexpr size_type max_bucket_count() const noexcept;
+ constexpr size_type bucket_size(size_type n) const;
+ constexpr size_type bucket(const key_type& k) const;
+ template<class K> constexpr size_type bucket(const K& k) const;
+ constexpr local_iterator begin(size_type n);
+ constexpr const_local_iterator begin(size_type n) const;
+ constexpr local_iterator end(size_type n);
+ constexpr const_local_iterator end(size_type n) const;
+ constexpr const_local_iterator cbegin(size_type n) const;
+    constexpr const_local_iterator cend(size_type n) const;
     // hash policy
+ constexpr float load_factor() const noexcept;
+ constexpr float max_load_factor() const noexcept;
+ constexpr void max_load_factor(float z);
+ constexpr void rehash(size_type n);
+ constexpr void reserve(size_type n);
   };
   template<class InputIterator,
            class Hash = hash<iter-value-type<InputIterator>>,
            class Pred = equal_to<iter-value-type<InputIterator>>,
 deduction guide.
 #### Constructors <a id="unord.set.cnstr">[[unord.set.cnstr]]</a>
 ``` cpp
+constexpr unordered_set() : unordered_set(size_type(see below)) { }
+constexpr explicit unordered_set(size_type n, const hasher& hf = hasher(),
                                  const key_equal& eql = key_equal(),
                                  const allocator_type& a = allocator_type());
 ```
 *Effects:* Constructs an empty `unordered_set` using the specified hash
 *Complexity:* Constant.
 ``` cpp
 template<class InputIterator>
+ constexpr unordered_set(InputIterator f, InputIterator l,
+ size_type n = see below, const hasher& hf = hasher(),
                           const key_equal& eql = key_equal(),
                           const allocator_type& a = allocator_type());
 template<container-compatible-range<value_type> R>
+ constexpr unordered_multiset(from_range_t, R&& rg,
+ size_type n = see below, const hasher& hf = hasher(),
                                const key_equal& eql = key_equal(),
                                const allocator_type& a = allocator_type());
+constexpr unordered_set(initializer_list<value_type> il,
+ size_type n = see below, const hasher& hf = hasher(),
                         const key_equal& eql = key_equal(),
                         const allocator_type& a = allocator_type());
 ```
 *Effects:* Constructs an empty `unordered_set` using the specified hash
 #### Erasure <a id="unord.set.erasure">[[unord.set.erasure]]</a>
 ``` cpp
 template<class K, class H, class P, class A, class Predicate>
+ constexpr typename unordered_set<K, H, P, A>::size_type
     erase_if(unordered_set<K, H, P, A>& c, Predicate pred);
 ```
 *Effects:* Equivalent to:
   }
 }
 return original_size - c.size();
 ```
+#### Modifiers <a id="unord.set.modifiers">[[unord.set.modifiers]]</a>
+``` cpp
+template<class K> constexpr pair<iterator, bool> insert(K&& obj);
+template<class K> constexpr iterator insert(const_iterator hint, K&& obj);
+```
+*Constraints:* The *qualified-id*s `Hash::is_transparent` and
+`Pred::is_transparent` are valid and denote types. For the second
+overload, `is_convertible_v<K&&, const_iterator>` and
+`is_convertible_v<K&&, iterator>` are both `false`.
+*Preconditions:* `value_type` is *Cpp17EmplaceConstructible* into
+`unordered_set` from `std::forward<K> (obj)`.
+*Effects:* If the set already contains an element that is equivalent to
+`obj`, there is no effect. Otherwise, let `h` be `hash_function()(obj)`.
+Constructs an object `u` of type `value_type` with
+`std::forward<K>(obj)`. If `hash_function()(u) != h || contains(u)` is
+`true`, the behavior is undefined. Inserts `u` into `*this`.
+*Returns:* For 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 set element that is equivalent to `obj`.
+*Complexity:* Average case constant, worst case linear.
 ### Class template `unordered_multiset` <a id="unord.multiset">[[unord.multiset]]</a>
 #### Overview <a id="unord.multiset.overview">[[unord.multiset.overview]]</a>
 An `unordered_multiset` is an unordered associative container that
 Subclause  [[unord.multiset]] only describes operations on
 `unordered_multiset` that are not described in one of the requirement
 tables, or for which there is additional semantic information.
+The types `iterator` and `const_iterator` meet the constexpr iterator
+requirements [[iterator.requirements.general]].
 ``` cpp
 namespace std {
   template<class Key,
            class Hash = hash<Key>,
            class Pred = equal_to<Key>,
     using key_type             = Key;
     using value_type           = Key;
     using hasher               = Hash;
     using key_equal            = Pred;
     using allocator_type       = Allocator;
+    using pointer              = allocator_traits<Allocator>::pointer;
+    using const_pointer        = allocator_traits<Allocator>::const_pointer;
     using reference            = value_type&;
     using const_reference      = const value_type&;
     using size_type            = implementation-defined  // type of unordered_multiset::size_type; // see [container.requirements]
     using difference_type      = implementation-defined  // type of unordered_multiset::difference_type; // see [container.requirements]
     using local_iterator       = implementation-defined  // type of unordered_multiset::local_iterator; // see [container.requirements]
     using const_local_iterator = implementation-defined  // type of unordered_multiset::const_local_iterator; // see [container.requirements]
     using node_type            = unspecified;
     // [unord.multiset.cnstr], construct/copy/destroy
+ constexpr unordered_multiset();
+ constexpr explicit unordered_multiset(size_type n, const hasher& hf = hasher(),
                                           const key_equal& eql = key_equal(),
                                           const allocator_type& a = allocator_type());
     template<class InputIterator>
+ constexpr unordered_multiset(InputIterator f, InputIterator l,
+ size_type n = see below, const hasher& hf = hasher(),
                                    const key_equal& eql = key_equal(),
                                    const allocator_type& a = allocator_type());
     template<container-compatible-range<value_type> R>
+ constexpr unordered_multiset(from_range_t, R&& rg,
+ size_type n = see below, const hasher& hf = hasher(),
                                    const key_equal& eql = key_equal(),
                                    const allocator_type& a = allocator_type());
+ constexpr unordered_multiset(const unordered_multiset&);
+ constexpr unordered_multiset(unordered_multiset&&);
+ constexpr explicit unordered_multiset(const Allocator&);
+ constexpr unordered_multiset(const unordered_multiset&, const type_identity_t<Allocator>&);
+ constexpr unordered_multiset(unordered_multiset&&, const type_identity_t<Allocator>&);
+ constexpr unordered_multiset(initializer_list<value_type> il,
+ size_type n = see below, const hasher& hf = hasher(),
                                  const key_equal& eql = key_equal(),
                                  const allocator_type& a = allocator_type());
+ constexpr unordered_multiset(size_type n, const allocator_type& a)
       : unordered_multiset(n, hasher(), key_equal(), a) { }
+ constexpr unordered_multiset(size_type n, const hasher& hf, const allocator_type& a)
       : unordered_multiset(n, hf, key_equal(), a) { }
     template<class InputIterator>
+ constexpr unordered_multiset(InputIterator f, InputIterator l, size_type n,
+                                   const allocator_type& a)
         : unordered_multiset(f, l, n, hasher(), key_equal(), a) { }
     template<class InputIterator>
+ constexpr unordered_multiset(InputIterator f, InputIterator l, size_type n,
+ const hasher& hf, const allocator_type& a)
       : unordered_multiset(f, l, n, hf, key_equal(), a) { }
     template<container-compatible-range<value_type> R>
+ constexpr unordered_multiset(from_range_t, R&& rg, size_type n, const allocator_type& a)
         : unordered_multiset(from_range, std::forward<R>(rg),
                              n, hasher(), key_equal(), a) { }
     template<container-compatible-range<value_type> R>
+ constexpr unordered_multiset(from_range_t, R&& rg, size_type n, const hasher& hf,
                                    const allocator_type& a)
         : unordered_multiset(from_range, std::forward<R>(rg), n, hf, key_equal(), a) { }
+ constexpr unordered_multiset(initializer_list<value_type> il, size_type n,
+                                 const allocator_type& a)
       : unordered_multiset(il, n, hasher(), key_equal(), a) { }
+ constexpr unordered_multiset(initializer_list<value_type> il, size_type n, const hasher& hf,
                                  const allocator_type& a)
       : unordered_multiset(il, n, hf, key_equal(), a) { }
+ constexpr ~unordered_multiset();
+ constexpr unordered_multiset& operator=(const unordered_multiset&);
+ constexpr unordered_multiset& operator=(unordered_multiset&&)
       noexcept(allocator_traits<Allocator>::is_always_equal::value &&
+               is_nothrow_move_assignable_v<Hash> && is_nothrow_move_assignable_v<Pred>);
+    constexpr unordered_multiset& operator=(initializer_list<value_type>);
+ constexpr allocator_type get_allocator() const noexcept;
     // iterators
+ constexpr iterator       begin() noexcept;
+ constexpr const_iterator begin() const noexcept;
+ constexpr iterator       end() noexcept;
+ constexpr const_iterator end() const noexcept;
+ constexpr const_iterator cbegin() const noexcept;
+ constexpr const_iterator cend() const noexcept;
     // capacity
+ constexpr bool empty() const noexcept;
+ constexpr size_type size() const noexcept;
+ constexpr size_type max_size() const noexcept;
     // modifiers
+    template<class... Args> constexpr iterator emplace(Args&&... args);
+    template<class... Args>
+      constexpr iterator emplace_hint(const_iterator position, Args&&... args);
+ constexpr iterator insert(const value_type& obj);
+ constexpr iterator insert(value_type&& obj);
+ constexpr iterator insert(const_iterator hint, const value_type& obj);
+ constexpr iterator insert(const_iterator hint, value_type&& obj);
+    template<class InputIterator> constexpr void insert(InputIterator first, InputIterator last);
     template<container-compatible-range<value_type> R>
+ constexpr void insert_range(R&& rg);
+ constexpr void insert(initializer_list<value_type>);
+ constexpr node_type extract(const_iterator position);
+ constexpr node_type extract(const key_type& x);
+    template<class K> constexpr node_type extract(K&& x);
+ constexpr iterator insert(node_type&& nh);
+ constexpr iterator insert(const_iterator hint, node_type&& nh);
+ constexpr iterator  erase(iterator position)
       requires (!same_as<iterator, const_iterator>);
+ constexpr iterator  erase(const_iterator position);
+ constexpr size_type erase(const key_type& k);
+    template<class K> constexpr size_type erase(K&& x);
+ constexpr iterator  erase(const_iterator first, const_iterator last);
+ constexpr void      swap(unordered_multiset&)
       noexcept(allocator_traits<Allocator>::is_always_equal::value &&
+               is_nothrow_swappable_v<Hash> && is_nothrow_swappable_v<Pred>);
+    constexpr void      clear() noexcept;
     template<class H2, class P2>
+ constexpr void merge(unordered_multiset<Key, H2, P2, Allocator>& source);
     template<class H2, class P2>
+ constexpr void merge(unordered_multiset<Key, H2, P2, Allocator>&& source);
     template<class H2, class P2>
+ constexpr void merge(unordered_set<Key, H2, P2, Allocator>& source);
     template<class H2, class P2>
+ constexpr void merge(unordered_set<Key, H2, P2, Allocator>&& source);
     // observers
+ constexpr hasher hash_function() const;
+ constexpr key_equal key_eq() const;
     // set operations
+ constexpr iterator         find(const key_type& k);
+ constexpr const_iterator   find(const key_type& k) const;
     template<class K>
+ constexpr iterator       find(const K& k);
     template<class K>
+ constexpr const_iterator find(const K& k) const;
+ constexpr size_type        count(const key_type& k) const;
     template<class K>
+ constexpr size_type      count(const K& k) const;
+ constexpr bool             contains(const key_type& k) const;
     template<class K>
+ constexpr bool           contains(const K& k) const;
+ constexpr pair<iterator, iterator>               equal_range(const key_type& k);
+ constexpr pair<const_iterator, const_iterator>   equal_range(const key_type& k) const;
     template<class K>
+ constexpr pair<iterator, iterator>             equal_range(const K& k);
     template<class K>
+ constexpr pair<const_iterator, const_iterator> equal_range(const K& k) const;
     // bucket interface
+ constexpr size_type bucket_count() const noexcept;
+ constexpr size_type max_bucket_count() const noexcept;
+ constexpr size_type bucket_size(size_type n) const;
+ constexpr size_type bucket(const key_type& k) const;
+ template<class K> constexpr size_type bucket(const K& k) const;
+ constexpr local_iterator begin(size_type n);
+ constexpr const_local_iterator begin(size_type n) const;
+ constexpr local_iterator end(size_type n);
+ constexpr const_local_iterator end(size_type n) const;
+ constexpr const_local_iterator cbegin(size_type n) const;
+    constexpr const_local_iterator cend(size_type n) const;
     // hash policy
+ constexpr float load_factor() const noexcept;
+ constexpr float max_load_factor() const noexcept;
+ constexpr void max_load_factor(float z);
+ constexpr void rehash(size_type n);
+ constexpr void reserve(size_type n);
   };
   template<class InputIterator,
            class Hash = hash<iter-value-type<InputIterator>>,
            class Pred = equal_to<iter-value-type<InputIterator>>,
            class Allocator = allocator<iter-value-type<InputIterator>>>
+    unordered_multiset(InputIterator, InputIterator, typename see below::size_type = see below,
                        Hash = Hash(), Pred = Pred(), Allocator = Allocator())
       -> unordered_multiset<iter-value-type<InputIterator>,
                             Hash, Pred, Allocator>;
   template<ranges::input_range R,
 deduction guide.
 #### Constructors <a id="unord.multiset.cnstr">[[unord.multiset.cnstr]]</a>
 ``` cpp
+constexpr unordered_multiset() : unordered_multiset(size_type(see below)) { }
+constexpr explicit unordered_multiset(size_type n, const hasher& hf = hasher(),
                                       const key_equal& eql = key_equal(),
                                       const allocator_type& a = allocator_type());
 ```
 *Effects:* Constructs an empty `unordered_multiset` using the specified
 *Complexity:* Constant.
 ``` cpp
 template<class InputIterator>
+ constexpr unordered_multiset(InputIterator f, InputIterator l,
+ size_type n = see below, const hasher& hf = hasher(),
                                const key_equal& eql = key_equal(),
                                const allocator_type& a = allocator_type());
 template<container-compatible-range<value_type> R>
+ constexpr unordered_multiset(from_range_t, R&& rg,
+ size_type n = see below, const hasher& hf = hasher(),
                                const key_equal& eql = key_equal(),
                                const allocator_type& a = allocator_type());
+constexpr unordered_multiset(initializer_list<value_type> il,
+ size_type n = see below, const hasher& hf = hasher(),
                              const key_equal& eql = key_equal(),
                              const allocator_type& a = allocator_type());
 ```
 *Effects:* Constructs an empty `unordered_multiset` using the specified
 #### Erasure <a id="unord.multiset.erasure">[[unord.multiset.erasure]]</a>
 ``` cpp
 template<class K, class H, class P, class A, class Predicate>
+ constexpr typename unordered_multiset<K, H, P, A>::size_type
     erase_if(unordered_multiset<K, H, P, A>& c, Predicate pred);
 ```
 *Effects:* Equivalent to:
 return original_size - c.size();
 ```
 ## Container adaptors <a id="container.adaptors">[[container.adaptors]]</a>
+### General <a id="container.adaptors.general">[[container.adaptors.general]]</a>
 The headers `<queue>`, `<stack>`, `<flat_map>`, and `<flat_set>` define
 the container adaptors `queue` and `priority_queue`, `stack`, `flat_map`
 and `flat_multimap`, and `flat_set` and `flat_multiset`, respectively.
 The following exposition-only alias template may appear in deduction
 guides for container adaptors:
 ``` cpp
 template<class Allocator, class T>
+  using alloc-rebind = allocator_traits<Allocator>::template rebind_alloc<T>;   // exposition only
 ```
 ### Header `<queue>` synopsis <a id="queue.syn">[[queue.syn]]</a>
 ``` cpp
 namespace std {
   // [queue], class template queue
   template<class T, class Container = deque<T>> class queue;
   template<class T, class Container>
+ constexpr bool operator==(const queue<T, Container>& x, const queue<T, Container>& y);
   template<class T, class Container>
+ constexpr bool operator!=(const queue<T, Container>& x, const queue<T, Container>& y);
   template<class T, class Container>
+ constexpr bool operator< (const queue<T, Container>& x, const queue<T, Container>& y);
   template<class T, class Container>
+ constexpr bool operator> (const queue<T, Container>& x, const queue<T, Container>& y);
   template<class T, class Container>
+ constexpr bool operator<=(const queue<T, Container>& x, const queue<T, Container>& y);
   template<class T, class Container>
+ constexpr bool operator>=(const queue<T, Container>& x, const queue<T, Container>& y);
   template<class T, three_way_comparable Container>
+ constexpr compare_three_way_result_t<Container>
       operator<=>(const queue<T, Container>& x, const queue<T, Container>& y);
   template<class T, class Container>
+ constexpr void swap(queue<T, Container>& x, queue<T, Container>& y)
+      noexcept(noexcept(x.swap(y)));
   template<class T, class Container, class Alloc>
     struct uses_allocator<queue<T, Container>, Alloc>;
+  // [container.adaptors.format], formatter specialization for queue
+  template<class charT, class T, formattable<charT> Container>
+    struct formatter<queue<T, Container>, charT>;
   // [priority.queue], class template priority_queue
   template<class T, class Container = vector<T>,
            class Compare = less<typename Container::value_type>>
     class priority_queue;
   template<class T, class Container, class Compare>
+ constexpr void swap(priority_queue<T, Container, Compare>& x,
                         priority_queue<T, Container, Compare>& y) noexcept(noexcept(x.swap(y)));
   template<class T, class Container, class Compare, class Alloc>
     struct uses_allocator<priority_queue<T, Container, Compare>, Alloc>;
+  // [container.adaptors.format], formatter specialization for priority_queue
+  template<class charT, class T, formattable<charT> Container, class Compare>
+    struct formatter<priority_queue<T, Container, Compare>, charT>;
 }
 ```
 ### Class template `queue` <a id="queue">[[queue]]</a>
 ``` cpp
 namespace std {
   template<class T, class Container = deque<T>>
   class queue {
   public:
+    using value_type      = Container::value_type;
+    using reference       = Container::reference;
+    using const_reference = Container::const_reference;
+    using size_type       = Container::size_type;
     using container_type  = Container;
   protected:
     Container c;
   public:
+ constexpr queue() : queue(Container()) {}
+ constexpr explicit queue(const Container&);
+ constexpr explicit queue(Container&&);
+    template<class InputIterator> constexpr queue(InputIterator first, InputIterator last);
+    template<container-compatible-range<T> R> constexpr queue(from_range_t, R&& rg);
+    template<class Alloc> constexpr explicit queue(const Alloc&);
+    template<class Alloc> constexpr queue(const Container&, const Alloc&);
+    template<class Alloc> constexpr queue(Container&&, const Alloc&);
+    template<class Alloc> constexpr queue(const queue&, const Alloc&);
+    template<class Alloc> constexpr queue(queue&&, const Alloc&);
     template<class InputIterator, class Alloc>
+ constexpr queue(InputIterator first, InputIterator last, const Alloc&);
     template<container-compatible-range<T> R, class Alloc>
+ constexpr queue(from_range_t, R&& rg, const Alloc&);
+ constexpr bool empty() const { return c.empty(); }
+ constexpr size_type         size()  const     { return c.size(); }
+ constexpr reference         front()           { return c.front(); }
+ constexpr const_reference   front() const     { return c.front(); }
+ constexpr reference         back()            { return c.back(); }
+ constexpr const_reference   back() const      { return c.back(); }
+ constexpr void push(const value_type& x)      { c.push_back(x); }
+ constexpr void push(value_type&& x)           { c.push_back(std::move(x)); }
+    template<container-compatible-range<T> R> constexpr void push_range(R&& rg);
     template<class... Args>
+ constexpr decltype(auto) emplace(Args&&... args)
         { return c.emplace_back(std::forward<Args>(args)...); }
+ constexpr void pop()                          { c.pop_front(); }
+ constexpr void swap(queue& q) noexcept(is_nothrow_swappable_v<Container>)
       { using std::swap; swap(c, q.c); }
   };
   template<class Container>
     queue(Container) -> queue<typename Container::value_type, Container>;
 ```
 #### Constructors <a id="queue.cons">[[queue.cons]]</a>
 ``` cpp
+constexpr explicit queue(const Container& cont);
 ```
 *Effects:* Initializes `c` with `cont`.
 ``` cpp
+constexpr explicit queue(Container&& cont);
 ```
 *Effects:* Initializes `c` with `std::move(cont)`.
 ``` cpp
 template<class InputIterator>
+ constexpr queue(InputIterator first, InputIterator last);
 ```
 *Effects:* Initializes `c` with `first` as the first argument and `last`
 as the second argument.
 ``` cpp
 template<container-compatible-range<T> R>
+ constexpr queue(from_range_t, R&& rg);
 ```
 *Effects:* Initializes `c` with
 `ranges::to<Container>(std::forward<R>(rg))`.
 If `uses_allocator_v<container_type, Alloc>` is `false` the constructors
 in this subclause shall not participate in overload resolution.
 ``` cpp
+template<class Alloc> constexpr explicit queue(const Alloc& a);
 ```
 *Effects:* Initializes `c` with `a`.
 ``` cpp
+template<class Alloc> constexpr queue(const container_type& cont, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `cont` as the first argument and `a` as
 the second argument.
 ``` cpp
+template<class Alloc> constexpr queue(container_type&& cont, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `std::move(cont)` as the first argument
 and `a` as the second argument.
 ``` cpp
+template<class Alloc> constexpr queue(const queue& q, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `q.c` as the first argument and `a` as
 the second argument.
 ``` cpp
+template<class Alloc> constexpr queue(queue&& q, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `std::move(q.c)` as the first argument
 and `a` as the second argument.
 ``` cpp
 template<class InputIterator, class Alloc>
+ constexpr queue(InputIterator first, InputIterator last, const Alloc& alloc);
 ```
 *Effects:* Initializes `c` with `first` as the first argument, `last` as
 the second argument, and `alloc` as the third argument.
 ``` cpp
 template<container-compatible-range<T> R, class Alloc>
+ constexpr queue(from_range_t, R&& rg, const Alloc& a);
 ```
 *Effects:* Initializes `c` with
 `ranges::to<Container>(std::forward<R>(rg), a)`.
 #### Modifiers <a id="queue.mod">[[queue.mod]]</a>
 ``` cpp
 template<container-compatible-range<T> R>
+ constexpr void push_range(R&& rg);
 ```
 *Effects:* Equivalent to `c.append_range(std::forward<R>(rg))` if that
 is a valid expression, otherwise `ranges::copy(rg, back_inserter(c))`.
 #### Operators <a id="queue.ops">[[queue.ops]]</a>
 ``` cpp
 template<class T, class Container>
+ constexpr bool operator==(const queue<T, Container>& x, const queue<T, Container>& y);
 ```
 *Returns:* `x.c == y.c`.
 ``` cpp
 template<class T, class Container>
+ constexpr bool operator!=(const queue<T, Container>& x,  const queue<T, Container>& y);
 ```
 *Returns:* `x.c != y.c`.
 ``` cpp
 template<class T, class Container>
+ constexpr bool operator< (const queue<T, Container>& x, const queue<T, Container>& y);
 ```
 *Returns:* `x.c < y.c`.
 ``` cpp
 template<class T, class Container>
+ constexpr bool operator> (const queue<T, Container>& x, const queue<T, Container>& y);
 ```
 *Returns:* `x.c > y.c`.
 ``` cpp
 template<class T, class Container>
+ constexpr bool operator<=(const queue<T, Container>& x, const queue<T, Container>& y);
 ```
 *Returns:* `x.c <= y.c`.
 ``` cpp
 template<class T, class Container>
+  constexpr bool operator>=(const queue<T, Container>& x, const queue<T, Container>& y);
 ```
 *Returns:* `x.c >= y.c`.
 ``` cpp
 template<class T, three_way_comparable Container>
+ constexpr compare_three_way_result_t<Container>
     operator<=>(const queue<T, Container>& x, const queue<T, Container>& y);
 ```
 *Returns:* `x.c <=> y.c`.
 #### Specialized algorithms <a id="queue.special">[[queue.special]]</a>
 ``` cpp
 template<class T, class Container>
+ constexpr void swap(queue<T, Container>& x, queue<T, Container>& y)
+    noexcept(noexcept(x.swap(y)));
 ```
 *Constraints:* `is_swappable_v<Container>` is `true`.
 *Effects:* As if by `x.swap(y)`.
 namespace std {
   template<class T, class Container = vector<T>,
            class Compare = less<typename Container::value_type>>
   class priority_queue {
   public:
+    using value_type      = Container::value_type;
+    using reference       = Container::reference;
+    using const_reference = Container::const_reference;
+    using size_type       = Container::size_type;
     using container_type  = Container;
     using value_compare   = Compare;
   protected:
     Container c;
     Compare comp;
   public:
+ constexpr priority_queue() : priority_queue(Compare()) {}
+ constexpr explicit priority_queue(const Compare& x) : priority_queue(x, Container()) {}
+ constexpr priority_queue(const Compare& x, const Container&);
+ constexpr priority_queue(const Compare& x, Container&&);
     template<class InputIterator>
+ constexpr priority_queue(InputIterator first, InputIterator last,
+                               const Compare& x = Compare());
     template<class InputIterator>
+ constexpr priority_queue(InputIterator first, InputIterator last, const Compare& x,
                                const Container&);
     template<class InputIterator>
+ constexpr priority_queue(InputIterator first, InputIterator last, const Compare& x,
                                Container&&);
     template<container-compatible-range<T> R>
+ constexpr priority_queue(from_range_t, R&& rg, const Compare& x = Compare());
+    template<class Alloc> constexpr explicit priority_queue(const Alloc&);
+    template<class Alloc> constexpr priority_queue(const Compare&, const Alloc&);
+    template<class Alloc>
+      constexpr priority_queue(const Compare&, const Container&, const Alloc&);
+    template<class Alloc> constexpr priority_queue(const Compare&, Container&&, const Alloc&);
+    template<class Alloc> constexpr priority_queue(const priority_queue&, const Alloc&);
+    template<class Alloc> constexpr priority_queue(priority_queue&&, const Alloc&);
     template<class InputIterator, class Alloc>
+ constexpr priority_queue(InputIterator, InputIterator, const Alloc&);
     template<class InputIterator, class Alloc>
+ constexpr priority_queue(InputIterator, InputIterator, const Compare&, const Alloc&);
     template<class InputIterator, class Alloc>
+ constexpr priority_queue(InputIterator, InputIterator, const Compare&, const Container&,
                                const Alloc&);
     template<class InputIterator, class Alloc>
+ constexpr priority_queue(InputIterator, InputIterator, const Compare&, Container&&,
+                               const Alloc&);
     template<container-compatible-range<T> R, class Alloc>
+ constexpr priority_queue(from_range_t, R&& rg, const Compare&, const Alloc&);
     template<container-compatible-range<T> R, class Alloc>
+ constexpr priority_queue(from_range_t, R&& rg, const Alloc&);
+ constexpr bool empty() const { return c.empty(); }
+ constexpr size_type       size()  const { return c.size(); }
+ constexpr const_reference top() const { return c.front(); }
+ constexpr void push(const value_type& x);
+ constexpr void push(value_type&& x);
     template<container-compatible-range<T> R>
+ constexpr void push_range(R&& rg);
+    template<class... Args> constexpr void emplace(Args&&... args);
+ constexpr void pop();
+ constexpr void swap(priority_queue& q)
+      noexcept(is_nothrow_swappable_v<Container> && is_nothrow_swappable_v<Compare>)
       { using std::swap; swap(c, q.c); swap(comp, q.comp); }
   };
   template<class Compare, class Container>
     priority_queue(Compare, Container)
 ```
 #### Constructors <a id="priqueue.cons">[[priqueue.cons]]</a>
 ``` cpp
+constexpr priority_queue(const Compare& x, const Container& y);
+constexpr priority_queue(const Compare& x, Container&& y);
 ```
 *Preconditions:* `x` defines a strict weak ordering [[alg.sorting]].
 *Effects:* Initializes `comp` with `x` and `c` with `y` (copy
 constructing or move constructing as appropriate); calls
 `make_heap(c.begin(), c.end(), comp)`.
 ``` cpp
 template<class InputIterator>
+ constexpr priority_queue(InputIterator first, InputIterator last, const Compare& x = Compare());
 ```
 *Preconditions:* `x` defines a strict weak ordering [[alg.sorting]].
 *Effects:* Initializes `c` with `first` as the first argument and `last`
 as the second argument, and initializes `comp` with `x`; then calls
 `make_heap(c.begin(), c.end(), comp)`.
 ``` cpp
 template<class InputIterator>
+ constexpr priority_queue(InputIterator first, InputIterator last, const Compare& x,
+                           const Container& y);
 template<class InputIterator>
+ constexpr priority_queue(InputIterator first, InputIterator last, const Compare& x,
+                           Container&& y);
 ```
 *Preconditions:* `x` defines a strict weak ordering [[alg.sorting]].
 *Effects:* Initializes `comp` with `x` and `c` with `y` (copy
 `c.insert(c.end(), first, last)`; and finally calls
 `make_heap(c.begin(), c.end(), comp)`.
 ``` cpp
 template<container-compatible-range<T> R>
+ constexpr priority_queue(from_range_t, R&& rg, const Compare& x = Compare());
 ```
 *Preconditions:* `x` defines a strict weak ordering [[alg.sorting]].
 *Effects:* Initializes `comp` with `x` and `c` with
 If `uses_allocator_v<container_type, Alloc>` is `false` the constructors
 in this subclause shall not participate in overload resolution.
 ``` cpp
+template<class Alloc> constexpr explicit priority_queue(const Alloc& a);
 ```
 *Effects:* Initializes `c` with `a` and value-initializes `comp`.
 ``` cpp
+template<class Alloc> constexpr priority_queue(const Compare& compare, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `a` and initializes `comp` with
 `compare`.
 ``` cpp
 template<class Alloc>
+ constexpr priority_queue(const Compare& compare, const Container& cont, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `cont` as the first argument and `a` as
 the second argument, and initializes `comp` with `compare`; calls
 `make_heap(c.begin(), c.end(), comp)`.
 ``` cpp
 template<class Alloc>
+ constexpr priority_queue(const Compare& compare, Container&& cont, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `std::move(cont)` as the first argument
 and `a` as the second argument, and initializes `comp` with `compare`;
 calls `make_heap(c.begin(), c.end(), comp)`.
 ``` cpp
+template<class Alloc> constexpr priority_queue(const priority_queue& q, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `q.c` as the first argument and `a` as
 the second argument, and initializes `comp` with `q.comp`.
 ``` cpp
+template<class Alloc> constexpr priority_queue(priority_queue&& q, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `std::move(q.c)` as the first argument
 and `a` as the second argument, and initializes `comp` with
 `std::move(q.comp)`.
 ``` cpp
 template<class InputIterator, class Alloc>
+ constexpr priority_queue(InputIterator first, InputIterator last, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `first` as the first argument, `last` as
 the second argument, and `a` as the third argument, and
 value-initializes `comp`; calls `make_heap(c.begin(), c.end(), comp)`.
 ``` cpp
 template<class InputIterator, class Alloc>
+ constexpr priority_queue(InputIterator first, InputIterator last,
+                           const Compare& compare, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `first` as the first argument, `last` as
 the second argument, and `a` as the third argument, and initializes
 `comp` with `compare`; calls `make_heap(c.begin(), c.end(), comp)`.
 ``` cpp
 template<class InputIterator, class Alloc>
+ constexpr priority_queue(InputIterator first, InputIterator last, const Compare& compare,
                            const Container& cont, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `cont` as the first argument and `a` as
 the second argument, and initializes `comp` with `compare`; calls
 `c.insert(c.end(), first, last)`; and finally calls
 `make_heap(c.begin(), c.end(), comp)`.
 ``` cpp
 template<class InputIterator, class Alloc>
+ constexpr priority_queue(InputIterator first, InputIterator last, const Compare& compare,
+                           Container&& cont, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `std::move(cont)` as the first argument
 and `a` as the second argument, and initializes `comp` with `compare`;
 calls `c.insert(c.end(), first, last)`; and finally calls
 `make_heap(c.begin(), c.end(), comp)`.
 ``` cpp
 template<container-compatible-range<T> R, class Alloc>
+ constexpr priority_queue(from_range_t, R&& rg, const Compare& compare, const Alloc& a);
 ```
 *Effects:* Initializes `comp` with `compare` and `c` with
 `ranges::to<Container>(std::forward<R>(rg), a)`; calls
 `make_heap(c.begin(), c.end(), comp)`.
 ``` cpp
 template<container-compatible-range<T> R, class Alloc>
+ constexpr priority_queue(from_range_t, R&& rg, const Alloc& a);
 ```
 *Effects:* Initializes `c` with
+`ranges::to<Container>(std::forward<R>(rg), a)` and value-initializes
+`comp`; calls `make_heap(c.begin(), c.end(), comp)`.
 #### Members <a id="priqueue.members">[[priqueue.members]]</a>
 ``` cpp
+constexpr void push(const value_type& x);
 ```
 *Effects:* As if by:
 ``` cpp
 c.push_back(x);
 push_heap(c.begin(), c.end(), comp);
 ```
 ``` cpp
+constexpr void push(value_type&& x);
 ```
 *Effects:* As if by:
 ``` cpp
 push_heap(c.begin(), c.end(), comp);
 ```
 ``` cpp
 template<container-compatible-range<T> R>
+ constexpr void push_range(R&& rg);
 ```
 *Effects:* Inserts all elements of `rg` in `c` via
 `c.append_range(std::forward<R>(rg))` if that is a valid expression, or
 `ranges::copy(rg, back_inserter(c))` otherwise. Then restores the heap
 property as if by `make_heap(c.begin(), c.end(), comp)`.
 *Ensures:* `is_heap(c.begin(), c.end(), comp)` is `true`.
 ``` cpp
+template<class... Args> constexpr void emplace(Args&&... args);
 ```
 *Effects:* As if by:
 ``` cpp
 c.emplace_back(std::forward<Args>(args)...);
 push_heap(c.begin(), c.end(), comp);
 ```
 ``` cpp
+constexpr void pop();
 ```
 *Effects:* As if by:
 ``` cpp
 #### Specialized algorithms <a id="priqueue.special">[[priqueue.special]]</a>
 ``` cpp
 template<class T, class Container, class Compare>
+ constexpr void swap(priority_queue<T, Container, Compare>& x,
                       priority_queue<T, Container, Compare>& y) noexcept(noexcept(x.swap(y)));
 ```
 *Constraints:* `is_swappable_v<Container>` is `true` and
 `is_swappable_v<Compare>` is `true`.
 *Effects:* As if by `x.swap(y)`.
+### Header `<stack>` synopsis <a id="stack.syn">[[stack.syn]]</a>
+``` cpp
+#include <compare>              // see [compare.syn]
+#include <initializer_list>     // see [initializer.list.syn]
+namespace std {
+  // [stack], class template stack
+  template<class T, class Container = deque<T>> class stack;
+  template<class T, class Container>
+    constexpr bool operator==(const stack<T, Container>& x, const stack<T, Container>& y);
+  template<class T, class Container>
+    constexpr bool operator!=(const stack<T, Container>& x, const stack<T, Container>& y);
+  template<class T, class Container>
+    constexpr bool operator< (const stack<T, Container>& x, const stack<T, Container>& y);
+  template<class T, class Container>
+    constexpr bool operator> (const stack<T, Container>& x, const stack<T, Container>& y);
+  template<class T, class Container>
+    constexpr bool operator<=(const stack<T, Container>& x, const stack<T, Container>& y);
+  template<class T, class Container>
+    constexpr bool operator>=(const stack<T, Container>& x, const stack<T, Container>& y);
+  template<class T, three_way_comparable Container>
+    constexpr compare_three_way_result_t<Container>
+      operator<=>(const stack<T, Container>& x, const stack<T, Container>& y);
+  template<class T, class Container>
+    constexpr void swap(stack<T, Container>& x, stack<T, Container>& y)
+      noexcept(noexcept(x.swap(y)));
+  template<class T, class Container, class Alloc>
+    struct uses_allocator<stack<T, Container>, Alloc>;
+  // [container.adaptors.format], formatter specialization for stack
+  template<class charT, class T, formattable<charT> Container>
+    struct formatter<stack<T, Container>, charT>;
+}
+```
 ### Class template `stack` <a id="stack">[[stack]]</a>
 #### General <a id="stack.general">[[stack.general]]</a>
 Any sequence container supporting operations `back()`, `push_back()` and
 ``` cpp
 namespace std {
   template<class T, class Container = deque<T>>
   class stack {
   public:
+    using value_type      = Container::value_type;
+    using reference       = Container::reference;
+    using const_reference = Container::const_reference;
+    using size_type       = Container::size_type;
     using container_type  = Container;
   protected:
     Container c;
   public:
+ constexpr stack() : stack(Container()) {}
+ constexpr explicit stack(const Container&);
+ constexpr explicit stack(Container&&);
+    template<class InputIterator> constexpr stack(InputIterator first, InputIterator last);
+    template<container-compatible-range<T> R>
+      constexpr stack(from_range_t, R&& rg);
+    template<class Alloc> constexpr explicit stack(const Alloc&);
+    template<class Alloc> constexpr stack(const Container&, const Alloc&);
+    template<class Alloc> constexpr stack(Container&&, const Alloc&);
+    template<class Alloc> constexpr stack(const stack&, const Alloc&);
+    template<class Alloc> constexpr stack(stack&&, const Alloc&);
     template<class InputIterator, class Alloc>
+ constexpr stack(InputIterator first, InputIterator last, const Alloc&);
     template<container-compatible-range<T> R, class Alloc>
+ constexpr stack(from_range_t, R&& rg, const Alloc&);
+ constexpr bool empty() const { return c.empty(); }
+ constexpr size_type         size()  const { return c.size(); }
+ constexpr reference         top()             { return c.back(); }
+ constexpr const_reference   top() const { return c.back(); }
+ constexpr void push(const value_type& x)      { c.push_back(x); }
+ constexpr void push(value_type&& x)           { c.push_back(std::move(x)); }
     template<container-compatible-range<T> R>
+ constexpr void push_range(R&& rg);
     template<class... Args>
+ constexpr decltype(auto) emplace(Args&&... args)
         { return c.emplace_back(std::forward<Args>(args)...); }
+ constexpr void pop()                          { c.pop_back(); }
+ constexpr void swap(stack& s) noexcept(is_nothrow_swappable_v<Container>)
       { using std::swap; swap(c, s.c); }
   };
   template<class Container>
     stack(Container) -> stack<typename Container::value_type, Container>;
 ```
 #### Constructors <a id="stack.cons">[[stack.cons]]</a>
 ``` cpp
+constexpr explicit stack(const Container& cont);
 ```
 *Effects:* Initializes `c` with `cont`.
 ``` cpp
+constexpr explicit stack(Container&& cont);
 ```
 *Effects:* Initializes `c` with `std::move(cont)`.
 ``` cpp
 template<class InputIterator>
+ constexpr stack(InputIterator first, InputIterator last);
 ```
 *Effects:* Initializes `c` with `first` as the first argument and `last`
 as the second argument.
 ``` cpp
 template<container-compatible-range<T> R>
+ constexpr stack(from_range_t, R&& rg);
 ```
 *Effects:* Initializes `c` with
 `ranges::to<Container>(std::forward<R>(rg))`.
 If `uses_allocator_v<container_type, Alloc>` is `false` the constructors
 in this subclause shall not participate in overload resolution.
 ``` cpp
+template<class Alloc> constexpr explicit stack(const Alloc& a);
 ```
 *Effects:* Initializes `c` with `a`.
 ``` cpp
+template<class Alloc> constexpr stack(const container_type& cont, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `cont` as the first argument and `a` as
 the second argument.
 ``` cpp
+template<class Alloc> constexpr stack(container_type&& cont, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `std::move(cont)` as the first argument
 and `a` as the second argument.
 ``` cpp
+template<class Alloc> constexpr stack(const stack& s, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `s.c` as the first argument and `a` as
 the second argument.
 ``` cpp
+template<class Alloc> constexpr stack(stack&& s, const Alloc& a);
 ```
 *Effects:* Initializes `c` with `std::move(s.c)` as the first argument
 and `a` as the second argument.
 ``` cpp
 template<class InputIterator, class Alloc>
+ constexpr stack(InputIterator first, InputIterator last, const Alloc& alloc);
 ```
 *Effects:* Initializes `c` with `first` as the first argument, `last` as
 the second argument, and `alloc` as the third argument.
 ``` cpp
 template<container-compatible-range<T> R, class Alloc>
+ constexpr stack(from_range_t, R&& rg, const Alloc& a);
 ```
 *Effects:* Initializes `c` with
 `ranges::to<Container>(std::forward<R>(rg), a)`.
 #### Modifiers <a id="stack.mod">[[stack.mod]]</a>
 ``` cpp
 template<container-compatible-range<T> R>
+ constexpr void push_range(R&& rg);
 ```
 *Effects:* Equivalent to `c.append_range(std::forward<R>(rg))` if that
 is a valid expression, otherwise `ranges::copy(rg, back_inserter(c))`.
 #### Operators <a id="stack.ops">[[stack.ops]]</a>
 ``` cpp
 template<class T, class Container>
+ constexpr bool operator==(const stack<T, Container>& x, const stack<T, Container>& y);
 ```
 *Returns:* `x.c == y.c`.
 ``` cpp
 template<class T, class Container>
+ constexpr bool operator!=(const stack<T, Container>& x, const stack<T, Container>& y);
 ```
 *Returns:* `x.c != y.c`.
 ``` cpp
 template<class T, class Container>
+ constexpr bool operator< (const stack<T, Container>& x, const stack<T, Container>& y);
 ```
 *Returns:* `x.c < y.c`.
 ``` cpp
 template<class T, class Container>
+ constexpr bool operator> (const stack<T, Container>& x, const stack<T, Container>& y);
 ```
 *Returns:* `x.c > y.c`.
 ``` cpp
 template<class T, class Container>
+ constexpr bool operator<=(const stack<T, Container>& x, const stack<T, Container>& y);
 ```
 *Returns:* `x.c <= y.c`.
 ``` cpp
 template<class T, class Container>
+ constexpr bool operator>=(const stack<T, Container>& x, const stack<T, Container>& y);
 ```
 *Returns:* `x.c >= y.c`.
 ``` cpp
 template<class T, three_way_comparable Container>
+ constexpr compare_three_way_result_t<Container>
     operator<=>(const stack<T, Container>& x, const stack<T, Container>& y);
 ```
 *Returns:* `x.c <=> y.c`.
 #### Specialized algorithms <a id="stack.special">[[stack.special]]</a>
 ``` cpp
 template<class T, class Container>
+ constexpr void swap(stack<T, Container>& x, stack<T, Container>& y)
+    noexcept(noexcept(x.swap(y)));
 ```
 *Constraints:* `is_swappable_v<Container>` is `true`.
 *Effects:* As if by `x.swap(y)`.
+### Header `<flat_map>` synopsis <a id="flat.map.syn">[[flat.map.syn]]</a>
+``` cpp
+#include <compare>              // see [compare.syn]
+#include <initializer_list>     // see [initializer.list.syn]
+namespace std {
+  // [flat.map], class template flat_map
+  template<class Key, class T, class Compare = less<Key>,
+           class KeyContainer = vector<Key>, class MappedContainer = vector<T>>
+    class flat_map;
+  struct sorted_unique_t { explicit sorted_unique_t() = default; };
+  inline constexpr sorted_unique_t sorted_unique{};
+  template<class Key, class T, class Compare, class KeyContainer, class MappedContainer,
+           class Allocator>
+    struct uses_allocator<flat_map<Key, T, Compare, KeyContainer, MappedContainer>,
+                          Allocator>;
+  // [flat.map.erasure], erasure for flat_map
+  template<class Key, class T, class Compare, class KeyContainer, class MappedContainer,
+           class Predicate>
+    constexpr typename flat_map<Key, T, Compare, KeyContainer, MappedContainer>::size_type
+      erase_if(flat_map<Key, T, Compare, KeyContainer, MappedContainer>& c, Predicate pred);
+  // [flat.multimap], class template flat_multimap
+  template<class Key, class T, class Compare = less<Key>,
+           class KeyContainer = vector<Key>, class MappedContainer = vector<T>>
+    class flat_multimap;
+  struct sorted_equivalent_t { explicit sorted_equivalent_t() = default; };
+  inline constexpr sorted_equivalent_t sorted_equivalent{};
+  template<class Key, class T, class Compare, class KeyContainer, class MappedContainer,
+           class Allocator>
+    struct uses_allocator<flat_multimap<Key, T, Compare, KeyContainer, MappedContainer>,
+                          Allocator>;
+  // [flat.multimap.erasure], erasure for flat_multimap
+  template<class Key, class T, class Compare, class KeyContainer, class MappedContainer,
+           class Predicate>
+    constexpr typename flat_multimap<Key, T, Compare, KeyContainer, MappedContainer>::size_type
+      erase_if(flat_multimap<Key, T, Compare, KeyContainer, MappedContainer>& c, Predicate pred);
+}
+```
 ### Class template `flat_map` <a id="flat.map">[[flat.map]]</a>
 #### Overview <a id="flat.map.overview">[[flat.map.overview]]</a>
 A `flat_map` is a container adaptor that provides an associative
 The effect of calling a constructor that takes both `key_container_type`
 and `mapped_container_type` arguments with containers of different sizes
 is undefined.
+The effect of calling a member function that takes a `sorted_unique_t`
+argument with a container, containers, or range that is not sorted with
+respect to `key_comp()`, or that contains equal elements, is undefined.
+The types `iterator` and `const_iterator` meet the constexpr iterator
+requirements [[iterator.requirements.general]].
 #### Definition <a id="flat.map.defn">[[flat.map.defn]]</a>
 ``` cpp
 namespace std {
     using mapped_container_type  = MappedContainer;
     class value_compare {
     private:
       key_compare comp;                                         // exposition only
+ constexpr value_compare(key_compare c) : comp(c) { } // exposition only
     public:
+ constexpr bool operator()(const_reference x, const_reference y) const {
         return comp(x.first, y.first);
       }
     };
     struct containers {
       key_container_type keys;
       mapped_container_type values;
     };
+    // [flat.map.cons], constructors
+ constexpr flat_map() : flat_map(key_compare()) { }
+ constexpr explicit flat_map(const key_compare& comp)
       : c(), compare(comp) { }
+    constexpr flat_map(key_container_type key_cont, mapped_container_type mapped_cont,
+                       const key_compare& comp = key_compare());
+    constexpr flat_map(sorted_unique_t, key_container_type key_cont,
+                       mapped_container_type mapped_cont,
+                       const key_compare& comp = key_compare());
     template<class InputIterator>
+ constexpr flat_map(InputIterator first, InputIterator last,
+                         const key_compare& comp = key_compare())
         : c(), compare(comp) { insert(first, last); }
+    template<class InputIterator>
+      constexpr flat_map(sorted_unique_t, InputIterator first, InputIterator last,
+                         const key_compare& comp = key_compare())
+        : c(), compare(comp) { insert(sorted_unique, first, last); }
     template<container-compatible-range<value_type> R>
+ constexpr flat_map(from_range_t, R&& rg)
+        : flat_map(from_range, std::forward<R>(rg), key_compare()) { }
     template<container-compatible-range<value_type> R>
+ constexpr flat_map(from_range_t, R&& rg, const key_compare& comp)
         : flat_map(comp) { insert_range(std::forward<R>(rg)); }
+ constexpr flat_map(initializer_list<value_type> il, const key_compare& comp = key_compare())
         : flat_map(il.begin(), il.end(), comp) { }
+ constexpr flat_map(sorted_unique_t, initializer_list<value_type> il,
                        const key_compare& comp = key_compare())
+        : flat_map(sorted_unique, il.begin(), il.end(), comp) { }
+ // [flat.map.cons.alloc], constructors with allocators
+    template<class Alloc>
+      constexpr explicit flat_map(const Alloc& a);
+    template<class Alloc>
+      constexpr flat_map(const key_compare& comp, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_map(const key_container_type& key_cont,
+                         const mapped_container_type& mapped_cont,
+                         const Alloc& a);
+    template<class Alloc>
+      constexpr flat_map(const key_container_type& key_cont,
+                         const mapped_container_type& mapped_cont,
+                         const key_compare& comp, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_map(sorted_unique_t, const key_container_type& key_cont,
+                         const mapped_container_type& mapped_cont, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_map(sorted_unique_t, const key_container_type& key_cont,
+                         const mapped_container_type& mapped_cont, const key_compare& comp,
+                         const Alloc& a);
+    template<class Alloc>
+      constexpr flat_map(const flat_map&, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_map(flat_map&&, const Alloc& a);
+    template<class InputIterator, class Alloc>
+      constexpr flat_map(InputIterator first, InputIterator last, const Alloc& a);
+    template<class InputIterator, class Alloc>
+      constexpr flat_map(InputIterator first, InputIterator last,
+                         const key_compare& comp, const Alloc& a);
+    template<class InputIterator, class Alloc>
+      constexpr flat_map(sorted_unique_t, InputIterator first, InputIterator last,
+                         const Alloc& a);
+    template<class InputIterator, class Alloc>
+      constexpr flat_map(sorted_unique_t, InputIterator first, InputIterator last,
+                         const key_compare& comp, const Alloc& a);
+    template<container-compatible-range<value_type> R, class Alloc>
+      constexpr flat_map(from_range_t, R&& rg, const Alloc& a);
+    template<container-compatible-range<value_type> R, class Alloc>
+      constexpr flat_map(from_range_t, R&& rg, const key_compare& comp, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_map(initializer_list<value_type> il, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_map(initializer_list<value_type> il, const key_compare& comp,
+                         const Alloc& a);
+    template<class Alloc>
+      constexpr flat_map(sorted_unique_t, initializer_list<value_type> il, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_map(sorted_unique_t, initializer_list<value_type> il,
+                         const key_compare& comp, const Alloc& a);
+    constexpr flat_map& operator=(initializer_list<value_type>);
     // iterators
+ constexpr iterator               begin() noexcept;
+ constexpr const_iterator         begin() const noexcept;
+ constexpr iterator               end() noexcept;
+ constexpr const_iterator         end() const noexcept;
+ constexpr reverse_iterator       rbegin() noexcept;
+ constexpr const_reverse_iterator rbegin() const noexcept;
+ constexpr reverse_iterator       rend() noexcept;
+ constexpr const_reverse_iterator rend() const noexcept;
+ constexpr const_iterator         cbegin() const noexcept;
+ constexpr const_iterator         cend() const noexcept;
+ constexpr const_reverse_iterator crbegin() const noexcept;
+ constexpr const_reverse_iterator crend() const noexcept;
     // [flat.map.capacity], capacity
+ constexpr bool empty() const noexcept;
+ constexpr size_type size() const noexcept;
+ constexpr size_type max_size() const noexcept;
     // [flat.map.access], element access
+ constexpr mapped_type& operator[](const key_type& x);
+ constexpr mapped_type& operator[](key_type&& x);
+    template<class K> constexpr mapped_type& operator[](K&& x);
+ constexpr mapped_type& at(const key_type& x);
+ constexpr const mapped_type& at(const key_type& x) const;
+    template<class K> constexpr mapped_type& at(const K& x);
+    template<class K> constexpr const mapped_type& at(const K& x) const;
     // [flat.map.modifiers], modifiers
+    template<class... Args> constexpr pair<iterator, bool> emplace(Args&&... args);
     template<class... Args>
+ constexpr iterator emplace_hint(const_iterator position, Args&&... args);
+ constexpr pair<iterator, bool> insert(const value_type& x)
       { return emplace(x); }
+ constexpr pair<iterator, bool> insert(value_type&& x)
       { return emplace(std::move(x)); }
+ constexpr iterator insert(const_iterator position, const value_type& x)
       { return emplace_hint(position, x); }
+ constexpr iterator insert(const_iterator position, value_type&& x)
       { return emplace_hint(position, std::move(x)); }
+    template<class P> constexpr pair<iterator, bool> insert(P&& x);
     template<class P>
+ constexpr iterator insert(const_iterator position, P&&);
     template<class InputIterator>
+ constexpr void insert(InputIterator first, InputIterator last);
     template<class InputIterator>
+ constexpr void insert(sorted_unique_t, InputIterator first, InputIterator last);
     template<container-compatible-range<value_type> R>
+ constexpr void insert_range(R&& rg);
+ constexpr void insert(initializer_list<value_type> il)
       { insert(il.begin(), il.end()); }
+ constexpr void insert(sorted_unique_t, initializer_list<value_type> il)
+      { insert(sorted_unique, il.begin(), il.end()); }
+ constexpr containers extract() &&;
+ constexpr void replace(key_container_type&& key_cont, mapped_container_type&& mapped_cont);
     template<class... Args>
+ constexpr pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
     template<class... Args>
+ constexpr pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
     template<class K, class... Args>
+ constexpr pair<iterator, bool> try_emplace(K&& k, Args&&... args);
     template<class... Args>
+ constexpr iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args);
     template<class... Args>
+ constexpr iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);
     template<class K, class... Args>
+ constexpr iterator try_emplace(const_iterator hint, K&& k, Args&&... args);
     template<class M>
+ constexpr pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);
     template<class M>
+ constexpr pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj);
     template<class K, class M>
+ constexpr pair<iterator, bool> insert_or_assign(K&& k, M&& obj);
     template<class M>
+ constexpr iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);
     template<class M>
+ constexpr iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj);
     template<class K, class M>
+ constexpr iterator insert_or_assign(const_iterator hint, K&& k, M&& obj);
+ constexpr iterator erase(iterator position);
+ constexpr iterator erase(const_iterator position);
+ constexpr size_type erase(const key_type& x);
+    template<class K> constexpr size_type erase(K&& x);
+ constexpr iterator erase(const_iterator first, const_iterator last);
+ constexpr void swap(flat_map& y) noexcept;
+ constexpr void clear() noexcept;
     // observers
+ constexpr key_compare key_comp() const;
+ constexpr value_compare value_comp() const;
+ constexpr const key_container_type& keys() const noexcept      { return c.keys; }
+ constexpr const mapped_container_type& values() const noexcept { return c.values; }
     // map operations
+ constexpr iterator find(const key_type& x);
+ constexpr const_iterator find(const key_type& x) const;
+    template<class K> constexpr iterator find(const K& x);
+    template<class K> constexpr const_iterator find(const K& x) const;
+ constexpr size_type count(const key_type& x) const;
+    template<class K> constexpr size_type count(const K& x) const;
+ constexpr bool contains(const key_type& x) const;
+    template<class K> constexpr bool contains(const K& x) const;
+ constexpr iterator lower_bound(const key_type& x);
+ constexpr const_iterator lower_bound(const key_type& x) const;
+    template<class K> constexpr iterator lower_bound(const K& x);
+    template<class K> constexpr const_iterator lower_bound(const K& x) const;
+ constexpr iterator upper_bound(const key_type& x);
+ constexpr const_iterator upper_bound(const key_type& x) const;
+    template<class K> constexpr iterator upper_bound(const K& x);
+    template<class K> constexpr const_iterator upper_bound(const K& x) const;
+ constexpr pair<iterator, iterator> equal_range(const key_type& x);
+ constexpr pair<const_iterator, const_iterator> equal_range(const key_type& x) const;
+    template<class K> constexpr pair<iterator, iterator> equal_range(const K& x);
+    template<class K>
+      constexpr pair<const_iterator, const_iterator> equal_range(const K& x) const;
+    friend constexpr bool operator==(const flat_map& x, const flat_map& y);
+    friend constexpr synth-three-way-result<value_type>
       operator<=>(const flat_map& x, const flat_map& y);
+    friend constexpr void swap(flat_map& x, flat_map& y) noexcept
       { x.swap(y); }
   private:
     containers c;               // exposition only
     key_compare compare;        // exposition only
+    struct key-equiv {  // exposition only
+ constexpr key-equiv(key_compare c) : comp(c) { }
+ constexpr bool operator()(const_reference x, const_reference y) const {
         return !comp(x.first, y.first) && !comp(y.first, x.first);
       }
       key_compare comp;
     };
   };
 specified.
 #### Constructors <a id="flat.map.cons">[[flat.map.cons]]</a>
 ``` cpp
+constexpr flat_map(key_container_type key_cont, mapped_container_type mapped_cont,
                    const key_compare& comp = key_compare());
 ```
+*Effects:* Initializes *`c`*`.keys` with `std::move(key_cont)`,
+*`c`*`.values` with `std::move(mapped_cont)`, and *compare* with `comp`;
+sorts the range \[`begin()`, `end()`) with respect to `value_comp()`;
+and finally erases the duplicate elements as if by:
 ``` cpp
+auto zv = views::zip(c.keys, c.values);
+auto it = ranges::unique(zv, key-equiv(compare)).begin();
 auto dist = distance(zv.begin(), it);
 c.keys.erase(c.keys.begin() + dist, c.keys.end());
 c.values.erase(c.values.begin() + dist, c.values.end());
 ```
 *Complexity:* Linear in N if the container arguments are already sorted
 with respect to `value_comp()` and otherwise N log N, where N is the
 value of `key_cont.size()` before this call.
 ``` cpp
+constexpr flat_map(sorted_unique_t, key_container_type key_cont, mapped_container_type mapped_cont,
+ const key_compare& comp = key_compare());
 ```
+*Effects:* Initializes *`c`*`.keys` with `std::move(key_cont)`,
+*`c`*`.values` with `std::move(mapped_cont)`, and *compare* with `comp`.
+*Complexity:* Constant.
+#### Constructors with allocators <a id="flat.map.cons.alloc">[[flat.map.cons.alloc]]</a>
+The constructors in this subclause shall not participate in overload
+resolution unless `uses_allocator_v<key_container_type, Alloc>` is
+`true` and `uses_allocator_v<mapped_container_type, Alloc>` is `true`.
+``` cpp
+template<class Alloc>
+  constexpr flat_map(const key_container_type& key_cont, const mapped_container_type& mapped_cont,
+                     const Alloc& a);
+template<class Alloc>
+  constexpr flat_map(const key_container_type& key_cont, const mapped_container_type& mapped_cont,
+                     const key_compare& comp, const Alloc& a);
+```
 *Effects:* Equivalent to `flat_map(key_cont, mapped_cont)` and
 `flat_map(key_cont, mapped_cont, comp)`, respectively, except that
+*`c`*`.keys` and *`c`*`.values` are constructed with uses-allocator
 construction [[allocator.uses.construction]].
 *Complexity:* Same as `flat_map(key_cont, mapped_cont)` and
 `flat_map(key_cont, mapped_cont, comp)`, respectively.
 ``` cpp
+template<class Alloc>
+  constexpr flat_map(sorted_unique_t, const key_container_type& key_cont,
+                     const mapped_container_type& mapped_cont, const Alloc& a);
+template<class Alloc>
+  constexpr flat_map(sorted_unique_t, const key_container_type& key_cont,
                      const mapped_container_type& mapped_cont, const key_compare& comp,
+ const Alloc& a);
 ```
+*Effects:* Equivalent to
+`flat_map(sorted_unique, key_cont, mapped_cont)` and
+`flat_map(sorted_unique, key_cont, mapped_cont, comp)`, respectively,
+except that *`c`*`.keys` and *`c`*`.values` are constructed with
+uses-allocator construction [[allocator.uses.construction]].
 *Complexity:* Linear.
 ``` cpp
+template<class Alloc>
+ constexpr explicit flat_map(const Alloc& a);
+template<class Alloc>
+ constexpr flat_map(const key_compare& comp, const Alloc& a);
+template<class Alloc>
+ constexpr flat_map(const flat_map&, const Alloc& a);
+template<class Alloc>
+ constexpr flat_map(flat_map&&, const Alloc& a);
+template<class InputIterator, class Alloc>
+ constexpr flat_map(InputIterator first, InputIterator last, const Alloc& a);
+template<class InputIterator, class Alloc>
+ constexpr flat_map(InputIterator first, InputIterator last, const key_compare& comp,
+                     const Alloc& a);
+template<class InputIterator, class Alloc>
+  constexpr flat_map(sorted_unique_t, InputIterator first, InputIterator last, const Alloc& a);
+template<class InputIterator, class Alloc>
+ constexpr flat_map(sorted_unique_t, InputIterator first, InputIterator last,
+                     const key_compare& comp, const Alloc& a);
+template<container-compatible-range<value_type> R, class Alloc>
+  constexpr flat_map(from_range_t, R&& rg, const Alloc& a);
+template<container-compatible-range<value_type> R, class Alloc>
+  constexpr flat_map(from_range_t, R&& rg, const key_compare& comp, const Alloc& a);
+template<class Alloc>
+  constexpr flat_map(initializer_list<value_type> il, const Alloc& a);
+template<class Alloc>
+ constexpr flat_map(initializer_list<value_type> il, const key_compare& comp, const Alloc& a);
+template<class Alloc>
+  constexpr flat_map(sorted_unique_t, initializer_list<value_type> il, const Alloc& a);
+template<class Alloc>
+  constexpr flat_map(sorted_unique_t, initializer_list<value_type> il,
+                     const key_compare& comp, const Alloc& a);
 ```
 *Effects:* Equivalent to the corresponding non-allocator constructors
+except that *`c`*`.keys` and *`c`*`.values` are constructed with
+uses-allocator construction [[allocator.uses.construction]].
 #### Capacity <a id="flat.map.capacity">[[flat.map.capacity]]</a>
 ``` cpp
+constexpr size_type size() const noexcept;
 ```
+*Returns:* *`c`*`.keys.size()`.
 ``` cpp
+constexpr size_type max_size() const noexcept;
 ```
+*Returns:*
+`min<size_type>(`*`c`*`.keys.max_size(), `*`c`*`.values.max_size())`.
 #### Access <a id="flat.map.access">[[flat.map.access]]</a>
 ``` cpp
+constexpr mapped_type& operator[](const key_type& x);
 ```
 *Effects:* Equivalent to: `return try_emplace(x).first->second;`
 ``` cpp
+constexpr mapped_type& operator[](key_type&& x);
 ```
 *Effects:* Equivalent to:
 `return try_emplace(std::move(x)).first->second;`
 ``` cpp
+template<class K> constexpr mapped_type& operator[](K&& x);
 ```
 *Constraints:* The *qualified-id* `Compare::is_transparent` is valid and
 denotes a type.
 *Effects:* Equivalent to:
 `return try_emplace(std::forward<K>(x)).first->second;`
 ``` cpp
+constexpr mapped_type&       at(const key_type& x);
+constexpr const mapped_type& at(const key_type& x) const;
 ```
 *Returns:* A reference to the `mapped_type` corresponding to `x` in
 `*this`.
 is present.
 *Complexity:* Logarithmic.
 ``` cpp
+template<class K> constexpr mapped_type&       at(const K& x);
+template<class K> constexpr const mapped_type& at(const K& x) const;
 ```
 *Constraints:* The *qualified-id* `Compare::is_transparent` is valid and
 denotes a type.
 *Complexity:* Logarithmic.
 #### Modifiers <a id="flat.map.modifiers">[[flat.map.modifiers]]</a>
 ``` cpp
+template<class... Args> constexpr pair<iterator, bool> emplace(Args&&... args);
 ```
 *Constraints:*
 `is_constructible_v<pair<key_type, mapped_type>, Args...>` is `true`.
 *Returns:* The `bool` component of the returned pair is `true` if and
 only if the insertion took place, and the iterator component of the pair
 points to the element with key equivalent to `t.first`.
 ``` cpp
+template<class P> constexpr pair<iterator, bool> insert(P&& x);
+template<class P> constexpr iterator insert(const_iterator position, P&& x);
 ```
 *Constraints:* `is_constructible_v<pair<key_type, mapped_type>, P>` is
 `true`.
 `return emplace(std::forward<P>(x));`. The second form is equivalent to
 `return emplace_hint(position, std::forward<P>(x));`.
 ``` cpp
 template<class InputIterator>
+ constexpr void insert(InputIterator first, InputIterator last);
 ```
+*Effects:* Adds elements to *c* as if by:
 ``` cpp
 for (; first != last; ++first) {
   value_type value = *first;
   c.keys.insert(c.keys.end(), std::move(value.first));
 `value_comp()`; merges the resulting sorted range and the sorted range
 of pre-existing elements into a single sorted range; and finally erases
 the duplicate elements as if by:
 ``` cpp
+auto zv = views::zip(c.keys, c.values);
+auto it = ranges::unique(zv, key-equiv(compare)).begin();
 auto dist = distance(zv.begin(), it);
 c.keys.erase(c.keys.begin() + dist, c.keys.end());
 c.values.erase(c.values.begin() + dist, c.values.end());
 ```
 *Remarks:* Since this operation performs an in-place merge, it may
 allocate memory.
 ``` cpp
 template<class InputIterator>
+ constexpr void insert(sorted_unique_t, InputIterator first, InputIterator last);
 ```
+*Effects:* Equivalent to `insert(first, last)`.
 *Complexity:* Linear in N, where N is `size()` after the operation.
 ``` cpp
 template<container-compatible-range<value_type> R>
+ constexpr void insert_range(R&& rg);
 ```
+*Effects:* Adds elements to *c* as if by:
 ``` cpp
 for (const auto& e : rg) {
   c.keys.insert(c.keys.end(), e.first);
   c.values.insert(c.values.end(), e.second);
 `value_comp()`; merges the resulting sorted range and the sorted range
 of pre-existing elements into a single sorted range; and finally erases
 the duplicate elements as if by:
 ``` cpp
+auto zv = views::zip(c.keys, c.values);
+auto it = ranges::unique(zv, key-equiv(compare)).begin();
 auto dist = distance(zv.begin(), it);
 c.keys.erase(c.keys.begin() + dist, c.keys.end());
 c.values.erase(c.values.begin() + dist, c.values.end());
 ```
 *Remarks:* Since this operation performs an in-place merge, it may
 allocate memory.
 ``` cpp
 template<class... Args>
+ constexpr pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
 template<class... Args>
+ constexpr pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
 template<class... Args>
+ constexpr iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args);
 template<class... Args>
+ constexpr iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);
 ```
 *Constraints:* `is_constructible_v<mapped_type, Args...>` is `true`.
 *Effects:* If the map already contains an element whose key is
 *Complexity:* The same as `emplace` for the first two overloads, and the
 same as `emplace_hint` for the last two overloads.
 ``` cpp
 template<class K, class... Args>
+ constexpr pair<iterator, bool> try_emplace(K&& k, Args&&... args);
 template<class K, class... Args>
+ constexpr iterator try_emplace(const_iterator hint, K&& k, Args&&... args);
 ```
 *Constraints:*
 - The *qualified-id* `Compare::is_transparent` is valid and denotes a
 *Effects:* If the map already contains an element whose key is
 equivalent to `k`, `*this` and `args...` are unchanged. Otherwise
 equivalent to:
 ``` cpp
+auto key_it = upper_bound(c.keys.begin(), c.keys.end(), k, compare);
 auto value_it = c.values.begin() + distance(c.keys.begin(), key_it);
 c.keys.emplace(key_it, std::forward<K>(k));
 c.values.emplace(value_it, std::forward<Args>(args)...);
 ```
 *Complexity:* The same as `emplace` and `emplace_hint`, respectively.
 ``` cpp
 template<class M>
+ constexpr pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);
 template<class M>
+ constexpr pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj);
 template<class M>
+ constexpr iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);
 template<class M>
+ constexpr iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj);
 ```
 *Constraints:* `is_assignable_v<mapped_type&, M>` is `true` and
 `is_constructible_v<mapped_type, M>` is `true`.
 *Complexity:* The same as `emplace` for the first two overloads and the
 same as `emplace_hint` for the last two overloads.
 ``` cpp
 template<class K, class M>
+ constexpr pair<iterator, bool> insert_or_assign(K&& k, M&& obj);
 template<class K, class M>
+ constexpr iterator insert_or_assign(const_iterator hint, K&& k, M&& obj);
 ```
 *Constraints:*
 - The *qualified-id* `Compare::is_transparent` is valid and denotes a
 iterator points to the map element whose key is equivalent to `k`.
 *Complexity:* The same as `emplace` and `emplace_hint`, respectively.
 ``` cpp
+constexpr void swap(flat_map& y) noexcept;
 ```
 *Effects:* Equivalent to:
 ``` cpp
 ranges::swap(c.keys, y.c.keys);
 ranges::swap(c.values, y.c.values);
 ```
 ``` cpp
+constexpr containers extract() &&;
 ```
 *Ensures:* `*this` is emptied, even if the function exits via an
 exception.
+*Returns:* `std::move(`*`c`*`)`.
 ``` cpp
+constexpr void replace(key_container_type&& key_cont, mapped_container_type&& mapped_cont);
 ```
 *Preconditions:* `key_cont.size() == mapped_cont.size()` is `true`, the
+elements of `key_cont` are sorted with respect to *compare*, and
 `key_cont` contains no equal elements.
 *Effects:* Equivalent to:
 ``` cpp
 #### Erasure <a id="flat.map.erasure">[[flat.map.erasure]]</a>
 ``` cpp
 template<class Key, class T, class Compare, class KeyContainer, class MappedContainer,
          class Predicate>
+ constexpr typename flat_map<Key, T, Compare, KeyContainer, MappedContainer>::size_type
     erase_if(flat_map<Key, T, Compare, KeyContainer, MappedContainer>& c, Predicate pred);
 ```
 *Preconditions:* `Key` and `T` meet the *Cpp17MoveAssignable*
 requirements.
 The effect of calling a constructor that takes both `key_container_type`
 and `mapped_container_type` arguments with containers of different sizes
 is undefined.
+The effect of calling a member function that takes a
 `sorted_equivalent_t` argument with a container, containers, or range
 that are not sorted with respect to `key_comp()` is undefined.
+The types `iterator` and `const_iterator` meet the constexpr iterator
+requirements [[iterator.requirements.general]].
 #### Definition <a id="flat.multimap.defn">[[flat.multimap.defn]]</a>
 ``` cpp
 namespace std {
   template<class Key, class T, class Compare = less<Key>,
     using mapped_container_type  = MappedContainer;
     class value_compare {
     private:
       key_compare comp;                                         // exposition only
+ constexpr value_compare(key_compare c) : comp(c) { } // exposition only
     public:
+ constexpr bool operator()(const_reference x, const_reference y) const {
         return comp(x.first, y.first);
       }
     };
     struct containers {
       key_container_type keys;
       mapped_container_type values;
     };
+    // [flat.multimap.cons], constructors
+ constexpr flat_multimap() : flat_multimap(key_compare()) { }
+ constexpr explicit flat_multimap(const key_compare& comp)
+      : c(), compare(comp) { }
+    constexpr flat_multimap(key_container_type key_cont, mapped_container_type mapped_cont,
                             const key_compare& comp = key_compare());
+ constexpr flat_multimap(sorted_equivalent_t,
                             key_container_type key_cont, mapped_container_type mapped_cont,
                   const key_compare& comp = key_compare());
     template<class InputIterator>
+ constexpr flat_multimap(InputIterator first, InputIterator last,
                               const key_compare& comp = key_compare())
         : c(), compare(comp)
         { insert(first, last); }
+    template<class InputIterator>
+      constexpr flat_multimap(sorted_equivalent_t, InputIterator first, InputIterator last,
+                              const key_compare& comp = key_compare())
+        : c(), compare(comp) { insert(sorted_equivalent, first, last); }
     template<container-compatible-range<value_type> R>
+ constexpr flat_multimap(from_range_t, R&& rg)
+        : flat_multimap(from_range, std::forward<R>(rg), key_compare()) { }
     template<container-compatible-range<value_type> R>
+ constexpr flat_multimap(from_range_t, R&& rg, const key_compare& comp)
         : flat_multimap(comp) { insert_range(std::forward<R>(rg)); }
+ constexpr flat_multimap(initializer_list<value_type> il,
                             const key_compare& comp = key_compare())
         : flat_multimap(il.begin(), il.end(), comp) { }
+ constexpr flat_multimap(sorted_equivalent_t, initializer_list<value_type> il,
                             const key_compare& comp = key_compare())
+        : flat_multimap(sorted_equivalent, il.begin(), il.end(), comp) { }
+ // [flat.multimap.cons.alloc], constructors with allocators
+    template<class Alloc>
+      constexpr explicit flat_multimap(const Alloc& a);
+    template<class Alloc>
+      constexpr flat_multimap(const key_compare& comp, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_multimap(const key_container_type& key_cont,
+                              const mapped_container_type& mapped_cont, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_multimap(const key_container_type& key_cont,
+                              const mapped_container_type& mapped_cont,
+                              const key_compare& comp, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_multimap(sorted_equivalent_t, const key_container_type& key_cont,
+                              const mapped_container_type& mapped_cont, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_multimap(sorted_equivalent_t, const key_container_type& key_cont,
+                              const mapped_container_type& mapped_cont,
+                              const key_compare& comp, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_multimap(const flat_multimap&, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_multimap(flat_multimap&&, const Alloc& a);
+    template<class InputIterator, class Alloc>
+      constexpr flat_multimap(InputIterator first, InputIterator last, const Alloc& a);
+    template<class InputIterator, class Alloc>
+      constexpr flat_multimap(InputIterator first, InputIterator last,
+                              const key_compare& comp, const Alloc& a);
+    template<class InputIterator, class Alloc>
+      constexpr flat_multimap(sorted_equivalent_t, InputIterator first, InputIterator last,
+                              const Alloc& a);
+    template<class InputIterator, class Alloc>
+      constexpr flat_multimap(sorted_equivalent_t, InputIterator first, InputIterator last,
+                              const key_compare& comp, const Alloc& a);
+    template<container-compatible-range<value_type> R, class Alloc>
+      constexpr flat_multimap(from_range_t, R&& rg, const Alloc& a);
+    template<container-compatible-range<value_type> R, class Alloc>
+      constexpr flat_multimap(from_range_t, R&& rg, const key_compare& comp, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_multimap(initializer_list<value_type> il, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_multimap(initializer_list<value_type> il, const key_compare& comp,
+                              const Alloc& a);
+    template<class Alloc>
+      constexpr flat_multimap(sorted_equivalent_t, initializer_list<value_type> il,
+                              const Alloc& a);
+    template<class Alloc>
+      constexpr flat_multimap(sorted_equivalent_t, initializer_list<value_type> il,
+                              const key_compare& comp, const Alloc& a);
+    flat_multimap& operator=(initializer_list<value_type>);
     // iterators
+ constexpr iterator               begin() noexcept;
+ constexpr const_iterator         begin() const noexcept;
+ constexpr iterator               end() noexcept;
+ constexpr const_iterator         end() const noexcept;
+ constexpr reverse_iterator       rbegin() noexcept;
+ constexpr const_reverse_iterator rbegin() const noexcept;
+ constexpr reverse_iterator       rend() noexcept;
+ constexpr const_reverse_iterator rend() const noexcept;
+ constexpr const_iterator         cbegin() const noexcept;
+ constexpr const_iterator         cend() const noexcept;
+ constexpr const_reverse_iterator crbegin() const noexcept;
+ constexpr const_reverse_iterator crend() const noexcept;
     // capacity
+ constexpr bool empty() const noexcept;
+ constexpr size_type size() const noexcept;
+ constexpr size_type max_size() const noexcept;
     // modifiers
+    template<class... Args> constexpr iterator emplace(Args&&... args);
     template<class... Args>
+ constexpr iterator emplace_hint(const_iterator position, Args&&... args);
+ constexpr iterator insert(const value_type& x)
       { return emplace(x); }
+ constexpr iterator insert(value_type&& x)
       { return emplace(std::move(x)); }
+ constexpr iterator insert(const_iterator position, const value_type& x)
       { return emplace_hint(position, x); }
+ constexpr iterator insert(const_iterator position, value_type&& x)
       { return emplace_hint(position, std::move(x)); }
+    template<class P> constexpr iterator insert(P&& x);
     template<class P>
+ constexpr iterator insert(const_iterator position, P&&);
     template<class InputIterator>
+ constexpr void insert(InputIterator first, InputIterator last);
     template<class InputIterator>
+ constexpr void insert(sorted_equivalent_t, InputIterator first, InputIterator last);
     template<container-compatible-range<value_type> R>
+ constexpr void insert_range(R&& rg);
+ constexpr void insert(initializer_list<value_type> il)
       { insert(il.begin(), il.end()); }
+ constexpr void insert(sorted_equivalent_t, initializer_list<value_type> il)
+      { insert(sorted_equivalent, il.begin(), il.end()); }
+ constexpr containers extract() &&;
+ constexpr void replace(key_container_type&& key_cont, mapped_container_type&& mapped_cont);
+ constexpr iterator erase(iterator position);
+ constexpr iterator erase(const_iterator position);
+ constexpr size_type erase(const key_type& x);
+    template<class K> constexpr size_type erase(K&& x);
+ constexpr iterator erase(const_iterator first, const_iterator last);
+ constexpr void swap(flat_multimap&) noexcept;
+ constexpr void clear() noexcept;
     // observers
+ constexpr key_compare key_comp() const;
+ constexpr value_compare value_comp() const;
+ constexpr const key_container_type& keys() const noexcept { return c.keys; }
+ constexpr const mapped_container_type& values() const noexcept { return c.values; }
     // map operations
+ constexpr iterator find(const key_type& x);
+ constexpr const_iterator find(const key_type& x) const;
+    template<class K> constexpr iterator find(const K& x);
+    template<class K> constexpr const_iterator find(const K& x) const;
+ constexpr size_type count(const key_type& x) const;
+    template<class K> constexpr size_type count(const K& x) const;
+ constexpr bool contains(const key_type& x) const;
+    template<class K> constexpr bool contains(const K& x) const;
+ constexpr iterator lower_bound(const key_type& x);
+ constexpr const_iterator lower_bound(const key_type& x) const;
+    template<class K> constexpr iterator lower_bound(const K& x);
+    template<class K> constexpr const_iterator lower_bound(const K& x) const;
+ constexpr iterator upper_bound(const key_type& x);
+ constexpr const_iterator upper_bound(const key_type& x) const;
+    template<class K> constexpr iterator upper_bound(const K& x);
+    template<class K> constexpr const_iterator upper_bound(const K& x) const;
+ constexpr pair<iterator, iterator> equal_range(const key_type& x);
+ constexpr pair<const_iterator, const_iterator> equal_range(const key_type& x) const;
     template<class K>
+ constexpr pair<iterator, iterator> equal_range(const K& x);
     template<class K>
+ constexpr pair<const_iterator, const_iterator> equal_range(const K& x) const;
+    friend constexpr bool operator==(const flat_multimap& x, const flat_multimap& y);
+    friend constexpr synth-three-way-result<value_type>
       operator<=>(const flat_multimap& x, const flat_multimap& y);
+    friend constexpr void swap(flat_multimap& x, flat_multimap& y) noexcept
       { x.swap(y); }
   private:
     containers c;               // exposition only
     key_compare compare;        // exposition only
 specified.
 #### Constructors <a id="flat.multimap.cons">[[flat.multimap.cons]]</a>
 ``` cpp
+constexpr flat_multimap(key_container_type key_cont, mapped_container_type mapped_cont,
                         const key_compare& comp = key_compare());
 ```
+*Effects:* Initializes *`c`*`.keys` with `std::move(key_cont)`,
+*`c`*`.values` with `std::move(mapped_cont)`, and *compare* with `comp`;
+sorts the range \[`begin()`, `end()`) with respect to `value_comp()`.
 *Complexity:* Linear in N if the container arguments are already sorted
 with respect to `value_comp()` and otherwise N log N, where N is the
 value of `key_cont.size()` before this call.
 ``` cpp
+constexpr flat_multimap(sorted_equivalent_t, key_container_type key_cont,
+ mapped_container_type mapped_cont,
+ const key_compare& comp = key_compare());
 ```
+*Effects:* Initializes *`c`*`.keys` with `std::move(key_cont)`,
+*`c`*`.values` with `std::move(mapped_cont)`, and *compare* with `comp`.
+*Complexity:* Constant.
+#### Constructors with allocators <a id="flat.multimap.cons.alloc">[[flat.multimap.cons.alloc]]</a>
+The constructors in this subclause shall not participate in overload
+resolution unless `uses_allocator_v<key_container_type, Alloc>` is
+`true` and `uses_allocator_v<mapped_container_type, Alloc>` is `true`.
+``` cpp
+template<class Alloc>
+  constexpr flat_multimap(const key_container_type& key_cont,
+                          const mapped_container_type& mapped_cont, const Alloc& a);
+template<class Alloc>
+  constexpr flat_multimap(const key_container_type& key_cont,
+                          const mapped_container_type& mapped_cont,
+                          const key_compare& comp, const Alloc& a);
+```
 *Effects:* Equivalent to `flat_multimap(key_cont, mapped_cont)` and
 `flat_multimap(key_cont, mapped_cont, comp)`, respectively, except that
+*`c`*`.keys` and *`c`*`.values` are constructed with uses-allocator
 construction [[allocator.uses.construction]].
 *Complexity:* Same as `flat_multimap(key_cont, mapped_cont)` and
 `flat_multimap(key_cont, mapped_cont, comp)`, respectively.
 ``` cpp
+template<class Alloc>
+  constexpr flat_multimap(sorted_equivalent_t, const key_container_type& key_cont,
+                const mapped_container_type& mapped_cont, const Alloc& a);
+template<class Alloc>
+  constexpr flat_multimap(sorted_equivalent_t, const key_container_type& key_cont,
                 const mapped_container_type& mapped_cont, const key_compare& comp,
+                const Alloc& a);
 ```
+*Effects:* Equivalent to
+`flat_multimap(sorted_equivalent, key_cont, mapped_cont)` and
+`flat_multimap(sorted_equivalent, key_cont, mapped_cont, comp)`,
+respectively, except that *`c`*`.keys` and *`c`*`.values` are
+constructed with uses-allocator
 construction [[allocator.uses.construction]].
 *Complexity:* Linear.
 ``` cpp
+template<class Alloc>
+ constexpr explicit flat_multimap(const Alloc& a);
+template<class Alloc>
+ constexpr flat_multimap(const key_compare& comp, const Alloc& a);
+template<class Alloc>
+ constexpr flat_multimap(const flat_multimap&, const Alloc& a);
+template<class Alloc>
+  constexpr flat_multimap(flat_multimap&&, const Alloc& a);
+template<class InputIterator, class Alloc>
+  constexpr flat_multimap(InputIterator first, InputIterator last, const Alloc& a);
+template<class InputIterator, class Alloc>
+  constexpr flat_multimap(InputIterator first, InputIterator last, const key_compare& comp,
+ const Alloc& a);
+template<class InputIterator, class Alloc>
+ constexpr flat_multimap(sorted_equivalent_t, InputIterator first, InputIterator last,
+ const Alloc& a);
+template<class InputIterator, class Alloc>
+ constexpr flat_multimap(sorted_equivalent_t, InputIterator first, InputIterator last,
+ const key_compare& comp, const Alloc& a);
+template<container-compatible-range<value_type> R, class Alloc>
+ constexpr flat_multimap(from_range_t, R&& rg, const Alloc& a);
+template<container-compatible-range<value_type> R, class Alloc>
+ constexpr flat_multimap(from_range_t, R&& rg, const key_compare& comp, const Alloc& a);
+template<class Alloc>
+ constexpr flat_multimap(initializer_list<value_type> il, const Alloc& a);
+template<class Alloc>
+  constexpr flat_multimap(initializer_list<value_type> il, const key_compare& comp,
+ const Alloc& a);
+template<class Alloc>
+  constexpr flat_multimap(sorted_equivalent_t, initializer_list<value_type> il, const Alloc& a);
+template<class Alloc>
+  constexpr flat_multimap(sorted_equivalent_t, initializer_list<value_type> il,
+                          const key_compare& comp, const Alloc& a);
 ```
 *Effects:* Equivalent to the corresponding non-allocator constructors
+except that *`c`*`.keys` and *`c`*`.values` are constructed with
+uses-allocator construction [[allocator.uses.construction]].
 #### Erasure <a id="flat.multimap.erasure">[[flat.multimap.erasure]]</a>
 ``` cpp
 template<class Key, class T, class Compare, class KeyContainer, class MappedContainer,
          class Predicate>
+ constexpr typename flat_multimap<Key, T, Compare, KeyContainer, MappedContainer>::size_type
     erase_if(flat_multimap<Key, T, Compare, KeyContainer, MappedContainer>& c, Predicate pred);
 ```
 *Preconditions:* `Key` and `T` meet the *Cpp17MoveAssignable*
 requirements.
 state [[defns.valid]].
 [*Note 1*: `c` still meets its invariants, but can be
 empty. — *end note*]
+### Header `<flat_set>` synopsis <a id="flat.set.syn">[[flat.set.syn]]</a>
+``` cpp
+#include <compare>              // see [compare.syn]
+#include <initializer_list>     // see [initializer.list.syn]
+namespace std {
+  // [flat.set], class template flat_set
+  template<class Key, class Compare = less<Key>, class KeyContainer = vector<Key>>
+    class flat_set;
+  struct sorted_unique_t { explicit sorted_unique_t() = default; };
+  inline constexpr sorted_unique_t sorted_unique{};
+  template<class Key, class Compare, class KeyContainer, class Allocator>
+    struct uses_allocator<flat_set<Key, Compare, KeyContainer>, Allocator>;
+  // [flat.set.erasure], erasure for flat_set
+  template<class Key, class Compare, class KeyContainer, class Predicate>
+    constexpr typename flat_set<Key, Compare, KeyContainer>::size_type
+      erase_if(flat_set<Key, Compare, KeyContainer>& c, Predicate pred);
+  // [flat.multiset], class template flat_multiset
+  template<class Key, class Compare = less<Key>, class KeyContainer = vector<Key>>
+    class flat_multiset;
+  struct sorted_equivalent_t { explicit sorted_equivalent_t() = default; };
+  inline constexpr sorted_equivalent_t sorted_equivalent{};
+  template<class Key, class Compare, class KeyContainer, class Allocator>
+    struct uses_allocator<flat_multiset<Key, Compare, KeyContainer>, Allocator>;
+  // [flat.multiset.erasure], erasure for flat_multiset
+  template<class Key, class Compare, class KeyContainer, class Predicate>
+    constexpr typename flat_multiset<Key, Compare, KeyContainer>::size_type
+      erase_if(flat_multiset<Key, Compare, KeyContainer>& c, Predicate pred);
+}
+```
 ### Class template `flat_set` <a id="flat.set">[[flat.set]]</a>
 #### Overview <a id="flat.set.overview">[[flat.set.overview]]</a>
 A `flat_set` is a container adaptor that provides an associative
 [*Note 3*: `vector<bool>` is not a sequence container. — *end note*]
 The program is ill-formed if `Key` is not the same type as
 `KeyContainer::value_type`.
+The effect of calling a member function that takes a `sorted_unique_t`
+argument with a range that is not sorted with respect to `key_comp()`,
+or that contains equal elements, is undefined.
+The types `iterator` and `const_iterator` meet the constexpr iterator
+requirements [[iterator.requirements.general]].
 #### Definition <a id="flat.set.defn">[[flat.set.defn]]</a>
 ``` cpp
 namespace std {
     using value_type                = Key;
     using key_compare               = Compare;
     using value_compare             = Compare;
     using reference                 = value_type&;
     using const_reference           = const value_type&;
+    using size_type                 = KeyContainer::size_type;
+    using difference_type           = KeyContainer::difference_type;
     using iterator                  = implementation-defined  // type of flat_set::iterator;  // see [container.requirements]
     using const_iterator            = implementation-defined  // type of flat_set::const_iterator;  // see [container.requirements]
     using reverse_iterator          = std::reverse_iterator<iterator>;
     using const_reverse_iterator    = std::reverse_iterator<const_iterator>;
     using container_type            = KeyContainer;
     // [flat.set.cons], constructors
+ constexpr flat_set() : flat_set(key_compare()) { }
+ constexpr explicit flat_set(const key_compare& comp)
       : c(), compare(comp) { }
+    constexpr explicit flat_set(container_type cont, const key_compare& comp = key_compare());
+    constexpr flat_set(sorted_unique_t, container_type cont,
+                       const key_compare& comp = key_compare())
+      : c(std::move(cont)), compare(comp) { }
     template<class InputIterator>
+ constexpr flat_set(InputIterator first, InputIterator last,
+                         const key_compare& comp = key_compare())
         : c(), compare(comp)
         { insert(first, last); }
+    template<class InputIterator>
+      constexpr flat_set(sorted_unique_t, InputIterator first, InputIterator last,
+               const key_compare& comp = key_compare())
+        : c(first, last), compare(comp) { }
     template<container-compatible-range<value_type> R>
+ constexpr flat_set(from_range_t, R&& rg)
+        : flat_set(from_range, std::forward<R>(rg), key_compare()) { }
     template<container-compatible-range<value_type> R>
+ constexpr flat_set(from_range_t, R&& rg, const key_compare& comp)
         : flat_set(comp)
         { insert_range(std::forward<R>(rg)); }
+ constexpr flat_set(initializer_list<value_type> il, const key_compare& comp = key_compare())
         : flat_set(il.begin(), il.end(), comp) { }
+ constexpr flat_set(sorted_unique_t, initializer_list<value_type> il,
              const key_compare& comp = key_compare())
+        : flat_set(sorted_unique, il.begin(), il.end(), comp) { }
+ // [flat.set.cons.alloc], constructors with allocators
+    template<class Alloc>
+      constexpr explicit flat_set(const Alloc& a);
+    template<class Alloc>
+      constexpr flat_set(const key_compare& comp, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_set(const container_type& cont, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_set(const container_type& cont, const key_compare& comp, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_set(sorted_unique_t, const container_type& cont, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_set(sorted_unique_t, const container_type& cont,
+                         const key_compare& comp, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_set(const flat_set&, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_set(flat_set&&, const Alloc& a);
+    template<class InputIterator, class Alloc>
+      constexpr flat_set(InputIterator first, InputIterator last, const Alloc& a);
+    template<class InputIterator, class Alloc>
+      constexpr flat_set(InputIterator first, InputIterator last,
+                         const key_compare& comp, const Alloc& a);
+    template<class InputIterator, class Alloc>
+      constexpr flat_set(sorted_unique_t, InputIterator first, InputIterator last,
+                         const Alloc& a);
+    template<class InputIterator, class Alloc>
+      constexpr flat_set(sorted_unique_t, InputIterator first, InputIterator last,
+                         const key_compare& comp, const Alloc& a);
+    template<container-compatible-range<value_type> R, class Alloc>
+      constexpr flat_set(from_range_t, R&& rg, const Alloc& a);
+    template<container-compatible-range<value_type> R, class Alloc>
+      constexpr flat_set(from_range_t, R&& rg, const key_compare& comp, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_set(initializer_list<value_type> il, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_set(initializer_list<value_type> il, const key_compare& comp,
+                         const Alloc& a);
+    template<class Alloc>
+      constexpr flat_set(sorted_unique_t, initializer_list<value_type> il, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_set(sorted_unique_t, initializer_list<value_type> il,
+                         const key_compare& comp, const Alloc& a);
+    constexpr flat_set& operator=(initializer_list<value_type>);
     // iterators
+ constexpr iterator               begin() noexcept;
+ constexpr const_iterator         begin() const noexcept;
+ constexpr iterator               end() noexcept;
+ constexpr const_iterator         end() const noexcept;
+ constexpr reverse_iterator       rbegin() noexcept;
+ constexpr const_reverse_iterator rbegin() const noexcept;
+ constexpr reverse_iterator       rend() noexcept;
+ constexpr const_reverse_iterator rend() const noexcept;
+ constexpr const_iterator         cbegin() const noexcept;
+ constexpr const_iterator         cend() const noexcept;
+ constexpr const_reverse_iterator crbegin() const noexcept;
+ constexpr const_reverse_iterator crend() const noexcept;
     // capacity
+ constexpr bool empty() const noexcept;
+ constexpr size_type size() const noexcept;
+ constexpr size_type max_size() const noexcept;
     // [flat.set.modifiers], modifiers
+    template<class... Args> constexpr pair<iterator, bool> emplace(Args&&... args);
     template<class... Args>
+ constexpr iterator emplace_hint(const_iterator position, Args&&... args);
+ constexpr pair<iterator, bool> insert(const value_type& x)
       { return emplace(x); }
+ constexpr pair<iterator, bool> insert(value_type&& x)
       { return emplace(std::move(x)); }
+    template<class K> constexpr pair<iterator, bool> insert(K&& x);
+ constexpr iterator insert(const_iterator position, const value_type& x)
       { return emplace_hint(position, x); }
+ constexpr iterator insert(const_iterator position, value_type&& x)
       { return emplace_hint(position, std::move(x)); }
+    template<class K> constexpr iterator insert(const_iterator hint, K&& x);
     template<class InputIterator>
+ constexpr void insert(InputIterator first, InputIterator last);
     template<class InputIterator>
+ constexpr void insert(sorted_unique_t, InputIterator first, InputIterator last);
     template<container-compatible-range<value_type> R>
+ constexpr void insert_range(R&& rg);
+ constexpr void insert(initializer_list<value_type> il)
       { insert(il.begin(), il.end()); }
+ constexpr void insert(sorted_unique_t, initializer_list<value_type> il)
+      { insert(sorted_unique, il.begin(), il.end()); }
+ constexpr container_type extract() &&;
+ constexpr void replace(container_type&&);
+ constexpr iterator erase(iterator position);
+ constexpr iterator erase(const_iterator position);
+ constexpr size_type erase(const key_type& x);
+    template<class K> constexpr size_type erase(K&& x);
+ constexpr iterator erase(const_iterator first, const_iterator last);
+ constexpr void swap(flat_set& y) noexcept;
+ constexpr void clear() noexcept;
     // observers
+ constexpr key_compare key_comp() const;
+ constexpr value_compare value_comp() const;
     // set operations
+ constexpr iterator find(const key_type& x);
+ constexpr const_iterator find(const key_type& x) const;
+    template<class K> constexpr iterator find(const K& x);
+    template<class K> constexpr const_iterator find(const K& x) const;
+ constexpr size_type count(const key_type& x) const;
+    template<class K> constexpr size_type count(const K& x) const;
+ constexpr bool contains(const key_type& x) const;
+    template<class K> constexpr bool contains(const K& x) const;
+ constexpr iterator lower_bound(const key_type& x);
+ constexpr const_iterator lower_bound(const key_type& x) const;
+    template<class K> constexpr iterator lower_bound(const K& x);
+    template<class K> constexpr const_iterator lower_bound(const K& x) const;
+ constexpr iterator upper_bound(const key_type& x);
+ constexpr const_iterator upper_bound(const key_type& x) const;
+    template<class K> constexpr iterator upper_bound(const K& x);
+    template<class K> constexpr const_iterator upper_bound(const K& x) const;
+ constexpr pair<iterator, iterator> equal_range(const key_type& x);
+ constexpr pair<const_iterator, const_iterator> equal_range(const key_type& x) const;
     template<class K>
+ constexpr pair<iterator, iterator> equal_range(const K& x);
     template<class K>
+ constexpr pair<const_iterator, const_iterator> equal_range(const K& x) const;
+    friend constexpr bool operator==(const flat_set& x, const flat_set& y);
+    friend constexpr synth-three-way-result<value_type>
       operator<=>(const flat_set& x, const flat_set& y);
+    friend constexpr void swap(flat_set& x, flat_set& y) noexcept { x.swap(y); }
   private:
     container_type c;           // exposition only
     key_compare compare;        // exposition only
   };
 ```
 #### Constructors <a id="flat.set.cons">[[flat.set.cons]]</a>
 ``` cpp
+constexpr explicit flat_set(container_type cont, const key_compare& comp = key_compare());
 ```
 *Effects:* Initializes *c* with `std::move(cont)` and *compare* with
 `comp`, sorts the range \[`begin()`, `end()`) with respect to *compare*,
 and finally erases all but the first element from each group of
 consecutive equivalent elements.
+*Complexity:* Linear in N if `cont` is already sorted with respect to
+*compare* and otherwise N log N, where N is the value of `cont.size()`
+before this call.
+#### Constructors with allocators <a id="flat.set.cons.alloc">[[flat.set.cons.alloc]]</a>
+The constructors in this subclause shall not participate in overload
+resolution unless `uses_allocator_v<container_type, Alloc>` is `true`.
 ``` cpp
+template<class Alloc>
+ constexpr flat_set(const container_type& cont, const Alloc& a);
+template<class Alloc>
+ constexpr flat_set(const container_type& cont, const key_compare& comp, const Alloc& a);
 ```
 *Effects:* Equivalent to `flat_set(cont)` and `flat_set(cont, comp)`,
 respectively, except that *c* is constructed with uses-allocator
 construction [[allocator.uses.construction]].
 *Complexity:* Same as `flat_set(cont)` and `flat_set(cont, comp)`,
 respectively.
 ``` cpp
+template<class Alloc>
+ constexpr flat_set(sorted_unique_t, const container_type& cont, const Alloc& a);
+template<class Alloc>
+ constexpr flat_set(sorted_unique_t, const container_type& cont,
+ const key_compare& comp, const Alloc& a);
 ```
+*Effects:* Equivalent to `flat_set(sorted_unique, cont)` and
+`flat_set(sorted_unique, cont,comp)`, respectively, except that *c* is
+constructed with uses-allocator
+construction [[allocator.uses.construction]].
 *Complexity:* Linear.
 ``` cpp
+template<class Alloc>
+ constexpr explicit flat_set(const Alloc& a);
+template<class Alloc>
+ constexpr flat_set(const key_compare& comp, const Alloc& a);
+template<class Alloc>
+ constexpr flat_set(const flat_set&, const Alloc& a);
+template<class Alloc>
+ constexpr flat_set(flat_set&&, const Alloc& a);
+template<class InputIterator, class Alloc>
+ constexpr flat_set(InputIterator first, InputIterator last, const Alloc& a);
+template<class InputIterator, class Alloc>
+ constexpr flat_set(InputIterator first, InputIterator last, const key_compare& comp,
+                     const Alloc& a);
+template<class InputIterator, class Alloc>
+  constexpr flat_set(sorted_unique_t, InputIterator first, InputIterator last, const Alloc& a);
+template<class InputIterator, class Alloc>
+ constexpr flat_set(sorted_unique_t, InputIterator first, InputIterator last,
+                     const key_compare& comp, const Alloc& a);
+template<container-compatible-range<value_type> R, class Alloc>
+  constexpr flat_set(from_range_t, R&& rg, const Alloc& a);
+template<container-compatible-range<value_type> R, class Alloc>
+  constexpr flat_set(from_range_t, R&& rg, const key_compare& comp, const Alloc& a);
+template<class Alloc>
+  constexpr flat_set(initializer_list<value_type> il, const Alloc& a);
+template<class Alloc>
+ constexpr flat_set(initializer_list<value_type> il, const key_compare& comp, const Alloc& a);
+template<class Alloc>
+  constexpr flat_set(sorted_unique_t, initializer_list<value_type> il, const Alloc& a);
+template<class Alloc>
+  constexpr flat_set(sorted_unique_t, initializer_list<value_type> il,
+                     const key_compare& comp, const Alloc& a);
 ```
 *Effects:* Equivalent to the corresponding non-allocator constructors
 except that *c* is constructed with uses-allocator
 construction [[allocator.uses.construction]].
 #### Modifiers <a id="flat.set.modifiers">[[flat.set.modifiers]]</a>
 ``` cpp
+template<class K> constexpr pair<iterator, bool> insert(K&& x);
+template<class K> constexpr iterator insert(const_iterator hint, K&& x);
 ```
 *Constraints:* The *qualified-id* `Compare::is_transparent` is valid and
 denotes a type. `is_constructible_v<value_type, K>` is `true`.
 *Preconditions:* The conversion from `x` into `value_type` constructs an
+object `u`, for which `find(x) == find(u)` is `true`.
 *Effects:* If the set already contains an element equivalent to `x`,
 `*this` and `x` are unchanged. Otherwise, inserts a new element as if by
 `emplace(std::forward<K>(x))`.
 pair is `true` if and only if the insertion took place. The returned
 iterator points to the element whose key is equivalent to `x`.
 ``` cpp
 template<class InputIterator>
+ constexpr void insert(InputIterator first, InputIterator last);
 ```
 *Effects:* Adds elements to *c* as if by:
 ``` cpp
 *Remarks:* Since this operation performs an in-place merge, it may
 allocate memory.
 ``` cpp
 template<class InputIterator>
+ constexpr void insert(sorted_unique_t, InputIterator first, InputIterator last);
 ```
 *Effects:* Equivalent to `insert(first, last)`.
 *Complexity:* Linear.
 ``` cpp
 template<container-compatible-range<value_type> R>
+ constexpr void insert_range(R&& rg);
 ```
 *Effects:* Adds elements to *c* as if by:
 ``` cpp
 *Remarks:* Since this operation performs an in-place merge, it may
 allocate memory.
 ``` cpp
+constexpr void swap(flat_set& y) noexcept;
 ```
 *Effects:* Equivalent to:
 ``` cpp
 ranges::swap(compare, y.compare);
 ranges::swap(c, y.c);
 ```
 ``` cpp
+constexpr container_type extract() &&;
 ```
 *Ensures:* `*this` is emptied, even if the function exits via an
 exception.
 *Returns:* `std::move(`*`c`*`)`.
 ``` cpp
+constexpr void replace(container_type&& cont);
 ```
 *Preconditions:* The elements of `cont` are sorted with respect to
 *compare*, and `cont` contains no equal elements.
 #### Erasure <a id="flat.set.erasure">[[flat.set.erasure]]</a>
 ``` cpp
 template<class Key, class Compare, class KeyContainer, class Predicate>
+ constexpr typename flat_set<Key, Compare, KeyContainer>::size_type
     erase_if(flat_set<Key, Compare, KeyContainer>& c, Predicate pred);
 ```
 *Preconditions:* `Key` meets the *Cpp17MoveAssignable* requirements.
 [*Note 3*: `vector<bool>` is not a sequence container. — *end note*]
 The program is ill-formed if `Key` is not the same type as
 `KeyContainer::value_type`.
+The effect of calling a member function that takes a
 `sorted_equivalent_t` argument with a range that is not sorted with
 respect to `key_comp()` is undefined.
+The types `iterator` and `const_iterator` meet the constexpr iterator
+requirements [[iterator.requirements.general]].
 #### Definition <a id="flat.multiset.defn">[[flat.multiset.defn]]</a>
 ``` cpp
 namespace std {
   template<class Key, class Compare = less<Key>, class KeyContainer = vector<Key>>
     using value_type                = Key;
     using key_compare               = Compare;
     using value_compare             = Compare;
     using reference                 = value_type&;
     using const_reference           = const value_type&;
+    using size_type                 = KeyContainer::size_type;
+    using difference_type           = KeyContainer::difference_type;
     using iterator                  = implementation-defined  // type of flat_multiset::iterator;  // see [container.requirements]
     using const_iterator            = implementation-defined  // type of flat_multiset::const_iterator;  // see [container.requirements]
     using reverse_iterator          = std::reverse_iterator<iterator>;
     using const_reverse_iterator    = std::reverse_iterator<const_iterator>;
     using container_type            = KeyContainer;
     // [flat.multiset.cons], constructors
+ constexpr flat_multiset() : flat_multiset(key_compare()) { }
+ constexpr explicit flat_multiset(const key_compare& comp)
       : c(), compare(comp) { }
+    constexpr explicit flat_multiset(container_type cont,
+                                     const key_compare& comp = key_compare());
+    constexpr flat_multiset(sorted_equivalent_t, container_type cont,
+                            const key_compare& comp = key_compare())
+      : c(std::move(cont)), compare(comp) { }
     template<class InputIterator>
+ constexpr flat_multiset(InputIterator first, InputIterator last,
                               const key_compare& comp = key_compare())
         : c(), compare(comp)
         { insert(first, last); }
+    template<class InputIterator>
+      constexpr flat_multiset(sorted_equivalent_t, InputIterator first, InputIterator last,
+                              const key_compare& comp = key_compare())
+        : c(first, last), compare(comp) { }
     template<container-compatible-range<value_type> R>
+ constexpr flat_multiset(from_range_t, R&& rg)
+        : flat_multiset(from_range, std::forward<R>(rg), key_compare()) { }
     template<container-compatible-range<value_type> R>
+ constexpr flat_multiset(from_range_t, R&& rg, const key_compare& comp)
         : flat_multiset(comp)
         { insert_range(std::forward<R>(rg)); }
+ constexpr flat_multiset(initializer_list<value_type> il,
                             const key_compare& comp = key_compare())
       : flat_multiset(il.begin(), il.end(), comp) { }
+ constexpr flat_multiset(sorted_equivalent_t, initializer_list<value_type> il,
                             const key_compare& comp = key_compare())
+        : flat_multiset(sorted_equivalent, il.begin(), il.end(), comp) { }
+ // [flat.multiset.cons.alloc], constructors with allocators
+    template<class Alloc>
+      constexpr explicit flat_multiset(const Alloc& a);
+    template<class Alloc>
+      constexpr flat_multiset(const key_compare& comp, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_multiset(const container_type& cont, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_multiset(const container_type& cont, const key_compare& comp,
+                              const Alloc& a);
+    template<class Alloc>
+      constexpr flat_multiset(sorted_equivalent_t, const container_type& cont, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_multiset(sorted_equivalent_t, const container_type& cont,
+                              const key_compare& comp, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_multiset(const flat_multiset&, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_multiset(flat_multiset&&, const Alloc& a);
+    template<class InputIterator, class Alloc>
+      constexpr flat_multiset(InputIterator first, InputIterator last, const Alloc& a);
+    template<class InputIterator, class Alloc>
+      constexpr flat_multiset(InputIterator first, InputIterator last,
+                              const key_compare& comp, const Alloc& a);
+    template<class InputIterator, class Alloc>
+      constexpr flat_multiset(sorted_equivalent_t, InputIterator first, InputIterator last,
+                              const Alloc& a);
+    template<class InputIterator, class Alloc>
+      constexpr flat_multiset(sorted_equivalent_t, InputIterator first, InputIterator last,
+                              const key_compare& comp, const Alloc& a);
+    template<container-compatible-range<value_type> R, class Alloc>
+      constexpr flat_multiset(from_range_t, R&& rg, const Alloc& a);
+    template<container-compatible-range<value_type> R, class Alloc>
+      constexpr flat_multiset(from_range_t, R&& rg, const key_compare& comp, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_multiset(initializer_list<value_type> il, const Alloc& a);
+    template<class Alloc>
+      constexpr flat_multiset(initializer_list<value_type> il, const key_compare& comp,
+                              const Alloc& a);
+    template<class Alloc>
+      constexpr flat_multiset(sorted_equivalent_t, initializer_list<value_type> il,
+                              const Alloc& a);
+    template<class Alloc>
+      constexpr flat_multiset(sorted_equivalent_t, initializer_list<value_type> il,
+                              const key_compare& comp, const Alloc& a);
+    constexpr flat_multiset& operator=(initializer_list<value_type>);
     // iterators
+ constexpr iterator               begin() noexcept;
+ constexpr const_iterator         begin() const noexcept;
+ constexpr iterator               end() noexcept;
+ constexpr const_iterator         end() const noexcept;
+ constexpr reverse_iterator       rbegin() noexcept;
+ constexpr const_reverse_iterator rbegin() const noexcept;
+ constexpr reverse_iterator       rend() noexcept;
+ constexpr const_reverse_iterator rend() const noexcept;
+ constexpr const_iterator         cbegin() const noexcept;
+ constexpr const_iterator         cend() const noexcept;
+ constexpr const_reverse_iterator crbegin() const noexcept;
+ constexpr const_reverse_iterator crend() const noexcept;
     // capacity
+ constexpr bool empty() const noexcept;
+ constexpr size_type size() const noexcept;
+ constexpr size_type max_size() const noexcept;
     // [flat.multiset.modifiers], modifiers
+    template<class... Args> constexpr iterator emplace(Args&&... args);
     template<class... Args>
+ constexpr iterator emplace_hint(const_iterator position, Args&&... args);
+ constexpr iterator insert(const value_type& x)
       { return emplace(x); }
+ constexpr iterator insert(value_type&& x)
       { return emplace(std::move(x)); }
+ constexpr iterator insert(const_iterator position, const value_type& x)
       { return emplace_hint(position, x); }
+ constexpr iterator insert(const_iterator position, value_type&& x)
       { return emplace_hint(position, std::move(x)); }
     template<class InputIterator>
+ constexpr void insert(InputIterator first, InputIterator last);
     template<class InputIterator>
+ constexpr void insert(sorted_equivalent_t, InputIterator first, InputIterator last);
     template<container-compatible-range<value_type> R>
+ constexpr void insert_range(R&& rg);
+ constexpr void insert(initializer_list<value_type> il)
       { insert(il.begin(), il.end()); }
+ constexpr void insert(sorted_equivalent_t, initializer_list<value_type> il)
+      { insert(sorted_equivalent, il.begin(), il.end()); }
+ constexpr container_type extract() &&;
+ constexpr void replace(container_type&&);
+ constexpr iterator erase(iterator position);
+ constexpr iterator erase(const_iterator position);
+ constexpr size_type erase(const key_type& x);
+    template<class K> constexpr size_type erase(K&& x);
+ constexpr iterator erase(const_iterator first, const_iterator last);
+ constexpr void swap(flat_multiset& y) noexcept;
+ constexpr void clear() noexcept;
     // observers
+ constexpr key_compare key_comp() const;
+ constexpr value_compare value_comp() const;
     // set operations
+ constexpr iterator find(const key_type& x);
+ constexpr const_iterator find(const key_type& x) const;
+    template<class K> constexpr iterator find(const K& x);
+    template<class K> constexpr const_iterator find(const K& x) const;
+ constexpr size_type count(const key_type& x) const;
+    template<class K> constexpr size_type count(const K& x) const;
+ constexpr bool contains(const key_type& x) const;
+    template<class K> constexpr bool contains(const K& x) const;
+ constexpr iterator lower_bound(const key_type& x);
+ constexpr const_iterator lower_bound(const key_type& x) const;
+    template<class K> constexpr iterator lower_bound(const K& x);
+    template<class K> constexpr const_iterator lower_bound(const K& x) const;
+ constexpr iterator upper_bound(const key_type& x);
+ constexpr const_iterator upper_bound(const key_type& x) const;
+    template<class K> constexpr iterator upper_bound(const K& x);
+    template<class K> constexpr const_iterator upper_bound(const K& x) const;
+ constexpr pair<iterator, iterator> equal_range(const key_type& x);
+ constexpr pair<const_iterator, const_iterator> equal_range(const key_type& x) const;
     template<class K>
+ constexpr pair<iterator, iterator> equal_range(const K& x);
     template<class K>
+ constexpr pair<const_iterator, const_iterator> equal_range(const K& x) const;
+    friend constexpr bool operator==(const flat_multiset& x, const flat_multiset& y);
+    friend constexpr synth-three-way-result<value_type>
       operator<=>(const flat_multiset& x, const flat_multiset& y);
+    friend constexpr void swap(flat_multiset& x, flat_multiset& y) noexcept
       { x.swap(y); }
   private:
     container_type c;           // exposition only
     key_compare compare;        // exposition only
     flat_multiset(sorted_equivalent_t, KeyContainer, Compare, Allocator)
       -> flat_multiset<typename KeyContainer::value_type, Compare, KeyContainer>;
   template<class InputIterator, class Compare = less<iter-value-type<InputIterator>>>
     flat_multiset(InputIterator, InputIterator, Compare = Compare())
+      -> flat_multiset<iter-value-type<InputIterator>, Compare>;
   template<class InputIterator, class Compare = less<iter-value-type<InputIterator>>>
     flat_multiset(sorted_equivalent_t, InputIterator, InputIterator, Compare = Compare())
+      -> flat_multiset<iter-value-type<InputIterator>, Compare>;
   template<ranges::input_range R, class Compare = less<ranges::range_value_t<R>>,
            class Allocator = allocator<ranges::range_value_t<R>>>
     flat_multiset(from_range_t, R&&, Compare = Compare(), Allocator = Allocator())
       -> flat_multiset<ranges::range_value_t<R>, Compare,
 ```
 #### Constructors <a id="flat.multiset.cons">[[flat.multiset.cons]]</a>
 ``` cpp
+constexpr explicit flat_multiset(container_type cont, const key_compare& comp = key_compare());
 ```
 *Effects:* Initializes *c* with `std::move(cont)` and *compare* with
 `comp`, and sorts the range \[`begin()`, `end()`) with respect to
 *compare*.
+*Complexity:* Linear in N if `cont` is already sorted with respect to
+*compare* and otherwise N log N, where N is the value of `cont.size()`
+before this call.
+#### Constructors with allocators <a id="flat.multiset.cons.alloc">[[flat.multiset.cons.alloc]]</a>
+The constructors in this subclause shall not participate in overload
+resolution unless `uses_allocator_v<container_type, Alloc>` is `true`.
 ``` cpp
+template<class Alloc>
+ constexpr flat_multiset(const container_type& cont, const Alloc& a);
+template<class Alloc>
+ constexpr flat_multiset(const container_type& cont, const key_compare& comp, const Alloc& a);
 ```
 *Effects:* Equivalent to `flat_multiset(cont)` and
 `flat_multiset(cont, comp)`, respectively, except that *c* is
 constructed with uses-allocator
 construction [[allocator.uses.construction]].
 *Complexity:* Same as `flat_multiset(cont)` and
 `flat_multiset(cont, comp)`, respectively.
 ``` cpp
+template<class Alloc>
+ constexpr flat_multiset(sorted_equivalent_t, const container_type& cont, const Alloc& a);
+template<class Alloc>
+ constexpr flat_multiset(sorted_equivalent_t, const container_type& cont,
+ const key_compare& comp, const Alloc& a);
 ```
+*Effects:* Equivalent to `flat_multiset(sorted_equivalent, cont)` and
+`flat_multiset(sorted_equivalent, cont, comp)`, respectively, except
+that *c* is constructed with uses-allocator
 construction [[allocator.uses.construction]].
 *Complexity:* Linear.
 ``` cpp
+template<class Alloc>
+ constexpr explicit flat_multiset(const Alloc& a);
+template<class Alloc>
+ constexpr flat_multiset(const key_compare& comp, const Alloc& a);
+template<class Alloc>
+ constexpr flat_multiset(const flat_multiset&, const Alloc& a);
+template<class Alloc>
+  constexpr flat_multiset(flat_multiset&&, const Alloc& a);
+template<class InputIterator, class Alloc>
+  constexpr flat_multiset(InputIterator first, InputIterator last, const Alloc& a);
+template<class InputIterator, class Alloc>
+  constexpr flat_multiset(InputIterator first, InputIterator last,
+ const key_compare& comp, const Alloc& a);
+template<class InputIterator, class Alloc>
+ constexpr flat_multiset(sorted_equivalent_t, InputIterator first, InputIterator last,
+ const Alloc& a);
+template<class InputIterator, class Alloc>
+ constexpr flat_multiset(sorted_equivalent_t, InputIterator first, InputIterator last,
+                          const key_compare& comp, const Alloc& a);
+template<container-compatible-range<value_type> R, class Alloc>
+  constexpr flat_multiset(from_range_t, R&& rg, const Alloc& a);
+template<container-compatible-range<value_type> R, class Alloc>
+  constexpr flat_multiset(from_range_t, R&& rg, const key_compare& comp, const Alloc& a);
+template<class Alloc>
+  constexpr flat_multiset(initializer_list<value_type> il, const Alloc& a);
+template<class Alloc>
+ constexpr flat_multiset(initializer_list<value_type> il, const key_compare& comp,
+                          const Alloc& a);
+template<class Alloc>
+  constexpr flat_multiset(sorted_equivalent_t, initializer_list<value_type> il, const Alloc& a);
+template<class Alloc>
+  constexpr flat_multiset(sorted_equivalent_t, initializer_list<value_type> il,
+                          const key_compare& comp, const Alloc& a);
 ```
 *Effects:* Equivalent to the corresponding non-allocator constructors
 except that *c* is constructed with uses-allocator
 construction [[allocator.uses.construction]].
 #### Modifiers <a id="flat.multiset.modifiers">[[flat.multiset.modifiers]]</a>
 ``` cpp
+template<class... Args> constexpr iterator emplace(Args&&... args);
 ```
 *Constraints:* `is_constructible_v<value_type, Args...>` is `true`.
 *Effects:* First, initializes an object `t` of type `value_type` with
 *Returns:* An iterator that points to the inserted element.
 ``` cpp
 template<class InputIterator>
+ constexpr void insert(InputIterator first, InputIterator last);
 ```
 *Effects:* Adds elements to *c* as if by:
 ``` cpp
 *Remarks:* Since this operation performs an in-place merge, it may
 allocate memory.
 ``` cpp
 template<class InputIterator>
+ constexpr void insert(sorted_equivalent_t, InputIterator first, InputIterator last);
 ```
 *Effects:* Equivalent to `insert(first, last)`.
 *Complexity:* Linear.
 ``` cpp
+constexpr void swap(flat_multiset& y) noexcept;
 ```
 *Effects:* Equivalent to:
 ``` cpp
 ranges::swap(compare, y.compare);
 ranges::swap(c, y.c);
 ```
 ``` cpp
+constexpr container_type extract() &&;
 ```
 *Ensures:* `*this` is emptied, even if the function exits via an
 exception.
+*Returns:* `std::move(`*`c`*`)`.
 ``` cpp
+constexpr void replace(container_type&& cont);
 ```
 *Preconditions:* The elements of `cont` are sorted with respect to
 *compare*.
+*Effects:* Equivalent to: *`c`*` = std::move(cont);`
 #### Erasure <a id="flat.multiset.erasure">[[flat.multiset.erasure]]</a>
 ``` cpp
 template<class Key, class Compare, class KeyContainer, class Predicate>
+ constexpr typename flat_multiset<Key, Compare, KeyContainer>::size_type
     erase_if(flat_multiset<Key, Compare, KeyContainer>& c, Predicate pred);
 ```
 *Preconditions:* `Key` meets the *Cpp17MoveAssignable* requirements.
 ### Contiguous access <a id="views.contiguous">[[views.contiguous]]</a>
 #### Header `<span>` synopsis <a id="span.syn">[[span.syn]]</a>
 ``` cpp
+#include <initializer_list>     // see [initializer.list.syn]
+// mostly freestanding
 namespace std {
   // constants
   inline constexpr size_t dynamic_extent = numeric_limits<size_t>::max();
+  template<class T>
+    concept integral-constant-like =                    // exposition only
+      is_integral_v<remove_cvref_t<decltype(T::value)>> &&
+      !is_same_v<bool, remove_const_t<decltype(T::value)>> &&
+      convertible_to<T, decltype(T::value)> &&
+      equality_comparable_with<T, decltype(T::value)> &&
+      bool_constant<T() == T::value>::value &&
+      bool_constant<static_cast<decltype(T::value)>(T()) == T::value>::value;
+  template<class T>
+    constexpr size_t maybe-static-ext = dynamic_extent; // exposition only
+  template<integral-constant-like T>
+    constexpr size_t maybe-static-ext<T> = {T::value};
   // [views.span], class template span
   template<class ElementType, size_t Extent = dynamic_extent>
+    class span;                                                             // partially freestanding
   template<class ElementType, size_t Extent>
+    constexpr bool ranges::\libspec{enable_view}{span}<span<ElementType, Extent>> = true;
   template<class ElementType, size_t Extent>
+    constexpr bool ranges::\libspec{enable_borrowed_range}{span}<span<ElementType, Extent>> = true;
   // [span.objectrep], views of object representation
   template<class ElementType, size_t Extent>
     span<const byte, Extent == dynamic_extent ? dynamic_extent : sizeof(ElementType) * Extent>
       as_bytes(span<ElementType, Extent> s) noexcept;
       constexpr span(array<T, N>& arr) noexcept;
     template<class T, size_t N>
       constexpr span(const array<T, N>& arr) noexcept;
     template<class R>
       constexpr explicit(extent != dynamic_extent) span(R&& r);
+    constexpr explicit(extent != dynamic_extent) span(std::initializer_list<value_type> il);
     constexpr span(const span& other) noexcept = default;
     template<class OtherElementType, size_t OtherExtent>
       constexpr explicit(see below) span(const span<OtherElementType, OtherExtent>& s) noexcept;
     constexpr span& operator=(const span& other) noexcept = default;
     // [span.sub], subviews
     template<size_t Count>
       constexpr span<element_type, Count> first() const;
       size_type offset, size_type count = dynamic_extent) const;
     // [span.obs], observers
     constexpr size_type size() const noexcept;
     constexpr size_type size_bytes() const noexcept;
+    constexpr bool empty() const noexcept;
     // [span.elem], element access
     constexpr reference operator[](size_type idx) const;
+    constexpr reference at(size_type idx) const;                            // freestanding-deleted
     constexpr reference front() const;
     constexpr reference back() const;
     constexpr pointer data() const noexcept;
     // [span.iterators], iterator support
     pointer data_;              // exposition only
     size_type size_;            // exposition only
   };
   template<class It, class EndOrSize>
+    span(It, EndOrSize) -> span<remove_reference_t<iter_reference_t<It>>,
+                                maybe-static-ext<EndOrSize>>;
   template<class T, size_t N>
     span(T (&)[N]) -> span<T, N>;
   template<class T, size_t N>
     span(array<T, N>&) -> span<T, N>;
   template<class T, size_t N>
 [[term.trivially.copyable.type]].
 `ElementType` is required to be a complete object type that is not an
 abstract class type.
+For a `span` `s`, any operation that invalidates a pointer in the range
+\[`s.data()`, `s.data() + s.size()`) invalidates pointers, iterators,
+and references to elements of `s`.
 ##### Constructors, copy, and assignment <a id="span.cons">[[span.cons]]</a>
 ``` cpp
 constexpr span() noexcept;
 ```
 *Preconditions:*
 - \[`first`, `first + count`) is a valid range.
 - `It` models `contiguous_iterator`.
+If `extent` is not equal to `dynamic_extent`, then `count == extent` is
+`true`.
+*Effects:* Initializes *data\_* with `to_address(first)` and *size\_*
 with `count`.
 *Throws:* Nothing.
 ``` cpp
 - `End` satisfies `sized_sentinel_for<It>`.
 - `is_convertible_v<End, size_t>` is `false`.
 *Preconditions:*
 - \[`first`, `last`) is a valid range.
 - `It` models `contiguous_iterator`.
 - `End` models `sized_sentinel_for<It>`.
+If `extent` is not equal to `dynamic_extent`, then
+`(last - first) == extent` is `true`.
+*Effects:* Initializes *data\_* with `to_address(first)` and *size\_*
 with `last - first`.
 *Throws:* When and what `last - first` throws.
 ``` cpp
 template<size_t N> constexpr span(type_identity_t<element_type> (&arr)[N]) noexcept;
 template<class T, size_t N> constexpr span(array<T, N>& arr) noexcept;
 template<class T, size_t N> constexpr span(const array<T, N>& arr) noexcept;
 ```
+*Constraints:* Let `U` be `remove_pointer_t<decltype(std::data(arr))>`.
 - `extent == dynamic_extent || N == extent` is `true`, and
 - `is_convertible_v<U(*)[], element_type(*)[]>` is `true`.
   \[*Note 3*: The intent is to allow only qualification conversions of
   the array element type to `element_type`. — *end note*]
 *Effects:* Constructs a `span` that is a view over the supplied array.
 [*Note 1*: `type_identity_t` affects class template argument
 deduction. — *end note*]
+*Ensures:* `size() == N && data() == std::data(arr)` is `true`.
 ``` cpp
 template<class R> constexpr explicit(extent != dynamic_extent) span(R&& r);
 ```
   \[*Note 4*: The intent is to allow only qualification conversions of
   the range reference type to `element_type`. — *end note*]
 *Preconditions:*
 - `R` models `ranges::contiguous_range` and `ranges::sized_range`.
 - If `is_const_v<element_type>` is `false`, `R` models
   `ranges::borrowed_range`.
+If `extent` is not equal to `dynamic_extent`, then
+`ranges::size(r) == extent` is `true`.
+*Effects:* Initializes *data\_* with `ranges::data(r)` and *size\_* with
+`ranges::size(r)`.
 *Throws:* What and when `ranges::data(r)` and `ranges::size(r)` throw.
+``` cpp
+constexpr explicit(extent != dynamic_extent) span(std::initializer_list<value_type> il);
+```
+*Constraints:* `is_const_v<element_type>` is `true`.
+If `extent` is not equal to `dynamic_extent`, then `il.size() == extent`
+is `true`.
+*Effects:* Initializes *data\_* with `il.begin()` and *size\_* with
+`il.size()`.
 ``` cpp
 constexpr span(const span& other) noexcept = default;
 ```
 *Ensures:* `other.size() == size() && other.data() == data()`.
 - `is_convertible_v<OtherElementType(*)[], element_type(*)[]>` is
   `true`. \[*Note 5*: The intent is to allow only qualification
   conversions of the `OtherElementType` to
   `element_type`. — *end note*]
+If `extent` is not equal to `dynamic_extent`, then `s.size() == extent`
+is `true`.
 *Effects:* Constructs a `span` that is a view over the range
 \[`s.data()`, `s.data() + s.size()`).
 *Ensures:* `size() == s.size() && data() == s.data()`.
 ##### Deduction guides <a id="span.deduct">[[span.deduct]]</a>
 ``` cpp
 template<class It, class EndOrSize>
+  span(It, EndOrSize) -> span<remove_reference_t<iter_reference_t<It>>,
+                              maybe-static-ext<EndOrSize>>;
 ```
 *Constraints:* `It` satisfies `contiguous_iterator`.
 ``` cpp
 template<size_t Count> constexpr span<element_type, Count> first() const;
 ```
 *Mandates:* `Count <= Extent` is `true`.
+`Count <= size()` is `true`.
 *Effects:* Equivalent to: `return R{data(), Count};` where `R` is the
 return type.
 ``` cpp
 template<size_t Count> constexpr span<element_type, Count> last() const;
 ```
 *Mandates:* `Count <= Extent` is `true`.
+`Count <= size()` is `true`.
 *Effects:* Equivalent to: `return R{data() + (size() - Count), Count};`
 where `R` is the return type.
 ``` cpp
 Offset <= Extent && (Count == dynamic_extent || Count <= Extent - Offset)
 ```
 is `true`.
 ``` cpp
 Offset <= size() && (Count == dynamic_extent || Count <= size() - Offset)
 ```
 is `true`.
 ``` cpp
 constexpr span<element_type, dynamic_extent> first(size_type count) const;
 ```
+`count <= size()` is `true`.
 *Effects:* Equivalent to: `return {data(), count};`
 ``` cpp
 constexpr span<element_type, dynamic_extent> last(size_type count) const;
 ```
+`count <= size()` is `true`.
 *Effects:* Equivalent to: `return {data() + (size() - count), count};`
 ``` cpp
 constexpr span<element_type, dynamic_extent> subspan(
   size_type offset, size_type count = dynamic_extent) const;
 ```
 ``` cpp
 offset <= size() && (count == dynamic_extent || count <= size() - offset)
 ```
 is `true`.
 ```
 *Effects:* Equivalent to: `return size() * sizeof(element_type);`
 ``` cpp
+constexpr bool empty() const noexcept;
 ```
 *Effects:* Equivalent to: `return size() == 0;`
 ##### Element access <a id="span.elem">[[span.elem]]</a>
 ``` cpp
 constexpr reference operator[](size_type idx) const;
 ```
+`idx < size()` is `true`.
+*Returns:* `*(data() + idx)`.
+*Throws:* Nothing.
+``` cpp
+constexpr reference at(size_type idx) const;
+```
+*Returns:* `*(data() + idx)`.
+*Throws:* `out_of_range` if `idx >= size()` is `true`.
 ``` cpp
 constexpr reference front() const;
 ```
+`empty()` is `false`.
+*Returns:* `*data()`.
+*Throws:* Nothing.
 ``` cpp
 constexpr reference back() const;
 ```
+`empty()` is `false`.
+*Returns:* `*(data() + (size() - 1))`.
+*Throws:* Nothing.
 ``` cpp
 constexpr pointer data() const noexcept;
 ```
+*Returns:* *data\_*.
 ##### Iterator support <a id="span.iterators">[[span.iterators]]</a>
 ``` cpp
 using iterator = implementation-defined  // type of span::iterator;
   the interval [Lᵢ, Uᵢ) of S.
 #### Header `<mdspan>` synopsis <a id="mdspan.syn">[[mdspan.syn]]</a>
 ``` cpp
+// mostly freestanding
 namespace std {
   // [mdspan.extents], class template extents
   template<class IndexType, size_t... Extents>
     class extents;
   // [mdspan.extents.dextents], alias template dextents
   template<class IndexType, size_t Rank>
     using dextents = see below;
+  // [mdspan.extents.dims], alias template dims
+  template<size_t Rank, class IndexType = size_t>
+    using dims = see below;
   // [mdspan.layout], layout mapping
   struct layout_left;
   struct layout_right;
   struct layout_stride;
+  template<size_t PaddingValue = dynamic_extent>
+    struct layout_left_padded;
+  template<size_t PaddingValue = dynamic_extent>
+    struct layout_right_padded;
   // [mdspan.accessor.default], class template default_accessor
   template<class ElementType>
     class default_accessor;
+  // [mdspan.accessor.aligned], class template aligned_accessor
+  template<class ElementType, size_t ByteAlignment>
+    class aligned_accessor;
   // [mdspan.mdspan], class template mdspan
   template<class ElementType, class Extents, class LayoutPolicy = layout_right,
            class AccessorPolicy = default_accessor<ElementType>>
+    class mdspan;                                                           // partially freestanding
+  // [mdspan.sub], submdspan creation
+  template<class OffsetType, class LengthType, class StrideType>
+    struct strided_slice;
+  template<class LayoutMapping>
+    struct submdspan_mapping_result;
+  struct full_extent_t { explicit full_extent_t() = default; };
+  inline constexpr full_extent_t full_extent{};
+  template<class IndexType, size_t... Extents, class... SliceSpecifiers>
+    constexpr auto submdspan_extents(const extents<IndexType, Extents...>&, SliceSpecifiers...);
+  // [mdspan.sub.sub], submdspan function template
+  template<class ElementType, class Extents, class LayoutPolicy,
+           class AccessorPolicy, class... SliceSpecifiers>
+    constexpr auto submdspan(
+      const mdspan<ElementType, Extents, LayoutPolicy, AccessorPolicy>& src,
+      SliceSpecifiers... slices) -> see below;
+  template<class T, class IndexType>
+    concept index-pair-like =               // exposition only
+      pair-like<T> &&
+      convertible_to<tuple_element_t<0, T>, IndexType> &&
+      convertible_to<tuple_element_t<1, T>, IndexType>;
 }
 ```
 #### Class template `extents` <a id="mdspan.extents">[[mdspan.extents]]</a>
 ##### Overview <a id="mdspan.extents.overview">[[mdspan.extents.overview]]</a>
 The class template `extents` represents a multidimensional index space
+of rank equal to `sizeof...(Extents)`. In  [[views]], `extents` is used
+synonymously with multidimensional index space.
 ``` cpp
 namespace std {
   template<class IndexType, size_t... Extents>
   class extents {
 - If `N != rank_dynamic()` is `true`, `exts_arr[`r`]` equals Eᵣ for each
   r for which Eᵣ is a static extent, and
 - either
   - `sizeof...(exts) == 0` is `true`, or
+  - each element of `exts` is representable as a nonnegative value of
+    type `index_type`.
 *Ensures:* `*this == extents(exts_arr)` is `true`.
 ``` cpp
 template<class OtherIndexType, size_t N>
 - If `N != rank_dynamic()` is `true`, `exts[`r`]` equals Eᵣ for each r
   for which Eᵣ is a static extent, and
 - either
   - `N` is zero, or
+  - `exts[`r`]` is representable as a nonnegative value of type
     `index_type` for every rank index r.
 *Effects:*
+- If `N` equals `rank_dynamic()`, for all d in the range
   [0, `rank_dynamic()`), direct-non-list-initializes
   *`dynamic-extents`*`[`d`]` with `as_const(exts[`d`])`.
 - Otherwise, for all d in the range [0, `rank_dynamic()`),
   direct-non-list-initializes *`dynamic-extents`*`[`d`]` with
   `as_const(exts[`*`dynamic-index-inv`*`(`d`)])`.
   explicit extents(Integrals...) -> see below;
 ```
 *Constraints:* `(is_convertible_v<Integrals, size_t> && ...)` is `true`.
+*Remarks:* The deduced type is
+`extents<size_t, maybe-static-ext<Integrals>...>`.
 ##### Observers of the multidimensional index space <a id="mdspan.extents.obs">[[mdspan.extents.obs]]</a>
 ``` cpp
 static constexpr size_t static_extent(rank_type i) noexcept;
 *Result:* A type `E` that is a specialization of `extents` such that
 `E::rank() == Rank && E::rank() == E::rank_dynamic()` is `true`, and
 `E::index_type` denotes `IndexType`.
+##### Alias template `dims` <a id="mdspan.extents.dims">[[mdspan.extents.dims]]</a>
+``` cpp
+template<size_t Rank, class IndexType = size_t>
+  using dims = see below;
+```
+*Result:* A type `E` that is a specialization of `extents` such that
+`E::rank() == Rank && E::rank() == E::rank_dynamic()` is `true`, and
+`E::index_type` denotes `IndexType`.
 #### Layout mapping <a id="mdspan.layout">[[mdspan.layout]]</a>
 ##### General <a id="mdspan.layout.general">[[mdspan.layout.general]]</a>
+In [[mdspan.layout.reqmts]] and [[mdspan.layout.policy.reqmts]]:
 - `M` denotes a layout mapping class.
 - `m` denotes a (possibly const) value of type `M`.
 - `i` and `j` are packs of (possibly const) integers that are
   multidimensional indices in `m.extents()` [[mdspan.overview]].
 - `r` is a (possibly const) rank index of `typename M::extents_type`.
 - `dᵣ` is a pack of (possibly const) integers for which
   `sizeof...(dᵣ) == M::extents_type::rank()` is `true`, the rᵗʰ element
   is equal to 1, and all other elements are equal to 0.
+In [[mdspan.layout.reqmts]] through [[mdspan.layout.stride]]:
+- Let *`is-mapping-of`* be the exposition-only variable template defined
   as follows:
   ``` cpp
   template<class Layout, class Mapping>
   constexpr bool is-mapping-of =  // exposition only
     is_same_v<typename Layout::template mapping<typename Mapping::extents_type>, Mapping>;
   ```
+- Let *`is-layout-left-padded-mapping-of`* be the exposition-only
+  variable template defined as follows:
+  ``` cpp
+  template<class Mapping>
+  constexpr bool is-layout-left-padded-mapping-of = see below;   // exposition only
+  ```
+  where `is-layout-left-padded-mapping-of<Mapping>` is `true` if and
+  only if `Mapping` denotes a specialization of
+  `layout_left_padded<S>::mapping` for some value `S` of type `size_t`.
+- Let *`is-layout-right-padded-mapping-of`* be the exposition-only
+  variable template defined as follows:
+  ``` cpp
+  template<class Mapping>
+  constexpr bool is-layout-right-padded-mapping-of = see below;   // exposition only
+  ```
+  where `is-layout-right-padded-mapping-of<Mapping>` is `true` if and
+  only if `Mapping` denotes a specialization of
+  `layout_right_padded<S>::mapping` for some value `S` of type `size_t`.
+- For nonnegative integers x and y, let LEAST-MULTIPLE-AT-LEAST(x, y)
+  denote
+  - y if x is zero,
+  - otherwise, the least multiple of x that is greater than or equal to
+    y.
 ##### Requirements <a id="mdspan.layout.reqmts">[[mdspan.layout.reqmts]]</a>
 A type `M` meets the *layout mapping* requirements if
 *Result:* `typename M::index_type`
 *Returns:* sᵣ as defined in `m.is_strided()` above.
+[*Note 5*: It is not required for `m.stride(r)` to be well-formed if
+`m.extents().rank()` is zero, even if `m.is_always_strided()` is
+`true`. — *end note*]
 ``` cpp
 M::is_always_unique()
 ```
 *Result:* A constant expression [[expr.const]] of type `bool`.
 *Returns:* `true` only if `m.is_unique()` is `true` for all possible
 objects `m` of type `M`.
+[*Note 6*: A mapping can return `false` even if the above condition is
 met. For certain layout mappings, it is possibly not feasible to
 determine whether every instance is unique. — *end note*]
 ``` cpp
 M::is_always_exhaustive()
 *Result:* A constant expression [[expr.const]] of type `bool`.
 *Returns:* `true` only if `m.is_exhaustive()` is `true` for all possible
 objects `m` of type `M`.
+[*Note 7*: A mapping can return `false` even if the above condition is
 met. For certain layout mappings, it is possibly not feasible to
 determine whether every instance is exhaustive. — *end note*]
 ``` cpp
 M::is_always_strided()
 *Result:* A constant expression [[expr.const]] of type `bool`.
 *Returns:* `true` only if `m.is_strided()` is `true` for all possible
 objects `m` of type `M`.
+[*Note 8*: A mapping can return `false` even if the above condition is
 met. For certain layout mappings, it is possibly not feasible to
 determine whether every instance is strided. — *end note*]
 ##### Layout mapping policy requirements <a id="mdspan.layout.policy.reqmts">[[mdspan.layout.policy.reqmts]]</a>
   };
   struct layout_stride {
     template<class Extents>
       class mapping;
   };
+  template<size_t PaddingValue>
+  struct layout_left_padded {
+    template<class Extents> class mapping;
+  };
+  template<size_t PaddingValue>
+  struct layout_right_padded {
+    template<class Extents> class mapping;
+  };
 }
 ```
+Each of `layout_left`, `layout_right`, and `layout_stride`, as well as
+each specialization of `layout_left_padded` and `layout_right_padded`,
+meets the layout mapping policy requirements and is a trivially copyable
+type. Furthermore, `is_trivially_default_constructible_v<T>` is `true`
+for any such type `T`.
 ##### Class template `layout_left::mapping` <a id="mdspan.layout.left">[[mdspan.layout.left]]</a>
 ###### Overview <a id="mdspan.layout.left.overview">[[mdspan.layout.left.overview]]</a>
 namespace std {
   template<class Extents>
   class layout_left::mapping {
   public:
     using extents_type = Extents;
+    using index_type = extents_type::index_type;
+    using size_type = extents_type::size_type;
+    using rank_type = extents_type::rank_type;
     using layout_type = layout_left;
     // [mdspan.layout.left.cons], constructors
     constexpr mapping() noexcept = default;
     constexpr mapping(const mapping&) noexcept = default;
       constexpr explicit(!is_convertible_v<OtherExtents, extents_type>)
         mapping(const mapping<OtherExtents>&) noexcept;
     template<class OtherExtents>
       constexpr explicit(!is_convertible_v<OtherExtents, extents_type>)
         mapping(const layout_right::mapping<OtherExtents>&) noexcept;
+    template<class LayoutLeftPaddedMapping>
+      constexpr explicit(!is_convertible_v<typename LayoutLeftPaddedMapping::extents_type,
+                                           extents_type>)
+        mapping(const LayoutLeftPaddedMapping&) noexcept;
     template<class OtherExtents>
       constexpr explicit(extents_type::rank() > 0)
         mapping(const layout_stride::mapping<OtherExtents>&);
     constexpr mapping& operator=(const mapping&) noexcept = default;
     template<class OtherExtents>
       friend constexpr bool operator==(const mapping&, const mapping<OtherExtents>&) noexcept;
   private:
     extents_type extents_{};                                               // exposition only
+    // [mdspan.sub.map], submdspan mapping specialization
+    template<class... SliceSpecifiers>
+      constexpr auto submdspan-mapping-impl(SliceSpecifiers...) const     // exposition only
+        -> see below;
+    template<class... SliceSpecifiers>
+      friend constexpr auto submdspan_mapping(
+        const mapping& src, SliceSpecifiers... slices) {
+          return src.submdspan-mapping-impl(slices...);
+      }
   };
 }
 ```
 If `Extents` is not a specialization of `extents`, then the program is
 *Effects:* Direct-non-list-initializes *extents\_* with
 `other.extents()`.
 ``` cpp
+template<class OtherExtents>
   constexpr explicit(!is_convertible_v<OtherExtents, extents_type>)
     mapping(const layout_right::mapping<OtherExtents>& other) noexcept;
 ```
 *Constraints:*
 value of type `index_type` [[basic.fundamental]].
 *Effects:* Direct-non-list-initializes *extents\_* with
 `other.extents()`.
+``` cpp
+template<class LayoutLeftPaddedMapping>
+  constexpr explicit(!is_convertible_v<typename LayoutLeftPaddedMapping::extents_type,
+                                       extents_type>)
+    mapping(const LayoutLeftPaddedMapping&) noexcept;
+```
+*Constraints:*
+- *`is-layout-left-padded-mapping-of`*`<LayoutLeftPaddedMapping>` is
+  `true`.
+- `is_constructible_v<extents_type, typename LayoutLeftPaddedMapping::extents_type>`
+  is `true`.
+*Mandates:* If
+- `Extents::rank()` is greater than one,
+- `Extents::static_extent(0)` does not equal `dynamic_extent`, and
+- `LayoutLeftPaddedMapping::`*`static-padding-stride`* does not equal
+  `dynamic_extent`,
+then `Extents::static_extent(0)` equals
+`LayoutLeftPaddedMapping::`*`static-padding-stride`*.
+*Preconditions:*
+- If `extents_type::rank() > 1` is `true`, then `other.stride(1)` equals
+  `other.extents().extent(0)`.
+- `other.required_span_size()` is representable as a value of type
+  `index_type`.
+*Effects:* Direct-non-list-initializes `extents_` with
+`other.extents()`.
 ``` cpp
 template<class OtherExtents>
   constexpr explicit(extents_type::rank() > 0)
     mapping(const layout_stride::mapping<OtherExtents>& other);
 ```
 ``` cpp
 return ((static_cast<index_type>(i) * stride(P)) + ... + 0);
 ```
 ``` cpp
+constexpr index_type stride(rank_type i) const noexcept;
 ```
 *Constraints:* `extents_type::rank() > 0` is `true`.
 *Preconditions:* `i < extents_type::rank()` is `true`.
 namespace std {
   template<class Extents>
   class layout_right::mapping {
   public:
     using extents_type = Extents;
+    using index_type = extents_type::index_type;
+    using size_type = extents_type::size_type;
+    using rank_type = extents_type::rank_type;
     using layout_type = layout_right;
     // [mdspan.layout.right.cons], constructors
     constexpr mapping() noexcept = default;
     constexpr mapping(const mapping&) noexcept = default;
       constexpr explicit(!is_convertible_v<OtherExtents, extents_type>)
         mapping(const mapping<OtherExtents>&) noexcept;
     template<class OtherExtents>
       constexpr explicit(!is_convertible_v<OtherExtents, extents_type>)
         mapping(const layout_left::mapping<OtherExtents>&) noexcept;
+    template<class LayoutRightPaddedMapping>
+      constexpr explicit(!is_convertible_v<typename LayoutRightPaddedMapping::extents_type,
+                                           extents_type>)
+        mapping(const LayoutRightPaddedMapping&) noexcept;
     template<class OtherExtents>
       constexpr explicit(extents_type::rank() > 0)
         mapping(const layout_stride::mapping<OtherExtents>&) noexcept;
     constexpr mapping& operator=(const mapping&) noexcept = default;
     template<class OtherExtents>
       friend constexpr bool operator==(const mapping&, const mapping<OtherExtents>&) noexcept;
   private:
     extents_type extents_{};    // exposition only
+    // [mdspan.sub.map], submdspan mapping specialization
+    template<class... SliceSpecifiers>
+      constexpr auto submdspan-mapping-impl(SliceSpecifiers...) const       // exposition only
+        -> see below;
+    template<class... SliceSpecifiers>
+      friend constexpr auto submdspan_mapping(
+        const mapping& src, SliceSpecifiers... slices) {
+          return src.submdspan-mapping-impl(slices...);
+      }
   };
 }
 ```
 If `Extents` is not a specialization of `extents`, then the program is
 value of type `index_type` [[basic.fundamental]].
 *Effects:* Direct-non-list-initializes *extents\_* with
 `other.extents()`.
+``` cpp
+template<class LayoutRightPaddedMapping>
+  constexpr explicit(!is_convertible_v<typename LayoutRightPaddedMapping::extents_type,
+                                       extents_type>)
+    mapping(const LayoutRightPaddedMapping&) noexcept;
+```
+*Constraints:*
+- *`is-layout-right-padded-mapping-of`*`<LayoutRightPaddedMapping>` is
+  `true`.
+- `is_constructible_v<extents_type, typename LayoutRightPaddedMapping::extents_- type>`
+  is `true`.
+*Mandates:* If
+- `Extents::rank()` is greater than one,
+- `Extents::static_extent(Extents::rank() - 1)` does not equal
+  `dynamic_extent`, and
+- `LayoutRightPaddedMapping::`*`static-padding-stride`* does not equal
+  `dynamic_extent`,
+then `Extents::static_extent(Extents::rank() - 1)` equals
+`LayoutRightPaddedMapping::`*`static-padding-stride`*.
+*Preconditions:*
+- If `extents_type::rank() > 1` is `true`, then
+  `other.stride(extents_type::rank() - 2)` equals
+  `other.extents().extent(extents_type::rank() - 1)`.
+- `other.required_span_size()` is representable as a value of type
+  `index_type`.
+*Effects:* Direct-non-list-initializes `extents_` with
+`other.extents()`.
 ``` cpp
 template<class OtherExtents>
  constexpr explicit(extents_type::rank() > 0)
     mapping(const layout_stride::mapping<OtherExtents>& other) noexcept;
 ```
 `other.extents()`.
 ###### Observers <a id="mdspan.layout.right.obs">[[mdspan.layout.right.obs]]</a>
 ``` cpp
+constexpr index_type required_span_size() const noexcept;
 ```
 *Returns:* `extents().`*`fwd-prod-of-extents`*`(extents_type::rank())`.
 ``` cpp
 namespace std {
   template<class Extents>
   class layout_stride::mapping {
   public:
     using extents_type = Extents;
+    using index_type = extents_type::index_type;
+    using size_type = extents_type::size_type;
+    using rank_type = extents_type::rank_type;
     using layout_type = layout_stride;
   private:
     static constexpr rank_type rank_ = extents_type::rank();    // exposition only
       friend constexpr bool operator==(const mapping&, const OtherMapping&) noexcept;
   private:
     extents_type extents_{};                    // exposition only
     array<index_type, rank_> strides_{};        // exposition only
+    // [mdspan.sub.map], submdspan mapping specialization
+    template<class... SliceSpecifiers>
+      constexpr auto submdspan-mapping-impl(SliceSpecifiers...) const       // exposition only
+        -> see below;
+    template<class... SliceSpecifiers>
+      friend constexpr auto submdspan_mapping(
+        const mapping& src, SliceSpecifiers... slices) {
+          return src.submdspan-mapping-impl(slices...);
+      }
   };
 }
 ```
 If `Extents` is not a specialization of `extents`, then the program is
 - `1`, if `e.rank() == 0` is `true`,
 - otherwise `0`, if the size of the multidimensional index space `e` is
   0,
 - otherwise `1` plus the sum of products of `(e.extent(r) - 1)` and
+  ``` cpp
+  extents_type::index-cast(strides[r])
+  ```
+  for all r in the range [0, `e.rank()`).
 Let `OFFSET(m)` be:
 - `m()`, if `e.rank() == 0` is `true`,
 - otherwise `0`, if the size of the multidimensional index space `e` is
 - `is_nothrow_constructible_v<index_type, const OtherIndexType&>` is
   `true`.
 *Preconditions:*
+- The result of converting `s[`i`]` to `index_type` is greater than `0`
+  for all i in the range [0, rank_).
 - *`REQUIRED-SPAN-SIZE`*`(e, s)` is representable as a value of type
   `index_type` [[basic.fundamental]].
 - If *rank\_* is greater than 0, then there exists a permutation P of
   the integers in the range [0, rank_), such that
   `s[`pᵢ`] >= s[`pᵢ₋₁`] * e.extent(p`ᵢ₋₁`)` is `true` for all i in the
 - `StridedLayoutMapping::is_always_strided()` is `true`.
 *Preconditions:*
 - `StridedLayoutMapping` meets the layout mapping
+  requirements [[mdspan.layout.reqmts]],
 - `other.stride(`r`) > 0` is `true` for every rank index r of
   `extents()`,
 - `other.required_span_size()` is representable as a value of type
   `index_type` [[basic.fundamental]], and
 - *`OFFSET`*`(other) == 0` is `true`.
 Remarks: The expression inside `explicit` is equivalent to:
 ``` cpp
 !(is_convertible_v<typename StridedLayoutMapping::extents_type, extents_type> &&
+  (is-mapping-of<layout_left, StridedLayoutMapping> ||
+   is-mapping-of<layout_right, StridedLayoutMapping> ||
+   is-layout-left-padded-mapping-of<StridedLayoutMapping> ||
+   is-layout-right-padded-mapping-of<StridedLayoutMapping> ||
+   is-mapping-of<layout_stride, StridedLayoutMapping>))
 ```
 ###### Observers <a id="mdspan.layout.stride.obs">[[mdspan.layout.stride.obs]]</a>
 ``` cpp
 *Returns:* `true` if `x.extents() == y.extents()` is `true`,
 *`OFFSET`*`(y) == 0` is `true`, and each of
 `x.stride(`r`) == y.stride(`r`)` is `true` for r in the range
 [0, `x.extents().rank()`). Otherwise, `false`.
+##### Class template `layout_left_padded::mapping` <a id="mdspan.layout.leftpad">[[mdspan.layout.leftpad]]</a>
+###### Overview <a id="mdspan.layout.leftpad.overview">[[mdspan.layout.leftpad.overview]]</a>
+`layout_left_padded` provides a layout mapping that behaves like
+`layout_left::mapping`, except that the padding stride `stride(1)` can
+be greater than or equal to `extent(0)`.
+``` cpp
+namespace std {
+  template<size_t PaddingValue>
+  template<class Extents>
+  class layout_left_padded<PaddingValue>::mapping {
+  public:
+    static constexpr size_t padding_value = PaddingValue;
+    using extents_type = Extents;
+    using index_type = extents_type::index_type;
+    using size_type = extents_type::size_type;
+    using rank_type = extents_type::rank_type;
+    using layout_type = layout_left_padded<PaddingValue>;
+  private:
+    static constexpr size_t rank_ = extents_type::rank();         // exposition only
+    static constexpr size_t first-static-extent =                 // exposition only
+      extents_type::static_extent(0);
+    // [mdspan.layout.leftpad.expo], exposition-only members
+    static constexpr size_t static-padding-stride = see below;  // exposition only
+  public:
+    // [mdspan.layout.leftpad.cons], constructors
+    constexpr mapping() noexcept : mapping(extents_type{}) {}
+    constexpr mapping(const mapping&) noexcept = default;
+    constexpr mapping(const extents_type&);
+    template<class OtherIndexType>
+      constexpr mapping(const extents_type&, OtherIndexType);
+    template<class OtherExtents>
+      constexpr explicit(!is_convertible_v<OtherExtents, extents_type>)
+        mapping(const layout_left::mapping<OtherExtents>&);
+    template<class OtherExtents>
+      constexpr explicit(extents_type::rank() > 0)
+        mapping(const layout_stride::mapping<OtherExtents>&);
+    template<class LayoutLeftPaddedMapping>
+      constexpr explicit(see below)
+        mapping(const LayoutLeftPaddedMapping&);
+    template<class LayoutRightPaddedMapping>
+      constexpr explicit(see below)
+        mapping(const LayoutRightPaddedMapping&) noexcept;
+    constexpr mapping& operator=(const mapping&) noexcept = default;
+    // [mdspan.layout.leftpad.obs], observers
+    constexpr const extents_type& extents() const noexcept { return extents_; }
+    constexpr array<index_type, rank_> strides() const noexcept;
+    constexpr index_type required_span_size() const noexcept;
+    template<class... Indices>
+      constexpr index_type operator()(Indices...) const noexcept;
+    static constexpr bool is_always_unique() noexcept { return true; }
+    static constexpr bool is_always_exhaustive() noexcept;
+    static constexpr bool is_always_strided() noexcept { return true; }
+    static constexpr bool is_unique() noexcept { return true; }
+    constexpr bool is_exhaustive() const noexcept;
+    static constexpr bool is_strided() noexcept { return true; }
+    constexpr index_type stride(rank_type) const noexcept;
+    template<class LayoutLeftPaddedMapping>
+      friend constexpr bool operator==(const mapping&, const LayoutLeftPaddedMapping&) noexcept;
+  private:
+    // [mdspan.layout.leftpad.expo], exposition-only members
+    index_type stride-1 = static-padding-stride;                           // exposition only
+    extents_type extents_{};                                               // exposition only
+    // [mdspan.sub.map], submdspan mapping specialization
+    template<class... SliceSpecifiers>
+      constexpr auto submdspan-mapping-impl(SliceSpecifiers...) const     // exposition only
+        -> see below;
+    template<class... SliceSpecifiers>
+      friend constexpr auto submdspan_mapping(const mapping& src, SliceSpecifiers... slices) {
+      return src.submdspan-mapping-impl(slices...);
+    }
+  };
+}
+```
+If `Extents` is not a specialization of `extents`, then the program is
+ill-formed.
+`layout_left_padded::mapping<E>` is a trivially copyable type that
+models `regular` for each `E`.
+Throughout [[mdspan.layout.leftpad]], let `P_rank` be the following size
+*`rank_`* parameter pack of `size_`t values:
+- the empty parameter pack, if *`rank_`* equals zero;
+- otherwise, `0zu`, if *`rank_`* equals one;
+- otherwise, the parameter pack `0zu`, `1zu`, …, `rank_- 1`.
+*Mandates:*
+- If `rank_dynamic() == 0` is `true`, then the size of the
+  multidimensional index space `Extents()` is representable as a value
+  of type `index_type`.
+- `padding_value` is representable as a value of type `index_type`.
+- If
+  - *`rank_`* is greater than one,
+  - `padding_value` does not equal `dynamic_extent`, and
+  - *`first-static-extent`* does not equal `dynamic_extent`,
+  then `LEAST-MULTIPLE-AT-LEAST(padding_value, first-static-extent)` is
+  representable as a value of type `size_t`, and is representable as a
+  value of type `index_type`.
+- If
+  - *`rank_`* is greater than one,
+  - `padding_value` does not equal `dynamic_extent`, and
+  - `extents_type::static_extent(k)` does not equal `dynamic_extent` for
+    all k in the range \[`0`, `extents_type::rank()`),
+  then the product of
+  `LEAST-MULTIPLE-AT-LEAST(padding_value, ext.static_extent(0))` and all
+  values `ext.static_extent(k)` with k in the range of \[`1`, *`rank_`*)
+  is representable as a value of type `size_t`, and is representable as
+  a value of type `index_type`.
+###### Exposition-only members <a id="mdspan.layout.leftpad.expo">[[mdspan.layout.leftpad.expo]]</a>
+``` cpp
+static constexpr size_t static-padding-stride = see below;
+```
+The value is
+- `0`, if *rank\_* equals zero or one;
+- otherwise, `dynamic_extent`, if `padding_value` or
+  *first-static-extent* equals `dynamic_extent`;
+- otherwise, the `size_t` value which is
+  *`LEAST-MULTIPLE-AT-LEAST`*`(padding_value, `*`first-static-extent`*`)`.
+``` cpp
+index_type stride-1 = static-padding-stride;
+```
+*Recommended practice:* Implementations should not store this value if
+*static-padding-stride* is not `dynamic_extent`.
+[*Note 9*: Using `extents<index_type, `*`static-padding-stride`*`>`
+instead of `index_type` as the type of *stride-1* would achieve
+this. — *end note*]
+###### Constructors <a id="mdspan.layout.leftpad.cons">[[mdspan.layout.leftpad.cons]]</a>
+``` cpp
+constexpr mapping(const extents_type& ext);
+```
+*Preconditions:*
+- The size of the multidimensional index space `ext` is representable as
+  a value of type `index_type`.
+- If *rank\_* is greater than one and `padding_value` does not equal
+  `dynamic_extent`, then
+  *`LEAST-MULTIPLE-AT-LEAST`*`(padding_value, ext.extent(0))` is
+  representable as a value of type *index_type*.
+- If *rank\_* is greater than one and `padding_value` does not equal
+  `dynamic_extent`, then the product of
+  *`LEAST-MULTIPLE-AT-LEAST`*`(padding_value, ext.extent(0))` and all
+  values `ext.extent(`k`)` with k in the range of \[`1`, *`rank_`*) is
+  representable as a value of type `index_type`.
+*Effects:*
+- Direct-non-list-initializes *extents\_* with `ext`; and
+- if *rank\_* is greater than one, direct-non-list-initializes
+  *stride-1*
+  - with `ext.extent(0)` if padding_value is `dynamic_extent`,
+  - otherwise with
+    *`LEAST-MULTIPLE-AT-LEAST`*`(padding_value, ext.extent(0))`.
+``` cpp
+template<class OtherIndexType>
+constexpr mapping(const extents_type& ext, OtherIndexType pad);
+```
+*Constraints:*
+- `is_convertible_v<OtherIndexType, index_type>` is `true`.
+- `is_nothrow_constructible_v<index_type, OtherIndexType>` is `true`.
+*Preconditions:*
+- `pad` is representable as a value of type `index_type`.
+- `extents_type::`*`index-cast`*`(pad)` is greater than zero.
+- If *rank\_* is greater than one, then
+  *`LEAST-MULTIPLE-AT-LEAST`*`(pad, ext.extent(0))` is representable as
+  a value of type `index_type.`
+- If *rank\_* is greater than one, then the product of
+  *`LEAST-MULTIPLE-AT-LEAST`*`(pad, ext.extent(0))` and all values
+  `ext.extent(`k`)` with k in the range of \[`1`, *`rank_`*) is
+  representable as a value of type `index_type`.
+- If `padding_value` is not equal to `dynamic_extent`, `padding_value`
+  equals `extents_type::`*`index-cast`*`(pad)`.
+*Effects:* Direct-non-list-initializes *extents\_* with `ext`, and if
+*rank\_* is greater than one, direct-non-list-initializes *stride-1*
+with *`LEAST-MULTIPLE-AT-LEAST`*`(pad, ext.extent(0))`.
+``` cpp
+template<class OtherExtents>
+  constexpr explicit(!is_convertible_v<OtherExtents, extents_type>)
+    mapping(const layout_left::mapping<OtherExtents>& other);
+```
+*Constraints:* `is_constructible_v<extents_type, OtherExtents>` is
+`true`.
+*Mandates:* If `OtherExtents::rank()` is greater than `1`, then
+``` cpp
+(static-padding-stride == dynamic_extent) ||
+(OtherExtents::static_extent(0) == dynamic_extent) ||
+(static-padding-stride == OtherExtents::static_extent(0))
+```
+is `true`.
+*Preconditions:*
+- If `extents_type::rank() > 1` is `true` and `padding_value` ==
+  `dynamic_extent` is `false`, then `other.stride(1)` equals
+  ``` cpp
+  LEAST-MULTIPLE-AT-LEAST(padding_value,
+                          extents_type::index-cast(other.extents().extent(0)))
+  ```
+  and
+- `other.required_span_size()` is representable as a value of type
+  `index_type`.
+*Effects:* Equivalent to `mapping(other.extents())`.
+``` cpp
+template<class OtherExtents>
+  constexpr explicit(rank_ > 0)
+    mapping(const layout_stride::mapping<OtherExtents>& other);
+```
+*Constraints:* `is_constructible_v<extents_type, OtherExtents>` is
+`true`.
+*Preconditions:*
+- If *rank\_* is greater than `1` and `padding_value` does not equal
+  `dynamic_extent`, then `other.stride(1)` equals
+  ``` cpp
+  LEAST-MULTIPLE-AT-LEAST(padding_value,
+                          extents_type::index-cast(other.extents().extent(0)))
+  ```
+- If *rank\_* is greater than 0, then `other.stride(0)` equals 1.
+- If *rank\_* is greater than 2, then for all r in the range \[`2`,
+  *`rank_`*), `other.stride(r)` equals
+  ``` cpp
+  (other.extents().fwd-prod-of-extents(r) / other.extents().extent(0)) * other.stride(1)
+  ```
+- `other.required_span_size()` is representable as a value of type
+  *index_type*.
+*Effects:*
+- Direct-non-list-initializes *extents\_* with `other.extents()` and
+- if *rank\_* is greater than one, direct-non-list-initializes
+  *stride-1* with `other.stride(1)`.
+``` cpp
+template<class LayoutLeftPaddedMapping>
+  constexpr explicit(see below)
+    mapping(const LayoutLeftPaddedMapping& other);
+```
+*Constraints:*
+- *`is-layout-left-padded-mapping-of`*`<LayoutLeftPaddedMapping>` is
+  `true`.
+- `is_constructible_v<extents_type, typename LayoutLeftPaddedMapping::extents_type>`
+  is `true`.
+*Mandates:* If *rank\_* is greater than 1, then
+``` cpp
+padding_value == dynamic_extent ||
+LayoutLeftPaddedMapping::padding_value == dynamic_extent ||
+padding_value == LayoutLeftPaddedMapping::padding_value
+```
+is `true`.
+*Preconditions:*
+- If *rank\_* is greater than 1 and `padding_value` does not equal
+  `dynamic_extent`, then `other.stride(1)` equals
+  ``` cpp
+  LEAST-MULTIPLE-AT-LEAST(padding_value,
+                          extents_type::index-cast(other.extent(0)))
+  ```
+- `other.required_span_size()` is representable as a value of type
+  `index_type`.
+*Effects:*
+- Direct-non-list-initializes *extents\_* with `other.extents()` and
+- if *rank\_* is greater than one, direct-non-list-initializes
+  *stride-1* with `other.stride(1)`.
+*Remarks:* The expression inside `explicit` is equivalent to:
+``` cpp
+rank_> 1 &&
+(padding_value != dynamic_extent ||
+ LayoutLeftPaddedMapping::padding_value == dynamic_extent)
+```
+``` cpp
+template<class LayoutRightPaddedMapping>
+  constexpr explicit(see below)
+    mapping(const LayoutRightPaddedMapping& other) noexcept;
+```
+*Constraints:*
+- *`is-layout-right-padded-mapping-of`*`<LayoutRightPaddedMapping>` is
+  `true` or *`is-mapping-of`*`<layout_right, LayoutRightPaddedMapping>`
+  is `true`.
+- *rank\_* equals zero or one.
+- `is_constructible_v<extents_type, typename LayoutRightPaddedMapping::extents_- type>`
+  is `true`.
+*Preconditions:* `other.required_span_size()` is representable as a
+value of type `index_type`.
+*Effects:* Direct-non-list-initializes *extents\_* with
+`other.extents()`.
+*Remarks:* The expression inside `explicit` is equivalent to:
+``` cpp
+!is_convertible_v<typename LayoutRightPaddedMapping::extents_type, extents_type>
+```
+[*Note 10*: Neither the input mapping nor the mapping to be constructed
+uses the padding stride in the rank-0 or rank-1 case, so the padding
+stride does not affect either the constraints or the
+preconditions. — *end note*]
+###### Observers <a id="mdspan.layout.leftpad.obs">[[mdspan.layout.leftpad.obs]]</a>
+``` cpp
+constexpr array<index_type, rank_> strides() const noexcept;
+```
+*Returns:* `array<index_type, `*`rank_`*`>({stride(P_rank)...})`.
+``` cpp
+constexpr index_type required_span_size() const noexcept;
+```
+*Returns:*
+- `0` if the multidimensional index space *extents\_* is empty,
+- otherwise,
+  `(*this)(`*`extents_`*`.extent(P_rank) - index_type(1)...) + 1`.
+``` cpp
+template<class... Indices>
+constexpr size_t operator()(Indices... idxs) const noexcept;
+```
+*Constraints:*
+- `sizeof...(Indices) == `*`rank_`* is `true`.
+- `(is_convertible_v<Indices, index_type> && ...)` is `true`.
+- `(is_nothrow_constructible_v<index_type, Indices> && ...)` is `true`.
+*Preconditions:* `extents_type::`*`index-cast`*`(idxs)` is a
+multidimensional index in `extents()` [[mdspan.overview]].
+*Returns:*
+`((static_cast<index_type>(idxs) * stride(P_rank)) + ... + 0)`.
+``` cpp
+static constexpr bool is_always_exhaustive() noexcept;
+```
+*Returns:*
+- If *rank\_* equals zero or one, then `true`;
+- otherwise, if neither *static-padding-stride* nor
+  *first-static-extent* equal `dynamic_extent`, then
+  *`static-padding-stride`*` == `*`first-static-extent`*;
+- otherwise, `false`.
+``` cpp
+constexpr bool is_exhaustive() const noexcept;
+```
+*Returns:* `true` if *rank\_* equals zero or one; otherwise,
+`extents_.extent(0) == stride(1)`.
+``` cpp
+constexpr index_type stride(rank_type r) const noexcept;
+```
+*Preconditions:* `r` is smaller than *rank\_*.
+*Returns:*
+- If `r` equals zero: 1;
+- otherwise, if `r` equals one: *stride-1*;
+- otherwise, the product of *stride-1* and all values
+  `extents_.extent(`k`)` with k in the range \[`1`, `r`).
+``` cpp
+template<class LayoutLeftPaddedMapping>
+  friend constexpr bool operator==(const mapping& x, const LayoutLeftPaddedMapping& y) noexcept;
+```
+*Constraints:*
+- *`is-layout-left-padded-mapping-of`*`<LayoutLeftPaddedMapping>` is
+  `true`.
+- `LayoutLeftPaddedMapping::extents_type::rank() == rank_` is `true`.
+*Returns:* `true` if `x.extents() == y.extents()` is `true` and
+*`rank_`*` < 2 || x.stride(1) == y. stride(1)` is `true`. Otherwise,
+`false`.
+##### Class template `layout_right_padded::mapping` <a id="mdspan.layout.rightpad">[[mdspan.layout.rightpad]]</a>
+###### Overview <a id="mdspan.layout.rightpad.overview">[[mdspan.layout.rightpad.overview]]</a>
+`layout_right_padded` provides a layout mapping that behaves like
+`layout_right::mapping`, except that the padding stride
+`stride(extents_type::rank() - 2)` can be greater than or equal to
+`extents_type::extent(extents_type::rank() - 1)`.
+``` cpp
+namespace std {
+  template<size_t PaddingValue>
+  template<class Extents>
+  class layout_right_padded<PaddingValue>::mapping {
+  public:
+    static constexpr size_t padding_value = PaddingValue;
+    using extents_type = Extents;
+    using index_type = extents_type::index_type;
+    using size_type = extents_type::size_type;
+    using rank_type = extents_type::rank_type;
+    using layout_type = layout_right_padded<PaddingValue>;
+  private:
+    static constexpr size_t rank_ = extents_type::rank();    // exposition only
+    static constexpr size_t last-static-extent =             // exposition only
+      extents_type::static_extent(rank_ - 1);
+    // [mdspan.layout.rightpad.expo], exposition-only members
+    static constexpr size_t static-padding-stride = see below; // exposition only
+  public:
+    // [mdspan.layout.rightpad.cons], constructors
+    constexpr mapping() noexcept : mapping(extents_type{}) {}
+    constexpr mapping(const mapping&) noexcept = default;
+    constexpr mapping(const extents_type&);
+    template<class OtherIndexType>
+      constexpr mapping(const extents_type&, OtherIndexType);
+    template<class OtherExtents>
+      constexpr explicit(!is_convertible_v<OtherExtents, extents_type>)
+        mapping(const layout_right::mapping<OtherExtents>&);
+    template<class OtherExtents>
+      constexpr explicit(rank_ > 0)
+        mapping(const layout_stride::mapping<OtherExtents>&);
+    template<class LayoutRightPaddedMapping>
+      constexpr explicit(see below)
+        mapping(const LayoutRightPaddedMapping&);
+    template<class LayoutLeftPaddedMapping>
+      constexpr explicit(see below)
+        mapping(const LayoutLeftPaddedMapping&) noexcept;
+    constexpr mapping& operator=(const mapping&) noexcept = default;
+    // [mdspan.layout.rightpad.obs], observers
+    constexpr const extents_type& extents() const noexcept { return extents_; }
+    constexpr array<index_type, rank_> strides() const noexcept;
+    constexpr index_type required_span_size() const noexcept;
+    template<class... Indices>
+      constexpr index_type operator()(Indices...) const noexcept;
+    static constexpr bool is_always_unique() noexcept { return true; }
+    static constexpr bool is_always_exhaustive() noexcept;
+    static constexpr bool is_always_strided() noexcept { return true; }
+    static constexpr bool is_unique() noexcept { return true; }
+    constexpr bool is_exhaustive() const noexcept;
+    static constexpr bool is_strided() noexcept { return true; }
+    constexpr index_type stride(rank_type) const noexcept;
+    template<class LayoutRightPaddedMapping>
+      friend constexpr bool operator==(const mapping&, const LayoutRightPaddedMapping&) noexcept;
+  private:
+    // [mdspan.layout.rightpad.expo], exposition-only members
+    index_type stride-rm2 = static-padding-stride;                         // exposition only
+    extents_type extents_{};                                               // exposition only
+    // [mdspan.sub.map], submdspan mapping specialization
+    template<class... SliceSpecifiers>
+      constexpr auto submdspan-mapping-impl(SliceSpecifiers...) const     // exposition only
+        -> see below;
+    template<class... SliceSpecifiers>
+      friend constexpr auto submdspan_mapping(const mapping& src, SliceSpecifiers... slices) {
+      return src.submdspan-mapping-impl(slices...);
+    }
+  };
+}
+```
+If `Extents` is not a specialization of `extents`, then the program is
+ill-formed.
+`layout_right_padded::mapping<E>` is a trivially copyable type that
+models `regular` for each `E`.
+Throughout [[mdspan.layout.rightpad]], let `P_rank` be the following
+size *`rank_`* parameter pack of `size_`t values:
+- the empty parameter pack, if *`rank_`* equals zero;
+- otherwise, `0zu`, if *`rank_`* equals one;
+- otherwise, the parameter pack `0zu`, `1zu`, …, `rank_- 1`.
+*Mandates:*
+- If `rank_dynamic() == 0` is `true`, then the size of the
+  multidimensional index space `Extents()` is representable as a value
+  of type `index_type`.
+- `padding_value` is representable as a value of type `index_type`.
+- If
+  - *`rank_`* is greater than one,
+  - `padding_value` does not equal `dynamic_extent`, and
+  - *`last-static-extent`* does not equal `dynamic_extent`,
+  then `LEAST-MULTIPLE-AT-LEAST(padding_value, last-static-extent)` is
+  representable as a value of type `size_t`, and is representable as a
+  value of type `index_type`.
+- If
+  - *`rank_`* is greater than one,
+  - `padding_value` does not equal `dynamic_extent`, and
+  - `extents_type::static_extent(k)` does not equal `dynamic_extent` for
+    all k in the range \[`0`, *`rank_`*),
+  then the product of
+  `LEAST-MULTIPLE-AT-LEAST(padding_value, ext.static_extent(rank_ - 1))`
+  and all values `ext.static_extent(k)` with k in the range of \[`0`,
+  *`rank_`*` - 1`) is representable as a value of type `size_t`, and is
+  representable as a value of type `index_type`.
+###### Exposition-only members <a id="mdspan.layout.rightpad.expo">[[mdspan.layout.rightpad.expo]]</a>
+``` cpp
+static constexpr size_t static-padding-stride = see below;
+```
+The value is
+- `0`, if *rank\_* equals zero or one;
+- otherwise, `dynamic_extent`, if `padding_value` or
+  *last-static-extent* equals `dynamic_extent`;
+- otherwise, the `size_t` value which is
+  *`LEAST-MULTIPLE-AT-LEAST`*`(padding_value, `*`last-static-extent`*`)`.
+``` cpp
+index_type stride-rm2 = static-padding-stride;
+```
+*Recommended practice:* Implementations should not store this value if
+*static-padding-stride* is not `dynamic_extent`.
+[*Note 11*: Using `extents<index_type, `*`static-padding-stride`*`>`
+instead of `index_type` as the type of *stride-rm2* would achieve
+this. — *end note*]
+###### Constructors <a id="mdspan.layout.rightpad.cons">[[mdspan.layout.rightpad.cons]]</a>
+``` cpp
+constexpr mapping(const extents_type& ext);
+```
+*Preconditions:*
+- The size of the multidimensional index space `ext` is representable as
+  a value of type `index_type`.
+- If *rank\_* is greater than one and `padding_value` does not equal
+  `dynamic_extent`, then
+  *`LEAST-MULTIPLE-AT-LEAST`*`(padding_value, ext.extent(`*`rank_`*` - 1))`
+  is representable as a value of type *index_type*.
+- If *rank\_* is greater than one and `padding_value` does not equal
+  `dynamic_extent`, then the product of
+  *`LEAST-MULTIPLE-AT-LEAST`*`(padding_value, ext.extent(`*`rank_`*` - 1))`
+  and all values `ext.extent(`k`)` with k in the range of \[`0`,
+  *`rank_`*` - 1`) is representable as a value of type `index_type`.
+*Effects:*
+- Direct-non-list-initializes *extents\_* with `ext`; and
+- if *rank\_* is greater than one, direct-non-list-initializes
+  *stride-rm2*
+  - with `ext.extent(`*`rank_`*` - 1)` if `padding_value` is
+    `dynamic_extent`,
+  - otherwise with
+    *`LEAST-MULTIPLE-AT-LEAST`*`(padding_value, ext.extent(`*`rank_`*` - 1))`.
+``` cpp
+template<class OtherIndexType>
+constexpr mapping(const extents_type& ext, OtherIndexType pad);
+```
+*Constraints:*
+- `is_convertible_v<OtherIndexType, index_type>` is `true`.
+- `is_nothrow_constructible_v<index_type, OtherIndexType>` is `true`.
+*Preconditions:*
+- `pad` is representable as a value of type `index_type`.
+- `extents_type::`*`index-cast`*`(pad)` is greater than zero.
+- If *rank\_* is greater than one, then
+  *`LEAST-MULTIPLE-AT-LEAST`*`(pad, ext.extent(`*`rank_`*` - 1))` is
+  representable as a value of type `index_type`.
+- If *rank\_* is greater than one, then the product of
+  *`LEAST-MULTIPLE-AT-LEAST`*`(pad, ext.extent(`*`rank_`*` - 1))` and
+  all values `ext.extent(`k`)` with k in the range of \[`0`,
+  *`rank_`*` - 1`) is representable as a value of type `index_type`.
+- If `padding_value` is not equal to `dynamic_extent`, `padding_value`
+  equals `extents_type::`*`index-cast`*`(pad)`.
+*Effects:* Direct-non-list-initializes *extents\_* with `ext`, and if
+*rank\_* is greater than one, direct-non-list-initializes *stride-rm2*
+with *`LEAST-MULTIPLE-AT-LEAST`*`(pad, ext.extent(`*`rank_`*` - 1))`.
+``` cpp
+template<class OtherExtents>
+  constexpr explicit(!is_convertible_v<OtherExtents, extents_type>)
+    mapping(const layout_right::mapping<OtherExtents>& other);
+```
+*Constraints:* `is_constructible_v<extents_type, OtherExtents>` is
+`true`.
+*Mandates:* If `OtherExtents::rank()` is greater than 1, then
+``` cpp
+(static-padding-stride == dynamic_extent) ||
+(OtherExtents::static_extent(rank_ - 1) == dynamic_extent) ||
+(static-padding-stride == OtherExtents::static_extent(rank_ - 1))
+```
+is `true`.
+*Preconditions:*
+- If *`rank_`*` > 1` is `true` and `padding_value == dynamic_extent` is
+  `false`, then `other.stride( `*`rank_`*` - 2)` equals
+  ``` cpp
+  LEAST-MULTIPLE-AT-LEAST(padding_value,
+                          extents_type::index-cast(other.extents().extent(rank_ - 1)))
+  ```
+  and
+- `other.required_span_size()` is representable as a value of type
+  `index_type`.
+*Effects:* Equivalent to `mapping(other.extents())`.
+``` cpp
+template<class OtherExtents>
+  constexpr explicit(rank_ > 0)
+    mapping(const layout_stride::mapping<OtherExtents>& other);
+```
+*Constraints:* `is_constructible_v<extents_type, OtherExtents>` is
+`true`.
+*Preconditions:*
+- If *rank\_* is greater than 1 and `padding_value` does not equal
+  `dynamic_extent`, then `other.stride(`*`rank_`*` - 2)` equals
+  ``` cpp
+  LEAST-MULTIPLE-AT-LEAST(padding_value,
+                          extents_type::index-cast(other.extents().extent(rank_ - 1)))
+  ```
+- If *rank\_* is greater than 0, then other.stride(*rank\_* - 1) equals
+  1.
+- If *rank\_* is greater than 2, then for all r in the range \[`0`,
+  *`rank_`*` - 2`), `other.stride(`r`)` equals
+  ``` cpp
+  (other.extents().rev-prod-of-extents(r) / other.extents().extent(rank_ - 1)) *
+    other.stride(rank_ - 2)
+  ```
+- `other.required_span_size()` is representable as a value of type
+  `index_type`.
+*Effects:*
+- Direct-non-list-initializes *extents\_* with `other.extents()`; and
+- if *rank\_* is greater than one, direct-non-list-initializes
+  *stride-rm2* with `other.stride(`*`rank_`*` - 2)`.
+``` cpp
+template<class LayoutRightPaddedMapping>
+  constexpr explicit(see below)
+    mapping(const LayoutRightPaddedMapping& other);
+```
+*Constraints:*
+- *`is-layout-right-padded-mapping-of`*`<LayoutRightPaddedMapping>` is
+  `true`.
+- `is_constructible_v<extents_type, typename LayoutRightPaddedMapping::extents_- type>`
+  is `true`.
+*Mandates:* If *rank\_* is greater than 1, then
+``` cpp
+padding_value == dynamic_extent ||
+LayoutRightPaddedMapping::padding_value == dynamic_extent ||
+padding_value == LayoutRightPaddedMapping::padding_value
+```
+is `true`.
+*Preconditions:*
+- If *rank\_* is greater than 1 and `padding_value` does not equal
+  `dynamic_extent`, then `other.stride(`*`rank_`*` - 2)` equals
+  ``` cpp
+  LEAST-MULTIPLE-AT-LEAST(padding_value,
+                          extents_type::index-cast(other.extent(rank_ - 1)))
+  ```
+- `other.required_span_size()` is representable as a value of type
+  `index_type`.
+*Effects:*
+- Direct-non-list-initializes *extents\_* with `other.extents()`; and
+- if *rank\_* is greater than one, direct-non-list-initializes
+  *stride-rm2* with `other.stride(rank_ - 2)`.
+*Remarks:* The expression inside `explicit` is equivalent to:
+``` cpp
+rank_ > 1 &&
+(padding_value != dynamic_extent ||
+ LayoutRightPaddedMapping::padding_value == dynamic_extent)
+```
+``` cpp
+template<class LayoutLeftPaddedMapping>
+  constexpr explicit(see below)
+    mapping(const LayoutLeftPaddedMapping& other) noexcept;
+```
+*Constraints:*
+- *`is-layout-left-padded-mapping-of`*`<LayoutLeftPaddedMapping>` is
+  `true` or *`is-mapping-of`*`<layout_left, LayoutLeftPaddedMapping>` is
+  `true`.
+- *rank\_* equals zero or one.
+- `is_constructible_v<extents_type, typename LayoutLeftPaddedMapping::extents_type>`
+  is `true`.
+*Preconditions:* `other.required_span_size()` is representable as a
+value of type `index_type`.
+*Effects:* Direct-non-list-initializes *extents\_* with
+`other.extents()`.
+*Remarks:* The expression inside `explicit` is equivalent to:
+``` cpp
+!is_convertible_v<typename LayoutLeftPaddedMapping::extents_type, extents_type>
+```
+[*Note 12*: Neither the input mapping nor the mapping to be constructed
+uses the padding stride in the rank-0 or rank-1 case, so the padding
+stride affects neither the constraints nor the
+preconditions. — *end note*]
+###### Observers <a id="mdspan.layout.rightpad.obs">[[mdspan.layout.rightpad.obs]]</a>
+``` cpp
+constexpr array<index_type, rank_> strides() const noexcept;
+```
+*Returns:* `array<index_type, `*`rank_`*`>(``stride(P_rank)...``)`.
+``` cpp
+constexpr index_type required_span_size() const noexcept;
+```
+*Returns:* `0` if the multidimensional index space *extents\_* is empty,
+otherwise
+`(*this)(`*`extents_`*`.extent(P_rank) - index_type(1)...) + 1`.
+``` cpp
+template<class... Indices>
+constexpr size_t operator()(Indices... idxs) const noexcept;
+```
+*Constraints:*
+- `sizeof...(Indices) == `*`rank_`* is `true`.
+- `(is_convertible_v<Indices, index_type> && ...)` is `true`.
+- `(is_nothrow_constructible_v<index_type, Indices> && ...)` is `true`.
+*Preconditions:* `extents_type::`*`index-cast`*`(idxs)` is a
+multidimensional index in `extents()` [[mdspan.overview]].
+*Returns:*
+`((static_cast<index_type>(idxs) * stride(P_rank)) + ... + 0)`.
+``` cpp
+static constexpr bool is_always_exhaustive() noexcept;
+```
+*Returns:*
+- If *rank\_* equals zero or one, then `true`;
+- otherwise, if neither *static-padding-stride* nor *last-static-extent*
+  equal `dynamic_extent`, then
+  *`static-padding-stride`*` == `*`last-static-extent`*;
+- otherwise, `false`.
+``` cpp
+constexpr bool is_exhaustive() const noexcept;
+```
+*Returns:* `true` if *rank\_* equals zero or one; otherwise,
+``` cpp
+extents_.extent(rank_ - 1) == stride(rank_ - 2)
+```
+``` cpp
+constexpr index_type stride(rank_type r) const noexcept;
+```
+*Preconditions:* `r` is smaller than *rank\_*.
+*Returns:*
+- If `r` equals *`rank_`*` - 1`: `1`;
+- otherwise, if `r` equals *`rank_`*` - 2`: *stride-rm2*;
+- otherwise, the product of *stride-rm2* and all values
+  `extents_.extent(`k`)` with k in the range of \[`r + 1`,
+  *`rank_`*` - 1`).
+``` cpp
+template<class LayoutRightPaddedMapping>
+  friend constexpr bool operator==(const mapping& x, const LayoutRightPaddedMapping& y) noexcept;
+```
+*Constraints:*
+- *`is-layout-right-padded-mapping-of`*`<LayoutRightPaddedMapping>` is
+  `true`.
+- `LayoutRightPaddedMapping::extents_type::rank() == `*`rank_`* is
+  `true`.
+*Returns:* `true` if `x.extents() == y.extents()` is `true` and
+*`rank_`*` < 2 || x.stride(`*`rank_`*` - 2) == y.stride(`*`rank_`*` - 2)`
+is `true`. Otherwise, `false`.
 #### Accessor policy <a id="mdspan.accessor">[[mdspan.accessor]]</a>
 ##### General <a id="mdspan.accessor.general">[[mdspan.accessor.general]]</a>
 An *accessor policy* defines types and operations by which a reference
 A range of indices [0, N) is an *accessible range* of a given data
 handle and an accessor if, for each i in the range, the accessor
 policy’s `access` function produces a valid reference to an object.
+In [[mdspan.accessor.reqmts]],
 - `A` denotes an accessor policy.
 - `a` denotes a value of type `A` or `const A`.
 - `p` denotes a value of type `A::data_handle_type` or
   `const A::data_handle_type`. \[*Note 1*: The type
 constexpr data_handle_type offset(data_handle_type p, size_t i) const noexcept;
 ```
 *Effects:* Equivalent to: `return p + i;`
+##### Class template `aligned_accessor` <a id="mdspan.accessor.aligned">[[mdspan.accessor.aligned]]</a>
+###### Overview <a id="mdspan.accessor.aligned.overview">[[mdspan.accessor.aligned.overview]]</a>
+``` cpp
+namespace std {
+  template<class ElementType, size_t ByteAlignment>
+  struct aligned_accessor {
+    using offset_policy = default_accessor<ElementType>;
+    using element_type = ElementType;
+    using reference = ElementType&;
+    using data_handle_type = ElementType*;
+    static constexpr size_t byte_alignment = ByteAlignment;
+    constexpr aligned_accessor() noexcept = default;
+    template<class OtherElementType, size_t OtherByteAlignment>
+      constexpr aligned_accessor(
+        aligned_accessor<OtherElementType, OtherByteAlignment>) noexcept;
+    template<class OtherElementType>
+      constexpr explicit aligned_accessor(default_accessor<OtherElementType>) noexcept;
+    template<class OtherElementType>
+      constexpr operator default_accessor<OtherElementType>() const noexcept;
+    constexpr reference access(data_handle_type p, size_t i) const noexcept;
+    constexpr typename offset_policy::data_handle_type offset(
+      data_handle_type p, size_t i) const noexcept;
+  };
+}
+```
+*Mandates:*
+- `byte_alignment` is a power of two, and
+- `byte_alignment >= alignof(ElementType)` is `true`.
+`aligned_accessor` meets the accessor policy requirements.
+`ElementType` is required to be a complete object type that is neither
+an abstract class type nor an array type.
+Each specialization of `aligned_accessor` is a trivially copyable type
+that models `semiregular`.
+\[`0`, n) is an accessible range for an object `p` of type
+`data_handle_type` and an object of type `aligned_accessor` if and only
+if
+- \[`p`, `p + `n) is a valid range, and,
+- if n is greater than zero, then
+  `is_sufficiently_aligned<byte_alignment>(p)` is `true`.
+[*Example 1*:
+The following function `compute` uses `is_sufficiently_aligned` to check
+whether a given `mdspan` with `default_accessor` has a data handle with
+sufficient alignment to be used with
+`aligned_accessor<float, 4 * sizeof(float)>`. If so, the function
+dispatches to a function `compute_using_fourfold_overalignment` that
+requires fourfold over-alignment of arrays, but can therefore use
+hardware-specific instructions, such as four-wide SIMD (Single
+Instruction Multiple Data) instructions. Otherwise, `compute` dispatches
+to a possibly less optimized function
+`compute_without_requiring_overalignment` that has no over-alignment
+requirement.
+``` cpp
+void compute_using_fourfold_overalignment(
+  mdspan<float, dims<1>, layout_right, aligned_accessor<float, 4 * alignof(float)>> x);
+void compute_without_requiring_overalignment(
+  mdspan<float, dims<1>, layout_right> x);
+void compute(mdspan<float, dims<1>> x) {
+  constexpr auto byte_alignment = 4 * sizeof(float);
+  auto accessor = aligned_accessor<float, byte_alignment>{};
+  auto x_handle = x.data_handle();
+  if (is_sufficiently_aligned<byte_alignment>(x_handle)) {
+    compute_using_fourfold_overalignment(mdspan{x_handle, x.mapping(), accessor});
+  } else {
+    compute_without_requiring_overalignment(x);
+  }
+}
+```
+— *end example*]
+###### Members <a id="mdspan.accessor.aligned.members">[[mdspan.accessor.aligned.members]]</a>
+``` cpp
+template<class OtherElementType, size_t OtherByteAlignment>
+  constexpr aligned_accessor(aligned_accessor<OtherElementType, OtherByteAlignment>) noexcept;
+```
+*Constraints:*
+- `is_convertible_v<OtherElementType(*)[], element_type(*)[]>` is
+  `true`.
+- `OtherByteAlignment >= byte_alignment` is `true`.
+*Effects:* None.
+``` cpp
+template<class OtherElementType>
+  constexpr explicit aligned_accessor(default_accessor<OtherElementType>) noexcept;
+```
+*Constraints:*
+`is_convertible_v<OtherElementType(*)[], element_type(*)[]>` is `true`.
+*Effects:* None.
+``` cpp
+constexpr reference access(data_handle_type p, size_t i) const noexcept;
+```
+*Preconditions:* \[`0`, `i + 1`) is an accessible range for `p` and
+`*this`.
+*Effects:* Equivalent to: `return assume_aligned<byte_alignment>(p)[i];`
+``` cpp
+template<class OtherElementType>
+  constexpr operator default_accessor<OtherElementType>() const noexcept;
+```
+*Constraints:*
+`is_convertible_v<element_type(*)[], OtherElementType(*)[]>` is `true`.
+*Effects:* Equivalent to: `return {};`
+``` cpp
+constexpr typename offset_policy::data_handle_type
+  offset(data_handle_type p, size_t i) const noexcept;
+```
+*Preconditions:* \[`0`, `i + 1`) is an accessible range for `p` and
+`*this`.
+*Effects:* Equivalent to:
+`return assume_aligned<byte_alignment>(p) + i;`
 #### Class template `mdspan` <a id="mdspan.mdspan">[[mdspan.mdspan]]</a>
 ##### Overview <a id="mdspan.mdspan.overview">[[mdspan.mdspan.overview]]</a>
 `mdspan` is a view of a multidimensional array of elements.
   class mdspan {
   public:
     using extents_type = Extents;
     using layout_type = LayoutPolicy;
     using accessor_type = AccessorPolicy;
+    using mapping_type = layout_type::template mapping<extents_type>;
     using element_type = ElementType;
     using value_type = remove_cv_t<element_type>;
+    using index_type = extents_type::index_type;
+    using size_type = extents_type::size_type;
+    using rank_type = extents_type::rank_type;
+    using data_handle_type = accessor_type::data_handle_type;
+    using reference = accessor_type::reference;
     static constexpr rank_type rank() noexcept { return extents_type::rank(); }
     static constexpr rank_type rank_dynamic() noexcept { return extents_type::rank_dynamic(); }
     static constexpr size_t static_extent(rank_type r) noexcept
       { return extents_type::static_extent(r); }
     template<class OtherIndexType>
       constexpr reference operator[](span<OtherIndexType, rank()> indices) const;
     template<class OtherIndexType>
       constexpr reference operator[](const array<OtherIndexType, rank()>& indices) const;
+    template<class... OtherIndexTypes>
+      constexpr reference
+        at(OtherIndexTypes... indices) const;                           // freestanding-deleted
+    template<class OtherIndexType>
+      constexpr reference
+        at(span<OtherIndexType, rank()> indices) const;                 // freestanding-deleted
+    template<class OtherIndexType>
+      constexpr reference
+        at(const array<OtherIndexType, rank()>& indices) const;         // freestanding-deleted
     constexpr size_type size() const noexcept;
+    constexpr bool empty() const noexcept;
     friend constexpr void swap(mdspan& x, mdspan& y) noexcept;
     constexpr const extents_type& extents() const noexcept { return map_.extents(); }
     constexpr const data_handle_type& data_handle() const noexcept { return ptr_; }
       -> mdspan<remove_pointer_t<remove_reference_t<Pointer>>, extents<size_t>>;
   template<class ElementType, class... Integrals>
     requires ((is_convertible_v<Integrals, size_t> && ...) && sizeof...(Integrals) > 0)
     explicit mdspan(ElementType*, Integrals...)
+      -> mdspan<ElementType, extents<size_t, maybe-static-ext<Integrals>...>>;
   template<class ElementType, class OtherIndexType, size_t N>
     mdspan(ElementType*, span<OtherIndexType, N>)
       -> mdspan<ElementType, dextents<size_t, N>>;
 ```
 *Constraints:*
 - `is_convertible_v<const OtherIndexType&, index_type>` is `true`,
+- `is_nothrow_constructible_v<index_type, const OtherIndexType&>` is
+  `true`,
 - `N == rank() || N == rank_dynamic()` is `true`,
 - `is_constructible_v<mapping_type, extents_type>` is `true`, and
 - `is_default_constructible_v<accessor_type>` is `true`.
 *Preconditions:* $[0, \texttt{\textit{map_}.required_span_size()})$ is
 - `is_constructible_v<data_handle_type, const OtherAccessor::data_handle_type&>`
   is `true`, and
 - `is_constructible_v<extents_type, OtherExtents>` is `true`.
+*Preconditions:* $[0, \texttt{\textit{map_}.required_span_size()})$ is
+an accessible range of *ptr\_* and *acc\_* for values of *ptr\_*,
+*map\_*, and *acc\_* after the invocation of this constructor.
+For each rank index `r` of `extents_type`,
 `static_extent(r) == dynamic_extent || static_extent(r) == other.extent(r)`
 is `true`.
 *Effects:*
 - Direct-non-list-initializes *ptr\_* with `other.`*`ptr_`*,
 - direct-non-list-initializes *map\_* with `other.`*`map_`*, and
   `true`, and
 - `sizeof...(OtherIndexTypes) == rank()` is `true`.
 Let `I` be `extents_type::`*`index-cast`*`(std::move(indices))`.
+`I` is a multidimensional index in `extents()`.
 [*Note 1*: This implies that
 *`map_`*`(I) < `*`map_`*`.required_span_size()` is
 `true`. — *end note*]
 ```
 is `true`. Equivalent to:
 ``` cpp
+return operator[](extents_type::index-cast(as_const(indices[P]))...);
+```
+``` cpp
+template<class... OtherIndexTypes>
+  constexpr reference at(OtherIndexTypes... indices) const;
+```
+*Constraints:*
+- `(is_convertible_v<OtherIndexTypes, index_type> && ...)` is `true`,
+- `(is_nothrow_constructible_v<index_type, OtherIndexTypes> && ...)` is
+  `true`, and
+- `sizeof...(OtherIndexTypes) == rank()` is `true`.
+Let `I` be `extents_type::`*`index-cast`*`(std::move(indices))`.
+*Returns:* `(*this)[I...]`.
+*Throws:* `out_of_range` if `I` is not a multidimensional index in
+`extents()`.
+``` cpp
+template<class OtherIndexType>
+  constexpr reference at(span<OtherIndexType, rank()> indices) const;
+template<class OtherIndexType>
+  constexpr reference at(const array<OtherIndexType, rank()>& indices) const;
+```
+*Constraints:*
+- `is_convertible_v<const OtherIndexType&, index_type>` is `true`, and
+- `is_nothrow_constructible_v<index_type, const OtherIndexType&>` is
+  `true`.
+*Effects:* Let `P` be a parameter pack such that
+``` cpp
+is_same_v<make_index_sequence<rank()>, index_sequence<P...>>
+```
+is `true`. Equivalent to:
+``` cpp
+return at(extents_type::index-cast(as_const(indices[P]))...);
 ```
 ``` cpp
 constexpr size_type size() const noexcept;
 ```
 [[basic.fundamental]].
 *Returns:* `extents().`*`fwd-prod-of-extents`*`(rank())`.
 ``` cpp
+constexpr bool empty() const noexcept;
 ```
 *Returns:* `true` if the size of the multidimensional index space
 `extents()` is 0, otherwise `false`.
 swap(x.ptr_, y.ptr_);
 swap(x.map_, y.map_);
 swap(x.acc_, y.acc_);
 ```
+#### `submdspan` <a id="mdspan.sub">[[mdspan.sub]]</a>
+##### Overview <a id="mdspan.sub.overview">[[mdspan.sub.overview]]</a>
+The `submdspan` facilities create a new `mdspan` viewing a subset of
+elements of an existing input `mdspan`. The subset viewed by the created
+`mdspan` is determined by the `SliceSpecifier` arguments.
+For each function defined in [[mdspan.sub]] that takes a parameter pack
+named `slices` as an argument:
+- let `index_type` be
+  - `M::index_type` if the function is a member of a class `M`,
+  - otherwise, `remove_reference_t<decltype(src)>::index_type` if the
+    function has a parameter named `src`,
+  - otherwise, the same type as the function’s template argument
+    `IndexType`;
+- let `rank` be the number of elements in `slices`;
+- let sₖ be the kᵗʰ element of `slices`;
+- let Sₖ be the type of sₖ; and
+- let `map-rank` be an `array<size_t, rank>` such that for each k in the
+  range \[`0`, `rank`), `map-rank[k]` equals:
+  - `dynamic_extent` if Sₖ models `convertible_to<index_type>`,
+  - otherwise, the number of types Sⱼ with j < k that do not model
+    `convertible_to<index_type>`.
+##### `strided_slice` <a id="mdspan.sub.strided.slice">[[mdspan.sub.strided.slice]]</a>
+`strided_slice` represents a set of `extent` regularly spaced integer
+indices. The indices start at `offset`, and increase by increments of
+`stride`.
+``` cpp
+namespace std {
+  template<class OffsetType, class ExtentType, class StrideType>
+  struct strided_slice {
+    using offset_type = OffsetType;
+    using extent_type = ExtentType;
+    using stride_type = StrideType;
+    [[no_unique_address]] offset_type offset{};
+    [[no_unique_address]] extent_type extent{};
+    [[no_unique_address]] stride_type stride{};
+  };
+}
+```
+`strided_slice` has the data members and special members specified
+above. It has no base classes or members other than those specified.
+*Mandates:* `OffsetType`, `ExtentType`, and `StrideType` are signed or
+unsigned integer types, or model `integral-constant-like`.
+[*Note 1*:
+`strided_slice{.offset = 1, .extent = 10, .stride = 3}`
+indicates the indices `1`, `4`, `7`, and `10`. Indices are selected from
+the half-open interval \[`1`, `1 + 10`).
+— *end note*]
+##### `submdspan_mapping_result` <a id="mdspan.sub.map.result">[[mdspan.sub.map.result]]</a>
+Specializations of `submdspan_mapping_result` are returned by overloads
+of `submdspan_mapping`.
+``` cpp
+namespace std {
+  template<class LayoutMapping>
+  struct submdspan_mapping_result {
+    [[no_unique_address]] LayoutMapping mapping = LayoutMapping();
+    size_t offset{};
+  };
+}
+```
+`submdspan_mapping_result` has the data members and special members
+specified above. It has no base classes or members other than those
+specified.
+`LayoutMapping` shall meet the layout mapping requirements
+[[mdspan.layout.policy.reqmts]].
+##### Exposition-only helpers <a id="mdspan.sub.helpers">[[mdspan.sub.helpers]]</a>
+``` cpp
+template<class T>
+  constexpr T de-ice(T val) { return val; }
+template<integral-constant-like T>
+  constexpr auto de-ice(T) { return T::value; }
+template<class IndexType, size_t k, class... SliceSpecifiers>
+  constexpr IndexType first_(SliceSpecifiers... slices);
+```
+*Mandates:* `IndexType` is a signed or unsigned integer type.
+Let φₖ denote the following value:
+- sₖ if Sₖ models `convertible_to<IndexType>`;
+- otherwise, `get<0>(`sₖ`)` if Sₖ models `index-pair-like<IndexType>`;
+- otherwise, *`de-ice`*`(`sₖ`.offset)` if Sₖ is a specialization of
+  `strided_slice`;
+- otherwise, `0`.
+*Preconditions:* φₖ is representable as a value of type `IndexType`.
+*Returns:* `extents<IndexType>::`*`index-cast`*`(`φₖ`)`.
+``` cpp
+template<size_t k, class Extents, class... SliceSpecifiers>
+  constexpr auto last_(const Extents& src, SliceSpecifiers... slices);
+```
+*Mandates:* `Extents` is a specialization of `extents`.
+Let `index_type` be `typename Extents::index_type`.
+Let λₖ denote the following value:
+- *`de-ice`*`(`sₖ`) + 1` if Sₖ models `convertible_to<index_type>`;
+  otherwise
+- `get<1>(`sₖ`)` if Sₖ models `index-pair-like<index_type>`; otherwise
+- *`de-ice`*`(`sₖ`.offset)` `+` *`de-ice`*`(`sₖ`.extent)` if Sₖ is a
+  specialization of `strided_slice`; otherwise
+- `src.extent(k)`.
+*Preconditions:* λₖ is representable as a value of type `index_type`.
+*Returns:* `Extents::`*`index-cast`*`(`λₖ`)`.
+``` cpp
+template<class IndexType, size_t N, class... SliceSpecifiers>
+  constexpr array<IndexType, sizeof...(SliceSpecifiers)>
+    src-indices(const array<IndexType, N>& indices, SliceSpecifiers... slices);
+```
+*Mandates:* `IndexType` is a signed or unsigned integer type.
+*Returns:* An `array<IndexType, sizeof...(SliceSpecifiers)> src_idx`
+such that for each k in the range \[`0`, `sizeof...(SliceSpecifiers)`),
+`src_idx[`k`]` equals
+- *`first_`*`<IndexType, `k`>(slices...)` for each k where
+  *`map-rank`*`[`k`]` equals `dynamic_extent`,
+- otherwise, *`first_`*`<IndexType, `k`>(slices...)` `+`
+  `indices[`*`map-rank`*`[`k`]]`.
+##### `submdspan_extents` function <a id="mdspan.sub.extents">[[mdspan.sub.extents]]</a>
+``` cpp
+template<class IndexType, size_t... Extents, class... SliceSpecifiers>
+  constexpr auto submdspan_extents(const extents<IndexType, Extents...>& src,
+                                   SliceSpecifiers... slices);
+```
+*Constraints:* `sizeof...(slices)` equals `sizeof...(Extents)`.
+*Mandates:* For each rank index k of `src.extents()`, exactly one of the
+following is true:
+- Sₖ models `convertible_to<IndexType>`,
+- Sₖ models `index-pair-like<IndexType>`,
+- `is_convertible_v<`Sₖ`, full_extent_t>` is `true`, or
+- Sₖ is a specialization of `strided_slice`.
+*Preconditions:* For each rank index k of `src.extents()`, all of the
+following are `true`:
+- if Sₖ is a specialization of `strided_slice`
+  - `$s_k$.extent` = 0, or
+  - `$s_k$.stride` > 0
+- $0 \le \texttt{\textit{first_}<IndexType, $k$>(slices...)}$
+  $\le \texttt{\textit{last_}<$k$>(src, slices...)}$ ≤ `src.extent($k$)`
+Let `SubExtents` be a specialization of `extents` such that:
+- `SubExtents::rank()` equals the number of k such that Sₖ does not
+  model `convertible_to<IndexType>`; and
+- for each rank index k of `Extents` such that
+  *`map-rank`*`[`k`] != dynamic_extent` is `true`,
+  `SubExtents::static_extent(`*`map-rank`*`[`k`])` equals:
+  - `Extents::static_extent(`k`)` if
+    `is_convertible_v<`Sₖ`, full_extent_t>` is `true`; otherwise
+  - *`de-ice`*`(tuple_element_t<1, `Sₖ`>()) -`
+    *`de-ice`*`(tuple_element_t<0, `Sₖ`>())` if Sₖ models
+    `index-pair-like<IndexType>`, and both `tuple_element_t<0, `Sₖ`>`
+    and `tuple_element_t<1, `Sₖ`>` model `integral-constant-like`;
+    otherwise
+  - `0`, if Sₖ is a specialization of `strided_slice`, whose
+    `extent_type` models *`integral-constant-like`*, for which
+    `extent_type()` equals zero; otherwise
+  - `1 + (`*`de-ice`*`(`Sₖ`::extent_type()) - 1) /`
+    *`de-ice`*`(`Sₖ`::stride_type())`, if Sₖ is a specialization of
+    `strided_slice` whose `extent_type` and `stride_type` model
+    *`integral-constant-like`*;
+  - otherwise, `dynamic_extent`.
+*Returns:* A value `ext` of type `SubExtents` such that for each k for
+which *`map-rank`*`[`k`] != dynamic_extent` is `true`,
+`ext.extent(`*`map-rank`*`[`k`])` equals:
+- sₖ`.extent == 0 ? 0 : 1 + (`*`de-ice`*`(`sₖ`.extent) - 1) / `*`de-ice`*`(`sₖ`.stride)`
+  if Sₖ is a specialization of `strided_slice`,
+- otherwise,
+  *`last_`*`<`k`>(src, slices...) - `*`first_`*`<IndexType, `k`>(slices...)`.
+##### Specializations of `submdspan_mapping` <a id="mdspan.sub.map">[[mdspan.sub.map]]</a>
+###### Common <a id="mdspan.sub.map.common">[[mdspan.sub.map.common]]</a>
+The following elements apply to all functions in [[mdspan.sub.map]].
+*Constraints:* `sizeof...(slices)` equals `extents_type::rank()`.
+*Mandates:* For each rank index k of `extents()`, exactly one of the
+following is true:
+- Sₖ models `convertible_to<index_type>`,
+- Sₖ models `index-pair-like<index_type>`,
+- `is_convertible_v<Sₖ, full_extent_t>` is `true`, or
+- Sₖ is a specialization of `strided_slice`.
+*Preconditions:* For each rank index k of `extents()`, all of the
+following are `true`:
+- if Sₖ is a specialization of `strided_slice`, `sₖ.extent` is equal to
+  zero or `sₖ.stride` is greater than zero; and
+- $0            \leq \tcode{\exposid{first_}<index_type, $k$>(slices...)} \\
+  \hphantom{0 } \leq \tcode{\exposid{last_}<$k$>(extents(), slices...)} \\
+  \hphantom{0 } \leq \tcode{extents().extent($k$)}$
+Let `sub_ext` be the result of `submdspan_extents(extents(), slices...)`
+and let `SubExtents` be `decltype(sub_ext)`.
+Let `sub_strides` be an
+`array<SubExtents::index_type, SubExtents::rank()>` such that for each
+rank index k of `extents()` for which `map-rank[k]` is not
+`dynamic_extent`, `sub_strides[map-rank[k]]` equals:
+- `stride(k) * de-ice(sₖ.stride)` if Sₖ is a specialization of
+  `strided_slice` and `sₖ.stride < sₖ.extent` is `true`;
+- otherwise, `stride(k)`.
+Let `P` be a parameter pack such that
+`is_same_v<make_index_sequence<rank()>, index_sequence<P...>>` is
+`true`.
+If `first_<index_type, k>(slices...)` equals `extents().extent(k)` for
+any rank index k of `extents()`, then let `offset` be a value of type
+`size_t` equal to `(*this).required_span_size()`. Otherwise, let
+`offset` be a value of type `size_t` equal to
+`(*this)(first_<index_type, P>(slices...)...)`.
+Given a layout mapping type `M`, a type `S` is a *unit-stride slice for
+`M`* if
+- `S` is a specialization of `strided_slice` where `S::stride_type`
+  models `integral-constant-like` and `S::stride_type::value` equals
+  `1`,
+- `S` models `index-pair-like<M::index_type>`, or
+- `is_convertible_v<S, full_extent_t>` is `true`.
+###### `layout_left` specialization of `submdspan_mapping` <a id="mdspan.sub.map.left">[[mdspan.sub.map.left]]</a>
+``` cpp
+template<class Extents>
+template<class... SliceSpecifiers>
+constexpr auto layout_left::mapping<Extents>::submdspan-mapping-impl(
+      SliceSpecifiers... slices) const -> see below;
+```
+*Returns:*
+- `submdspan_mapping_result{*this, 0}`, if `Extents::rank() == 0` is
+  `true`;
+- otherwise,
+  `submdspan_mapping_result{layout_left::mapping(sub_ext), offset}`, if
+  `SubExtents::rank() == 0` is `true`;
+- otherwise,
+  `submdspan_mapping_result{layout_left::mapping(sub_ext), offset}`, if
+  - for each k in the range \[`0`, `SubExtents::rank() - 1)`),
+    `is_convertible_v<`Sₖ`, full_extent_t>` is `true`; and
+  - for k equal to `SubExtents::rank() - 1`, Sₖ is a unit-stride slice
+    for `mapping`;
+  \[*Note 2*: If the above conditions are true, all Sₖ with k larger
+  than `SubExtents::rank() - 1` are convertible to
+  `index_type`. — *end note*]
+- otherwise,
+  ``` cpp
+  submdspan_mapping_result{layout_left_padded<S_static>::mapping(sub_ext, stride(u + 1)),
+                           offset}
+  ```
+  if for a value u for which u+1 is the smallest value p larger than
+  zero for which Sₚ is a unit-stride slice for `mapping`, the following
+  conditions are met:
+  - S₀ is a unit-stride slice for `mapping`; and
+  - for each k in the range \[u` + 1`, u` + SubExtents::rank() - 1`),
+    `is_convertible_v<`Sₖ`, full_extent_t>` is `true`; and
+  - for k equal to u` + SubExtents::rank() - 1`, Sₖ is a unit-stride
+    slice for `mapping`;
+  and where `S_static` is:
+  - `dynamic_extent`, if `static_extent(`k`)` is `dynamic_extent` for
+    any k in the range \[`0`, u` + 1`),
+  - otherwise, the product of all values `static_extent(`k`)` for k in
+    the range \[`0`, u` + 1`);
+- otherwise,
+  ``` cpp
+  submdspan_mapping_result{layout_stride::mapping(sub_ext, sub_strides), offset}
+  ```
+###### `layout_right` specialization of `submdspan_mapping` <a id="mdspan.sub.map.right">[[mdspan.sub.map.right]]</a>
+``` cpp
+template<class Extents>
+template<class... SliceSpecifiers>
+constexpr auto layout_right::mapping<Extents>::submdspan-mapping-impl(
+      SliceSpecifiers... slices) const -> see below;
+```
+*Returns:*
+- `submdspan_mapping_result{*this, 0}`, if `Extents::rank() == 0` is
+  `true`;
+- otherwise,
+  `submdspan_mapping_result{layout_right::mapping(sub_ext), offset}`, if
+  `SubExtents::rank() == 0` is `true`;
+- otherwise,
+  `submdspan_mapping_result{layout_right::mapping(sub_ext), offset}`, if
+  - for each k in the range \[*`rank_`*` - SubExtents::rank() + 1`,
+    *`rank_`*), `is_convertible_v<`Sₖ`, full_extent_t>` is `true`; and
+  - for k equal to *rank\_* - `SubExtents::rank()`, Sₖ is a unit-stride
+    slice for `mapping`;
+  \[*Note 3*: If the above conditions are true, all Sₖ with
+  $k < \texttt{\textit{rank_} - SubExtents::rank()}$ are convertible to
+  `index_type`. — *end note*]
+- otherwise,
+  ``` cpp
+  submdspan_mapping_result{layout_right_padded<S_static>::mapping(sub_ext,
+                               stride(rank_ - u - 2)), offset}
+  ```
+  if for a value u for which rank_ - u - 2 is the largest value p
+  smaller than *`rank_`*` - 1` for which Sₚ is a unit-stride slice for
+  `mapping`, the following conditions are met:
+  - for k equal to *`rank_`*` - 1`, Sₖ is a unit-stride slice for
+    `mapping`; and
+  - for each k in the range
+    \[*`rank_`*` - SubExtents::rank() - `u` + 1`,
+    *`rank_`*` - `u` - 1`), `is_convertible_v<`Sₖ`, full_extent_t>` is
+    `true`; and
+  - for k equal to *`rank_`*` - SubExtents::rank() - `u, Sₖ is a
+    unit-stride slice for `mapping`;
+  and where `S_static` is:
+  - `dynamic_extent`, if `static_extent(`k`)` is `dynamic_extent` for
+    any k in the range \[*`rank_`*` - `u` - 1`, *`rank_`*),
+  - otherwise, the product of all values `static_extent(`k`)` for k in
+    the range \[*`rank_`*` - `u` - 1`, *`rank_`*);
+- otherwise,
+  ``` cpp
+  submdspan_mapping_result{layout_stride::mapping(sub_ext, sub_strides), offset}
+  ```
+###### `layout_stride` specialization of `submdspan_mapping` <a id="mdspan.sub.map.stride">[[mdspan.sub.map.stride]]</a>
+``` cpp
+template<class Extents>
+template<class... SliceSpecifiers>
+constexpr auto layout_stride::mapping<Extents>::submdspan-mapping-impl(
+      SliceSpecifiers... slices) const -> see below;
+```
+*Returns:*
+- `submdspan_mapping_result{*this, 0}`, if `Extents::rank() == 0` is
+  `true`;
+- otherwise,
+  ``` cpp
+  submdspan_mapping_result{layout_stride::mapping(sub_ext, sub_strides), offset}
+  ```
+###### `layout_left_padded` specialization of `submdspan_mapping` <a id="mdspan.sub.map.leftpad">[[mdspan.sub.map.leftpad]]</a>
+``` cpp
+template<class Extents>
+template<class... SliceSpecifiers>
+constexpr auto layout_left_padded::mapping<Extents>::submdspan-mapping-impl(
+    SliceSpecifiers... slices) const -> see below;
+```
+*Returns:*
+- `submdspan_mapping_result{*this, 0}`, if `Extents::rank() == 0` is
+  `true`;
+- otherwise,
+  `submdspan_mapping_result{layout_left::mapping(sub_ext), offset}`, if
+  *`rank_`*` == 1` is `true` or `SubExtents::rank() == 0` is `true`;
+- otherwise,
+  `submdspan_mapping_result{layout_left::mapping(sub_ext), offset}`, if
+  - `SubExtents::rank() == 1` is `true` and
+  - S₀ is a unit-stride slice for `mapping`;
+- otherwise,
+  ``` cpp
+  submdspan_mapping_result{layout_left_padded<S_static>::mapping(sub_ext, stride(u + 1)),
+                           offset}
+  ```
+  if for a value u for which u` + 1` is the smallest value p larger than
+  zero for which Sₚ is a unit-stride slice for `mapping`, the following
+  conditions are met:
+  - S₀ is a unit-stride slice for `mapping`; and
+  - for each k in the range \[u` + 1`, u` + SubExtents::rank() - 1`),
+    `is_convertible_v<`Sₖ`, full_extent_t>` is `true`; and
+  - for k equal to u` + SubExtents::rank() - 1`, Sₖ is a unit-stride
+    slice for `mapping`;
+  where `S_static` is:
+  - `dynamic_extent`, if *static-padding-stride* is `dynamic_extent` or
+    `static_extent(`k`)` is `dynamic_extent` for any k in the range
+    \[`1`, u` + 1`),
+  - otherwise, the product of *static-padding-stride* and all values
+    `static_extent(`k`)` for k in the range \[`1`, u` + 1`);
+- otherwise,
+  ``` cpp
+  submdspan_mapping_result{layout_stride::mapping(sub_ext, sub_strides), offset}
+  ```
+###### `layout_right_padded` specialization of `submdspan_mapping` <a id="mdspan.sub.map.rightpad">[[mdspan.sub.map.rightpad]]</a>
+``` cpp
+template<class Extents>
+template<class... SliceSpecifiers>
+constexpr auto layout_right_padded::mapping<Extents>::submdspan-mapping-impl(
+    SliceSpecifiers... slices) const -> see below;
+```
+*Returns:*
+- `submdspan_mapping_result{*this, 0}`, if *`rank_`*` == 0` is `true`;
+- otherwise,
+  `submdspan_mapping_result{layout_right::mapping(sub_ext), offset}`, if
+  *`rank_`*` == 1` is `true` or `SubExtents::rank() == 0` is `true`;
+- otherwise,
+  `submdspan_mapping_result{layout_right::mapping(sub_ext), offset}`, if
+  - `SubExtents::rank() == 1` is `true` and
+  - for k equal to *`rank_`*` - 1`, Sₖ is a unit-stride slice for
+    `mapping`;
+- otherwise,
+  ``` cpp
+  submdspan_mapping_result{layout_right_padded<S_static>::mapping(sub_ext,
+                               stride(rank_ - u - 2)), offset}
+  ```
+  if for a value u for which *`rank_`*` - `u` - 2` is the largest value
+  p smaller than *`rank_`*` - 1` for which Sₚ is a unit-stride slice for
+  `mapping`, the following conditions are met:
+  - for k equal to *`rank_`*` - 1`, Sₖ is a unit-stride slice for
+    `mapping`; and
+  - for each k in the range
+    \[*`rank_`*` - SubExtents::rank() - `u` + 1`,
+    *`rank_`*` - `u` - 1)`), `is_convertible_v<`Sₖ`, full_extent_t>` is
+    `true`; and
+  - for k equal to *`rank_`*` - SubExtents::rank() - `u, Sₖ is a
+    unit-stride slice for `mapping`;
+  and where `S_static` is:
+  - `dynamic_extent` if *static-padding-stride* is `dynamic_extent` or
+    for any k in the range \[*`rank_`*` - `u` - 1`, *`rank_`*` - 1`)
+    `static_extent(`k`)` is `dynamic_extent`,
+  - otherwise, the product of *static-padding-stride* and all values
+    `static_extent(`k`)` with k in the range \[*`rank_`*` - `u` - 1`,
+    *`rank_`*` - 1`);
+- otherwise,
+  ``` cpp
+  submdspan_mapping_result{layout_stride::mapping(sub_ext, sub_strides), offset}
+  ```
+##### `submdspan` function template <a id="mdspan.sub.sub">[[mdspan.sub.sub]]</a>
+``` cpp
+template<class ElementType, class Extents, class LayoutPolicy,
+         class AccessorPolicy, class... SliceSpecifiers>
+  constexpr auto submdspan(
+    const mdspan<ElementType, Extents, LayoutPolicy, AccessorPolicy>& src,
+    SliceSpecifiers... slices) -> see below;
+```
+Let `index_type` be `typename Extents::index_type`.
+Let `sub_map_offset` be the result of
+`submdspan_mapping(src.mapping(), slices...)`.
+[*Note 1*: This invocation of `submdspan_mapping` selects a function
+call via overload resolution on a candidate set that includes the lookup
+set found by argument-dependent
+lookup [[basic.lookup.argdep]]. — *end note*]
+*Constraints:*
+- `sizeof...(slices)` equals `Extents::rank()`, and
+- the expression `submdspan_mapping(src.mapping(), slices...)` is
+  well-formed when treated as an unevaluated operand.
+*Mandates:*
+- `decltype(submdspan_mapping(src.mapping(), slices...))` is a
+  specialization of `submd-span_mapping_result`.
+- `is_same_v<remove_cvref_t<decltype(sub_map_offset.mapping.extents())>,`
+  `decltype(submdspan_extents(src.mapping(), slices...))>` is `true`.
+- For each rank index k of `src.extents()`, exactly one of the following
+  is true:
+  - Sₖ models `convertible_to<index_type>`,
+  - Sₖ models `index-pair-like<index_type>`,
+  - `is_convertible_v<`Sₖ`, full_extent_t>` is `true`, or
+  - Sₖ is a specialization of `strided_slice`.
+*Preconditions:*
+- For each rank index k of `src.extents()`, all of the following are
+  `true`:
+  - if Sₖ is a specialization of `strided_slice`
+    - `$s_k$.extent` = 0, or
+    - `$s_k$.stride` > 0
+  - $0 \le \texttt{\textit{first_}<index_type, $k$>(slices...)}$
+    $\le \texttt{\textit{last_}<$k$>(src.extents(), slices...)}$
+    ≤ `{}src.extent($k$)`
+- `sub_map_offset.mapping.extents() == submdspan_extents(src.mapping(), slices...)`
+  is `true`; and
+- for each integer pack `I` which is a multidimensional index in
+  `sub_map_offset.mapping.extents()`,
+  ``` cpp
+  sub_map_offset.mapping(I...) + sub_map_offset.offset ==
+    src.mapping()(src-indices(array{I...}, slices...))
+  ```
+  is `true`.
+[*Note 2*: These conditions ensure that the mapping returned by
+`submdspan_mapping` matches the algorithmically expected index-mapping
+given the slice specifiers. — *end note*]
+*Effects:* Equivalent to:
+``` cpp
+auto sub_map_result = submdspan_mapping(src.mapping(), slices...);
+return mdspan(src.accessor().offset(src.data_handle(), sub_map_result.offset),
+              sub_map_result.mapping,
+              typename AccessorPolicy::offset_policy(src.accessor()));
+```
+[*Example 1*:
+Given a rank-3 `mdspan grid3d` representing a three-dimensional grid of
+regularly spaced points in a rectangular prism, the function
+`zero_surface` sets all elements on the surface of the 3-dimensional
+shape to zero. It does so by reusing a function `zero_2d` that takes a
+rank-2 `mdspan`.
+``` cpp
+// zero out all elements in an mdspan
+template<class T, class E, class L, class A>
+void zero_2d(mdspan<T, E, L, A> a) {
+  static_assert(a.rank() == 2);
+  for (int i = 0; i < a.extent(0); i++)
+    for (int j = 0; j < a.extent(1); j++)
+      a[i, j] = 0;
+}
+// zero out just the surface
+template<class T, class E, class L, class A>
+void zero_surface(mdspan<T, E, L, A> grid3d) {
+  static_assert(grid3d.rank() == 3);
+  zero_2d(submdspan(grid3d, 0, full_extent, full_extent));
+  zero_2d(submdspan(grid3d, full_extent, 0, full_extent));
+  zero_2d(submdspan(grid3d, full_extent, full_extent, 0));
+  zero_2d(submdspan(grid3d, grid3d.extent(0) - 1, full_extent, full_extent));
+  zero_2d(submdspan(grid3d, full_extent, grid3d.extent(1) - 1, full_extent));
+  zero_2d(submdspan(grid3d, full_extent, full_extent, grid3d.extent(2) - 1));
+}
+```
+— *end example*]
 <!-- Link reference definitions -->
 [alg.equal]: algorithms.md#alg.equal
 [alg.sorting]: algorithms.md#alg.sorting
 [algorithm.stable]: library.md#algorithm.stable
 [algorithms]: algorithms.md#algorithms
 [associative.reqmts]: #associative.reqmts
 [associative.reqmts.except]: #associative.reqmts.except
 [associative.reqmts.general]: #associative.reqmts.general
 [associative.set.syn]: #associative.set.syn
 [basic.fundamental]: basic.md#basic.fundamental
+[basic.lookup.argdep]: basic.md#basic.lookup.argdep
 [basic.string]: strings.md#basic.string
 [class.copy.ctor]: class.md#class.copy.ctor
 [class.default.ctor]: class.md#class.default.ctor
 [class.dtor]: class.md#class.dtor
 [container.adaptors]: #container.adaptors
 [container.adaptors.format]: #container.adaptors.format
 [container.adaptors.general]: #container.adaptors.general
 [container.alloc.reqmts]: #container.alloc.reqmts
 [container.insert.return]: #container.insert.return
+[container.intro.reqmts]: #container.intro.reqmts
 [container.node]: #container.node
 [container.node.compat]: #container.node.compat
 [container.node.cons]: #container.node.cons
 [container.node.dtor]: #container.node.dtor
 [container.node.modifiers]: #container.node.modifiers
 [expr.const]: expr.md#expr.const
 [flat.map]: #flat.map
 [flat.map.access]: #flat.map.access
 [flat.map.capacity]: #flat.map.capacity
 [flat.map.cons]: #flat.map.cons
+[flat.map.cons.alloc]: #flat.map.cons.alloc
 [flat.map.defn]: #flat.map.defn
 [flat.map.erasure]: #flat.map.erasure
 [flat.map.modifiers]: #flat.map.modifiers
 [flat.map.overview]: #flat.map.overview
 [flat.map.syn]: #flat.map.syn
 [flat.multimap]: #flat.multimap
 [flat.multimap.cons]: #flat.multimap.cons
+[flat.multimap.cons.alloc]: #flat.multimap.cons.alloc
 [flat.multimap.defn]: #flat.multimap.defn
 [flat.multimap.erasure]: #flat.multimap.erasure
 [flat.multimap.overview]: #flat.multimap.overview
 [flat.multiset]: #flat.multiset
 [flat.multiset.cons]: #flat.multiset.cons
+[flat.multiset.cons.alloc]: #flat.multiset.cons.alloc
 [flat.multiset.defn]: #flat.multiset.defn
 [flat.multiset.erasure]: #flat.multiset.erasure
 [flat.multiset.modifiers]: #flat.multiset.modifiers
 [flat.multiset.overview]: #flat.multiset.overview
 [flat.set]: #flat.set
 [flat.set.cons]: #flat.set.cons
+[flat.set.cons.alloc]: #flat.set.cons.alloc
 [flat.set.defn]: #flat.set.defn
 [flat.set.erasure]: #flat.set.erasure
 [flat.set.modifiers]: #flat.set.modifiers
 [flat.set.overview]: #flat.set.overview
 [flat.set.syn]: #flat.set.syn
 [forward.list.modifiers]: #forward.list.modifiers
 [forward.list.ops]: #forward.list.ops
 [forward.list.overview]: #forward.list.overview
 [forward.list.syn]: #forward.list.syn
 [hash.requirements]: library.md#hash.requirements
+[hive]: #hive
+[hive.capacity]: #hive.capacity
+[hive.cons]: #hive.cons
+[hive.erasure]: #hive.erasure
+[hive.modifiers]: #hive.modifiers
+[hive.operations]: #hive.operations
+[hive.overview]: #hive.overview
+[hive.syn]: #hive.syn
+[inplace.vector]: #inplace.vector
+[inplace.vector.capacity]: #inplace.vector.capacity
+[inplace.vector.cons]: #inplace.vector.cons
+[inplace.vector.data]: #inplace.vector.data
+[inplace.vector.erasure]: #inplace.vector.erasure
+[inplace.vector.modifiers]: #inplace.vector.modifiers
+[inplace.vector.overview]: #inplace.vector.overview
+[inplace.vector.syn]: #inplace.vector.syn
 [iterator.concept.contiguous]: iterators.md#iterator.concept.contiguous
 [iterator.concept.random.access]: iterators.md#iterator.concept.random.access
 [iterator.requirements]: iterators.md#iterator.requirements
 [iterator.requirements.general]: iterators.md#iterator.requirements.general
 [list]: #list
 [map.cons]: #map.cons
 [map.erasure]: #map.erasure
 [map.modifiers]: #map.modifiers
 [map.overview]: #map.overview
 [mdspan.accessor]: #mdspan.accessor
+[mdspan.accessor.aligned]: #mdspan.accessor.aligned
+[mdspan.accessor.aligned.members]: #mdspan.accessor.aligned.members
+[mdspan.accessor.aligned.overview]: #mdspan.accessor.aligned.overview
 [mdspan.accessor.default]: #mdspan.accessor.default
 [mdspan.accessor.default.members]: #mdspan.accessor.default.members
 [mdspan.accessor.default.overview]: #mdspan.accessor.default.overview
 [mdspan.accessor.general]: #mdspan.accessor.general
 [mdspan.accessor.reqmts]: #mdspan.accessor.reqmts
 [mdspan.extents]: #mdspan.extents
 [mdspan.extents.cmp]: #mdspan.extents.cmp
 [mdspan.extents.cons]: #mdspan.extents.cons
 [mdspan.extents.dextents]: #mdspan.extents.dextents
+[mdspan.extents.dims]: #mdspan.extents.dims
 [mdspan.extents.expo]: #mdspan.extents.expo
 [mdspan.extents.obs]: #mdspan.extents.obs
 [mdspan.extents.overview]: #mdspan.extents.overview
 [mdspan.layout]: #mdspan.layout
 [mdspan.layout.general]: #mdspan.layout.general
 [mdspan.layout.left]: #mdspan.layout.left
 [mdspan.layout.left.cons]: #mdspan.layout.left.cons
 [mdspan.layout.left.obs]: #mdspan.layout.left.obs
 [mdspan.layout.left.overview]: #mdspan.layout.left.overview
+[mdspan.layout.leftpad]: #mdspan.layout.leftpad
+[mdspan.layout.leftpad.cons]: #mdspan.layout.leftpad.cons
+[mdspan.layout.leftpad.expo]: #mdspan.layout.leftpad.expo
+[mdspan.layout.leftpad.obs]: #mdspan.layout.leftpad.obs
+[mdspan.layout.leftpad.overview]: #mdspan.layout.leftpad.overview
 [mdspan.layout.policy.overview]: #mdspan.layout.policy.overview
 [mdspan.layout.policy.reqmts]: #mdspan.layout.policy.reqmts
 [mdspan.layout.reqmts]: #mdspan.layout.reqmts
 [mdspan.layout.right]: #mdspan.layout.right
 [mdspan.layout.right.cons]: #mdspan.layout.right.cons
 [mdspan.layout.right.obs]: #mdspan.layout.right.obs
 [mdspan.layout.right.overview]: #mdspan.layout.right.overview
+[mdspan.layout.rightpad]: #mdspan.layout.rightpad
+[mdspan.layout.rightpad.cons]: #mdspan.layout.rightpad.cons
+[mdspan.layout.rightpad.expo]: #mdspan.layout.rightpad.expo
+[mdspan.layout.rightpad.obs]: #mdspan.layout.rightpad.obs
+[mdspan.layout.rightpad.overview]: #mdspan.layout.rightpad.overview
 [mdspan.layout.stride]: #mdspan.layout.stride
 [mdspan.layout.stride.cons]: #mdspan.layout.stride.cons
 [mdspan.layout.stride.expo]: #mdspan.layout.stride.expo
 [mdspan.layout.stride.obs]: #mdspan.layout.stride.obs
 [mdspan.layout.stride.overview]: #mdspan.layout.stride.overview
 [mdspan.mdspan]: #mdspan.mdspan
 [mdspan.mdspan.cons]: #mdspan.mdspan.cons
 [mdspan.mdspan.members]: #mdspan.mdspan.members
 [mdspan.mdspan.overview]: #mdspan.mdspan.overview
 [mdspan.overview]: #mdspan.overview
+[mdspan.sub]: #mdspan.sub
+[mdspan.sub.extents]: #mdspan.sub.extents
+[mdspan.sub.helpers]: #mdspan.sub.helpers
+[mdspan.sub.map]: #mdspan.sub.map
+[mdspan.sub.map.common]: #mdspan.sub.map.common
+[mdspan.sub.map.left]: #mdspan.sub.map.left
+[mdspan.sub.map.leftpad]: #mdspan.sub.map.leftpad
+[mdspan.sub.map.result]: #mdspan.sub.map.result
+[mdspan.sub.map.right]: #mdspan.sub.map.right
+[mdspan.sub.map.rightpad]: #mdspan.sub.map.rightpad
+[mdspan.sub.map.stride]: #mdspan.sub.map.stride
+[mdspan.sub.overview]: #mdspan.sub.overview
+[mdspan.sub.strided.slice]: #mdspan.sub.strided.slice
+[mdspan.sub.sub]: #mdspan.sub.sub
 [mdspan.syn]: #mdspan.syn
 [multimap]: #multimap
 [multimap.cons]: #multimap.cons
 [multimap.erasure]: #multimap.erasure
 [multimap.modifiers]: #multimap.modifiers
 [queue.mod]: #queue.mod
 [queue.ops]: #queue.ops
 [queue.special]: #queue.special
 [queue.syn]: #queue.syn
 [random.access.iterators]: iterators.md#random.access.iterators
+[re.results]: text.md#re.results
 [res.on.data.races]: library.md#res.on.data.races
 [sequence.reqmts]: #sequence.reqmts
 [sequences]: #sequences
 [sequences.general]: #sequences.general
 [set]: #set
 [set.cons]: #set.cons
 [set.erasure]: #set.erasure
+[set.modifiers]: #set.modifiers
 [set.overview]: #set.overview
 [span.cons]: #span.cons
 [span.deduct]: #span.deduct
 [span.elem]: #span.elem
 [span.iterators]: #span.iterators
 [stack.general]: #stack.general
 [stack.mod]: #stack.mod
 [stack.ops]: #stack.ops
 [stack.special]: #stack.special
 [stack.syn]: #stack.syn
+[stacktrace.basic]: diagnostics.md#stacktrace.basic
 [strings]: strings.md#strings
 [swappable.requirements]: library.md#swappable.requirements
 [temp.deduct]: temp.md#temp.deduct
 [temp.type]: temp.md#temp.type
+[term.structural.type]: temp.md#term.structural.type
 [term.trivially.copyable.type]: basic.md#term.trivially.copyable.type
 [unord]: #unord
 [unord.general]: #unord.general
 [unord.hash]: utilities.md#unord.hash
 [unord.map]: #unord.map
 [unord.req.except]: #unord.req.except
 [unord.req.general]: #unord.req.general
 [unord.set]: #unord.set
 [unord.set.cnstr]: #unord.set.cnstr
 [unord.set.erasure]: #unord.set.erasure
+[unord.set.modifiers]: #unord.set.modifiers
 [unord.set.overview]: #unord.set.overview
 [unord.set.syn]: #unord.set.syn
 [vector]: #vector
 [vector.bool]: #vector.bool
 [vector.bool.fmt]: #vector.bool.fmt

Diff to HTML by rtfpessoa