[thread] - C++23 → Trunk

Files changed (1) hide show

tmp/tmp4ul6xnb0/{from.md → to.md} +2448 -955

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

@@ -16,12 +16,13 @@ conditions and values between threads, as summarized in
 | [[thread.threads]]   | Threads             | `<thread>`                  |
 | [[atomics]]          | Atomic operations   | `<atomic>`, `<stdatomic.h>` |
 | [[thread.mutex]]     | Mutual exclusion    | `<mutex>`, `<shared_mutex>` |
 | [[thread.condition]] | Condition variables | `<condition_variable>`      |
 | [[thread.sema]]      | Semaphores          | `<semaphore>`               |
-| [[thread.coord]]     | Coordination types  | `<latch>` `<barrier>` |
 | [[futures]]          | Futures             | `<future>`                  |
 ## Requirements <a id="thread.req">[[thread.req]]</a>
 ### Template parameter names <a id="thread.req.paramname">[[thread.req.paramname]]</a>
@@ -144,11 +145,11 @@ exceptions*.
 supplied by the implementation as specified in  [[time.clock]] do not
 throw exceptions. — *end note*]
 ### Requirements for *Cpp17Lockable* types <a id="thread.req.lockable">[[thread.req.lockable]]</a>
-#### In general <a id="thread.req.lockable.general">[[thread.req.lockable.general]]</a>
 An *execution agent* is an entity such as a thread that may perform work
 in parallel with other execution agents.
 [*Note 1*: Implementations or users can introduce other kinds of agents
@@ -188,13 +189,13 @@ A lock on an object `m` is said to be
 nature of any lock ownership is not part of these
 definitions. — *end note*]
 #### *Cpp17BasicLockable* requirements <a id="thread.req.lockable.basic">[[thread.req.lockable.basic]]</a>
-A type `L` meets the *Cpp17BasicLockable* requirements if the following
-expressions are well-formed and have the specified semantics (`m`
-denotes a value of type `L`).
 ``` cpp
 m.lock()
 ```
@@ -214,14 +215,13 @@ execution agent.
 *Throws:* Nothing.
 #### *Cpp17Lockable* requirements <a id="thread.req.lockable.req">[[thread.req.lockable.req]]</a>
-A type `L` meets the *Cpp17Lockable* requirements if it meets the
-*Cpp17BasicLockable* requirements and the following expressions are
-well-formed and have the specified semantics (`m` denotes a value of
-type `L`).
 ``` cpp
 m.try_lock()
 ```
@@ -233,16 +233,16 @@ been acquired for the current execution agent.
 *Returns:* `true` if the lock was acquired, otherwise `false`.
 #### *Cpp17TimedLockable* requirements <a id="thread.req.lockable.timed">[[thread.req.lockable.timed]]</a>
-A type `L` meets the *Cpp17TimedLockable* requirements if it meets the
-*Cpp17Lockable* requirements and the following expressions are
-well-formed and have the specified semantics (`m` denotes a value of
-type `L`, `rel_time` denotes a value of an instantiation of `duration`
-[[time.duration]], and `abs_time` denotes a value of an instantiation of
-`time_point` [[time.point]]).
 ``` cpp
 m.try_lock_for(rel_time)
 ```
@@ -272,14 +272,13 @@ acquired for the current execution agent.
 *Returns:* `true` if the lock was acquired, otherwise `false`.
 #### *Cpp17SharedLockable* requirements <a id="thread.req.lockable.shared">[[thread.req.lockable.shared]]</a>
-A type `L` meets the *Cpp17SharedLockable* requirements if the following
-expressions are well-formed, have the specified semantics, and the
-expression `m.try_lock_shared()` has type `bool` (`m` denotes a value of
-type `L`):
 ``` cpp
 m.lock_shared()
 ```
@@ -308,16 +307,16 @@ agent.
 *Throws:* Nothing.
 #### *Cpp17SharedTimedLockable* requirements <a id="thread.req.lockable.shared.timed">[[thread.req.lockable.shared.timed]]</a>
-A type `L` meets the *Cpp17SharedTimedLockable* requirements if it meets
-the *Cpp17SharedLockable* requirements, and the following expressions
-are well-formed, have type `bool`, and have the specified semantics (`m`
-denotes a value of type `L`, `rel_time` denotes a value of a
-specialization of `chrono::duration`, and `abs_time` denotes a value of
-a specialization of `chrono::time_point`).
 ``` cpp
 m.try_lock_shared_for(rel_time)
 ```
@@ -350,42 +349,64 @@ acquired for the current execution agent.
 Subclause [[thread.stoptoken]] describes components that can be used to
 asynchronously request that an operation stops execution in a timely
 manner, typically because the result is no longer required. Such a
 request is called a *stop request*.
-`stop_source`, `stop_token`, and `stop_callback` implement semantics of
-shared ownership of a *stop state*. Any `stop_source`, `stop_token`, or
-`stop_callback` that shares ownership of the same stop state is an
-*associated* `stop_source`, `stop_token`, or `stop_callback`,
-respectively. The last remaining owner of the stop state automatically
-releases the resources associated with the stop state.
-A `stop_token` can be passed to an operation which can either
 - actively poll the token to check if there has been a stop request, or
-- register a callback using the `stop_callback` class template which
- will be called in the event that a stop request is made.
-A stop request made via a `stop_source` will be visible to all
-associated `stop_token` and `stop_source` objects. Once a stop request
-has been made it cannot be withdrawn (a subsequent stop request has no
-effect).
-Callbacks registered via a `stop_callback` object are called when a stop
-request is first made by any associated `stop_source` object.
-Calls to the functions `request_stop`, `stop_requested`, and
-`stop_possible` do not introduce data races. A call to `request_stop`
-that returns `true` synchronizes with a call to `stop_requested` on an
-associated `stop_token` or `stop_source` object that returns `true`.
-Registration of a callback synchronizes with the invocation of that
-callback.
 ### Header `<stop_token>` synopsis <a id="thread.stoptoken.syn">[[thread.stoptoken.syn]]</a>
 ``` cpp
 namespace std {
   // [stoptoken], class stop_token
   class stop_token;
   // [stopsource], class stop_source
   class stop_source;
@@ -397,399 +418,662 @@ namespace std {
   inline constexpr nostopstate_t nostopstate{};
   // [stopcallback], class template stop_callback
   template<class Callback>
     class stop_callback;
 }
 ```
 ### Class `stop_token` <a id="stoptoken">[[stoptoken]]</a>
 #### General <a id="stoptoken.general">[[stoptoken.general]]</a>
-The class `stop_token` provides an interface for querying whether a stop
-request has been made (`stop_requested`) or can ever be made
-(`stop_possible`) using an associated `stop_source` object
-[[stopsource]]. A `stop_token` can also be passed to a `stop_callback`
-[[stopcallback]] constructor to register a callback to be called when a
-stop request has been made from an associated `stop_source`.
 ``` cpp
 namespace std {
   class stop_token {
   public:
- // [stoptoken.cons], constructors, copy, and assignment
-    stop_token() noexcept;
-    stop_token(const stop_token&) noexcept;
-    stop_token(stop_token&&) noexcept;
- stop_token& operator=(const stop_token&) noexcept;
-    stop_token& operator=(stop_token&&) noexcept;
-    ~stop_token();
     void swap(stop_token&) noexcept;
- // [stoptoken.mem], stop handling
- [[nodiscard]] bool stop_requested() const noexcept;
-    [[nodiscard]] bool stop_possible() const noexcept;
- [[nodiscard]] friend bool operator==(const stop_token& lhs, const stop_token& rhs) noexcept;
-    friend void swap(stop_token& lhs, stop_token& rhs) noexcept;
   };
 }
 ```
-#### Constructors, copy, and assignment <a id="stoptoken.cons">[[stoptoken.cons]]</a>
-``` cpp
-stop_token() noexcept;
-```
-*Ensures:* `stop_possible()` is `false` and `stop_requested()` is
-`false`.
-[*Note 1*: Because the created `stop_token` object can never receive a
-stop request, no resources are allocated for a stop
-state. — *end note*]
-``` cpp
-stop_token(const stop_token& rhs) noexcept;
-```
-*Ensures:* `*this == rhs` is `true`.
-[*Note 2*: `*this` and `rhs` share the ownership of the same stop
-state, if any. — *end note*]
-``` cpp
-stop_token(stop_token&& rhs) noexcept;
-```
-*Ensures:* `*this` contains the value of `rhs` prior to the start of
-construction and `rhs.stop_possible()` is `false`.
-``` cpp
-~stop_token();
-```
-*Effects:* Releases ownership of the stop state, if any.
-``` cpp
-stop_token& operator=(const stop_token& rhs) noexcept;
-```
-*Effects:* Equivalent to: `stop_token(rhs).swap(*this)`.
-*Returns:* `*this`.
-``` cpp
-stop_token& operator=(stop_token&& rhs) noexcept;
-```
-*Effects:* Equivalent to: `stop_token(std::move(rhs)).swap(*this)`.
-*Returns:* `*this`.
 ``` cpp
 void swap(stop_token& rhs) noexcept;
 ```
-*Effects:* Exchanges the values of `*this` and `rhs`.
-#### Members <a id="stoptoken.mem">[[stoptoken.mem]]</a>
 ``` cpp
-[[nodiscard]] bool stop_requested() const noexcept;
 ```
-*Returns:* `true` if `*this` has ownership of a stop state that has
 received a stop request; otherwise, `false`.
 ``` cpp
-[[nodiscard]] bool stop_possible() const noexcept;
 ```
-*Returns:* `false` if:
-- `*this` does not have ownership of a stop state, or
 - a stop request was not made and there are no associated `stop_source`
   objects;
 otherwise, `true`.
-#### Non-member functions <a id="stoptoken.nonmembers">[[stoptoken.nonmembers]]</a>
-``` cpp
-[[nodiscard]] bool operator==(const stop_token& lhs, const stop_token& rhs) noexcept;
-```
-*Returns:* `true` if `lhs` and `rhs` have ownership of the same stop
-state or if both `lhs` and `rhs` do not have ownership of a stop state;
-otherwise `false`.
-``` cpp
-friend void swap(stop_token& x, stop_token& y) noexcept;
-```
-*Effects:* Equivalent to: `x.swap(y)`.
 ### Class `stop_source` <a id="stopsource">[[stopsource]]</a>
 #### General <a id="stopsource.general">[[stopsource.general]]</a>
-The class `stop_source` implements the semantics of making a stop
-request. A stop request made on a `stop_source` object is visible to all
-associated `stop_source` and `stop_token` [[stoptoken]] objects. Once a
-stop request has been made it cannot be withdrawn (a subsequent stop
-request has no effect).
 ``` cpp
 namespace std {
-  // no-shared-stop-state indicator
-  struct nostopstate_t {
-    explicit nostopstate_t() = default;
-  };
-  inline constexpr nostopstate_t nostopstate{};
   class stop_source {
   public:
     // [stopsource.cons], constructors, copy, and assignment
     stop_source();
-    explicit stop_source(nostopstate_t) noexcept;
- stop_source(const stop_source&) noexcept;
-    stop_source(stop_source&&) noexcept;
-    stop_source& operator=(const stop_source&) noexcept;
-    stop_source& operator=(stop_source&&) noexcept;
-    ~stop_source();
     void swap(stop_source&) noexcept;
- // [stopsource.mem], stop handling
- [[nodiscard]] stop_token get_token() const noexcept;
- [[nodiscard]] bool stop_possible() const noexcept;
-    [[nodiscard]] bool stop_requested() const noexcept;
     bool request_stop() noexcept;
- [[nodiscard]] friend bool
-      operator==(const stop_source& lhs, const stop_source& rhs) noexcept;
-    friend void swap(stop_source& lhs, stop_source& rhs) noexcept;
   };
 }
 ```
 #### Constructors, copy, and assignment <a id="stopsource.cons">[[stopsource.cons]]</a>
 ``` cpp
 stop_source();
 ```
-*Effects:* Initialises `*this` to have ownership of a new stop state.
 *Ensures:* `stop_possible()` is `true` and `stop_requested()` is
 `false`.
 *Throws:* `bad_alloc` if memory cannot be allocated for the stop state.
-``` cpp
-explicit stop_source(nostopstate_t) noexcept;
-```
-*Ensures:* `stop_possible()` is `false` and `stop_requested()` is
-`false`.
-[*Note 1*: No resources are allocated for the state. — *end note*]
-``` cpp
-stop_source(const stop_source& rhs) noexcept;
-```
-*Ensures:* `*this == rhs` is `true`.
-[*Note 2*: `*this` and `rhs` share the ownership of the same stop
-state, if any. — *end note*]
-``` cpp
-stop_source(stop_source&& rhs) noexcept;
-```
-*Ensures:* `*this` contains the value of `rhs` prior to the start of
-construction and `rhs.stop_possible()` is `false`.
-``` cpp
-~stop_source();
-```
-*Effects:* Releases ownership of the stop state, if any.
-``` cpp
-stop_source& operator=(const stop_source& rhs) noexcept;
-```
-*Effects:* Equivalent to: `stop_source(rhs).swap(*this)`.
-*Returns:* `*this`.
-``` cpp
-stop_source& operator=(stop_source&& rhs) noexcept;
-```
-*Effects:* Equivalent to: `stop_source(std::move(rhs)).swap(*this)`.
-*Returns:* `*this`.
 ``` cpp
 void swap(stop_source& rhs) noexcept;
 ```
-*Effects:* Exchanges the values of `*this` and `rhs`.
-#### Members <a id="stopsource.mem">[[stopsource.mem]]</a>
 ``` cpp
-[[nodiscard]] stop_token get_token() const noexcept;
 ```
 *Returns:* `stop_token()` if `stop_possible()` is `false`; otherwise a
-new associated `stop_token` object.
 ``` cpp
-[[nodiscard]] bool stop_possible() const noexcept;
 ```
-*Returns:* `true` if `*this` has ownership of a stop state; otherwise,
-`false`.
 ``` cpp
-[[nodiscard]] bool stop_requested() const noexcept;
 ```
-*Returns:* `true` if `*this` has ownership of a stop state that has
 received a stop request; otherwise, `false`.
 ``` cpp
 bool request_stop() noexcept;
 ```
-*Effects:* If `*this` does not have ownership of a stop state, returns
-`false`. Otherwise, atomically determines whether the owned stop state
-has received a stop request, and if not, makes a stop request. The
-determination and making of the stop request are an atomic
-read-modify-write operation [[intro.races]]. If the request was made,
-the callbacks registered by associated `stop_callback` objects are
-synchronously called. If an invocation of a callback exits via an
-exception then `terminate` is invoked [[except.terminate]].
-[*Note 1*: A stop request includes notifying all condition variables of
-type `condition_variable_any` temporarily registered during an
-interruptible wait [[thread.condvarany.intwait]]. — *end note*]
-*Ensures:* `stop_possible()` is `false` or `stop_requested()` is `true`.
-*Returns:* `true` if this call made a stop request; otherwise `false`.
-#### Non-member functions <a id="stopsource.nonmembers">[[stopsource.nonmembers]]</a>
-``` cpp
-[[nodiscard]] friend bool
-  operator==(const stop_source& lhs, const stop_source& rhs) noexcept;
-```
-*Returns:* `true` if `lhs` and `rhs` have ownership of the same stop
-state or if both `lhs` and `rhs` do not have ownership of a stop state;
-otherwise `false`.
-``` cpp
-friend void swap(stop_source& x, stop_source& y) noexcept;
-```
-*Effects:* Equivalent to: `x.swap(y)`.
 ### Class template `stop_callback` <a id="stopcallback">[[stopcallback]]</a>
 #### General <a id="stopcallback.general">[[stopcallback.general]]</a>
 ``` cpp
 namespace std {
-  template<class Callback>
   class stop_callback {
   public:
-    using callback_type = Callback;
     // [stopcallback.cons], constructors and destructor
-    template<class C>
-      explicit stop_callback(const stop_token& st, C&& cb)
-        noexcept(is_nothrow_constructible_v<Callback, C>);
-    template<class C>
-      explicit stop_callback(stop_token&& st, C&& cb)
-        noexcept(is_nothrow_constructible_v<Callback, C>);
     ~stop_callback();
     stop_callback(const stop_callback&) = delete;
     stop_callback(stop_callback&&) = delete;
     stop_callback& operator=(const stop_callback&) = delete;
     stop_callback& operator=(stop_callback&&) = delete;
   private:
- Callback callback; // exposition only
   };
-  template<class Callback>
-    stop_callback(stop_token, Callback) -> stop_callback<Callback>;
 }
 ```
 *Mandates:* `stop_callback` is instantiated with an argument for the
-template parameter `Callback` that satisfies both `invocable` and
 `destructible`.
-*Preconditions:* `stop_callback` is instantiated with an argument for
-the template parameter `Callback` that models both `invocable` and
-`destructible`.
 #### Constructors and destructor <a id="stopcallback.cons">[[stopcallback.cons]]</a>
 ``` cpp
-template<class C>
-explicit stop_callback(const stop_token& st, C&& cb)
- noexcept(is_nothrow_constructible_v<Callback, C>);
-template<class C>
-explicit stop_callback(stop_token&& st, C&& cb)
- noexcept(is_nothrow_constructible_v<Callback, C>);
 ```
-*Constraints:* `Callback` and `C` satisfy
-`constructible_from<Callback, C>`.
-*Preconditions:* `Callback` and `C` model
-`constructible_from<Callback, C>`.
-*Effects:* Initializes `callback` with `std::forward<C>(cb)`. If
-`st.stop_requested()` is `true`, then
-`std::forward<Callback>(callback)()` is evaluated in the current thread
-before the constructor returns. Otherwise, if `st` has ownership of a
-stop state, acquires shared ownership of that stop state and registers
-the callback with that stop state such that
-`std::forward<Callback>(callback)()` is evaluated by the first call to
-`request_stop()` on an associated `stop_source`.
-*Throws:* Any exception thrown by the initialization of `callback`.
-*Remarks:* If evaluating `std::forward<Callback>(callback)()` exits via
-an exception, then `terminate` is invoked [[except.terminate]].
 ``` cpp
 ~stop_callback();
 ```
-*Effects:* Unregisters the callback from the owned stop state, if any.
-The destructor does not block waiting for the execution of another
-callback registered by an associated `stop_callback`. If `callback` is
-concurrently executing on another thread, then the return from the
-invocation of `callback` strongly happens before [[intro.races]]
-`callback` is destroyed. If `callback` is executing on the current
-thread, then the destructor does not block [[defns.block]] waiting for
-the return from the invocation of `callback`. Releases ownership of the
-stop state, if any.
 ## Threads <a id="thread.threads">[[thread.threads]]</a>
 ### General <a id="thread.threads.general">[[thread.threads.general]]</a>
@@ -1193,26 +1477,26 @@ namespace std {
     jthread& operator=(const jthread&) = delete;
     jthread& operator=(jthread&&) noexcept;
     // [thread.jthread.mem], members
     void swap(jthread&) noexcept;
- [[nodiscard]] bool joinable() const noexcept;
     void join();
     void detach();
- [[nodiscard]] id get_id() const noexcept;
- [[nodiscard]] native_handle_type native_handle(); // see~[thread.req.native]
     // [thread.jthread.stop], stop token handling
- [[nodiscard]] stop_source get_stop_source() noexcept;
- [[nodiscard]] stop_token get_stop_token() const noexcept;
     bool request_stop() noexcept;
     // [thread.jthread.special], specialized algorithms
     friend void swap(jthread& lhs, jthread& rhs) noexcept;
     // [thread.jthread.static], static members
- [[nodiscard]] static unsigned int hardware_concurrency() noexcept;
   private:
     stop_source ssource;        // exposition only
   };
 }
@@ -1324,11 +1608,11 @@ void swap(jthread& x) noexcept;
 ```
 *Effects:* Exchanges the values of `*this` and `x`.
 ``` cpp
-[[nodiscard]] bool joinable() const noexcept;
 ```
 *Returns:* `get_id() != id()`.
 ``` cpp
@@ -1385,17 +1669,17 @@ represent a thread, otherwise `this_thread::get_id()` for the thread of
 execution represented by `*this`.
 #### Stop token handling <a id="thread.jthread.stop">[[thread.jthread.stop]]</a>
 ``` cpp
-[[nodiscard]] stop_source get_stop_source() noexcept;
 ```
 *Effects:* Equivalent to: `return ssource;`
 ``` cpp
-[[nodiscard]] stop_token get_stop_token() const noexcept;
 ```
 *Effects:* Equivalent to: `return ssource.get_token();`
 ``` cpp
@@ -1413,11 +1697,11 @@ friend void swap(jthread& x, jthread& y) noexcept;
 *Effects:* Equivalent to: `x.swap(y)`.
 #### Static members <a id="thread.jthread.static">[[thread.jthread.static]]</a>
 ``` cpp
-[[nodiscard]] static unsigned int hardware_concurrency() noexcept;
 ```
 *Returns:* `thread::hardware_concurrency()`.
 ### Namespace `this_thread` <a id="thread.thread.this">[[thread.thread.this]]</a>
@@ -1483,292 +1767,358 @@ Subclause [[atomics]] describes components for fine-grained atomic
 access. This access is provided via operations on atomic objects.
 ### Header `<atomic>` synopsis <a id="atomics.syn">[[atomics.syn]]</a>
 ``` cpp
 namespace std {
   // [atomics.order], order and consistency
-  enum class memory_order : unspecified;                                            // freestanding
-  inline constexpr memory_order memory_order_relaxed = memory_order::relaxed;       // freestanding
-  inline constexpr memory_order memory_order_consume = memory_order::consume;       // freestanding
-  inline constexpr memory_order memory_order_acquire = memory_order::acquire;       // freestanding
-  inline constexpr memory_order memory_order_release = memory_order::release;       // freestanding
-  inline constexpr memory_order memory_order_acq_rel = memory_order::acq_rel;       // freestanding
-  inline constexpr memory_order memory_order_seq_cst = memory_order::seq_cst;       // freestanding
-  template<class T>
-    T kill_dependency(T y) noexcept;                                                // freestanding
 }
 // [atomics.lockfree], lock-free property
-#define ATOMIC_BOOL_LOCK_FREE unspecified                                           // freestanding
-#define ATOMIC_CHAR_LOCK_FREE unspecified                                           // freestanding
-#define ATOMIC_CHAR8_T_LOCK_FREE unspecified                                        // freestanding
-#define ATOMIC_CHAR16_T_LOCK_FREE unspecified                                       // freestanding
-#define ATOMIC_CHAR32_T_LOCK_FREE unspecified                                       // freestanding
-#define ATOMIC_WCHAR_T_LOCK_FREE unspecified                                        // freestanding
-#define ATOMIC_SHORT_LOCK_FREE unspecified                                          // freestanding
-#define ATOMIC_INT_LOCK_FREE unspecified                                            // freestanding
-#define ATOMIC_LONG_LOCK_FREE unspecified                                           // freestanding
-#define ATOMIC_LLONG_LOCK_FREE unspecified                                          // freestanding
-#define ATOMIC_POINTER_LOCK_FREE unspecified                                        // freestanding
 namespace std {
   // [atomics.ref.generic], class template atomic_ref
-  template<class T> struct atomic_ref;                                              // freestanding
-  // [atomics.ref.pointer], partial specialization for pointers
-  template<class T> struct atomic_ref<T*>;                                          // freestanding
   // [atomics.types.generic], class template atomic
-  template<class T> struct atomic;                                                  // freestanding
   // [atomics.types.pointer], partial specialization for pointers
-  template<class T> struct atomic<T*>;                                              // freestanding
   // [atomics.nonmembers], non-member functions
   template<class T>
-    bool atomic_is_lock_free(const volatile atomic<T>*) noexcept;                   // freestanding
   template<class T>
-    bool atomic_is_lock_free(const atomic<T>*) noexcept;                            // freestanding
   template<class T>
-    void atomic_store(volatile atomic<T>*,                                          // freestanding
-                      typename atomic<T>::value_type) noexcept;
   template<class T>
-    void atomic_store(atomic<T>*, typename atomic<T>::value_type) noexcept;         // freestanding
   template<class T>
-    void atomic_store_explicit(volatile atomic<T>*,                                 // freestanding
-                               typename atomic<T>::value_type,
                                memory_order) noexcept;
   template<class T>
-    void atomic_store_explicit(atomic<T>*, typename atomic<T>::value_type,          // freestanding
                                          memory_order) noexcept;
   template<class T>
-    T atomic_load(const volatile atomic<T>*) noexcept;                              // freestanding
   template<class T>
-    T atomic_load(const atomic<T>*) noexcept;                                       // freestanding
   template<class T>
-    T atomic_load_explicit(const volatile atomic<T>*, memory_order) noexcept;       // freestanding
   template<class T>
-    T atomic_load_explicit(const atomic<T>*, memory_order) noexcept;                // freestanding
   template<class T>
-    T atomic_exchange(volatile atomic<T>*,                                          // freestanding
-                      typename atomic<T>::value_type) noexcept;
   template<class T>
-    T atomic_exchange(atomic<T>*, typename atomic<T>::value_type) noexcept;         // freestanding
   template<class T>
-    T atomic_exchange_explicit(volatile atomic<T>*,                                 // freestanding
-                               typename atomic<T>::value_type,
                                memory_order) noexcept;
   template<class T>
-    T atomic_exchange_explicit(atomic<T>*, typename atomic<T>::value_type,          // freestanding
                                          memory_order) noexcept;
   template<class T>
-    bool atomic_compare_exchange_weak(volatile atomic<T>*,                          // freestanding
                                       typename atomic<T>::value_type*,
                                       typename atomic<T>::value_type) noexcept;
   template<class T>
-    bool atomic_compare_exchange_weak(atomic<T>*,                                   // freestanding
                                                 typename atomic<T>::value_type*,
                                                 typename atomic<T>::value_type) noexcept;
   template<class T>
-    bool atomic_compare_exchange_strong(volatile atomic<T>*,                        // freestanding
                                         typename atomic<T>::value_type*,
                                         typename atomic<T>::value_type) noexcept;
   template<class T>
-    bool atomic_compare_exchange_strong(atomic<T>*,                                 // freestanding
                                                   typename atomic<T>::value_type*,
                                                   typename atomic<T>::value_type) noexcept;
   template<class T>
-    bool atomic_compare_exchange_weak_explicit(volatile atomic<T>*,                 // freestanding
                                                typename atomic<T>::value_type*,
                                                typename atomic<T>::value_type,
                                                memory_order, memory_order) noexcept;
   template<class T>
-    bool atomic_compare_exchange_weak_explicit(atomic<T>*,                          // freestanding
                                                          typename atomic<T>::value_type*,
                                                          typename atomic<T>::value_type,
                                                          memory_order, memory_order) noexcept;
   template<class T>
-    bool atomic_compare_exchange_strong_explicit(volatile atomic<T>*,               // freestanding
                                                  typename atomic<T>::value_type*,
                                                  typename atomic<T>::value_type,
                                                  memory_order, memory_order) noexcept;
   template<class T>
-    bool atomic_compare_exchange_strong_explicit(atomic<T>*,                        // freestanding
                                                            typename atomic<T>::value_type*,
                                                            typename atomic<T>::value_type,
                                                            memory_order, memory_order) noexcept;
   template<class T>
-    T atomic_fetch_add(volatile atomic<T>*,                                         // freestanding
-                       typename atomic<T>::difference_type) noexcept;
   template<class T>
-    T atomic_fetch_add(atomic<T>*, typename atomic<T>::difference_type) noexcept;   // freestanding
   template<class T>
-    T atomic_fetch_add_explicit(volatile atomic<T>*,                                // freestanding
-                                typename atomic<T>::difference_type,
                                 memory_order) noexcept;
   template<class T>
-    T atomic_fetch_add_explicit(atomic<T>*, typename atomic<T>::difference_type,    // freestanding
                                           memory_order) noexcept;
   template<class T>
-    T atomic_fetch_sub(volatile atomic<T>*,                                         // freestanding
-                       typename atomic<T>::difference_type) noexcept;
   template<class T>
-    T atomic_fetch_sub(atomic<T>*, typename atomic<T>::difference_type) noexcept;   // freestanding
   template<class T>
-    T atomic_fetch_sub_explicit(volatile atomic<T>*,                                // freestanding
-                                typename atomic<T>::difference_type,
                                 memory_order) noexcept;
   template<class T>
-    T atomic_fetch_sub_explicit(atomic<T>*, typename atomic<T>::difference_type,    // freestanding
                                           memory_order) noexcept;
   template<class T>
-    T atomic_fetch_and(volatile atomic<T>*,                                         // freestanding
-                       typename atomic<T>::value_type) noexcept;
   template<class T>
-    T atomic_fetch_and(atomic<T>*, typename atomic<T>::value_type) noexcept;        // freestanding
   template<class T>
-    T atomic_fetch_and_explicit(volatile atomic<T>*,                                // freestanding
-                                typename atomic<T>::value_type,
                                 memory_order) noexcept;
   template<class T>
-    T atomic_fetch_and_explicit(atomic<T>*, typename atomic<T>::value_type,         // freestanding
                                           memory_order) noexcept;
   template<class T>
-    T atomic_fetch_or(volatile atomic<T>*,                                          // freestanding
-                      typename atomic<T>::value_type) noexcept;
   template<class T>
-    T atomic_fetch_or(atomic<T>*, typename atomic<T>::value_type) noexcept;         // freestanding
   template<class T>
-    T atomic_fetch_or_explicit(volatile atomic<T>*,                                 // freestanding
-                               typename atomic<T>::value_type,
                                memory_order) noexcept;
   template<class T>
-    T atomic_fetch_or_explicit(atomic<T>*, typename atomic<T>::value_type,          // freestanding
                                          memory_order) noexcept;
   template<class T>
-    T atomic_fetch_xor(volatile atomic<T>*,                                         // freestanding
-                       typename atomic<T>::value_type) noexcept;
   template<class T>
-    T atomic_fetch_xor(atomic<T>*, typename atomic<T>::value_type) noexcept;        // freestanding
   template<class T>
-    T atomic_fetch_xor_explicit(volatile atomic<T>*,                                // freestanding
- typename atomic<T>::value_type,
                                 memory_order) noexcept;
   template<class T>
-    T atomic_fetch_xor_explicit(atomic<T>*, typename atomic<T>::value_type,         // freestanding
                                           memory_order) noexcept;
   template<class T>
-    void atomic_wait(const volatile atomic<T>*,                                     // freestanding
-                 typename atomic<T>::value_type) noexcept;
   template<class T>
-    void atomic_wait(const atomic<T>*, typename atomic<T>::value_type) noexcept;    // freestanding
   template<class T>
-    void atomic_wait_explicit(const volatile atomic<T>*,                            // freestanding
-                              typename atomic<T>::value_type,
                               memory_order) noexcept;
   template<class T>
-    void atomic_wait_explicit(const atomic<T>*, typename atomic<T>::value_type,     // freestanding
                                         memory_order) noexcept;
   template<class T>
-    void atomic_notify_one(volatile atomic<T>*) noexcept;                           // freestanding
   template<class T>
-    void atomic_notify_one(atomic<T>*) noexcept;                                    // freestanding
   template<class T>
-    void atomic_notify_all(volatile atomic<T>*) noexcept;                           // freestanding
   template<class T>
-    void atomic_notify_all(atomic<T>*) noexcept;                                    // freestanding
   // [atomics.alias], type aliases
-  using atomic_bool           = atomic<bool>;                                       // freestanding
-  using atomic_char           = atomic<char>;                                       // freestanding
-  using atomic_schar          = atomic<signed char>;                                // freestanding
-  using atomic_uchar          = atomic<unsigned char>;                              // freestanding
-  using atomic_short          = atomic<short>;                                      // freestanding
-  using atomic_ushort         = atomic<unsigned short>;                             // freestanding
-  using atomic_int            = atomic<int>;                                        // freestanding
-  using atomic_uint           = atomic<unsigned int>;                               // freestanding
-  using atomic_long           = atomic<long>;                                       // freestanding
-  using atomic_ulong          = atomic<unsigned long>;                              // freestanding
-  using atomic_llong          = atomic<long long>;                                  // freestanding
-  using atomic_ullong         = atomic<unsigned long long>;                         // freestanding
-  using atomic_char8_t        = atomic<char8_t>;                                    // freestanding
-  using atomic_char16_t       = atomic<char16_t>;                                   // freestanding
-  using atomic_char32_t       = atomic<char32_t>;                                   // freestanding
-  using atomic_wchar_t        = atomic<wchar_t>;                                    // freestanding
-  using atomic_int8_t         = atomic<int8_t>;                                     // freestanding
-  using atomic_uint8_t        = atomic<uint8_t>;                                    // freestanding
-  using atomic_int16_t        = atomic<int16_t>;                                    // freestanding
-  using atomic_uint16_t       = atomic<uint16_t>;                                   // freestanding
-  using atomic_int32_t        = atomic<int32_t>;                                    // freestanding
-  using atomic_uint32_t       = atomic<uint32_t>;                                   // freestanding
-  using atomic_int64_t        = atomic<int64_t>;                                    // freestanding
-  using atomic_uint64_t       = atomic<uint64_t>;                                   // freestanding
-  using atomic_int_least8_t   = atomic<int_least8_t>;                               // freestanding
-  using atomic_uint_least8_t  = atomic<uint_least8_t>;                              // freestanding
-  using atomic_int_least16_t  = atomic<int_least16_t>;                              // freestanding
-  using atomic_uint_least16_t = atomic<uint_least16_t>;                             // freestanding
-  using atomic_int_least32_t  = atomic<int_least32_t>;                              // freestanding
-  using atomic_uint_least32_t = atomic<uint_least32_t>;                             // freestanding
-  using atomic_int_least64_t  = atomic<int_least64_t>;                              // freestanding
-  using atomic_uint_least64_t = atomic<uint_least64_t>;                             // freestanding
-  using atomic_int_fast8_t    = atomic<int_fast8_t>;                                // freestanding
-  using atomic_uint_fast8_t   = atomic<uint_fast8_t>;                               // freestanding
-  using atomic_int_fast16_t   = atomic<int_fast16_t>;                               // freestanding
-  using atomic_uint_fast16_t  = atomic<uint_fast16_t>;                              // freestanding
-  using atomic_int_fast32_t   = atomic<int_fast32_t>;                               // freestanding
-  using atomic_uint_fast32_t  = atomic<uint_fast32_t>;                              // freestanding
-  using atomic_int_fast64_t   = atomic<int_fast64_t>;                               // freestanding
-  using atomic_uint_fast64_t  = atomic<uint_fast64_t>;                              // freestanding
-  using atomic_intptr_t       = atomic<intptr_t>;                                   // freestanding
-  using atomic_uintptr_t      = atomic<uintptr_t>;                                  // freestanding
-  using atomic_size_t         = atomic<size_t>;                                     // freestanding
-  using atomic_ptrdiff_t      = atomic<ptrdiff_t>;                                  // freestanding
-  using atomic_intmax_t       = atomic<intmax_t>;                                   // freestanding
-  using atomic_uintmax_t      = atomic<uintmax_t>;                                  // freestanding
-  using atomic_signed_lock_free   = see below;
-  using atomic_unsigned_lock_free = see below;
   // [atomics.flag], flag type and operations
-  struct atomic_flag;                                                               // freestanding
-  bool atomic_flag_test(const volatile atomic_flag*) noexcept;                      // freestanding
-  bool atomic_flag_test(const atomic_flag*) noexcept;                               // freestanding
-  bool atomic_flag_test_explicit(const volatile atomic_flag*,                       // freestanding
- memory_order) noexcept;
-  bool atomic_flag_test_explicit(const atomic_flag*, memory_order) noexcept;        // freestanding
-  bool atomic_flag_test_and_set(volatile atomic_flag*) noexcept;                    // freestanding
-  bool atomic_flag_test_and_set(atomic_flag*) noexcept;                             // freestanding
-  bool atomic_flag_test_and_set_explicit(volatile atomic_flag*,                     // freestanding
-                                         memory_order) noexcept;
- bool atomic_flag_test_and_set_explicit(atomic_flag*, memory_order) noexcept;      // freestanding
-  void atomic_flag_clear(volatile atomic_flag*) noexcept;                           // freestanding
-  void atomic_flag_clear(atomic_flag*) noexcept;                                    // freestanding
-  void atomic_flag_clear_explicit(volatile atomic_flag*, memory_order) noexcept;    // freestanding
-  void atomic_flag_clear_explicit(atomic_flag*, memory_order) noexcept;             // freestanding
-  void atomic_flag_wait(const volatile atomic_flag*, bool) noexcept;                // freestanding
-  void atomic_flag_wait(const atomic_flag*, bool) noexcept;                         // freestanding
-  void atomic_flag_wait_explicit(const volatile atomic_flag*,                       // freestanding
- bool, memory_order) noexcept;
-  void atomic_flag_wait_explicit(const atomic_flag*,                                // freestanding
-                                 bool, memory_order) noexcept;
-  void atomic_flag_notify_one(volatile atomic_flag*) noexcept;                      // freestanding
-  void atomic_flag_notify_one(atomic_flag*) noexcept;                               // freestanding
- void atomic_flag_notify_all(volatile atomic_flag*) noexcept;                      // freestanding
-  void atomic_flag_notify_all(atomic_flag*) noexcept;                               // freestanding
-  #define ATOMIC_FLAG_INIT see belownc                                                // freestanding
   // [atomics.fences], fences
-  extern "C" void atomic_thread_fence(memory_order) noexcept;                       // freestanding
-  extern "C" void atomic_signal_fence(memory_order) noexcept;                       // freestanding
 }
 ```
 ### Type aliases <a id="atomics.alias">[[atomics.alias]]</a>
@@ -1791,11 +2141,11 @@ operations [[atomics.wait]] are most efficient.
 ### Order and consistency <a id="atomics.order">[[atomics.order]]</a>
 ``` cpp
 namespace std {
   enum class memory_order : unspecified {
-    relaxed, consume, acquire, release, acq_rel, seq_cst
   };
 }
 ```
 The enumeration `memory_order` specifies the detailed regular
@@ -1805,21 +2155,15 @@ enumerated values and their meanings are as follows:
 - `memory_order::relaxed`: no operation orders memory.
 - `memory_order::release`, `memory_order::acq_rel`, and
   `memory_order::seq_cst`: a store operation performs a release
   operation on the affected memory location.
-- `memory_order::consume`: a load operation performs a consume operation
-  on the affected memory location. \[*Note 1*: Prefer
-  `memory_order::acquire`, which provides stronger guarantees than
-  `memory_order::consume`. Implementations have found it infeasible to
-  provide performance better than that of `memory_order::acquire`.
-  Specification revisions are under consideration. — *end note*]
 - `memory_order::acquire`, `memory_order::acq_rel`, and
   `memory_order::seq_cst`: a load operation performs an acquire
   operation on the affected memory location.
-[*Note 2*: Atomic operations specifying `memory_order::relaxed` are
 relaxed with respect to memory ordering. Implementations must still
 guarantee that any given atomic access to a particular atomic object be
 indivisible with respect to all other atomic accesses to that
 object. — *end note*]
@@ -1854,35 +2198,35 @@ S:
 - if a `memory_order::seq_cst` fence X happens before A and B is a
   `memory_order::seq_cst` operation, then X precedes B in S; and
 - if a `memory_order::seq_cst` fence X happens before A and B happens
   before a `memory_order::seq_cst` fence Y, then X precedes Y in S.
-[*Note 3*: This definition ensures that S is consistent with the
 modification order of any atomic object M. It also ensures that a
 `memory_order::seq_cst` load A of M gets its value either from the last
 modification of M that precedes A in S or from some
 non-`memory_order::seq_cst` modification of M that does not happen
 before any modification of M that precedes A in S. — *end note*]
-[*Note 4*: We do not require that S be consistent with “happens before”
 [[intro.races]]. This allows more efficient implementation of
 `memory_order::acquire` and `memory_order::release` on some machine
 architectures. It can produce surprising results when these are mixed
 with `memory_order::seq_cst` accesses. — *end note*]
-[*Note 5*: `memory_order::seq_cst` ensures sequential consistency only
 for a program that is free of data races and uses exclusively
 `memory_order::seq_cst` atomic operations. Any use of weaker ordering
 will invalidate this guarantee unless extreme care is used. In many
 cases, `memory_order::seq_cst` atomic operations are reorderable with
 respect to other atomic operations performed by the same
 thread. — *end note*]
 Implementations should ensure that no “out-of-thin-air” values are
 computed that circularly depend on their own computation.
-[*Note 6*:
 For example, with `x` and `y` initially zero,
 ``` cpp
 // Thread 1:
@@ -1901,11 +2245,11 @@ store of 42 to `y` is only possible if the store to `x` stores `42`,
 which circularly depends on the store to `y` storing `42`. Note that
 without this restriction, such an execution is possible.
 — *end note*]
-[*Note 7*:
 The recommendation similarly disallows `r1 == r2 == 42` in the following
 example, with `x` and `y` again initially zero:
 ``` cpp
@@ -1924,22 +2268,23 @@ if (r2 == 42) x.store(42, memory_order::relaxed);
 Atomic read-modify-write operations shall always read the last value (in
 the modification order) written before the write associated with the
 read-modify-write operation.
-Implementations should make atomic stores visible to atomic loads within
-a reasonable amount of time.
-``` cpp
-template<class T>
-  T kill_dependency(T y) noexcept;
-```
-*Effects:* The argument does not carry a dependency to the return
-value [[intro.multithread]].
-*Returns:* `y`.
 ### Lock-free property <a id="atomics.lockfree">[[atomics.lockfree]]</a>
 ``` cpp
 #define ATOMIC_BOOL_LOCK_FREE unspecified
@@ -2040,38 +2385,40 @@ namespace std {
   template<class T> struct atomic_ref {
   private:
     T* ptr;             // exposition only
   public:
-    using value_type = T;
     static constexpr size_t required_alignment = implementation-defined  // required alignment for atomic_ref type's operations;
     static constexpr bool is_always_lock_free = implementation-defined  // whether a given atomic_ref type's operations are always lock free;
     bool is_lock_free() const noexcept;
-    explicit atomic_ref(T&);
-    atomic_ref(const atomic_ref&) noexcept;
     atomic_ref& operator=(const atomic_ref&) = delete;
-    void store(T, memory_order = memory_order::seq_cst) const noexcept;
- T operator=(T) const noexcept;
- T load(memory_order = memory_order::seq_cst) const noexcept;
-    operator T() const noexcept;
- T exchange(T, memory_order = memory_order::seq_cst) const noexcept;
-    bool compare_exchange_weak(T&, T,
                                          memory_order, memory_order) const noexcept;
-    bool compare_exchange_strong(T&, T,
                                            memory_order, memory_order) const noexcept;
-    bool compare_exchange_weak(T&, T,
                                          memory_order = memory_order::seq_cst) const noexcept;
-    bool compare_exchange_strong(T&, T,
                                            memory_order = memory_order::seq_cst) const noexcept;
-    void wait(T, memory_order = memory_order::seq_cst) const noexcept;
-    void notify_one() const noexcept;
-    void notify_all() const noexcept;
   };
 }
 ```
 An `atomic_ref` object applies atomic operations [[atomics.general]] to
@@ -2096,10 +2443,13 @@ through any other `atomic_ref` referencing the same object.
 [*Note 1*: Atomic operations or the `atomic_ref` constructor can
 acquire a shared resource, such as a lock associated with the referenced
 object, to enable atomic operations to be applied to the referenced
 object. — *end note*]
 #### Operations <a id="atomics.ref.ops">[[atomics.ref.ops]]</a>
 ``` cpp
 static constexpr size_t required_alignment;
 ```
@@ -2128,94 +2478,103 @@ bool is_lock_free() const noexcept;
 *Returns:* `true` if operations on all objects of the type
 `atomic_ref<T>` are lock-free, `false` otherwise.
 ``` cpp
-atomic_ref(T& obj);
 ```
 *Preconditions:* The referenced object is aligned to
 `required_alignment`.
 *Ensures:* `*this` references `obj`.
 *Throws:* Nothing.
 ``` cpp
-atomic_ref(const atomic_ref& ref) noexcept;
 ```
 *Ensures:* `*this` references the object referenced by `ref`.
 ``` cpp
-void store(T desired, memory_order order = memory_order::seq_cst) const noexcept;
 ```
-*Preconditions:* The `order` argument is neither
-`memory_order::consume`, `memory_order::acquire`, nor
-`memory_order::acq_rel`.
 *Effects:* Atomically replaces the value referenced by `*ptr` with the
 value of `desired`. Memory is affected according to the value of
 `order`.
 ``` cpp
-T operator=(T desired) const noexcept;
 ```
 *Effects:* Equivalent to:
 ``` cpp
 store(desired);
 return desired;
 ```
 ``` cpp
-T load(memory_order order = memory_order::seq_cst) const noexcept;
 ```
-*Preconditions:* The `order` argument is neither `memory_order::release`
-nor `memory_order::acq_rel`.
 *Effects:* Memory is affected according to the value of `order`.
 *Returns:* Atomically returns the value referenced by `*ptr`.
 ``` cpp
-operator T() const noexcept;
 ```
 *Effects:* Equivalent to: `return load();`
 ``` cpp
-T exchange(T desired, memory_order order = memory_order::seq_cst) const noexcept;
 ```
 *Effects:* Atomically replaces the value referenced by `*ptr` with
 `desired`. Memory is affected according to the value of `order`. This
 operation is an atomic read-modify-write
 operation [[intro.multithread]].
 *Returns:* Atomically returns the value referenced by `*ptr` immediately
 before the effects.
 ``` cpp
-bool compare_exchange_weak(T& expected, T desired,
                            memory_order success, memory_order failure) const noexcept;
-bool compare_exchange_strong(T& expected, T desired,
                              memory_order success, memory_order failure) const noexcept;
-bool compare_exchange_weak(T& expected, T desired,
                            memory_order order = memory_order::seq_cst) const noexcept;
-bool compare_exchange_strong(T& expected, T desired,
                              memory_order order = memory_order::seq_cst) const noexcept;
 ```
-*Preconditions:* The `failure` argument is neither
-`memory_order::release` nor `memory_order::acq_rel`.
 *Effects:* Retrieves the value in `expected`. It then atomically
 compares the value representation of the value referenced by `*ptr` for
 equality with that previously retrieved from `expected`, and if `true`,
 replaces the value referenced by `*ptr` with that in `desired`. If and
@@ -2249,15 +2608,15 @@ compare-and-exchange is in a loop, the weak version will yield better
 performance on some platforms. When a weak compare-and-exchange would
 require a loop and a strong one would not, the strong one is
 preferable. — *end note*]
 ``` cpp
-void wait(T old, memory_order order = memory_order::seq_cst) const noexcept;
 ```
-*Preconditions:* `order` is neither `memory_order::release` nor
-`memory_order::acq_rel`.
 *Effects:* Repeatedly performs the following steps, in order:
 - Evaluates `load(order)` and compares its value representation for
   equality against that of `old`.
@@ -2267,102 +2626,131 @@ void wait(T old, memory_order order = memory_order::seq_cst) const noexcept;
 *Remarks:* This function is an atomic waiting operation [[atomics.wait]]
 on atomic object `*ptr`.
 ``` cpp
-void notify_one() const noexcept;
 ```
 *Effects:* Unblocks the execution of at least one atomic waiting
 operation on `*ptr` that is eligible to be unblocked [[atomics.wait]] by
 this call, if any such atomic waiting operations exist.
 *Remarks:* This function is an atomic notifying
 operation [[atomics.wait]] on atomic object `*ptr`.
 ``` cpp
-void notify_all() const noexcept;
 ```
 *Effects:* Unblocks the execution of all atomic waiting operations on
 `*ptr` that are eligible to be unblocked [[atomics.wait]] by this call.
 *Remarks:* This function is an atomic notifying
 operation [[atomics.wait]] on atomic object `*ptr`.
 #### Specializations for integral types <a id="atomics.ref.int">[[atomics.ref.int]]</a>
-There are specializations of the `atomic_ref` class template for the
-integral types `char`, `signed char`, `unsigned char`, `short`,
-`unsigned short`, `int`, `unsigned int`, `long`, `unsigned long`,
-`long long`, `unsigned long long`, `char8_t`, `char16_t`, `char32_t`,
-`wchar_t`, and any other types needed by the typedefs in the header
-`<cstdint>`. For each such type `integral-type`, the specialization
-`atomic_ref<integral-type>` provides additional atomic operations
-appropriate to integral types.
 [*Note 1*: The specialization `atomic_ref<bool>` uses the primary
 template [[atomics.ref.generic]]. — *end note*]
 ``` cpp
 namespace std {
   template<> struct atomic_ref<integral-type> {
   private:
     integral-type* ptr;         // exposition only
   public:
-    using value_type = integral-type;
     using difference_type = value_type;
     static constexpr size_t required_alignment = implementation-defined  // required alignment for atomic_ref type's operations;
     static constexpr bool is_always_lock_free = implementation-defined  // whether a given atomic_ref type's operations are always lock free;
     bool is_lock_free() const noexcept;
-    explicit atomic_ref(integral-type&);
-    atomic_ref(const atomic_ref&) noexcept;
     atomic_ref& operator=(const atomic_ref&) = delete;
-    void store(integral-type, memory_order = memory_order::seq_cst) const noexcept;
- integral-type operator=(integral-type) const noexcept;
- integral-type load(memory_order = memory_order::seq_cst) const noexcept;
-    operator integral-type() const noexcept;
- integral-type exchange(integral-type,
                                   memory_order = memory_order::seq_cst) const noexcept;
-    bool compare_exchange_weak(integral-type&, integral-type,
                                          memory_order, memory_order) const noexcept;
-    bool compare_exchange_strong(integral-type&, integral-type,
                                            memory_order, memory_order) const noexcept;
-    bool compare_exchange_weak(integral-type&, integral-type,
                                          memory_order = memory_order::seq_cst) const noexcept;
-    bool compare_exchange_strong(integral-type&, integral-type,
                                            memory_order = memory_order::seq_cst) const noexcept;
- integral-type fetch_add(integral-type,
                                    memory_order = memory_order::seq_cst) const noexcept;
- integral-type fetch_sub(integral-type,
                                    memory_order = memory_order::seq_cst) const noexcept;
- integral-type fetch_and(integral-type,
                                    memory_order = memory_order::seq_cst) const noexcept;
- integral-type fetch_or(integral-type,
                                   memory_order = memory_order::seq_cst) const noexcept;
- integral-type fetch_xor(integral-type,
                              memory_order = memory_order::seq_cst) const noexcept;
- integral-type operator++(int) const noexcept;
- integral-type operator--(int) const noexcept;
- integral-type operator++() const noexcept;
- integral-type operator--() const noexcept;
- integral-type operator+=(integral-type) const noexcept;
- integral-type operator-=(integral-type) const noexcept;
- integral-type operator&=(integral-type) const noexcept;
- integral-type operator|=(integral-type) const noexcept;
- integral-type operator^=(integral-type) const noexcept;
-    void wait(integral-type, memory_order = memory_order::seq_cst) const noexcept;
-    void notify_one() const noexcept;
-    void notify_all() const noexcept;
   };
 }
 ```
 Descriptions are provided below only for members that differ from the
@@ -2371,107 +2759,177 @@ primary template.
 The following operations perform arithmetic computations. The
 correspondence among key, operator, and computation is specified in
 [[atomic.types.int.comp]].
 ``` cpp
-integral-type fetch_key(integral-type operand,
   memory_order order = memory_order::seq_cst) const noexcept;
 ```
 *Effects:* Atomically replaces the value referenced by `*ptr` with the
 result of the computation applied to the value referenced by `*ptr` and
 the given operand. Memory is affected according to the value of `order`.
 These operations are atomic read-modify-write
 operations [[intro.races]].
 *Returns:* Atomically, the value referenced by `*ptr` immediately before
 the effects.
-*Remarks:* For signed integer types, the result is as if the object
-value and parameters were converted to their corresponding unsigned
-types, the computation performed on those types, and the result
-converted back to the signed type.
 [*Note 1*: There are no undefined results arising from the
 computation. — *end note*]
 ``` cpp
-integral-type operator op=(integral-type operand) const noexcept;
 ```
 *Effects:* Equivalent to:
 `return fetch_`*`key`*`(operand) `*`op`*` operand;`
 #### Specializations for floating-point types <a id="atomics.ref.float">[[atomics.ref.float]]</a>
 There are specializations of the `atomic_ref` class template for all
-cv-unqualified floating-point types. For each such type
-`floating-point-type`, the specialization `atomic_ref<floating-point>`
-provides additional atomic operations appropriate to floating-point
-types.
 ``` cpp
 namespace std {
   template<> struct atomic_ref<floating-point-type> {
   private:
     floating-point-type* ptr;   // exposition only
   public:
-    using value_type = floating-point-type;
     using difference_type = value_type;
     static constexpr size_t required_alignment = implementation-defined  // required alignment for atomic_ref type's operations;
     static constexpr bool is_always_lock_free = implementation-defined  // whether a given atomic_ref type's operations are always lock free;
     bool is_lock_free() const noexcept;
-    explicit atomic_ref(floating-point-type&);
-    atomic_ref(const atomic_ref&) noexcept;
     atomic_ref& operator=(const atomic_ref&) = delete;
-    void store(floating-point-type, memory_order = memory_order::seq_cst) const noexcept;
-    floating-point-type operator=(floating-point-type) const noexcept;
- floating-point-type load(memory_order = memory_order::seq_cst) const noexcept;
- operator floating-point-type() const noexcept;
- floating-point-type exchange(floating-point-type,
                                   memory_order = memory_order::seq_cst) const noexcept;
-    bool compare_exchange_weak(floating-point-type&, floating-point-type,
                                          memory_order, memory_order) const noexcept;
-    bool compare_exchange_strong(floating-point-type&, floating-point-type,
                                            memory_order, memory_order) const noexcept;
-    bool compare_exchange_weak(floating-point-type&, floating-point-type,
                                    memory_order = memory_order::seq_cst) const noexcept;
- bool compare_exchange_strong(floating-point-type&, floating-point-type,
                                             memory_order = memory_order::seq_cst) const noexcept;
- floating-point-type fetch_add(floating-point-type,
                                   memory_order = memory_order::seq_cst) const noexcept;
- floating-point-type fetch_sub(floating-point-type,
                                       memory_order = memory_order::seq_cst) const noexcept;
- floating-point-type operator+=(floating-point-type) const noexcept;
- floating-point-type operator-=(floating-point-type) const noexcept;
-    void wait(floating-point-type, memory_order = memory_order::seq_cst) const noexcept;
-    void notify_one() const noexcept;
-    void notify_all() const noexcept;
   };
 }
 ```
 Descriptions are provided below only for members that differ from the
 primary template.
 The following operations perform arithmetic computations. The
 correspondence among key, operator, and computation is specified in
-[[atomic.types.int.comp]].
 ``` cpp
-floating-point-type fetch_key(floating-point-type operand,
                           memory_order order = memory_order::seq_cst) const noexcept;
 ```
 *Effects:* Atomically replaces the value referenced by `*ptr` with the
 result of the computation applied to the value referenced by `*ptr` and
 the given operand. Memory is affected according to the value of `order`.
 These operations are atomic read-modify-write
 operations [[intro.races]].
@@ -2481,71 +2939,167 @@ the effects.
 *Remarks:* If the result is not a representable value for its
 type [[expr.pre]], the result is unspecified, but the operations
 otherwise have no undefined behavior. Atomic arithmetic operations on
 *`floating-point-type`* should conform to the
-`std::numeric_limits<`*`floating-point-type`*`>` traits associated with
-the floating-point type [[limits.syn]]. The floating-point
 environment [[cfenv]] for atomic arithmetic operations on
 *`floating-point-type`* may be different than the calling thread’s
 floating-point environment.
 ``` cpp
-floating-point-type operator op=(floating-point-type operand) const noexcept;
 ```
 *Effects:* Equivalent to:
 `return fetch_`*`key`*`(operand) `*`op`*` operand;`
-#### Partial specialization for pointers <a id="atomics.ref.pointer">[[atomics.ref.pointer]]</a>
 ``` cpp
 namespace std {
-  template<class T> struct atomic_ref<T*> {
   private:
- T** ptr;        // exposition only
   public:
-    using value_type = T*;
     using difference_type = ptrdiff_t;
     static constexpr size_t required_alignment = implementation-defined  // required alignment for atomic_ref type's operations;
     static constexpr bool is_always_lock_free = implementation-defined  // whether a given atomic_ref type's operations are always lock free;
     bool is_lock_free() const noexcept;
-    explicit atomic_ref(T*&);
-    atomic_ref(const atomic_ref&) noexcept;
     atomic_ref& operator=(const atomic_ref&) = delete;
-    void store(T*, memory_order = memory_order::seq_cst) const noexcept;
- T* operator=(T*) const noexcept;
- T* load(memory_order = memory_order::seq_cst) const noexcept;
-    operator T*() const noexcept;
- T* exchange(T*, memory_order = memory_order::seq_cst) const noexcept;
-    bool compare_exchange_weak(T*&, T*,
                                          memory_order, memory_order) const noexcept;
-    bool compare_exchange_strong(T*&, T*,
                                            memory_order, memory_order) const noexcept;
-    bool compare_exchange_weak(T*&, T*,
                                    memory_order = memory_order::seq_cst) const noexcept;
- bool compare_exchange_strong(T*&, T*,
                                    memory_order = memory_order::seq_cst) const noexcept;
- T* fetch_add(difference_type, memory_order = memory_order::seq_cst) const noexcept;
-    T* fetch_sub(difference_type, memory_order = memory_order::seq_cst) const noexcept;
- T* operator++(int) const noexcept;
- T* operator--(int) const noexcept;
- T* operator++() const noexcept;
- T* operator--() const noexcept;
- T* operator+=(difference_type) const noexcept;
- T* operator-=(difference_type) const noexcept;
-    void wait(T*, memory_order = memory_order::seq_cst) const noexcept;
-    void notify_one() const noexcept;
-    void notify_all() const noexcept;
   };
 }
 ```
 Descriptions are provided below only for members that differ from the
@@ -2554,14 +3108,18 @@ primary template.
 The following operations perform arithmetic computations. The
 correspondence among key, operator, and computation is specified in
 [[atomic.types.pointer.comp]].
 ``` cpp
-T* fetch_key(difference_type operand, memory_order order = memory_order::seq_cst) const noexcept;
 ```
-*Mandates:* `T` is a complete object type.
 *Effects:* Atomically replaces the value referenced by `*ptr` with the
 result of the computation applied to the value referenced by `*ptr` and
 the given operand. Memory is affected according to the value of `order`.
 These operations are atomic read-modify-write
@@ -2571,41 +3129,91 @@ operations [[intro.races]].
 the effects.
 *Remarks:* The result may be an undefined address, but the operations
 otherwise have no undefined behavior.
 ``` cpp
-T* operator op=(difference_type operand) const noexcept;
 ```
 *Effects:* Equivalent to:
 `return fetch_`*`key`*`(operand) `*`op`*` operand;`
 #### Member operators common to integers and pointers to objects <a id="atomics.ref.memop">[[atomics.ref.memop]]</a>
 ``` cpp
-value_type operator++(int) const noexcept;
 ```
 *Effects:* Equivalent to: `return fetch_add(1);`
 ``` cpp
-value_type operator--(int) const noexcept;
 ```
 *Effects:* Equivalent to: `return fetch_sub(1);`
 ``` cpp
-value_type operator++() const noexcept;
 ```
 *Effects:* Equivalent to: `return fetch_add(1) + 1;`
 ``` cpp
-value_type operator--() const noexcept;
 ```
 *Effects:* Equivalent to: `return fetch_sub(1) - 1;`
 ### Class template `atomic` <a id="atomics.types.generic">[[atomics.types.generic]]</a>
 #### General <a id="atomics.types.generic.general">[[atomics.types.generic.general]]</a>
@@ -2625,35 +3233,35 @@ namespace std {
     atomic(const atomic&) = delete;
     atomic& operator=(const atomic&) = delete;
     atomic& operator=(const atomic&) volatile = delete;
     T load(memory_order = memory_order::seq_cst) const volatile noexcept;
-    T load(memory_order = memory_order::seq_cst) const noexcept;
     operator T() const volatile noexcept;
-    operator T() const noexcept;
     void store(T, memory_order = memory_order::seq_cst) volatile noexcept;
-    void store(T, memory_order = memory_order::seq_cst) noexcept;
     T operator=(T) volatile noexcept;
-    T operator=(T) noexcept;
     T exchange(T, memory_order = memory_order::seq_cst) volatile noexcept;
-    T exchange(T, memory_order = memory_order::seq_cst) noexcept;
     bool compare_exchange_weak(T&, T, memory_order, memory_order) volatile noexcept;
-    bool compare_exchange_weak(T&, T, memory_order, memory_order) noexcept;
     bool compare_exchange_strong(T&, T, memory_order, memory_order) volatile noexcept;
-    bool compare_exchange_strong(T&, T, memory_order, memory_order) noexcept;
     bool compare_exchange_weak(T&, T, memory_order = memory_order::seq_cst) volatile noexcept;
-    bool compare_exchange_weak(T&, T, memory_order = memory_order::seq_cst) noexcept;
     bool compare_exchange_strong(T&, T, memory_order = memory_order::seq_cst) volatile noexcept;
-    bool compare_exchange_strong(T&, T, memory_order = memory_order::seq_cst) noexcept;
     void wait(T, memory_order = memory_order::seq_cst) const volatile noexcept;
-    void wait(T, memory_order = memory_order::seq_cst) const noexcept;
     void notify_one() volatile noexcept;
-    void notify_one() noexcept;
     void notify_all() volatile noexcept;
-    void notify_all() noexcept;
   };
 }
 ```
 The template argument for `T` shall meet the *Cpp17CopyConstructible*
@@ -2661,19 +3269,21 @@ and *Cpp17CopyAssignable* requirements. The program is ill-formed if any
 of
 - `is_trivially_copyable_v<T>`,
 - `is_copy_constructible_v<T>`,
 - `is_move_constructible_v<T>`,
-- `is_copy_assignable_v<T>`, or
-- `is_move_assignable_v<T>`
 is `false`.
 [*Note 1*: Type arguments that are not also statically initializable
 can be difficult to use. — *end note*]
-The specialization `atomic<bool>` is a standard-layout struct.
 [*Note 2*: The representation of an atomic specialization need not have
 the same size and alignment requirement as its corresponding argument
 type. — *end note*]
@@ -2681,11 +3291,11 @@ type. — *end note*]
 ``` cpp
 constexpr atomic() noexcept(is_nothrow_default_constructible_v<T>);
 ```
-*Mandates:* `is_default_constructible_v<T>` is `true`.
 *Effects:* Initializes the atomic object with the value of `T()`.
 Initialization is not an atomic operation [[intro.multithread]].
 ``` cpp
@@ -2725,27 +3335,26 @@ otherwise.
 consistent with the value of `is_always_lock_free` for the same
 type. — *end note*]
 ``` cpp
 void store(T desired, memory_order order = memory_order::seq_cst) volatile noexcept;
-void store(T desired, memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
-*Preconditions:* The `order` argument is neither
-`memory_order::consume`, `memory_order::acquire`, nor
-`memory_order::acq_rel`.
 *Effects:* Atomically replaces the value pointed to by `this` with the
 value of `desired`. Memory is affected according to the value of
 `order`.
 ``` cpp
 T operator=(T desired) volatile noexcept;
-T operator=(T desired) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
@@ -2753,36 +3362,36 @@ T operator=(T desired) noexcept;
 *Returns:* `desired`.
 ``` cpp
 T load(memory_order order = memory_order::seq_cst) const volatile noexcept;
-T load(memory_order order = memory_order::seq_cst) const noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
-*Preconditions:* The `order` argument is neither `memory_order::release`
-nor `memory_order::acq_rel`.
 *Effects:* Memory is affected according to the value of `order`.
 *Returns:* Atomically returns the value pointed to by `this`.
 ``` cpp
 operator T() const volatile noexcept;
-operator T() const noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
 *Effects:* Equivalent to: `return load();`
 ``` cpp
 T exchange(T desired, memory_order order = memory_order::seq_cst) volatile noexcept;
-T exchange(T desired, memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
@@ -2795,31 +3404,31 @@ operations [[intro.multithread]].
 before the effects.
 ``` cpp
 bool compare_exchange_weak(T& expected, T desired,
                            memory_order success, memory_order failure) volatile noexcept;
-bool compare_exchange_weak(T& expected, T desired,
                            memory_order success, memory_order failure) noexcept;
 bool compare_exchange_strong(T& expected, T desired,
                              memory_order success, memory_order failure) volatile noexcept;
-bool compare_exchange_strong(T& expected, T desired,
                              memory_order success, memory_order failure) noexcept;
 bool compare_exchange_weak(T& expected, T desired,
                            memory_order order = memory_order::seq_cst) volatile noexcept;
-bool compare_exchange_weak(T& expected, T desired,
                            memory_order order = memory_order::seq_cst) noexcept;
 bool compare_exchange_strong(T& expected, T desired,
                              memory_order order = memory_order::seq_cst) volatile noexcept;
-bool compare_exchange_strong(T& expected, T desired,
                              memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
-*Preconditions:* The `failure` argument is neither
-`memory_order::release` nor `memory_order::acq_rel`.
 *Effects:* Retrieves the value in `expected`. It then atomically
 compares the value representation of the value pointed to by `this` for
 equality with that previously retrieved from `expected`, and if true,
 replaces the value pointed to by `this` with that in `desired`. If and
@@ -2904,14 +3513,14 @@ preferable. — *end note*]
 [*Note 6*: Under cases where the `memcpy` and `memcmp` semantics of the
 compare-and-exchange operations apply, the comparisons can fail for
 values that compare equal with `operator==` if the value representation
 has trap bits or alternate representations of the same value. Notably,
-on implementations conforming to ISO/IEC/IEEE 60559, floating-point
-`-0.0` and `+0.0` will not compare equal with `memcmp` but will compare
-equal with `operator==`, and NaNs with the same payload will compare
-equal with `memcmp` but will not compare equal with
 `operator==`. — *end note*]
 [*Note 7*:
 Because compare-and-exchange acts on an object’s value representation,
@@ -2958,15 +3567,15 @@ bool party(pony desired) {
 — *end note*]
 ``` cpp
 void wait(T old, memory_order order = memory_order::seq_cst) const volatile noexcept;
-void wait(T old, memory_order order = memory_order::seq_cst) const noexcept;
 ```
-*Preconditions:* `order` is neither `memory_order::release` nor
-`memory_order::acq_rel`.
 *Effects:* Repeatedly performs the following steps, in order:
 - Evaluates `load(order)` and compares its value representation for
   equality against that of `old`.
@@ -2977,11 +3586,11 @@ void wait(T old, memory_order order = memory_order::seq_cst) const noexcept;
 *Remarks:* This function is an atomic waiting
 operation [[atomics.wait]].
 ``` cpp
 void notify_one() volatile noexcept;
-void notify_one() noexcept;
 ```
 *Effects:* Unblocks the execution of at least one atomic waiting
 operation that is eligible to be unblocked [[atomics.wait]] by this
 call, if any such atomic waiting operations exist.
@@ -2989,11 +3598,11 @@ call, if any such atomic waiting operations exist.
 *Remarks:* This function is an atomic notifying
 operation [[atomics.wait]].
 ``` cpp
 void notify_all() volatile noexcept;
-void notify_all() noexcept;
 ```
 *Effects:* Unblocks the execution of all atomic waiting operations that
 are eligible to be unblocked [[atomics.wait]] by this call.
@@ -3029,85 +3638,122 @@ namespace std {
     atomic(const atomic&) = delete;
     atomic& operator=(const atomic&) = delete;
     atomic& operator=(const atomic&) volatile = delete;
     void store(integral-type, memory_order = memory_order::seq_cst) volatile noexcept;
-    void store(integral-type, memory_order = memory_order::seq_cst) noexcept;
     integral-type operator=(integral-type) volatile noexcept;
-    integral-type operator=(integral-type) noexcept;
     integral-type load(memory_order = memory_order::seq_cst) const volatile noexcept;
-    integral-type load(memory_order = memory_order::seq_cst) const noexcept;
     operator integral-type() const volatile noexcept;
-    operator integral-type() const noexcept;
     integral-type exchange(integral-type,
                            memory_order = memory_order::seq_cst) volatile noexcept;
-    integral-type exchange(integral-type,
                            memory_order = memory_order::seq_cst) noexcept;
     bool compare_exchange_weak(integral-type&, integral-type,
                                memory_order, memory_order) volatile noexcept;
-    bool compare_exchange_weak(integral-type&, integral-type,
                                memory_order, memory_order) noexcept;
     bool compare_exchange_strong(integral-type&, integral-type,
                                  memory_order, memory_order) volatile noexcept;
-    bool compare_exchange_strong(integral-type&, integral-type,
                                  memory_order, memory_order) noexcept;
     bool compare_exchange_weak(integral-type&, integral-type,
                                memory_order = memory_order::seq_cst) volatile noexcept;
-    bool compare_exchange_weak(integral-type&, integral-type,
                                memory_order = memory_order::seq_cst) noexcept;
     bool compare_exchange_strong(integral-type&, integral-type,
                                  memory_order = memory_order::seq_cst) volatile noexcept;
-    bool compare_exchange_strong(integral-type&, integral-type,
                                  memory_order = memory_order::seq_cst) noexcept;
     integral-type fetch_add(integral-type,
                             memory_order = memory_order::seq_cst) volatile noexcept;
-    integral-type fetch_add(integral-type,
                             memory_order = memory_order::seq_cst) noexcept;
     integral-type fetch_sub(integral-type,
                             memory_order = memory_order::seq_cst) volatile noexcept;
-    integral-type fetch_sub(integral-type,
                             memory_order = memory_order::seq_cst) noexcept;
     integral-type fetch_and(integral-type,
                             memory_order = memory_order::seq_cst) volatile noexcept;
-    integral-type fetch_and(integral-type,
                             memory_order = memory_order::seq_cst) noexcept;
     integral-type fetch_or(integral-type,
                             memory_order = memory_order::seq_cst) volatile noexcept;
-    integral-type fetch_or(integral-type,
                             memory_order = memory_order::seq_cst) noexcept;
     integral-type fetch_xor(integral-type,
                             memory_order = memory_order::seq_cst) volatile noexcept;
-    integral-type fetch_xor(integral-type,
                              memory_order = memory_order::seq_cst) noexcept;
     integral-type operator++(int) volatile noexcept;
-    integral-type operator++(int) noexcept;
     integral-type operator--(int) volatile noexcept;
-    integral-type operator--(int) noexcept;
     integral-type operator++() volatile noexcept;
-    integral-type operator++() noexcept;
     integral-type operator--() volatile noexcept;
-    integral-type operator--() noexcept;
     integral-type operator+=(integral-type) volatile noexcept;
-    integral-type operator+=(integral-type) noexcept;
     integral-type operator-=(integral-type) volatile noexcept;
-    integral-type operator-=(integral-type) noexcept;
     integral-type operator&=(integral-type) volatile noexcept;
-    integral-type operator&=(integral-type) noexcept;
     integral-type operator|=(integral-type) volatile noexcept;
-    integral-type operator|=(integral-type) noexcept;
     integral-type operator^=(integral-type) volatile noexcept;
-    integral-type operator^=(integral-type) noexcept;
     void wait(integral-type, memory_order = memory_order::seq_cst) const volatile noexcept;
-    void wait(integral-type, memory_order = memory_order::seq_cst) const noexcept;
     void notify_one() volatile noexcept;
-    void notify_one() noexcept;
     void notify_all() volatile noexcept;
-    void notify_all() noexcept;
   };
 }
 ```
 The atomic integral specializations are standard-layout structs. They
@@ -3121,18 +3767,21 @@ correspondence among key, operator, and computation is specified in
 [[atomic.types.int.comp]].
 **Table: Atomic arithmetic computations** <a id="atomic.types.int.comp">[atomic.types.int.comp]</a>
 |       |     |             |       |     |                      |
-| ----- | --- | -------------------- | ----- | --- | -------------------- |
-| `add` | `+` | addition | `sub` | `-` | subtraction          |
-| `or` | `|` | bitwise inclusive or | `xor` | `^` | bitwise exclusive or |
-| `and` | `&` | bitwise and          |       |     |                      |
 ``` cpp
-T fetch_key(T operand, memory_order order = memory_order::seq_cst) volatile noexcept;
-T fetch_key(T operand, memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
@@ -3143,21 +3792,59 @@ the given `operand`. Memory is affected according to the value of
 operations [[intro.multithread]].
 *Returns:* Atomically, the value pointed to by `this` immediately before
 the effects.
-*Remarks:* For signed integer types, the result is as if the object
-value and parameters were converted to their corresponding unsigned
-types, the computation performed on those types, and the result
-converted back to the signed type.
 [*Note 1*: There are no undefined results arising from the
 computation. — *end note*]
 ``` cpp
-T operator op=(T operand) volatile noexcept;
-T operator op=(T operand) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
@@ -3187,59 +3874,117 @@ namespace std {
     atomic(const atomic&) = delete;
     atomic& operator=(const atomic&) = delete;
     atomic& operator=(const atomic&) volatile = delete;
     void store(floating-point-type, memory_order = memory_order::seq_cst) volatile noexcept;
-    void store(floating-point-type, memory_order = memory_order::seq_cst) noexcept;
     floating-point-type operator=(floating-point-type) volatile noexcept;
-    floating-point-type operator=(floating-point-type) noexcept;
     floating-point-type load(memory_order = memory_order::seq_cst) volatile noexcept;
-    floating-point-type load(memory_order = memory_order::seq_cst) noexcept;
     operator floating-point-type() volatile noexcept;
-    operator floating-point-type() noexcept;
     floating-point-type exchange(floating-point-type,
                                  memory_order = memory_order::seq_cst) volatile noexcept;
-    floating-point-type exchange(floating-point-type,
                                            memory_order = memory_order::seq_cst) noexcept;
     bool compare_exchange_weak(floating-point-type&, floating-point-type,
                                memory_order, memory_order) volatile noexcept;
-    bool compare_exchange_weak(floating-point-type&, floating-point-type,
                                          memory_order, memory_order) noexcept;
     bool compare_exchange_strong(floating-point-type&, floating-point-type,
                                  memory_order, memory_order) volatile noexcept;
-    bool compare_exchange_strong(floating-point-type&, floating-point-type,
                                            memory_order, memory_order) noexcept;
     bool compare_exchange_weak(floating-point-type&, floating-point-type,
                                memory_order = memory_order::seq_cst) volatile noexcept;
-    bool compare_exchange_weak(floating-point-type&, floating-point-type,
                                          memory_order = memory_order::seq_cst) noexcept;
     bool compare_exchange_strong(floating-point-type&, floating-point-type,
                                  memory_order = memory_order::seq_cst) volatile noexcept;
-    bool compare_exchange_strong(floating-point-type&, floating-point-type,
                                            memory_order = memory_order::seq_cst) noexcept;
     floating-point-type fetch_add(floating-point-type,
                                   memory_order = memory_order::seq_cst) volatile noexcept;
-    floating-point-type fetch_add(floating-point-type,
                                             memory_order = memory_order::seq_cst) noexcept;
     floating-point-type fetch_sub(floating-point-type,
                                   memory_order = memory_order::seq_cst) volatile noexcept;
-    floating-point-type fetch_sub(floating-point-type,
                                       memory_order = memory_order::seq_cst) noexcept;
     floating-point-type operator+=(floating-point-type) volatile noexcept;
-    floating-point-type operator+=(floating-point-type) noexcept;
     floating-point-type operator-=(floating-point-type) volatile noexcept;
-    floating-point-type operator-=(floating-point-type) noexcept;
     void wait(floating-point-type, memory_order = memory_order::seq_cst) const volatile noexcept;
-    void wait(floating-point-type, memory_order = memory_order::seq_cst) const noexcept;
     void notify_one() volatile noexcept;
-    void notify_one() noexcept;
     void notify_all() volatile noexcept;
-    void notify_all() noexcept;
   };
 }
 ```
 The atomic floating-point specializations are standard-layout structs.
@@ -3248,15 +3993,19 @@ They each have a trivial destructor.
 Descriptions are provided below only for members that differ from the
 primary template.
 The following operations perform arithmetic addition and subtraction
 computations. The correspondence among key, operator, and computation is
-specified in [[atomic.types.int.comp]].
 ``` cpp
-T fetch_key(T operand, memory_order order = memory_order::seq_cst) volatile noexcept;
-T fetch_key(T operand, memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
@@ -3277,13 +4026,92 @@ otherwise have no undefined behavior. Atomic arithmetic operations on
 the floating-point type [[limits.syn]]. The floating-point
 environment [[cfenv]] for atomic arithmetic operations on
 *`floating-point-type`* may be different than the calling thread’s
 floating-point environment.
 ``` cpp
-T operator op=(T operand) volatile noexcept;
-T operator op=(T operand) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
@@ -3317,57 +4145,70 @@ namespace std {
     atomic(const atomic&) = delete;
     atomic& operator=(const atomic&) = delete;
     atomic& operator=(const atomic&) volatile = delete;
     void store(T*, memory_order = memory_order::seq_cst) volatile noexcept;
-    void store(T*, memory_order = memory_order::seq_cst) noexcept;
     T* operator=(T*) volatile noexcept;
-    T* operator=(T*) noexcept;
     T* load(memory_order = memory_order::seq_cst) const volatile noexcept;
-    T* load(memory_order = memory_order::seq_cst) const noexcept;
     operator T*() const volatile noexcept;
-    operator T*() const noexcept;
     T* exchange(T*, memory_order = memory_order::seq_cst) volatile noexcept;
-    T* exchange(T*, memory_order = memory_order::seq_cst) noexcept;
     bool compare_exchange_weak(T*&, T*, memory_order, memory_order) volatile noexcept;
-    bool compare_exchange_weak(T*&, T*, memory_order, memory_order) noexcept;
     bool compare_exchange_strong(T*&, T*, memory_order, memory_order) volatile noexcept;
-    bool compare_exchange_strong(T*&, T*, memory_order, memory_order) noexcept;
     bool compare_exchange_weak(T*&, T*,
                                memory_order = memory_order::seq_cst) volatile noexcept;
-    bool compare_exchange_weak(T*&, T*,
                                memory_order = memory_order::seq_cst) noexcept;
     bool compare_exchange_strong(T*&, T*,
                                  memory_order = memory_order::seq_cst) volatile noexcept;
-    bool compare_exchange_strong(T*&, T*,
                                  memory_order = memory_order::seq_cst) noexcept;
     T* fetch_add(ptrdiff_t, memory_order = memory_order::seq_cst) volatile noexcept;
-    T* fetch_add(ptrdiff_t, memory_order = memory_order::seq_cst) noexcept;
     T* fetch_sub(ptrdiff_t, memory_order = memory_order::seq_cst) volatile noexcept;
-    T* fetch_sub(ptrdiff_t, memory_order = memory_order::seq_cst) noexcept;
     T* operator++(int) volatile noexcept;
-    T* operator++(int) noexcept;
     T* operator--(int) volatile noexcept;
-    T* operator--(int) noexcept;
     T* operator++() volatile noexcept;
-    T* operator++() noexcept;
     T* operator--() volatile noexcept;
-    T* operator--() noexcept;
     T* operator+=(ptrdiff_t) volatile noexcept;
-    T* operator+=(ptrdiff_t) noexcept;
     T* operator-=(ptrdiff_t) volatile noexcept;
-    T* operator-=(ptrdiff_t) noexcept;
     void wait(T*, memory_order = memory_order::seq_cst) const volatile noexcept;
-    void wait(T*, memory_order = memory_order::seq_cst) const noexcept;
     void notify_one() volatile noexcept;
-    void notify_one() noexcept;
     void notify_all() volatile noexcept;
-    void notify_all() noexcept;
   };
 }
 ```
 There is a partial specialization of the `atomic` class template for
@@ -3384,14 +4225,15 @@ among key, operator, and computation is specified in
 **Table: Atomic pointer computations** <a id="atomic.types.pointer.comp">[atomic.types.pointer.comp]</a>
 |       |     |          |       |     |             |
 | ----- | --- | -------- | ----- | --- | ----------- |
 | `add` | `+` | addition | `sub` | `-` | subtraction |
 ``` cpp
-T* fetch_key(ptrdiff_t operand, memory_order order = memory_order::seq_cst) volatile noexcept;
-T* fetch_key(ptrdiff_t operand, memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
@@ -3410,13 +4252,51 @@ operations [[intro.multithread]].
 the effects.
 *Remarks:* The result may be an undefined address, but the operations
 otherwise have no undefined behavior.
 ``` cpp
 T* operator op=(ptrdiff_t operand) volatile noexcept;
-T* operator op=(ptrdiff_t operand) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
@@ -3425,41 +4305,41 @@ T* operator op=(ptrdiff_t operand) noexcept;
 #### Member operators common to integers and pointers to objects <a id="atomics.types.memop">[[atomics.types.memop]]</a>
 ``` cpp
 value_type operator++(int) volatile noexcept;
-value_type operator++(int) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
 *Effects:* Equivalent to: `return fetch_add(1);`
 ``` cpp
 value_type operator--(int) volatile noexcept;
-value_type operator--(int) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
 *Effects:* Equivalent to: `return fetch_sub(1);`
 ``` cpp
 value_type operator++() volatile noexcept;
-value_type operator++() noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
 *Effects:* Equivalent to: `return fetch_add(1) + 1;`
 ``` cpp
 value_type operator--() volatile noexcept;
-value_type operator--() noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
@@ -3532,33 +4412,36 @@ namespace std {
     static constexpr bool is_always_lock_free = implementation-defined  // whether a given atomic type's operations are always lock free;
     bool is_lock_free() const noexcept;
     constexpr atomic() noexcept;
     constexpr atomic(nullptr_t) noexcept : atomic() { }
-    atomic(shared_ptr<T> desired) noexcept;
     atomic(const atomic&) = delete;
     void operator=(const atomic&) = delete;
-    shared_ptr<T> load(memory_order order = memory_order::seq_cst) const noexcept;
-    operator shared_ptr<T>() const noexcept;
-    void store(shared_ptr<T> desired, memory_order order = memory_order::seq_cst) noexcept;
-    void operator=(shared_ptr<T> desired) noexcept;
-    shared_ptr<T> exchange(shared_ptr<T> desired,
                                      memory_order order = memory_order::seq_cst) noexcept;
-    bool compare_exchange_weak(shared_ptr<T>& expected, shared_ptr<T> desired,
                                          memory_order success, memory_order failure) noexcept;
-    bool compare_exchange_strong(shared_ptr<T>& expected, shared_ptr<T> desired,
                                            memory_order success, memory_order failure) noexcept;
-    bool compare_exchange_weak(shared_ptr<T>& expected, shared_ptr<T> desired,
                                          memory_order order = memory_order::seq_cst) noexcept;
-    bool compare_exchange_strong(shared_ptr<T>& expected, shared_ptr<T> desired,
                                            memory_order order = memory_order::seq_cst) noexcept;
-    void wait(shared_ptr<T> old, memory_order order = memory_order::seq_cst) const noexcept;
-    void notify_one() noexcept;
-    void notify_all() noexcept;
   private:
     shared_ptr<T> p;            // exposition only
   };
 }
@@ -3566,14 +4449,14 @@ namespace std {
 ``` cpp
 constexpr atomic() noexcept;
 ```
-*Effects:* Initializes `p{}`.
 ``` cpp
-atomic(shared_ptr<T> desired) noexcept;
 ```
 *Effects:* Initializes the object with the value `desired`.
 Initialization is not an atomic operation [[intro.multithread]].
@@ -3583,63 +4466,70 @@ the just-constructed object `A` to another thread via
 `memory_order::relaxed` operations on a suitable atomic pointer
 variable, and then immediately accessing `A` in the receiving thread.
 This results in undefined behavior. — *end note*]
 ``` cpp
-void store(shared_ptr<T> desired, memory_order order = memory_order::seq_cst) noexcept;
 ```
-*Preconditions:* `order` is neither `memory_order::consume`,
-`memory_order::acquire`, nor `memory_order::acq_rel`.
 *Effects:* Atomically replaces the value pointed to by `this` with the
 value of `desired` as if by `p.swap(desired)`. Memory is affected
 according to the value of `order`.
 ``` cpp
-void operator=(shared_ptr<T> desired) noexcept;
 ```
 *Effects:* Equivalent to `store(desired)`.
 ``` cpp
-shared_ptr<T> load(memory_order order = memory_order::seq_cst) const noexcept;
 ```
-*Preconditions:* `order` is neither `memory_order::release` nor
-`memory_order::acq_rel`.
 *Effects:* Memory is affected according to the value of `order`.
 *Returns:* Atomically returns `p`.
 ``` cpp
-operator shared_ptr<T>() const noexcept;
 ```
 *Effects:* Equivalent to: `return load();`
 ``` cpp
-shared_ptr<T> exchange(shared_ptr<T> desired, memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Effects:* Atomically replaces `p` with `desired` as if by
 `p.swap(desired)`. Memory is affected according to the value of `order`.
 This is an atomic read-modify-write operation [[intro.races]].
 *Returns:* Atomically returns the value of `p` immediately before the
 effects.
 ``` cpp
-bool compare_exchange_weak(shared_ptr<T>& expected, shared_ptr<T> desired,
                                      memory_order success, memory_order failure) noexcept;
-bool compare_exchange_strong(shared_ptr<T>& expected, shared_ptr<T> desired,
                                        memory_order success, memory_order failure) noexcept;
 ```
-*Preconditions:* `failure` is neither `memory_order::release` nor
-`memory_order::acq_rel`.
 *Effects:* If `p` is equivalent to `expected`, assigns `desired` to `p`
 and has synchronization semantics corresponding to the value of
 `success`, otherwise assigns `p` to `expected` and has synchronization
 semantics corresponding to the value of `failure`.
@@ -3660,11 +4550,11 @@ object in the attempted atomic update. The `use_count` update
 corresponding to the write to `expected` is part of the atomic
 operation. The write to `expected` itself is not required to be part of
 the atomic operation.
 ``` cpp
-bool compare_exchange_weak(shared_ptr<T>& expected, shared_ptr<T> desired,
                                      memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Effects:* Equivalent to:
@@ -3676,11 +4566,11 @@ where `fail_order` is the same as `order` except that a value of
 `memory_order::acq_rel` shall be replaced by the value
 `memory_order::acquire` and a value of `memory_order::release` shall be
 replaced by the value `memory_order::relaxed`.
 ``` cpp
-bool compare_exchange_strong(shared_ptr<T>& expected, shared_ptr<T> desired,
                                        memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Effects:* Equivalent to:
@@ -3692,15 +4582,15 @@ where `fail_order` is the same as `order` except that a value of
 `memory_order::acq_rel` shall be replaced by the value
 `memory_order::acquire` and a value of `memory_order::release` shall be
 replaced by the value `memory_order::relaxed`.
 ``` cpp
-void wait(shared_ptr<T> old, memory_order order = memory_order::seq_cst) const noexcept;
 ```
-*Preconditions:* `order` is neither `memory_order::release` nor
-`memory_order::acq_rel`.
 *Effects:* Repeatedly performs the following steps, in order:
 - Evaluates `load(order)` and compares it to `old`.
 - If the two are not equivalent, returns.
@@ -3710,22 +4600,22 @@ void wait(shared_ptr<T> old, memory_order order = memory_order::seq_cst) const n
 *Remarks:* Two `shared_ptr` objects are equivalent if they store the
 same pointer and either share ownership or are both empty. This function
 is an atomic waiting operation [[atomics.wait]].
 ``` cpp
-void notify_one() noexcept;
 ```
 *Effects:* Unblocks the execution of at least one atomic waiting
 operation that is eligible to be unblocked [[atomics.wait]] by this
 call, if any such atomic waiting operations exist.
 *Remarks:* This function is an atomic notifying
 operation [[atomics.wait]].
 ``` cpp
-void notify_all() noexcept;
 ```
 *Effects:* Unblocks the execution of all atomic waiting operations that
 are eligible to be unblocked [[atomics.wait]] by this call.
@@ -3741,33 +4631,35 @@ namespace std {
     static constexpr bool is_always_lock_free = implementation-defined  // whether a given atomic type's operations are always lock free;
     bool is_lock_free() const noexcept;
     constexpr atomic() noexcept;
-    atomic(weak_ptr<T> desired) noexcept;
     atomic(const atomic&) = delete;
     void operator=(const atomic&) = delete;
-    weak_ptr<T> load(memory_order order = memory_order::seq_cst) const noexcept;
-    operator weak_ptr<T>() const noexcept;
-    void store(weak_ptr<T> desired, memory_order order = memory_order::seq_cst) noexcept;
-    void operator=(weak_ptr<T> desired) noexcept;
-    weak_ptr<T> exchange(weak_ptr<T> desired,
                                    memory_order order = memory_order::seq_cst) noexcept;
-    bool compare_exchange_weak(weak_ptr<T>& expected, weak_ptr<T> desired,
                                          memory_order success, memory_order failure) noexcept;
-    bool compare_exchange_strong(weak_ptr<T>& expected, weak_ptr<T> desired,
                                            memory_order success, memory_order failure) noexcept;
-    bool compare_exchange_weak(weak_ptr<T>& expected, weak_ptr<T> desired,
                                          memory_order order = memory_order::seq_cst) noexcept;
-    bool compare_exchange_strong(weak_ptr<T>& expected, weak_ptr<T> desired,
                                            memory_order order = memory_order::seq_cst) noexcept;
-    void wait(weak_ptr<T> old, memory_order order = memory_order::seq_cst) const noexcept;
-    void notify_one() noexcept;
-    void notify_all() noexcept;
   private:
     weak_ptr<T> p;              // exposition only
   };
 }
@@ -3775,14 +4667,14 @@ namespace std {
 ``` cpp
 constexpr atomic() noexcept;
 ```
-*Effects:* Initializes `p{}`.
 ``` cpp
-atomic(weak_ptr<T> desired) noexcept;
 ```
 *Effects:* Initializes the object with the value `desired`.
 Initialization is not an atomic operation [[intro.multithread]].
@@ -3792,63 +4684,64 @@ the just-constructed object `A` to another thread via
 `memory_order::relaxed` operations on a suitable atomic pointer
 variable, and then immediately accessing `A` in the receiving thread.
 This results in undefined behavior. — *end note*]
 ``` cpp
-void store(weak_ptr<T> desired, memory_order order = memory_order::seq_cst) noexcept;
 ```
-*Preconditions:* `order` is neither `memory_order::consume`,
-`memory_order::acquire`, nor `memory_order::acq_rel`.
 *Effects:* Atomically replaces the value pointed to by `this` with the
 value of `desired` as if by `p.swap(desired)`. Memory is affected
 according to the value of `order`.
 ``` cpp
-void operator=(weak_ptr<T> desired) noexcept;
 ```
 *Effects:* Equivalent to `store(desired)`.
 ``` cpp
-weak_ptr<T> load(memory_order order = memory_order::seq_cst) const noexcept;
 ```
-*Preconditions:* `order` is neither `memory_order::release` nor
-`memory_order::acq_rel`.
 *Effects:* Memory is affected according to the value of `order`.
 *Returns:* Atomically returns `p`.
 ``` cpp
-operator weak_ptr<T>() const noexcept;
 ```
 *Effects:* Equivalent to: `return load();`
 ``` cpp
-weak_ptr<T> exchange(weak_ptr<T> desired, memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Effects:* Atomically replaces `p` with `desired` as if by
 `p.swap(desired)`. Memory is affected according to the value of `order`.
 This is an atomic read-modify-write operation [[intro.races]].
 *Returns:* Atomically returns the value of `p` immediately before the
 effects.
 ``` cpp
-bool compare_exchange_weak(weak_ptr<T>& expected, weak_ptr<T> desired,
                                      memory_order success, memory_order failure) noexcept;
-bool compare_exchange_strong(weak_ptr<T>& expected, weak_ptr<T> desired,
                                        memory_order success, memory_order failure) noexcept;
 ```
-*Preconditions:* `failure` is neither `memory_order::release` nor
-`memory_order::acq_rel`.
 *Effects:* If `p` is equivalent to `expected`, assigns `desired` to `p`
 and has synchronization semantics corresponding to the value of
 `success`, otherwise assigns `p` to `expected` and has synchronization
 semantics corresponding to the value of `failure`.
@@ -3869,11 +4762,11 @@ object in the attempted atomic update. The `use_count` update
 corresponding to the write to `expected` is part of the atomic
 operation. The write to `expected` itself is not required to be part of
 the atomic operation.
 ``` cpp
-bool compare_exchange_weak(weak_ptr<T>& expected, weak_ptr<T> desired,
                                      memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Effects:* Equivalent to:
@@ -3885,11 +4778,11 @@ where `fail_order` is the same as `order` except that a value of
 `memory_order::acq_rel` shall be replaced by the value
 `memory_order::acquire` and a value of `memory_order::release` shall be
 replaced by the value `memory_order::relaxed`.
 ``` cpp
-bool compare_exchange_strong(weak_ptr<T>& expected, weak_ptr<T> desired,
                                        memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Effects:* Equivalent to:
@@ -3901,15 +4794,15 @@ where `fail_order` is the same as `order` except that a value of
 `memory_order::acq_rel` shall be replaced by the value
 `memory_order::acquire` and a value of `memory_order::release` shall be
 replaced by the value `memory_order::relaxed`.
 ``` cpp
-void wait(weak_ptr<T> old, memory_order order = memory_order::seq_cst) const noexcept;
 ```
-*Preconditions:* `order` is neither `memory_order::release` nor
-`memory_order::acq_rel`.
 *Effects:* Repeatedly performs the following steps, in order:
 - Evaluates `load(order)` and compares it to `old`.
 - If the two are not equivalent, returns.
@@ -3919,22 +4812,22 @@ void wait(weak_ptr<T> old, memory_order order = memory_order::seq_cst) const noe
 *Remarks:* Two `weak_ptr` objects are equivalent if they store the same
 pointer and either share ownership or are both empty. This function is
 an atomic waiting operation [[atomics.wait]].
 ``` cpp
-void notify_one() noexcept;
 ```
 *Effects:* Unblocks the execution of at least one atomic waiting
 operation that is eligible to be unblocked [[atomics.wait]] by this
 call, if any such atomic waiting operations exist.
 *Remarks:* This function is an atomic notifying
 operation [[atomics.wait]].
 ``` cpp
-void notify_all() noexcept;
 ```
 *Effects:* Unblocks the execution of all atomic waiting operations that
 are eligible to be unblocked [[atomics.wait]] by this call.
@@ -3965,22 +4858,22 @@ namespace std {
     atomic_flag(const atomic_flag&) = delete;
     atomic_flag& operator=(const atomic_flag&) = delete;
     atomic_flag& operator=(const atomic_flag&) volatile = delete;
     bool test(memory_order = memory_order::seq_cst) const volatile noexcept;
-    bool test(memory_order = memory_order::seq_cst) const noexcept;
     bool test_and_set(memory_order = memory_order::seq_cst) volatile noexcept;
-    bool test_and_set(memory_order = memory_order::seq_cst) noexcept;
     void clear(memory_order = memory_order::seq_cst) volatile noexcept;
-    void clear(memory_order = memory_order::seq_cst) noexcept;
     void wait(bool, memory_order = memory_order::seq_cst) const volatile noexcept;
-    void wait(bool, memory_order = memory_order::seq_cst) const noexcept;
     void notify_one() volatile noexcept;
-    void notify_one() noexcept;
     void notify_all() volatile noexcept;
-    void notify_all() noexcept;
   };
 }
 ```
 The `atomic_flag` type provides the classic test-and-set functionality.
@@ -3998,36 +4891,36 @@ constexpr atomic_flag::atomic_flag() noexcept;
 *Effects:* Initializes `*this` to the clear state.
 ``` cpp
 bool atomic_flag_test(const volatile atomic_flag* object) noexcept;
-bool atomic_flag_test(const atomic_flag* object) noexcept;
 bool atomic_flag_test_explicit(const volatile atomic_flag* object,
                                memory_order order) noexcept;
-bool atomic_flag_test_explicit(const atomic_flag* object,
                                memory_order order) noexcept;
 bool atomic_flag::test(memory_order order = memory_order::seq_cst) const volatile noexcept;
-bool atomic_flag::test(memory_order order = memory_order::seq_cst) const noexcept;
 ```
 For `atomic_flag_test`, let `order` be `memory_order::seq_cst`.
-*Preconditions:* `order` is neither `memory_order::release` nor
-`memory_order::acq_rel`.
 *Effects:* Memory is affected according to the value of `order`.
 *Returns:* Atomically returns the value pointed to by `object` or
 `this`.
 ``` cpp
 bool atomic_flag_test_and_set(volatile atomic_flag* object) noexcept;
-bool atomic_flag_test_and_set(atomic_flag* object) noexcept;
 bool atomic_flag_test_and_set_explicit(volatile atomic_flag* object, memory_order order) noexcept;
-bool atomic_flag_test_and_set_explicit(atomic_flag* object, memory_order order) noexcept;
 bool atomic_flag::test_and_set(memory_order order = memory_order::seq_cst) volatile noexcept;
-bool atomic_flag::test_and_set(memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Effects:* Atomically sets the value pointed to by `object` or by `this`
 to `true`. Memory is affected according to the value of `order`. These
 operations are atomic read-modify-write
@@ -4036,43 +4929,42 @@ operations [[intro.multithread]].
 *Returns:* Atomically, the value of the object immediately before the
 effects.
 ``` cpp
 void atomic_flag_clear(volatile atomic_flag* object) noexcept;
-void atomic_flag_clear(atomic_flag* object) noexcept;
 void atomic_flag_clear_explicit(volatile atomic_flag* object, memory_order order) noexcept;
-void atomic_flag_clear_explicit(atomic_flag* object, memory_order order) noexcept;
 void atomic_flag::clear(memory_order order = memory_order::seq_cst) volatile noexcept;
-void atomic_flag::clear(memory_order order = memory_order::seq_cst) noexcept;
 ```
-*Preconditions:* The `order` argument is neither
-`memory_order::consume`, `memory_order::acquire`, nor
-`memory_order::acq_rel`.
 *Effects:* Atomically sets the value pointed to by `object` or by `this`
 to `false`. Memory is affected according to the value of `order`.
 ``` cpp
 void atomic_flag_wait(const volatile atomic_flag* object, bool old) noexcept;
-void atomic_flag_wait(const atomic_flag* object, bool old) noexcept;
 void atomic_flag_wait_explicit(const volatile atomic_flag* object,
                                bool old, memory_order order) noexcept;
-void atomic_flag_wait_explicit(const atomic_flag* object,
                                bool old, memory_order order) noexcept;
 void atomic_flag::wait(bool old, memory_order order =
                                    memory_order::seq_cst) const volatile noexcept;
-void atomic_flag::wait(bool old, memory_order order =
                                    memory_order::seq_cst) const noexcept;
 ```
 For `atomic_flag_wait`, let `order` be `memory_order::seq_cst`. Let
 `flag` be `object` for the non-member functions and `this` for the
 member functions.
-*Preconditions:* `order` is neither `memory_order::release` nor
-`memory_order::acq_rel`.
 *Effects:* Repeatedly performs the following steps, in order:
 - Evaluates `flag->test(order) != old`.
 - If the result of that evaluation is `true`, returns.
@@ -4082,13 +4974,13 @@ member functions.
 *Remarks:* This function is an atomic waiting
 operation [[atomics.wait]].
 ``` cpp
 void atomic_flag_notify_one(volatile atomic_flag* object) noexcept;
-void atomic_flag_notify_one(atomic_flag* object) noexcept;
 void atomic_flag::notify_one() volatile noexcept;
-void atomic_flag::notify_one() noexcept;
 ```
 *Effects:* Unblocks the execution of at least one atomic waiting
 operation that is eligible to be unblocked [[atomics.wait]] by this
 call, if any such atomic waiting operations exist.
@@ -4096,13 +4988,13 @@ call, if any such atomic waiting operations exist.
 *Remarks:* This function is an atomic notifying
 operation [[atomics.wait]].
 ``` cpp
 void atomic_flag_notify_all(volatile atomic_flag* object) noexcept;
-void atomic_flag_notify_all(atomic_flag* object) noexcept;
 void atomic_flag::notify_all() volatile noexcept;
-void atomic_flag::notify_all() noexcept;
 ```
 *Effects:* Unblocks the execution of all atomic waiting operations that
 are eligible to be unblocked [[atomics.wait]] by this call.
@@ -4131,15 +5023,16 @@ This subclause introduces synchronization primitives called *fences*.
 Fences can have acquire semantics, release semantics, or both. A fence
 with acquire semantics is called an *acquire fence*. A fence with
 release semantics is called a *release fence*.
 A release fence A synchronizes with an acquire fence B if there exist
-atomic operations X and Y, both operating on some atomic object M, such
-that A is sequenced before X, X modifies M, Y is sequenced before B, and
-Y reads the value written by X or a value written by any side effect in
-the hypothetical release sequence X would head if it were a release
-operation.
 A release fence A synchronizes with an atomic operation B that performs
 an acquire operation on an atomic object M if there exists an atomic
 operation X such that A is sequenced before X, X modifies M, and B reads
 the value written by X or a value written by any side effect in the
@@ -4151,26 +5044,25 @@ synchronizes with an acquire fence B if there exists some atomic
 operation X on M such that X is sequenced before B and reads the value
 written by A or a value written by any side effect in the release
 sequence headed by A.
 ``` cpp
-extern "C" void atomic_thread_fence(memory_order order) noexcept;
 ```
 *Effects:* Depending on the value of `order`, this operation:
 - has no effects, if `order == memory_order::relaxed`;
-- is an acquire fence, if `order == memory_order::acquire` or
-  `order == memory_order::consume`;
 - is a release fence, if `order == memory_order::release`;
 - is both an acquire fence and a release fence, if
   `order == memory_order::acq_rel`;
 - is a sequentially consistent acquire and release fence, if
   `order == memory_order::seq_cst`.
 ``` cpp
-extern "C" void atomic_signal_fence(memory_order order) noexcept;
 ```
 *Effects:* Equivalent to `atomic_thread_fence(order)`, except that the
 resulting ordering constraints are established only between a thread and
 a signal handler executed in the same thread.
@@ -4327,11 +5219,11 @@ race-free programs [[intro.multithread]].
 namespace std {
   // [thread.mutex.class], class mutex
   class mutex;
   // [thread.mutex.recursive], class recursive_mutex
   class recursive_mutex;
-  // [thread.timedmutex.class] class timed_mutex
   class timed_mutex;
   // [thread.timedmutex.recursive], class recursive_timed_mutex
   class recursive_timed_mutex;
   struct defer_lock_t { explicit defer_lock_t() = default; };
@@ -4376,11 +5268,11 @@ namespace std {
 }
 ```
 ### Mutex requirements <a id="thread.mutex.requirements">[[thread.mutex.requirements]]</a>
-#### In general <a id="thread.mutex.requirements.general">[[thread.mutex.requirements.general]]</a>
 A mutex object facilitates protection against data races and allows safe
 synchronization of data between execution agents
 [[thread.req.lockable]]. An execution agent *owns* a mutex from the time
 it successfully calls one of the lock functions until it calls unlock.
@@ -4534,13 +5426,13 @@ another thread to acquire ownership of that object will fail (for
 released ownership with a call to `unlock()`.
 [*Note 4*: After a thread `A` has called `unlock()`, releasing a mutex,
 it is possible for another thread `B` to lock the same mutex, observe
 that it is no longer in use, unlock it, and destroy it, before thread
-`A` appears to have returned from its unlock call. Implementations are
-required to handle such scenarios correctly, as long as thread `A`
-doesn’t access the mutex after the unlock call returns. These cases
 typically occur when a reference-counted object contains a mutex that is
 used to protect the reference count. — *end note*]
 The class `mutex` meets all of the mutex requirements
 [[thread.mutex.requirements]]. It is a standard-layout class
@@ -4596,11 +5488,11 @@ ownership for a `recursive_mutex` object, additional calls to
 of type `system_error`. A thread shall call `unlock()` once for each
 level of ownership acquired by calls to `lock()` and `try_lock()`. Only
 when all levels of ownership have been released may ownership be
 acquired by another thread.
-The behavior of a program is undefined if:
 - it destroys a `recursive_mutex` object owned by any thread or
 - a thread terminates while owning a `recursive_mutex` object.
 #### Timed mutex types <a id="thread.timedmutex.requirements">[[thread.timedmutex.requirements]]</a>
@@ -4707,11 +5599,11 @@ a call to `unlock()` or the call to `try_lock_for()` or
 The class `timed_mutex` meets all of the timed mutex requirements
 [[thread.timedmutex.requirements]]. It is a standard-layout class
 [[class.prop]].
-The behavior of a program is undefined if:
 - it destroys a `timed_mutex` object owned by any thread,
 - a thread that owns a `timed_mutex` object calls `lock()`,
   `try_lock()`, `try_lock_for()`, or `try_lock_until()` on that object,
   or
@@ -4766,11 +5658,11 @@ for a `recursive_timed_mutex` object, additional calls to `try_lock()`,
 `unlock()` once for each level of ownership acquired by calls to
 `lock()`, `try_lock()`, `try_lock_for()`, and `try_lock_until()`. Only
 when all levels of ownership have been released may ownership of the
 object be acquired by another thread.
-The behavior of a program is undefined if:
 - it destroys a `recursive_timed_mutex` object owned by any thread, or
 - a thread terminates while owning a `recursive_timed_mutex` object.
 #### Shared mutex types <a id="thread.sharedmutex.requirements">[[thread.sharedmutex.requirements]]</a>
@@ -4895,11 +5787,11 @@ ownership semantics.
 The class `shared_mutex` meets all of the shared mutex requirements
 [[thread.sharedmutex.requirements]]. It is a standard-layout class
 [[class.prop]].
-The behavior of a program is undefined if:
 - it destroys a `shared_mutex` object owned by any thread,
 - a thread attempts to recursively gain any ownership of a
   `shared_mutex`, or
 - a thread terminates while possessing any ownership of a
@@ -5021,11 +5913,11 @@ shared ownership semantics.
 The class `shared_timed_mutex` meets all of the shared timed mutex
 requirements [[thread.sharedtimedmutex.requirements]]. It is a
 standard-layout class [[class.prop]].
-The behavior of a program is undefined if:
 - it destroys a `shared_timed_mutex` object owned by any thread,
 - a thread attempts to recursively gain any ownership of a
   `shared_timed_mutex`, or
 - a thread terminates while possessing any ownership of a
@@ -5205,11 +6097,11 @@ namespace std {
     unique_lock(const unique_lock&) = delete;
     unique_lock& operator=(const unique_lock&) = delete;
     unique_lock(unique_lock&& u) noexcept;
-    unique_lock& operator=(unique_lock&& u);
     // [thread.lock.unique.locking], locking
     void lock();
     bool try_lock();
@@ -5331,24 +6223,16 @@ unique_lock(unique_lock&& u) noexcept;
 *Ensures:* `pm == u_p.pm` and `owns == u_p.owns` (where `u_p` is the
 state of `u` just prior to this construction), `u.pm == 0` and
 `u.owns == false`.
 ``` cpp
-unique_lock& operator=(unique_lock&& u);
 ```
-*Effects:* If `owns` calls `pm->unlock()`.
-*Ensures:* `pm == u_p.pm` and `owns == u_p.owns` (where `u_p` is the
-state of `u` just prior to this construction), `u.pm == 0` and
-`u.owns == false`.
-[*Note 1*: With a recursive mutex it is possible for both `*this` and
-`u` to own the same mutex before the assignment. In this case, `*this`
-will own the mutex after the assignment and `u` will not. — *end note*]
-*Throws:* Nothing.
 ``` cpp
 ~unique_lock();
 ```
@@ -5653,15 +6537,13 @@ state of `sl` just prior to this construction), `sl.pm == nullptr` and
 ``` cpp
 shared_lock& operator=(shared_lock&& sl) noexcept;
 ```
-*Effects:* If `owns` calls `pm->unlock_shared()`.
-*Ensures:* `pm == sl_p.pm` and `owns == sl_p.owns` (where `sl_p` is the
-state of `sl` just prior to this assignment), `sl.pm == nullptr` and
-`sl.owns == false`.
 ##### Locking <a id="thread.lock.shared.locking">[[thread.lock.shared.locking]]</a>
 ``` cpp
 void lock();
@@ -5886,11 +6768,11 @@ template<class Callable, class... Args>
 *Mandates:* `is_invocable_v<Callable, Args...>` is `true`.
 *Effects:* An execution of `call_once` that does not call its `func` is
 a *passive* execution. An execution of `call_once` that calls its `func`
-is an *active* execution. An active execution calls *INVOKE*(
 std::forward\<Callable\>(func),
 std::forward\<Args\>(args)...) [[func.require]]. If such a call to
 `func` throws an exception the execution is *exceptional*, otherwise it
 is *returning*. An exceptional execution propagates the exception to the
 caller of `call_once`. Among all executions of `call_once` for any given
@@ -6003,11 +6885,11 @@ void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk);
   supplied by all concurrently waiting (via `wait`, `wait_for`, or
   `wait_until`) threads.
 *Effects:* Transfers ownership of the lock associated with `lk` into
 internal storage and schedules `cond` to be notified when the current
-thread exits, after all objects of thread storage duration associated
 with the current thread have been destroyed. This notification is
 equivalent to:
 ``` cpp
 lk.unlock();
@@ -6020,11 +6902,11 @@ the current thread.
 [*Note 1*: The supplied lock is held until the thread exits, which
 might cause deadlock due to lock ordering issues. — *end note*]
 [*Note 2*: It is the user’s responsibility to ensure that waiting
-threads do not erroneously assume that the thread has finished if they
 experience spurious wakeups. This typically requires that the condition
 being waited for is satisfied while holding the lock on `lk`, and that
 this lock is not released and reacquired prior to calling
 `notify_all_at_thread_exit`. — *end note*]
@@ -6329,13 +7211,13 @@ exception. — *end note*]
 ### Class `condition_variable_any` <a id="thread.condition.condvarany">[[thread.condition.condvarany]]</a>
 #### General <a id="thread.condition.condvarany.general">[[thread.condition.condvarany.general]]</a>
-In this subclause [[thread.condition.condvarany]], template arguments
-for template parameters named `Lock` shall meet the *Cpp17BasicLockable*
-requirements [[thread.req.lockable.basic]].
 [*Note 1*: All of the standard mutex types meet this requirement. If a
 type other than one of the standard mutex types or a `unique_lock`
 wrapper for a standard mutex type is used with `condition_variable_any`,
 any necessary synchronization is assumed to be in place with respect to
@@ -6967,11 +7849,11 @@ namespace std {
     ~barrier();
     barrier(const barrier&) = delete;
     barrier& operator=(const barrier&) = delete;
- [[nodiscard]] arrival_token arrive(ptrdiff_t update = 1);
     void wait(arrival_token&& arrival) const;
     void arrive_and_wait();
     void arrive_and_drop();
@@ -7055,11 +7937,11 @@ destroyed. — *end note*]
 *Throws:* Any exception thrown by `CompletionFunction`’s move
 constructor.
 ``` cpp
-[[nodiscard]] arrival_token arrive(ptrdiff_t update = 1);
 ```
 *Preconditions:* `update > 0` is `true`, and `update` is less than or
 equal to the expected count for the current barrier phase.
@@ -7182,13 +8064,10 @@ namespace std {
   template<> class promise<void>;
   template<class R>
     void swap(promise<R>& x, promise<R>& y) noexcept;
-  template<class R, class Alloc>
-    struct uses_allocator<promise<R>, Alloc>;
   // [futures.unique.future], class template future
   template<class R> class future;
   template<class R> class future<R&>;
   template<> class future<void>;
@@ -7205,14 +8084,14 @@ namespace std {
   template<class R, class... ArgTypes>
     void swap(packaged_task<R(ArgTypes...)>&, packaged_task<R(ArgTypes...)>&) noexcept;
   // [futures.async], function template async
   template<class F, class... Args>
- [[nodiscard]] future<invoke_result_t<decay_t<F>, decay_t<Args>...>>
       async(F&& f, Args&&... args);
   template<class F, class... Args>
- [[nodiscard]] future<invoke_result_t<decay_t<F>, decay_t<Args>...>>
       async(launch policy, F&& f, Args&&... args);
 }
 ```
 The `enum` type `launch` is a bitmask type [[bitmask.types]] with
@@ -7310,11 +8189,12 @@ waiting function*, otherwise it is a *non-timed waiting function*.
 An *asynchronous provider* is an object that provides a result to a
 shared state. The result of a shared state is set by respective
 functions on the asynchronous provider.
-[*Note 3*: Such as promises or tasks. — *end note*]
 The means of setting the result of a shared state is specified in the
 description of those classes and functions that create such a state
 object.
@@ -7364,11 +8244,11 @@ of each of that thread’s objects with thread storage duration
 [[basic.stc.thread]] is sequenced before making that shared state ready.
 Access to the result of the same shared state may conflict
 [[intro.multithread]].
-[*Note 4*: This explicitly specifies that the result of the shared
 state is visible in the objects that reference this state in the sense
 of data race avoidance [[res.on.data.races]]. For example, concurrent
 accesses through references returned by `shared_future::get()`
 [[futures.shared.future]] must either use read-only operations or
 provide additional synchronization. — *end note*]
@@ -7401,13 +8281,10 @@ namespace std {
     // setting the result with deferred notification
     void set_value_at_thread_exit(see below);
     void set_exception_at_thread_exit(exception_ptr p);
   };
-  template<class R, class Alloc>
-    struct uses_allocator<promise<R>, Alloc>;
 }
 ```
 For the primary template, `R` shall be an object type that meets the
 *Cpp17Destructible* requirements.
@@ -7420,19 +8297,10 @@ in the argument type of the member functions `set_value` and
 The `set_value`, `set_exception`, `set_value_at_thread_exit`, and
 `set_exception_at_thread_exit` member functions behave as though they
 acquire a single mutex associated with the promise object while updating
 the promise object.
-``` cpp
-template<class R, class Alloc>
-  struct uses_allocator<promise<R>, Alloc>
-    : true_type { };
-```
-*Preconditions:* `Alloc` meets the *Cpp17Allocator*
-requirements [[allocator.requirements.general]].
 ``` cpp
 promise();
 template<class Allocator>
   promise(allocator_arg_t, const Allocator& a);
 ```
@@ -7547,11 +8415,11 @@ void promise<R&>::set_value_at_thread_exit(R& r);
 void promise<void>::set_value_at_thread_exit();
 ```
 *Effects:* Stores the value `r` in the shared state without making that
 state ready immediately. Schedules that state to be made ready when the
-current thread exits, after all objects of thread storage duration
 associated with the current thread have been destroyed.
 *Throws:*
 - `future_error` if its shared state already has a stored value or
@@ -7573,12 +8441,12 @@ void set_exception_at_thread_exit(exception_ptr p);
 *Preconditions:* `p` is not null.
 *Effects:* Stores the exception pointer `p` in the shared state without
 making that state ready immediately. Schedules that state to be made
-ready when the current thread exits, after all objects of thread storage
-duration associated with the current thread have been destroyed.
 *Throws:* `future_error` if an error condition occurs.
 *Error conditions:*
@@ -7606,11 +8474,11 @@ respective function on an object that shares the same shared state.
 [*Note 1*: Member functions of `future` do not synchronize with
 themselves or with member functions of `shared_future`. — *end note*]
 The effect of calling any member function other than the destructor, the
-move-assignment operator, `share`, or `valid` on a `future` object for
 which `valid() == false` is undefined.
 [*Note 2*: It is valid to move from a future object for which
 `valid() == false`. — *end note*]
@@ -7805,11 +8673,11 @@ object that shares the same shared state.
 [*Note 1*: Member functions of `shared_future` do not synchronize with
 themselves, but they synchronize with the shared state. — *end note*]
 The effect of calling any member function other than the destructor, the
-move-assignment operator, the copy-assignment operator, or `valid()` on
 a `shared_future` object for which `valid() == false` is undefined.
 [*Note 2*: It is valid to copy or move from a `shared_future` object
 for which `valid()` is `false`. — *end note*]
@@ -8014,14 +8882,14 @@ The function template `async` provides a mechanism to launch a function
 potentially in a new thread and provides the result of the function in a
 `future` object with which it shares a shared state.
 ``` cpp
 template<class F, class... Args>
- [[nodiscard]] future<invoke_result_t<decay_t<F>, decay_t<Args>...>>
     async(F&& f, Args&&... args);
 template<class F, class... Args>
- [[nodiscard]] future<invoke_result_t<decay_t<F>, decay_t<Args>...>>
     async(launch policy, F&& f, Args&&... args);
 ```
 *Mandates:* The following are all `true`:
@@ -8138,10 +9006,12 @@ namespace std {
   public:
     // construction and destruction
     packaged_task() noexcept;
     template<class F>
       explicit packaged_task(F&& f);
     ~packaged_task();
     // no copy
     packaged_task(const packaged_task&) = delete;
     packaged_task& operator=(const packaged_task&) = delete;
@@ -8181,24 +9051,37 @@ packaged_task() noexcept;
 ``` cpp
 template<class F>
   explicit packaged_task(F&& f);
 ```
 *Constraints:* `remove_cvref_t<F>` is not the same type as
 `packaged_task<R(ArgTypes...)>`.
-*Mandates:* `is_invocable_r_v<R, F&, ArgTypes...>` is `true`.
-*Preconditions:* Invoking a copy of `f` behaves the same as invoking
-`f`.
-*Effects:* Constructs a new `packaged_task` object with a shared state
-and initializes the object’s stored task with `std::forward<F>(f)`.
-*Throws:* Any exceptions thrown by the copy or move constructor of `f`,
-or `bad_alloc` if memory for the internal data structures cannot be
-allocated.
 ``` cpp
 template<class F> packaged_task(F) -> packaged_task<see below>;
 ```
@@ -8308,11 +9191,11 @@ where `f` is the stored task and `t`₁`, t`₂`, `…`, t`$_N$ are the values
 in `args...`. If the task returns normally, the return value is stored
 as the asynchronous result in the shared state of `*this`, otherwise the
 exception thrown by the task is stored. In either case, this is done
 without making that state ready [[futures.state]] immediately. Schedules
 the shared state to be made ready when the current thread exits, after
-all objects of thread storage duration associated with the current
 thread have been destroyed.
 *Throws:* `future_error` if an error condition occurs.
 *Error conditions:*
@@ -8323,21 +9206,28 @@ thread have been destroyed.
 ``` cpp
 void reset();
 ```
-*Effects:* As if `*this = packaged_task(std::move(f))`, where `f` is the
-task stored in `*this`.
 [*Note 2*: This constructs a new shared state for `*this`. The old
 state is abandoned [[futures.state]]. — *end note*]
 *Throws:*
-- `bad_alloc` if memory for the new shared state cannot be allocated.
-- Any exception thrown by the move constructor of the task stored in the
-  shared state.
 - `future_error` with an error condition of `no_state` if `*this` has no
   shared state.
 #### Globals <a id="futures.task.nonmembers">[[futures.task.nonmembers]]</a>
@@ -8346,11 +9236,583 @@ template<class R, class... ArgTypes>
   void swap(packaged_task<R(ArgTypes...)>& x, packaged_task<R(ArgTypes...)>& y) noexcept;
 ```
 *Effects:* As if by `x.swap(y)`.
 <!-- Link reference definitions -->
 [alg.sorting]: algorithms.md#alg.sorting
 [allocator.requirements.general]: library.md#allocator.requirements.general
 [atomic.types.int.comp]: #atomic.types.int.comp
 [atomic.types.pointer.comp]: #atomic.types.pointer.comp
 [atomics]: #atomics
@@ -8379,26 +9841,29 @@ template<class R, class... ArgTypes>
 [atomics.wait]: #atomics.wait
 [barrier.syn]: #barrier.syn
 [basic.align]: basic.md#basic.align
 [basic.fundamental]: basic.md#basic.fundamental
 [basic.life]: basic.md#basic.life
 [basic.stc.thread]: basic.md#basic.stc.thread
 [bitmask.types]: library.md#bitmask.types
 [cfenv]: numerics.md#cfenv
 [class.prop]: class.md#class.prop
 [compliance]: library.md#compliance
 [concept.booleantestable]: concepts.md#concept.booleantestable
 [condition.variable.syn]: #condition.variable.syn
 [conv.rval]: expr.md#conv.rval
 [cpp17.defaultconstructible]: #cpp17.defaultconstructible
 [cpp17.destructible]: #cpp17.destructible
 [cpp17.moveassignable]: #cpp17.moveassignable
 [cpp17.moveconstructible]: #cpp17.moveconstructible
 [defns.block]: intro.md#defns.block
 [except.terminate]: except.md#except.terminate
 [expr.pre]: expr.md#expr.pre
-[format.string.std]: utilities.md#format.string.std
 [func.invoke]: utilities.md#func.invoke
 [func.require]: utilities.md#func.require
 [function.objects]: utilities.md#function.objects
 [future.syn]: #future.syn
 [futures]: #futures
@@ -8412,34 +9877,62 @@ template<class R, class... ArgTypes>
 [futures.task]: #futures.task
 [futures.task.general]: #futures.task.general
 [futures.task.members]: #futures.task.members
 [futures.task.nonmembers]: #futures.task.nonmembers
 [futures.unique.future]: #futures.unique.future
 [intro.multithread]: basic.md#intro.multithread
 [intro.progress]: basic.md#intro.progress
 [intro.races]: basic.md#intro.races
 [latch.syn]: #latch.syn
 [limits.syn]: support.md#limits.syn
 [mutex.syn]: #mutex.syn
 [res.on.data.races]: library.md#res.on.data.races
 [res.on.exception.handling]: library.md#res.on.exception.handling
 [semaphore.syn]: #semaphore.syn
 [shared.mutex.syn]: #shared.mutex.syn
 [stdatomic.h.syn]: #stdatomic.h.syn
 [stopcallback]: #stopcallback
 [stopcallback.cons]: #stopcallback.cons
 [stopcallback.general]: #stopcallback.general
 [stopsource]: #stopsource
 [stopsource.cons]: #stopsource.cons
 [stopsource.general]: #stopsource.general
 [stopsource.mem]: #stopsource.mem
-[stopsource.nonmembers]: #stopsource.nonmembers
 [stoptoken]: #stoptoken
-[stoptoken.cons]: #stoptoken.cons
 [stoptoken.general]: #stoptoken.general
 [stoptoken.mem]: #stoptoken.mem
-[stoptoken.nonmembers]: #stoptoken.nonmembers
 [syserr]: diagnostics.md#syserr
 [syserr.syserr]: diagnostics.md#syserr.syserr
 [term.padding.bits]: basic.md#term.padding.bits
 [term.unevaluated.operand]: expr.md#term.unevaluated.operand
 [thread]: #thread

 | [[thread.threads]]   | Threads             | `<thread>`                  |
 | [[atomics]]          | Atomic operations   | `<atomic>`, `<stdatomic.h>` |
 | [[thread.mutex]]     | Mutual exclusion    | `<mutex>`, `<shared_mutex>` |
 | [[thread.condition]] | Condition variables | `<condition_variable>`      |
 | [[thread.sema]]      | Semaphores          | `<semaphore>`               |
+| [[thread.coord]]     | Coordination types  | `<latch>`, `<barrier>` |
 | [[futures]]          | Futures             | `<future>`                  |
+| [[saferecl]]         | Safe reclamation    | `<rcu>`, `<hazard_pointer>` |
 ## Requirements <a id="thread.req">[[thread.req]]</a>
 ### Template parameter names <a id="thread.req.paramname">[[thread.req.paramname]]</a>
 supplied by the implementation as specified in  [[time.clock]] do not
 throw exceptions. — *end note*]
 ### Requirements for *Cpp17Lockable* types <a id="thread.req.lockable">[[thread.req.lockable]]</a>
+#### General <a id="thread.req.lockable.general">[[thread.req.lockable.general]]</a>
 An *execution agent* is an entity such as a thread that may perform work
 in parallel with other execution agents.
 [*Note 1*: Implementations or users can introduce other kinds of agents
 nature of any lock ownership is not part of these
 definitions. — *end note*]
 #### *Cpp17BasicLockable* requirements <a id="thread.req.lockable.basic">[[thread.req.lockable.basic]]</a>
+A type `L` meets the requirements if the following expressions are
+well-formed and have the specified semantics (`m` denotes a value of
+type `L`).
 ``` cpp
 m.lock()
 ```
 *Throws:* Nothing.
 #### *Cpp17Lockable* requirements <a id="thread.req.lockable.req">[[thread.req.lockable.req]]</a>
+A type `L` meets the requirements if it meets the *Cpp17BasicLockable*
+requirements and the following expressions are well-formed and have the
+specified semantics (`m` denotes a value of type `L`).
 ``` cpp
 m.try_lock()
 ```
 *Returns:* `true` if the lock was acquired, otherwise `false`.
 #### *Cpp17TimedLockable* requirements <a id="thread.req.lockable.timed">[[thread.req.lockable.timed]]</a>
+A type `L` meets the requirements if it meets the *Cpp17Lockable*
+requirements and the following expressions are well-formed and have the
+specified semantics (`m` denotes a value of type `L`, `rel_time` denotes
+a value of an instantiation of `duration` [[time.duration]], and
+`abs_time` denotes a value of an instantiation of `time_point`
+[[time.point]]).
 ``` cpp
 m.try_lock_for(rel_time)
 ```
 *Returns:* `true` if the lock was acquired, otherwise `false`.
 #### *Cpp17SharedLockable* requirements <a id="thread.req.lockable.shared">[[thread.req.lockable.shared]]</a>
+A type `L` meets the requirements if the following expressions are
+well-formed, have the specified semantics, and the expression
+`m.try_lock_shared()` has type `bool` (`m` denotes a value of type `L`):
 ``` cpp
 m.lock_shared()
 ```
 *Throws:* Nothing.
 #### *Cpp17SharedTimedLockable* requirements <a id="thread.req.lockable.shared.timed">[[thread.req.lockable.shared.timed]]</a>
+A type `L` meets the requirements if it meets the *Cpp17SharedLockable*
+requirements, and the following expressions are well-formed, have type
+`bool`, and have the specified semantics (`m` denotes a value of type
+`L`, `rel_time` denotes a value of a specialization of
+`chrono::duration`, and `abs_time` denotes a value of a specialization
+of `chrono::time_point`).
 ``` cpp
 m.try_lock_shared_for(rel_time)
 ```
 Subclause [[thread.stoptoken]] describes components that can be used to
 asynchronously request that an operation stops execution in a timely
 manner, typically because the result is no longer required. Such a
 request is called a *stop request*.
+The concepts `stoppable-source`, `stoppable_token`, and
+`stoppable-callback-for` specify the required syntax and semantics of
+shared access to a *stop state*. Any object modeling `stoppable-source`,
+`stoppable_token`, or `stoppable-callback-for` that refers to the same
+stop state is an *associated* `stoppable-source`, `stoppable_token`, or
+`stoppable-callback-for`, respectively.
+An object of a type that models `stoppable_token` can be passed to an
+operation that can either
 - actively poll the token to check if there has been a stop request, or
+- register a callback that will be called in the event that a stop
+  request is made.
+A stop request made via an object whose type models `stoppable-source`
+will be visible to all associated `stoppable_token` and
+`stoppable-source` objects. Once a stop request has been made it cannot
+be withdrawn (a subsequent stop request has no effect).
+Callbacks registered via an object whose type models
+`stoppable-callback-for` are called when a stop request is first made by
+any associated `stoppable-source` object.
+The types `stop_source` and `stop_token` and the class template
+`stop_callback` implement the semantics of shared ownership of a stop
+state. The last remaining owner of the stop state automatically releases
+the resources associated with the stop state.
+An object of type `inplace_stop_source` is the sole owner of its stop
+state. An object of type `inplace_stop_token` or of a specialization of
+the class template `inplace_stop_callback` does not participate in
+ownership of its associated stop state.
+[*Note 1*: They are for use when all uses of the associated token and
+callback objects are known to nest within the lifetime of the
+`inplace_stop_source` object. — *end note*]
 ### Header `<stop_token>` synopsis <a id="thread.stoptoken.syn">[[thread.stoptoken.syn]]</a>
 ``` cpp
 namespace std {
+  // [stoptoken.concepts], stop token concepts
+  template<class CallbackFn, class Token, class Initializer = CallbackFn>
+    concept stoppable-callback-for = see below;           // exposition only
+  template<class Token>
+    concept stoppable_token = see below;
+  template<class Token>
+    concept unstoppable_token = see below;
+  template<class Source>
+    concept stoppable-source = see below;                 // exposition only
   // [stoptoken], class stop_token
   class stop_token;
   // [stopsource], class stop_source
   class stop_source;
   inline constexpr nostopstate_t nostopstate{};
   // [stopcallback], class template stop_callback
   template<class Callback>
     class stop_callback;
+  // [stoptoken.never], class never_stop_token
+  class never_stop_token;
+  // [stoptoken.inplace], class inplace_stop_token
+  class inplace_stop_token;
+  // [stopsource.inplace], class inplace_stop_source
+  class inplace_stop_source;
+  // [stopcallback.inplace], class template inplace_stop_callback
+  template<class CallbackFn>
+    class inplace_stop_callback;
+  template<class T, class CallbackFn>
+    using stop_callback_for_t = T::template callback_type<CallbackFn>;
 }
 ```
+### Stop token concepts <a id="stoptoken.concepts">[[stoptoken.concepts]]</a>
+The exposition-only `stoppable-callback-for` concept checks for a
+callback compatible with a given `Token` type.
+``` cpp
+template<class CallbackFn, class Token, class Initializer = CallbackFn>
+  concept stoppable-callback-for =                          // exposition only
+    invocable<CallbackFn> &&
+    constructible_from<CallbackFn, Initializer> &&
+    requires { typename stop_callback_for_t<Token, CallbackFn>; } &&
+    constructible_from<stop_callback_for_t<Token, CallbackFn>, const Token&, Initializer>;
+```
+Let `t` and `u` be distinct, valid objects of type `Token` that
+reference the same logical stop state; let `init` be an expression such
+that `same_as<decltype(init), Initializer>` is `true`; and let `SCB`
+denote the type `stop_callback_for_t<Token, CallbackFn>`.
+The concept `stoppable-callback-for<CallbackFn, Token, Initializer>` is
+modeled only if:
+- The following concepts are modeled:
+  - `\texttt{constructible_from}<SCB, Token, Initializer>`
+  - `\texttt{constructible_from}<SCB, Token&, Initializer>`
+  - `\texttt{constructible_from}<SCB, const Token, Initializer>`
+- An object of type `SCB` has an associated callback function of type
+  `CallbackFn`. Let `scb` be an object of type `SCB` and let
+  `callback_fn` denote `scb`’s associated callback function.
+  Direct-non-list-initializing `scb` from arguments `t` and `init` shall
+  execute a *stoppable callback registration* as follows:
+  - If `t.stop_possible()` is `true`:
+    - `callback_fn` shall be direct-initialized with `init`.
+    - Construction of `scb` shall only throw exceptions thrown by the
+      initialization of `callback_fn` from `init`.
+    - The callback invocation `std::forward<CallbackFn>(callback_fn)()`
+      shall be registered with `t`’s associated stop state as follows:
+      - If `t.stop_requested()` evaluates to `false` at the time of
+        registration, the callback invocation is added to the stop
+        state’s list of callbacks such that
+        `std::forward<CallbackFn>( callback_fn)()` is evaluated if a
+        stop request is made on the stop state.
+      - Otherwise, `std::forward<CallbackFn>(callback_fn)()` shall be
+        immediately evaluated on the thread executing `scb`’s
+        constructor, and the callback invocation shall not be added to
+        the list of callback invocations.
+      If the callback invocation was added to stop state’s list of
+      callbacks, `scb` shall be associated with the stop state.
+  - \[*Note 1*: If `t.stop_possible()` is `false`, there is no
+    requirement that the initialization of `scb` causes the
+    initialization of `callback_fn`. — *end note*]
+- Destruction of `scb` shall execute a
+  *stoppable callback deregistration* as follows (in order):
+  - If the constructor of `scb` did not register a callback invocation
+    with `t`’s stop state, then the stoppable callback deregistration
+    shall have no effect other than destroying `callback_fn` if it was
+    constructed.
+  - Otherwise, the invocation of `callback_fn` shall be removed from the
+    associated stop state.
+  - If `callback_fn` is concurrently executing on another thread, then
+    the stoppable callback deregistration shall block [[defns.block]]
+    until the invocation of `callback_fn` returns such that the return
+    from the invocation of `callback_fn` strongly happens before
+    [[intro.races]] the destruction of `callback_fn`.
+  - If `callback_fn` is executing on the current thread, then the
+    destructor shall not block waiting for the return from the
+    invocation of `callback_fn`.
+  - A stoppable callback deregistration shall not block on the
+    completion of the invocation of some other callback registered with
+    the same logical stop state.
+  - The stoppable callback deregistration shall destroy `callback_fn`.
+The `stoppable_token` concept checks for the basic interface of a stop
+token that is copyable and allows polling to see if stop has been
+requested and also whether a stop request is possible. The
+`unstoppable_token` concept checks for a `stoppable_token` type that
+does not allow stopping.
+``` cpp
+template<template<class> class>
+  struct check-type-alias-exists;                               // exposition only
+template<class Token>
+  concept stoppable_token =
+    requires (const Token tok) {
+      typename check-type-alias-exists<Token::template callback_type>;
+      { tok.stop_requested() } noexcept -> same_as<bool>;
+      { tok.stop_possible() } noexcept -> same_as<bool>;
+      { Token(tok) } noexcept;                  // see implicit expression variations[concepts.equality]
+    } &&
+    copyable<Token> &&
+    equality_comparable<Token>;
+template<class Token>
+  concept unstoppable_token =
+    stoppable_token<Token> &&
+    requires (const Token tok) {
+      requires bool_constant<(!tok.stop_possible())>::value;
+    };
+```
+An object whose type models `stoppable_token` has at most one associated
+logical stop state. A `stoppable_token` object with no associated stop
+state is said to be *disengaged*.
+Let `SP` be an evaluation of `t.stop_possible()` that is `false`, and
+let SR be an evaluation of `t.stop_requested()` that is `true`.
+The type `Token` models `stoppable_token` only if:
+- Any evaluation of `u.stop_possible()` or `u.stop_requested()` that
+  happens after [[intro.races]] `SP` is `false`.
+- Any evaluation of `u.stop_possible()` or `u.stop_requested()` that
+  happens after `SR` is `true`.
+- For any types `CallbackFn` and `Initializer` such that
+  `stoppable-callback-for<CallbackFn, Token, Initializer>` is satisfied,
+  `stoppable-callback-for<CallbackFn, Token, Initializer>` is modeled.
+- If `t` is disengaged, evaluations of `t.stop_possible()` and
+  `t.stop_requested()` are `false`.
+- If `t` and `u` reference the same stop state, or if both `t` and `u`
+  are disengaged, `t == u` is `true`; otherwise, it is `false`.
+An object whose type models the exposition-only `stoppable-source`
+concept can be queried whether stop has been requested
+(`stop_requested`) and whether stop is possible (`stop_possible`). It is
+a factory for associated stop tokens (`get_token`), and a stop request
+can be made on it (`request_stop`). It maintains a list of registered
+stop callback invocations that it executes when a stop request is first
+made.
+``` cpp
+template<class Source>
+  concept stoppable-source =                                    // exposition only
+    requires (Source& src, const Source csrc) {         // see implicit expression variations[concepts.equality]
+      { csrc.get_token() } -> stoppable_token;
+      { csrc.stop_possible() } noexcept -> same_as<bool>;
+      { csrc.stop_requested() } noexcept -> same_as<bool>;
+      { src.request_stop() } -> same_as<bool>;
+    };
+```
+An object whose type models `stoppable-source` has at most one
+associated logical stop state. If it has no associated stop state, it is
+said to be disengaged. Let `s` be an object whose type models
+`stoppable-source` and that is disengaged. `s.stop_possible()` and
+`s.stop_requested()` shall be `false`.
+Let `t` be an object whose type models `stoppable-source`. If `t` is
+disengaged, `t.get_token()` shall return a disengaged stop token;
+otherwise, it shall return a stop token that is associated with the stop
+state of `t`.
+Calls to the member functions `request_stop`, `stop_requested`, and
+`stop_possible` and similarly named member functions on associated
+`stoppable_token` objects do not introduce data races. A call to
+`request_stop` that returns `true` synchronizes with a call to
+`stop_requested` on an associated `stoppable_token` or
+`stoppable-source` object that returns `true`. Registration of a
+callback synchronizes with the invocation of that callback.
+If the `stoppable-source` is disengaged, `request_stop` shall have no
+effect and return `false`. Otherwise, it shall execute a
+*stop request operation* on the associated stop state. A stop request
+operation determines whether the stop state has received a stop request,
+and if not, makes a stop request. The determination and making of the
+stop request shall happen atomically, as-if by a read-modify-write
+operation [[intro.races]]. If the request was made, the stop state’s
+registered callback invocations shall be synchronously executed. If an
+invocation of a callback exits via an exception then `terminate` shall
+be invoked [[except.terminate]].
+[*Note 2*: No constraint is placed on the order in which the callback
+invocations are executed. — *end note*]
+`request_stop` shall return `true` if a stop request was made, and
+`false` otherwise. After a call to `request_stop` either a call to
+`stop_possible` shall return `false` or a call to `stop_requested` shall
+return `true`.
+[*Note 3*: A stop request includes notifying all condition variables of
+type `condition_variable_any` temporarily registered during an
+interruptible wait [[thread.condvarany.intwait]]. — *end note*]
 ### Class `stop_token` <a id="stoptoken">[[stoptoken]]</a>
 #### General <a id="stoptoken.general">[[stoptoken.general]]</a>
+The class `stop_token` models the concept `stoppable_token`. It shares
+ownership of its stop state, if any, with its associated `stop_source`
+object [[stopsource]] and any `stop_token` objects to which it compares
+equal.
 ``` cpp
 namespace std {
   class stop_token {
   public:
+ template<class CallbackFn>
+      using callback_type = stop_callback<CallbackFn>;
+    stop_token() noexcept = default;
+ // [stoptoken.mem], member functions
     void swap(stop_token&) noexcept;
+ bool stop_requested() const noexcept;
+    bool stop_possible() const noexcept;
+    bool operator==(const stop_token& rhs) noexcept = default;
+  private:
+    shared_ptr<unspecified> stop-state;                           // exposition only
   };
 }
 ```
+*`stop-state`* refers to the `stop_token`’s associated stop state. A
+`stop_token` object is disengaged when *`stop-state`* is empty.
+#### Member functions <a id="stoptoken.mem">[[stoptoken.mem]]</a>
 ``` cpp
 void swap(stop_token& rhs) noexcept;
 ```
+*Effects:* Equivalent to:
+``` cpp
+stop-state.swap(rhs.stop-state);
+```
 ``` cpp
+bool stop_requested() const noexcept;
 ```
+*Returns:* `true` if *stop-state* refers to a stop state that has
 received a stop request; otherwise, `false`.
 ``` cpp
+bool stop_possible() const noexcept;
 ```
+*Returns:* `false` if
+- `*this` is disengaged, or
 - a stop request was not made and there are no associated `stop_source`
   objects;
 otherwise, `true`.
 ### Class `stop_source` <a id="stopsource">[[stopsource]]</a>
 #### General <a id="stopsource.general">[[stopsource.general]]</a>
 ``` cpp
 namespace std {
   class stop_source {
   public:
     // [stopsource.cons], constructors, copy, and assignment
     stop_source();
+    explicit stop_source(nostopstate_t) noexcept {}
+ // [stopsource.mem], member functions
     void swap(stop_source&) noexcept;
+ stop_token get_token() const noexcept;
+ bool stop_possible() const noexcept;
+    bool stop_requested() const noexcept;
     bool request_stop() noexcept;
+ bool operator==(const stop_source& rhs) noexcept = default;
+  private:
+    shared_ptr<unspecified> stop-state;                         // exposition only
   };
 }
 ```
+*`stop-state`* refers to the `stop_source`’s associated stop state. A
+`stop_source` object is disengaged when *`stop-state`* is empty.
+`stop_source` models `stoppable-source`, `copyable`,
+`equality_comparable`, and `swappable`.
 #### Constructors, copy, and assignment <a id="stopsource.cons">[[stopsource.cons]]</a>
 ``` cpp
 stop_source();
 ```
+*Effects:* Initializes *stop-state* with a pointer to a new stop state.
 *Ensures:* `stop_possible()` is `true` and `stop_requested()` is
 `false`.
 *Throws:* `bad_alloc` if memory cannot be allocated for the stop state.
+#### Member functions <a id="stopsource.mem">[[stopsource.mem]]</a>
 ``` cpp
 void swap(stop_source& rhs) noexcept;
 ```
+*Effects:* Equivalent to:
+``` cpp
+stop-state.swap(rhs.stop-state);
+```
 ``` cpp
+stop_token get_token() const noexcept;
 ```
 *Returns:* `stop_token()` if `stop_possible()` is `false`; otherwise a
+new associated `stop_token` object; i.e., its *stop-state* member is
+equal to the *stop-state* member of `*this`.
 ``` cpp
+bool stop_possible() const noexcept;
 ```
+*Returns:* *`stop-state`*` != nullptr`.
 ``` cpp
+bool stop_requested() const noexcept;
 ```
+*Returns:* `true` if *stop-state* refers to a stop state that has
 received a stop request; otherwise, `false`.
 ``` cpp
 bool request_stop() noexcept;
 ```
+*Effects:* Executes a stop request operation [[stoptoken.concepts]] on
+the associated stop state, if any.
 ### Class template `stop_callback` <a id="stopcallback">[[stopcallback]]</a>
 #### General <a id="stopcallback.general">[[stopcallback.general]]</a>
 ``` cpp
 namespace std {
+  template<class CallbackFn>
   class stop_callback {
   public:
+    using callback_type = CallbackFn;
     // [stopcallback.cons], constructors and destructor
+    template<class Initializer>
+      explicit stop_callback(const stop_token& st, Initializer&& init)
+        noexcept(is_nothrow_constructible_v<CallbackFn, Initializer>);
+    template<class Initializer>
+      explicit stop_callback(stop_token&& st, Initializer&& init)
+        noexcept(is_nothrow_constructible_v<CallbackFn, Initializer>);
     ~stop_callback();
     stop_callback(const stop_callback&) = delete;
     stop_callback(stop_callback&&) = delete;
     stop_callback& operator=(const stop_callback&) = delete;
     stop_callback& operator=(stop_callback&&) = delete;
   private:
+ CallbackFn callback-fn; // exposition only
   };
+  template<class CallbackFn>
+    stop_callback(stop_token, CallbackFn) -> stop_callback<CallbackFn>;
 }
 ```
 *Mandates:* `stop_callback` is instantiated with an argument for the
+template parameter `CallbackFn` that satisfies both `invocable` and
 `destructible`.
+*Remarks:* For a type `Initializer`, if
+`stoppable-callback-for<CallbackFn, stop_token, Initializer>` is
+satisfied, then
+`stoppable-callback-for<CallbackFn, stop_token, Initializer>` is
+modeled. The exposition-only *`callback-fn`* member is the associated
+callback function [[stoptoken.concepts]] of `stop_callback< CallbackFn>`
+objects.
 #### Constructors and destructor <a id="stopcallback.cons">[[stopcallback.cons]]</a>
 ``` cpp
+template<class Initializer>
+ explicit stop_callback(const stop_token& st, Initializer&& init)
+ noexcept(is_nothrow_constructible_v<CallbackFn, Initializer>);
+template<class Initializer>
+ explicit stop_callback(stop_token&& st, Initializer&& init)
+    noexcept(is_nothrow_constructible_v<CallbackFn, Initializer>);
 ```
+*Constraints:* `CallbackFn` and `Initializer` satisfy
+`constructible_from<CallbackFn, Initializer>`.
+*Effects:* Initializes *callback-fn* with
+`std::forward<Initializer>(init)` and executes a stoppable callback
+registration [[stoptoken.concepts]]. If a callback is registered with
+`st`’s shared stop state, then `*this` acquires shared ownership of that
+stop state.
 ``` cpp
 ~stop_callback();
 ```
+*Effects:* Executes a stoppable callback
+deregistration [[stoptoken.concepts]] and releases ownership of the stop
+state, if any.
+### Class `never_stop_token` <a id="stoptoken.never">[[stoptoken.never]]</a>
+The class `never_stop_token` models the `unstoppable_token` concept. It
+provides a stop token interface, but also provides static information
+that a stop is never possible nor requested.
+``` cpp
+namespace std {
+  class never_stop_token {
+    struct callback-type {                                      // exposition only
+      explicit callback-type(never_stop_token, auto&&) noexcept {}
+    };
+  public:
+    template<class>
+      using callback_type = callback-type;
+    static constexpr bool stop_requested() noexcept { return false; }
+    static constexpr bool stop_possible() noexcept { return false; }
+    bool operator==(const never_stop_token&) const = default;
+  };
+}
+```
+### Class `inplace_stop_token` <a id="stoptoken.inplace">[[stoptoken.inplace]]</a>
+#### General <a id="stoptoken.inplace.general">[[stoptoken.inplace.general]]</a>
+The class `inplace_stop_token` models the concept `stoppable_token`. It
+references the stop state of its associated `inplace_stop_source` object
+[[stopsource.inplace]], if any.
+``` cpp
+namespace std {
+  class inplace_stop_token {
+  public:
+    template<class CallbackFn>
+      using callback_type = inplace_stop_callback<CallbackFn>;
+    inplace_stop_token() = default;
+    bool operator==(const inplace_stop_token&) const = default;
+    // [stoptoken.inplace.mem], member functions
+    bool stop_requested() const noexcept;
+    bool stop_possible() const noexcept;
+    void swap(inplace_stop_token&) noexcept;
+  private:
+    const inplace_stop_source* stop-source = nullptr;           // exposition only
+  };
+}
+```
+#### Member functions <a id="stoptoken.inplace.mem">[[stoptoken.inplace.mem]]</a>
+``` cpp
+void swap(inplace_stop_token& rhs) noexcept;
+```
+*Effects:* Exchanges the values of *stop-source* and
+`rhs.`*`stop-source`*.
+``` cpp
+bool stop_requested() const noexcept;
+```
+*Effects:* Equivalent to:
+``` cpp
+return stop-source != nullptr && stop-source->stop_requested();
+```
+[*Note 1*: As specified in [[basic.life]], the behavior of
+`stop_requested` is undefined unless the call strongly happens before
+the start of the destructor of the associated `inplace_stop_source`
+object, if any. — *end note*]
+``` cpp
+stop_possible() const noexcept;
+```
+*Returns:* *`stop-source`*` != nullptr`.
+[*Note 2*: As specified in [[basic.stc.general]], the behavior of
+`stop_possible` is implementation-defined unless the call strongly
+happens before the end of the storage duration of the associated
+`inplace_stop_source` object, if any. — *end note*]
+### Class `inplace_stop_source` <a id="stopsource.inplace">[[stopsource.inplace]]</a>
+#### General <a id="stopsource.inplace.general">[[stopsource.inplace.general]]</a>
+The class `inplace_stop_source` models `stoppable-source`.
+``` cpp
+namespace std {
+  class inplace_stop_source {
+  public:
+    // [stopsource.inplace.cons], constructors
+    constexpr inplace_stop_source() noexcept;
+    inplace_stop_source(inplace_stop_source&&) = delete;
+    inplace_stop_source(const inplace_stop_source&) = delete;
+    inplace_stop_source& operator=(inplace_stop_source&&) = delete;
+    inplace_stop_source& operator=(const inplace_stop_source&) = delete;
+    ~inplace_stop_source();
+    // [stopsource.inplace.mem], stop handling
+    constexpr inplace_stop_token get_token() const noexcept;
+    static constexpr bool stop_possible() noexcept { return true; }
+    bool stop_requested() const noexcept;
+    bool request_stop() noexcept;
+  };
+}
+```
+#### Constructors <a id="stopsource.inplace.cons">[[stopsource.inplace.cons]]</a>
+``` cpp
+constexpr inplace_stop_source() noexcept;
+```
+*Effects:* Initializes a new stop state inside `*this`.
+*Ensures:* `stop_requested()` is `false`.
+#### Member functions <a id="stopsource.inplace.mem">[[stopsource.inplace.mem]]</a>
+``` cpp
+constexpr inplace_stop_token get_token() const noexcept;
+```
+*Returns:* A new associated `inplace_stop_token` object whose
+*stop-source* member is equal to `this`.
+``` cpp
+bool stop_requested() const noexcept;
+```
+*Returns:* `true` if the stop state inside `*this` has received a stop
+request; otherwise, `false`.
+``` cpp
+bool request_stop() noexcept;
+```
+*Effects:* Executes a stop request operation [[stoptoken.concepts]].
+*Ensures:* `stop_requested()` is `true`.
+### Class template `inplace_stop_callback` <a id="stopcallback.inplace">[[stopcallback.inplace]]</a>
+#### General <a id="stopcallback.inplace.general">[[stopcallback.inplace.general]]</a>
+``` cpp
+namespace std {
+  template<class CallbackFn>
+  class inplace_stop_callback {
+  public:
+    using callback_type = CallbackFn;
+    // [stopcallback.inplace.cons], constructors and destructor
+    template<class Initializer>
+      explicit inplace_stop_callback(inplace_stop_token st, Initializer&& init)
+        noexcept(is_nothrow_constructible_v<CallbackFn, Initializer>);
+    ~inplace_stop_callback();
+    inplace_stop_callback(inplace_stop_callback&&) = delete;
+    inplace_stop_callback(const inplace_stop_callback&) = delete;
+    inplace_stop_callback& operator=(inplace_stop_callback&&) = delete;
+    inplace_stop_callback& operator=(const inplace_stop_callback&) = delete;
+  private:
+    CallbackFn callback-fn;                                     // exposition only
+  };
+  template<class CallbackFn>
+    inplace_stop_callback(inplace_stop_token, CallbackFn)
+      -> inplace_stop_callback<CallbackFn>;
+}
+```
+*Mandates:* `CallbackFn` satisfies both `invocable` and `destructible`.
+*Remarks:* For a type `Initializer`, if
+``` cpp
+stoppable-callback-for<CallbackFn, inplace_stop_token, Initializer>
+```
+is satisfied, then
+``` cpp
+stoppable-callback-for<CallbackFn, inplace_stop_token, Initializer>
+```
+is modeled. For an `inplace_stop_callback<CallbackFn>` object, the
+exposition-only *`callback-fn`* member is its associated callback
+function [[stoptoken.concepts]].
+#### Constructors and destructor <a id="stopcallback.inplace.cons">[[stopcallback.inplace.cons]]</a>
+``` cpp
+template<class Initializer>
+  explicit inplace_stop_callback(inplace_stop_token st, Initializer&& init)
+    noexcept(is_nothrow_constructible_v<CallbackFn, Initializer>);
+```
+*Constraints:* `constructible_from<CallbackFn, Initializer>` is
+satisfied.
+*Effects:* Initializes *callback-fn* with
+`std::forward<Initializer>(init)` and executes a stoppable callback
+registration [[stoptoken.concepts]].
+``` cpp
+~inplace_stop_callback();
+```
+*Effects:* Executes a stoppable callback
+deregistration [[stoptoken.concepts]].
 ## Threads <a id="thread.threads">[[thread.threads]]</a>
 ### General <a id="thread.threads.general">[[thread.threads.general]]</a>
     jthread& operator=(const jthread&) = delete;
     jthread& operator=(jthread&&) noexcept;
     // [thread.jthread.mem], members
     void swap(jthread&) noexcept;
+    bool joinable() const noexcept;
     void join();
     void detach();
+    id get_id() const noexcept;
+    native_handle_type native_handle(); // see~[thread.req.native]
     // [thread.jthread.stop], stop token handling
+    stop_source get_stop_source() noexcept;
+    stop_token get_stop_token() const noexcept;
     bool request_stop() noexcept;
     // [thread.jthread.special], specialized algorithms
     friend void swap(jthread& lhs, jthread& rhs) noexcept;
     // [thread.jthread.static], static members
+    static unsigned int hardware_concurrency() noexcept;
   private:
     stop_source ssource;        // exposition only
   };
 }
 ```
 *Effects:* Exchanges the values of `*this` and `x`.
 ``` cpp
+bool joinable() const noexcept;
 ```
 *Returns:* `get_id() != id()`.
 ``` cpp
 execution represented by `*this`.
 #### Stop token handling <a id="thread.jthread.stop">[[thread.jthread.stop]]</a>
 ``` cpp
+stop_source get_stop_source() noexcept;
 ```
 *Effects:* Equivalent to: `return ssource;`
 ``` cpp
+stop_token get_stop_token() const noexcept;
 ```
 *Effects:* Equivalent to: `return ssource.get_token();`
 ``` cpp
 *Effects:* Equivalent to: `x.swap(y)`.
 #### Static members <a id="thread.jthread.static">[[thread.jthread.static]]</a>
 ``` cpp
+static unsigned int hardware_concurrency() noexcept;
 ```
 *Returns:* `thread::hardware_concurrency()`.
 ### Namespace `this_thread` <a id="thread.thread.this">[[thread.thread.this]]</a>
 access. This access is provided via operations on atomic objects.
 ### Header `<atomic>` synopsis <a id="atomics.syn">[[atomics.syn]]</a>
 ``` cpp
+// mostly freestanding
 namespace std {
   // [atomics.order], order and consistency
+  enum class memory_order : unspecified;
+  inline constexpr memory_order memory_order_relaxed = memory_order::relaxed;
+  inline constexpr memory_order memory_order_acquire = memory_order::acquire;
+  inline constexpr memory_order memory_order_release = memory_order::release;
+  inline constexpr memory_order memory_order_acq_rel = memory_order::acq_rel;
+  inline constexpr memory_order memory_order_seq_cst = memory_order::seq_cst;
 }
 // [atomics.lockfree], lock-free property
+#define ATOMIC_BOOL_LOCK_FREE unspecified
+#define ATOMIC_CHAR_LOCK_FREE unspecified
+#define ATOMIC_CHAR8_T_LOCK_FREE unspecified
+#define ATOMIC_CHAR16_T_LOCK_FREE unspecified
+#define ATOMIC_CHAR32_T_LOCK_FREE unspecified
+#define ATOMIC_WCHAR_T_LOCK_FREE unspecified
+#define ATOMIC_SHORT_LOCK_FREE unspecified
+#define ATOMIC_INT_LOCK_FREE unspecified
+#define ATOMIC_LONG_LOCK_FREE unspecified
+#define ATOMIC_LLONG_LOCK_FREE unspecified
+#define ATOMIC_POINTER_LOCK_FREE unspecified
 namespace std {
   // [atomics.ref.generic], class template atomic_ref
+  template<class T> struct atomic_ref;
   // [atomics.types.generic], class template atomic
+  template<class T> struct atomic;
   // [atomics.types.pointer], partial specialization for pointers
+  template<class T> struct atomic<T*>;
   // [atomics.nonmembers], non-member functions
   template<class T>
+    bool atomic_is_lock_free(const volatile atomic<T>*) noexcept;
   template<class T>
+    bool atomic_is_lock_free(const atomic<T>*) noexcept;
   template<class T>
+    void atomic_store(volatile atomic<T>*, typename atomic<T>::value_type) noexcept;
   template<class T>
+ constexpr void atomic_store(atomic<T>*, typename atomic<T>::value_type) noexcept;
   template<class T>
+    void atomic_store_explicit(volatile atomic<T>*, typename atomic<T>::value_type,
                                memory_order) noexcept;
   template<class T>
+ constexpr void atomic_store_explicit(atomic<T>*, typename atomic<T>::value_type,
                                          memory_order) noexcept;
   template<class T>
+    T atomic_load(const volatile atomic<T>*) noexcept;
   template<class T>
+ constexpr T atomic_load(const atomic<T>*) noexcept;
   template<class T>
+    T atomic_load_explicit(const volatile atomic<T>*, memory_order) noexcept;
   template<class T>
+ constexpr T atomic_load_explicit(const atomic<T>*, memory_order) noexcept;
   template<class T>
+    T atomic_exchange(volatile atomic<T>*, typename atomic<T>::value_type) noexcept;
   template<class T>
+ constexpr T atomic_exchange(atomic<T>*, typename atomic<T>::value_type) noexcept;
   template<class T>
+    T atomic_exchange_explicit(volatile atomic<T>*, typename atomic<T>::value_type,
                                memory_order) noexcept;
   template<class T>
+ constexpr T atomic_exchange_explicit(atomic<T>*, typename atomic<T>::value_type,
                                          memory_order) noexcept;
   template<class T>
+    bool atomic_compare_exchange_weak(volatile atomic<T>*,
                                       typename atomic<T>::value_type*,
                                       typename atomic<T>::value_type) noexcept;
   template<class T>
+ constexpr bool atomic_compare_exchange_weak(atomic<T>*,
                                                 typename atomic<T>::value_type*,
                                                 typename atomic<T>::value_type) noexcept;
   template<class T>
+    bool atomic_compare_exchange_strong(volatile atomic<T>*,
                                         typename atomic<T>::value_type*,
                                         typename atomic<T>::value_type) noexcept;
   template<class T>
+ constexpr bool atomic_compare_exchange_strong(atomic<T>*,
                                                   typename atomic<T>::value_type*,
                                                   typename atomic<T>::value_type) noexcept;
   template<class T>
+    bool atomic_compare_exchange_weak_explicit(volatile atomic<T>*,
                                                typename atomic<T>::value_type*,
                                                typename atomic<T>::value_type,
                                                memory_order, memory_order) noexcept;
   template<class T>
+ constexpr bool atomic_compare_exchange_weak_explicit(atomic<T>*,
                                                          typename atomic<T>::value_type*,
                                                          typename atomic<T>::value_type,
                                                          memory_order, memory_order) noexcept;
   template<class T>
+    bool atomic_compare_exchange_strong_explicit(volatile atomic<T>*,
                                                  typename atomic<T>::value_type*,
                                                  typename atomic<T>::value_type,
                                                  memory_order, memory_order) noexcept;
   template<class T>
+ constexpr bool atomic_compare_exchange_strong_explicit(atomic<T>*,
                                                            typename atomic<T>::value_type*,
                                                            typename atomic<T>::value_type,
                                                            memory_order, memory_order) noexcept;
   template<class T>
+    T atomic_fetch_add(volatile atomic<T>*, typename atomic<T>::difference_type) noexcept;
   template<class T>
+ constexpr T atomic_fetch_add(atomic<T>*, typename atomic<T>::difference_type) noexcept;
   template<class T>
+    T atomic_fetch_add_explicit(volatile atomic<T>*, typename atomic<T>::difference_type,
                                 memory_order) noexcept;
   template<class T>
+ constexpr T atomic_fetch_add_explicit(atomic<T>*, typename atomic<T>::difference_type,
                                           memory_order) noexcept;
   template<class T>
+    T atomic_fetch_sub(volatile atomic<T>*, typename atomic<T>::difference_type) noexcept;
   template<class T>
+ constexpr T atomic_fetch_sub(atomic<T>*, typename atomic<T>::difference_type) noexcept;
   template<class T>
+    T atomic_fetch_sub_explicit(volatile atomic<T>*, typename atomic<T>::difference_type,
                                 memory_order) noexcept;
   template<class T>
+ constexpr T atomic_fetch_sub_explicit(atomic<T>*, typename atomic<T>::difference_type,
                                           memory_order) noexcept;
   template<class T>
+    T atomic_fetch_and(volatile atomic<T>*, typename atomic<T>::value_type) noexcept;
   template<class T>
+ constexpr T atomic_fetch_and(atomic<T>*, typename atomic<T>::value_type) noexcept;
   template<class T>
+    T atomic_fetch_and_explicit(volatile atomic<T>*, typename atomic<T>::value_type,
                                 memory_order) noexcept;
   template<class T>
+ constexpr T atomic_fetch_and_explicit(atomic<T>*, typename atomic<T>::value_type,
                                           memory_order) noexcept;
   template<class T>
+    T atomic_fetch_or(volatile atomic<T>*, typename atomic<T>::value_type) noexcept;
   template<class T>
+ constexpr T atomic_fetch_or(atomic<T>*, typename atomic<T>::value_type) noexcept;
   template<class T>
+    T atomic_fetch_or_explicit(volatile atomic<T>*, typename atomic<T>::value_type,
                                memory_order) noexcept;
   template<class T>
+ constexpr T atomic_fetch_or_explicit(atomic<T>*, typename atomic<T>::value_type,
                                          memory_order) noexcept;
   template<class T>
+    T atomic_fetch_xor(volatile atomic<T>*, typename atomic<T>::value_type) noexcept;
   template<class T>
+ constexpr T atomic_fetch_xor(atomic<T>*, typename atomic<T>::value_type) noexcept;
   template<class T>
+    T atomic_fetch_xor_explicit(volatile atomic<T>*, typename atomic<T>::value_type,
+ memory_order) noexcept;
+  template<class T>
+    constexpr T atomic_fetch_xor_explicit(atomic<T>*, typename atomic<T>::value_type,
+                                          memory_order) noexcept;
+  template<class T>
+    T atomic_fetch_max(volatile atomic<T>*, typename atomic<T>::value_type) noexcept;
+  template<class T>
+    constexpr T atomic_fetch_max(atomic<T>*, typename atomic<T>::value_type) noexcept;
+  template<class T>
+    T atomic_fetch_max_explicit(volatile atomic<T>*, typename atomic<T>::value_type,
+                                memory_order) noexcept;
+  template<class T>
+    constexpr T atomic_fetch_max_explicit(atomic<T>*, typename atomic<T>::value_type,
+                                          memory_order) noexcept;
+  template<class T>
+    T atomic_fetch_min(volatile atomic<T>*, typename atomic<T>::value_type) noexcept;
+  template<class T>
+    constexpr T atomic_fetch_min(atomic<T>*, typename atomic<T>::value_type) noexcept;
+  template<class T>
+    T atomic_fetch_min_explicit(volatile atomic<T>*, typename atomic<T>::value_type,
                                 memory_order) noexcept;
   template<class T>
+ constexpr T atomic_fetch_min_explicit(atomic<T>*, typename atomic<T>::value_type,
                                           memory_order) noexcept;
   template<class T>
+    void atomic_store_add(volatile atomic<T>*, typename atomic<T>::difference_type) noexcept;
   template<class T>
+ constexpr void atomic_store_add(atomic<T>*, typename atomic<T>::difference_type) noexcept;
   template<class T>
+    void atomic_store_add_explicit(volatile atomic<T>*, typename atomic<T>::difference_type,
+                                   memory_order) noexcept;
+  template<class T>
+    constexpr void atomic_store_add_explicit(atomic<T>*, typename atomic<T>::difference_type,
+                                             memory_order) noexcept;
+  template<class T>
+    void atomic_store_sub(volatile atomic<T>*, typename atomic<T>::difference_type) noexcept;
+  template<class T>
+    constexpr void atomic_store_sub(atomic<T>*, typename atomic<T>::difference_type) noexcept;
+  template<class T>
+    void atomic_store_sub_explicit(volatile atomic<T>*, typename atomic<T>::difference_type,
+                                   memory_order) noexcept;
+  template<class T>
+    constexpr void atomic_store_sub_explicit(atomic<T>*, typename atomic<T>::difference_type,
+                                             memory_order) noexcept;
+  template<class T>
+    void atomic_store_and(volatile atomic<T>*, typename atomic<T>::value_type) noexcept;
+  template<class T>
+    constexpr void atomic_store_and(atomic<T>*, typename atomic<T>::value_type) noexcept;
+  template<class T>
+    void atomic_store_and_explicit(volatile atomic<T>*, typename atomic<T>::value_type,
+                                   memory_order) noexcept;
+  template<class T>
+    constexpr void atomic_store_and_explicit(atomic<T>*, typename atomic<T>::value_type,
+                                             memory_order) noexcept;
+  template<class T>
+    void atomic_store_or(volatile atomic<T>*, typename atomic<T>::value_type) noexcept;
+  template<class T>
+    constexpr void atomic_store_or(atomic<T>*, typename atomic<T>::value_type) noexcept;
+  template<class T>
+    void atomic_store_or_explicit(volatile atomic<T>*, typename atomic<T>::value_type,
+                                  memory_order) noexcept;
+  template<class T>
+    constexpr void atomic_store_or_explicit(atomic<T>*, typename atomic<T>::value_type,
+                                            memory_order) noexcept;
+  template<class T>
+    void atomic_store_xor(volatile atomic<T>*, typename atomic<T>::value_type) noexcept;
+  template<class T>
+    constexpr void atomic_store_xor(atomic<T>*, typename atomic<T>::value_type) noexcept;
+  template<class T>
+    void atomic_store_xor_explicit(volatile atomic<T>*, typename atomic<T>::value_type,
+                                   memory_order) noexcept;
+  template<class T>
+    constexpr void atomic_store_xor_explicit(atomic<T>*, typename atomic<T>::value_type,
+                                             memory_order) noexcept;
+  template<class T>
+    void atomic_store_max(volatile atomic<T>*, typename atomic<T>::value_type) noexcept;
+  template<class T>
+    constexpr void atomic_store_max(atomic<T>*, typename atomic<T>::value_type) noexcept;
+  template<class T>
+    void atomic_store_max_explicit(volatile atomic<T>*, typename atomic<T>::value_type,
+                                   memory_order) noexcept;
+  template<class T>
+    constexpr void atomic_store_max_explicit(atomic<T>*, typename atomic<T>::value_type,
+                                             memory_order) noexcept;
+  template<class T>
+    void atomic_store_min(volatile atomic<T>*, typename atomic<T>::value_type) noexcept;
+  template<class T>
+    constexpr void atomic_store_min(atomic<T>*, typename atomic<T>::value_type) noexcept;
+  template<class T>
+    void atomic_store_min_explicit(volatile atomic<T>*, typename atomic<T>::value_type,
+                                   memory_order) noexcept;
+  template<class T>
+    constexpr void atomic_store_min_explicit(atomic<T>*, typename atomic<T>::value_type,
+                                             memory_order) noexcept;
+  template<class T>
+    void atomic_wait(const volatile atomic<T>*, typename atomic<T>::value_type) noexcept;
+  template<class T>
+    constexpr void atomic_wait(const atomic<T>*, typename atomic<T>::value_type) noexcept;
+  template<class T>
+    void atomic_wait_explicit(const volatile atomic<T>*, typename atomic<T>::value_type,
                               memory_order) noexcept;
   template<class T>
+ constexpr void atomic_wait_explicit(const atomic<T>*, typename atomic<T>::value_type,
                                         memory_order) noexcept;
   template<class T>
+    void atomic_notify_one(volatile atomic<T>*) noexcept;
   template<class T>
+ constexpr void atomic_notify_one(atomic<T>*) noexcept;
   template<class T>
+    void atomic_notify_all(volatile atomic<T>*) noexcept;
   template<class T>
+ constexpr void atomic_notify_all(atomic<T>*) noexcept;
   // [atomics.alias], type aliases
+  using atomic_bool           = atomic<bool>;
+  using atomic_char           = atomic<char>;
+  using atomic_schar          = atomic<signed char>;
+  using atomic_uchar          = atomic<unsigned char>;
+  using atomic_short          = atomic<short>;
+  using atomic_ushort         = atomic<unsigned short>;
+  using atomic_int            = atomic<int>;
+  using atomic_uint           = atomic<unsigned int>;
+  using atomic_long           = atomic<long>;
+  using atomic_ulong          = atomic<unsigned long>;
+  using atomic_llong          = atomic<long long>;
+  using atomic_ullong         = atomic<unsigned long long>;
+  using atomic_char8_t        = atomic<char8_t>;
+  using atomic_char16_t       = atomic<char16_t>;
+  using atomic_char32_t       = atomic<char32_t>;
+  using atomic_wchar_t        = atomic<wchar_t>;
+  using atomic_int8_t         = atomic<int8_t>;
+  using atomic_uint8_t        = atomic<uint8_t>;
+  using atomic_int16_t        = atomic<int16_t>;
+  using atomic_uint16_t       = atomic<uint16_t>;
+  using atomic_int32_t        = atomic<int32_t>;
+  using atomic_uint32_t       = atomic<uint32_t>;
+  using atomic_int64_t        = atomic<int64_t>;
+  using atomic_uint64_t       = atomic<uint64_t>;
+  using atomic_int_least8_t   = atomic<int_least8_t>;
+  using atomic_uint_least8_t  = atomic<uint_least8_t>;
+  using atomic_int_least16_t  = atomic<int_least16_t>;
+  using atomic_uint_least16_t = atomic<uint_least16_t>;
+  using atomic_int_least32_t  = atomic<int_least32_t>;
+  using atomic_uint_least32_t = atomic<uint_least32_t>;
+  using atomic_int_least64_t  = atomic<int_least64_t>;
+  using atomic_uint_least64_t = atomic<uint_least64_t>;
+  using atomic_int_fast8_t    = atomic<int_fast8_t>;
+  using atomic_uint_fast8_t   = atomic<uint_fast8_t>;
+  using atomic_int_fast16_t   = atomic<int_fast16_t>;
+  using atomic_uint_fast16_t  = atomic<uint_fast16_t>;
+  using atomic_int_fast32_t   = atomic<int_fast32_t>;
+  using atomic_uint_fast32_t  = atomic<uint_fast32_t>;
+  using atomic_int_fast64_t   = atomic<int_fast64_t>;
+  using atomic_uint_fast64_t  = atomic<uint_fast64_t>;
+  using atomic_intptr_t       = atomic<intptr_t>;
+  using atomic_uintptr_t      = atomic<uintptr_t>;
+  using atomic_size_t         = atomic<size_t>;
+  using atomic_ptrdiff_t      = atomic<ptrdiff_t>;
+  using atomic_intmax_t       = atomic<intmax_t>;
+  using atomic_uintmax_t      = atomic<uintmax_t>;
+  using atomic_signed_lock_free   = see below;                  // hosted
+  using atomic_unsigned_lock_free = see below;                  // hosted
   // [atomics.flag], flag type and operations
+  struct atomic_flag;
+  bool atomic_flag_test(const volatile atomic_flag*) noexcept;
+ constexpr bool atomic_flag_test(const atomic_flag*) noexcept;
+  bool atomic_flag_test_explicit(const volatile atomic_flag*, memory_order) noexcept;
+  constexpr bool atomic_flag_test_explicit(const atomic_flag*, memory_order) noexcept;
+  bool atomic_flag_test_and_set(volatile atomic_flag*) noexcept;
+ constexpr bool atomic_flag_test_and_set(atomic_flag*) noexcept;
+  bool atomic_flag_test_and_set_explicit(volatile atomic_flag*, memory_order) noexcept;
+ constexpr bool atomic_flag_test_and_set_explicit(atomic_flag*, memory_order) noexcept;
+  void atomic_flag_clear(volatile atomic_flag*) noexcept;
+ constexpr void atomic_flag_clear(atomic_flag*) noexcept;
+  void atomic_flag_clear_explicit(volatile atomic_flag*, memory_order) noexcept;
+ constexpr void atomic_flag_clear_explicit(atomic_flag*, memory_order) noexcept;
+  void atomic_flag_wait(const volatile atomic_flag*, bool) noexcept;
+ constexpr void atomic_flag_wait(const atomic_flag*, bool) noexcept;
+  void atomic_flag_wait_explicit(const volatile atomic_flag*, bool, memory_order) noexcept;
+  constexpr void atomic_flag_wait_explicit(const atomic_flag*, bool, memory_order) noexcept;
+  void atomic_flag_notify_one(volatile atomic_flag*) noexcept;
+  constexpr void atomic_flag_notify_one(atomic_flag*) noexcept;
+  void atomic_flag_notify_all(volatile atomic_flag*) noexcept;
+ constexpr void atomic_flag_notify_all(atomic_flag*) noexcept;
+ #define ATOMIC_FLAG_INIT see belownc
   // [atomics.fences], fences
+  extern "C" constexpr void atomic_thread_fence(memory_order) noexcept;
+  extern "C" constexpr void atomic_signal_fence(memory_order) noexcept;
 }
 ```
 ### Type aliases <a id="atomics.alias">[[atomics.alias]]</a>
 ### Order and consistency <a id="atomics.order">[[atomics.order]]</a>
 ``` cpp
 namespace std {
   enum class memory_order : unspecified {
+    relaxed = 0, acquire = 2, release = 3, acq_rel = 4, seq_cst = 5
   };
 }
 ```
 The enumeration `memory_order` specifies the detailed regular
 - `memory_order::relaxed`: no operation orders memory.
 - `memory_order::release`, `memory_order::acq_rel`, and
   `memory_order::seq_cst`: a store operation performs a release
   operation on the affected memory location.
 - `memory_order::acquire`, `memory_order::acq_rel`, and
   `memory_order::seq_cst`: a load operation performs an acquire
   operation on the affected memory location.
+[*Note 1*: Atomic operations specifying `memory_order::relaxed` are
 relaxed with respect to memory ordering. Implementations must still
 guarantee that any given atomic access to a particular atomic object be
 indivisible with respect to all other atomic accesses to that
 object. — *end note*]
 - if a `memory_order::seq_cst` fence X happens before A and B is a
   `memory_order::seq_cst` operation, then X precedes B in S; and
 - if a `memory_order::seq_cst` fence X happens before A and B happens
   before a `memory_order::seq_cst` fence Y, then X precedes Y in S.
+[*Note 2*: This definition ensures that S is consistent with the
 modification order of any atomic object M. It also ensures that a
 `memory_order::seq_cst` load A of M gets its value either from the last
 modification of M that precedes A in S or from some
 non-`memory_order::seq_cst` modification of M that does not happen
 before any modification of M that precedes A in S. — *end note*]
+[*Note 3*: We do not require that S be consistent with “happens before”
 [[intro.races]]. This allows more efficient implementation of
 `memory_order::acquire` and `memory_order::release` on some machine
 architectures. It can produce surprising results when these are mixed
 with `memory_order::seq_cst` accesses. — *end note*]
+[*Note 4*: `memory_order::seq_cst` ensures sequential consistency only
 for a program that is free of data races and uses exclusively
 `memory_order::seq_cst` atomic operations. Any use of weaker ordering
 will invalidate this guarantee unless extreme care is used. In many
 cases, `memory_order::seq_cst` atomic operations are reorderable with
 respect to other atomic operations performed by the same
 thread. — *end note*]
 Implementations should ensure that no “out-of-thin-air” values are
 computed that circularly depend on their own computation.
+[*Note 5*:
 For example, with `x` and `y` initially zero,
 ``` cpp
 // Thread 1:
 which circularly depends on the store to `y` storing `42`. Note that
 without this restriction, such an execution is possible.
 — *end note*]
+[*Note 6*:
 The recommendation similarly disallows `r1 == r2 == 42` in the following
 example, with `x` and `y` again initially zero:
 ``` cpp
 Atomic read-modify-write operations shall always read the last value (in
 the modification order) written before the write associated with the
 read-modify-write operation.
+An *atomic modify-write operation* is an atomic read-modify-write
+operation with weaker synchronization requirements as specified in
+[[atomics.fences]].
+[*Note 7*: The intent is for atomic modify-write operations to be
+implemented using mechanisms that are not ordered, in hardware, by the
+implementation of acquire fences. No other semantic or hardware property
+(e.g., that the mechanism is a far atomic operation) is
+implied. — *end note*]
+*Recommended practice:* The implementation should make atomic stores
+visible to atomic loads, and atomic loads should observe atomic stores,
+within a reasonable amount of time.
 ### Lock-free property <a id="atomics.lockfree">[[atomics.lockfree]]</a>
 ``` cpp
 #define ATOMIC_BOOL_LOCK_FREE unspecified
   template<class T> struct atomic_ref {
   private:
     T* ptr;             // exposition only
   public:
+    using value_type = remove_cv_t<T>;
     static constexpr size_t required_alignment = implementation-defined  // required alignment for atomic_ref type's operations;
     static constexpr bool is_always_lock_free = implementation-defined  // whether a given atomic_ref type's operations are always lock free;
     bool is_lock_free() const noexcept;
+ constexpr explicit atomic_ref(T&);
+ constexpr atomic_ref(const atomic_ref&) noexcept;
     atomic_ref& operator=(const atomic_ref&) = delete;
+ constexpr void store(value_type, memory_order = memory_order::seq_cst) const noexcept;
+ constexpr value_type operator=(value_type) const noexcept;
+ constexpr value_type load(memory_order = memory_order::seq_cst) const noexcept;
+ constexpr operator value_type() const noexcept;
+ constexpr value_type exchange(value_type,
+                                  memory_order = memory_order::seq_cst) const noexcept;
+    constexpr bool compare_exchange_weak(value_type&, value_type,
                                          memory_order, memory_order) const noexcept;
+ constexpr bool compare_exchange_strong(value_type&, value_type,
                                            memory_order, memory_order) const noexcept;
+ constexpr bool compare_exchange_weak(value_type&, value_type,
                                          memory_order = memory_order::seq_cst) const noexcept;
+ constexpr bool compare_exchange_strong(value_type&, value_type,
                                            memory_order = memory_order::seq_cst) const noexcept;
+ constexpr void wait(value_type, memory_order = memory_order::seq_cst) const noexcept;
+ constexpr void notify_one() const noexcept;
+ constexpr void notify_all() const noexcept;
+    constexpr T* address() const noexcept;
   };
 }
 ```
 An `atomic_ref` object applies atomic operations [[atomics.general]] to
 [*Note 1*: Atomic operations or the `atomic_ref` constructor can
 acquire a shared resource, such as a lock associated with the referenced
 object, to enable atomic operations to be applied to the referenced
 object. — *end note*]
+The program is ill-formed if `is_always_lock_free` is `false` and
+`is_volatile_v<T>` is `true`.
 #### Operations <a id="atomics.ref.ops">[[atomics.ref.ops]]</a>
 ``` cpp
 static constexpr size_t required_alignment;
 ```
 *Returns:* `true` if operations on all objects of the type
 `atomic_ref<T>` are lock-free, `false` otherwise.
 ``` cpp
+constexpr atomic_ref(T& obj);
 ```
 *Preconditions:* The referenced object is aligned to
 `required_alignment`.
 *Ensures:* `*this` references `obj`.
 *Throws:* Nothing.
 ``` cpp
+constexpr atomic_ref(const atomic_ref& ref) noexcept;
 ```
 *Ensures:* `*this` references the object referenced by `ref`.
 ``` cpp
+constexpr void store(value_type desired,
+                     memory_order order = memory_order::seq_cst) const noexcept;
 ```
+*Constraints:* `is_const_v<T>` is `false`.
+*Preconditions:* `order` is `memory_order::relaxed`,
+`memory_order::release`, or `memory_order::seq_cst`.
 *Effects:* Atomically replaces the value referenced by `*ptr` with the
 value of `desired`. Memory is affected according to the value of
 `order`.
 ``` cpp
+constexpr value_type operator=(value_type desired) const noexcept;
 ```
+*Constraints:* `is_const_v<T>` is `false`.
 *Effects:* Equivalent to:
 ``` cpp
 store(desired);
 return desired;
 ```
 ``` cpp
+constexpr value_type load(memory_order order = memory_order::seq_cst) const noexcept;
 ```
+*Preconditions:* `order` is `memory_order::relaxed`,
+`memory_order::acquire`, or `memory_order::seq_cst`.
 *Effects:* Memory is affected according to the value of `order`.
 *Returns:* Atomically returns the value referenced by `*ptr`.
 ``` cpp
+constexpr operator value_type() const noexcept;
 ```
 *Effects:* Equivalent to: `return load();`
 ``` cpp
+constexpr value_type exchange(value_type desired,
+                              memory_order order = memory_order::seq_cst) const noexcept;
 ```
+*Constraints:* `is_const_v<T>` is `false`.
 *Effects:* Atomically replaces the value referenced by `*ptr` with
 `desired`. Memory is affected according to the value of `order`. This
 operation is an atomic read-modify-write
 operation [[intro.multithread]].
 *Returns:* Atomically returns the value referenced by `*ptr` immediately
 before the effects.
 ``` cpp
+constexpr bool compare_exchange_weak(value_type& expected, value_type desired,
                            memory_order success, memory_order failure) const noexcept;
+constexpr bool compare_exchange_strong(value_type& expected, value_type desired,
                              memory_order success, memory_order failure) const noexcept;
+constexpr bool compare_exchange_weak(value_type& expected, value_type desired,
                            memory_order order = memory_order::seq_cst) const noexcept;
+constexpr bool compare_exchange_strong(value_type& expected, value_type desired,
                              memory_order order = memory_order::seq_cst) const noexcept;
 ```
+*Constraints:* `is_const_v<T>` is `false`.
+*Preconditions:* `failure` is `memory_order::relaxed`,
+`memory_order::acquire`, or `memory_order::seq_cst`.
 *Effects:* Retrieves the value in `expected`. It then atomically
 compares the value representation of the value referenced by `*ptr` for
 equality with that previously retrieved from `expected`, and if `true`,
 replaces the value referenced by `*ptr` with that in `desired`. If and
 performance on some platforms. When a weak compare-and-exchange would
 require a loop and a strong one would not, the strong one is
 preferable. — *end note*]
 ``` cpp
+constexpr void wait(value_type old, memory_order order = memory_order::seq_cst) const noexcept;
 ```
+*Preconditions:* `order` is `memory_order::relaxed`,
+`memory_order::acquire`, or `memory_order::seq_cst`.
 *Effects:* Repeatedly performs the following steps, in order:
 - Evaluates `load(order)` and compares its value representation for
   equality against that of `old`.
 *Remarks:* This function is an atomic waiting operation [[atomics.wait]]
 on atomic object `*ptr`.
 ``` cpp
+constexpr void notify_one() const noexcept;
 ```
+*Constraints:* `is_const_v<T>` is `false`.
 *Effects:* Unblocks the execution of at least one atomic waiting
 operation on `*ptr` that is eligible to be unblocked [[atomics.wait]] by
 this call, if any such atomic waiting operations exist.
 *Remarks:* This function is an atomic notifying
 operation [[atomics.wait]] on atomic object `*ptr`.
 ``` cpp
+constexpr void notify_all() const noexcept;
 ```
+*Constraints:* `is_const_v<T>` is `false`.
 *Effects:* Unblocks the execution of all atomic waiting operations on
 `*ptr` that are eligible to be unblocked [[atomics.wait]] by this call.
 *Remarks:* This function is an atomic notifying
 operation [[atomics.wait]] on atomic object `*ptr`.
+``` cpp
+constexpr T* address() const noexcept;
+```
+*Returns:* `ptr`.
 #### Specializations for integral types <a id="atomics.ref.int">[[atomics.ref.int]]</a>
+There are specializations of the `atomic_ref` class template for all
+integral types except cv `bool`. For each such type `integral-type`, the
+specialization `atomic_ref<integral-type>` provides additional atomic
+operations appropriate to integral types.
 [*Note 1*: The specialization `atomic_ref<bool>` uses the primary
 template [[atomics.ref.generic]]. — *end note*]
+The program is ill-formed if `is_always_lock_free` is `false` and
+`is_volatile_v<integral-type>` is `true`.
 ``` cpp
 namespace std {
   template<> struct atomic_ref<integral-type> {
   private:
     integral-type* ptr;         // exposition only
   public:
+    using value_type = remove_cv_t<integral-type>;
     using difference_type = value_type;
     static constexpr size_t required_alignment = implementation-defined  // required alignment for atomic_ref type's operations;
     static constexpr bool is_always_lock_free = implementation-defined  // whether a given atomic_ref type's operations are always lock free;
     bool is_lock_free() const noexcept;
+ constexpr explicit atomic_ref(integral-type&);
+ constexpr atomic_ref(const atomic_ref&) noexcept;
     atomic_ref& operator=(const atomic_ref&) = delete;
+ constexpr void store(value_type, memory_order = memory_order::seq_cst) const noexcept;
+ constexpr value_type operator=(value_type) const noexcept;
+ constexpr value_type load(memory_order = memory_order::seq_cst) const noexcept;
+ constexpr operator value_type() const noexcept;
+ constexpr value_type exchange(value_type,
                                   memory_order = memory_order::seq_cst) const noexcept;
+ constexpr bool compare_exchange_weak(value_type&, value_type,
                                          memory_order, memory_order) const noexcept;
+ constexpr bool compare_exchange_strong(value_type&, value_type,
                                            memory_order, memory_order) const noexcept;
+ constexpr bool compare_exchange_weak(value_type&, value_type,
                                          memory_order = memory_order::seq_cst) const noexcept;
+ constexpr bool compare_exchange_strong(value_type&, value_type,
                                            memory_order = memory_order::seq_cst) const noexcept;
+ constexpr value_type fetch_add(value_type,
                                    memory_order = memory_order::seq_cst) const noexcept;
+ constexpr value_type fetch_sub(value_type,
                                    memory_order = memory_order::seq_cst) const noexcept;
+ constexpr value_type fetch_and(value_type,
                                    memory_order = memory_order::seq_cst) const noexcept;
+ constexpr value_type fetch_or(value_type,
                                   memory_order = memory_order::seq_cst) const noexcept;
+ constexpr value_type fetch_xor(value_type,
+                                   memory_order = memory_order::seq_cst) const noexcept;
+    constexpr value_type fetch_max(value_type,
+                                   memory_order = memory_order::seq_cst) const noexcept;
+    constexpr value_type fetch_min(value_type,
+                                   memory_order = memory_order::seq_cst) const noexcept;
+    constexpr void store_add(value_type,
+                             memory_order = memory_order::seq_cst) const noexcept;
+    constexpr void store_sub(value_type,
+                             memory_order = memory_order::seq_cst) const noexcept;
+    constexpr void store_and(value_type,
+                             memory_order = memory_order::seq_cst) const noexcept;
+    constexpr void store_or(value_type,
+                            memory_order = memory_order::seq_cst) const noexcept;
+    constexpr void store_xor(value_type,
+                             memory_order = memory_order::seq_cst) const noexcept;
+    constexpr void store_max(value_type,
+                             memory_order = memory_order::seq_cst) const noexcept;
+    constexpr void store_min(value_type,
                              memory_order = memory_order::seq_cst) const noexcept;
+ constexpr value_type operator++(int) const noexcept;
+ constexpr value_type operator--(int) const noexcept;
+ constexpr value_type operator++() const noexcept;
+ constexpr value_type operator--() const noexcept;
+ constexpr value_type operator+=(value_type) const noexcept;
+ constexpr value_type operator-=(value_type) const noexcept;
+ constexpr value_type operator&=(value_type) const noexcept;
+ constexpr value_type operator|=(value_type) const noexcept;
+ constexpr value_type operator^=(value_type) const noexcept;
+ constexpr void wait(value_type, memory_order = memory_order::seq_cst) const noexcept;
+ constexpr void notify_one() const noexcept;
+ constexpr void notify_all() const noexcept;
+    constexpr integral-type* address() const noexcept;
   };
 }
 ```
 Descriptions are provided below only for members that differ from the
 The following operations perform arithmetic computations. The
 correspondence among key, operator, and computation is specified in
 [[atomic.types.int.comp]].
 ``` cpp
+constexpr value_type fetch_key(value_type operand,
   memory_order order = memory_order::seq_cst) const noexcept;
 ```
+*Constraints:* `is_const_v<`*`integral-type`*`>` is `false`.
 *Effects:* Atomically replaces the value referenced by `*ptr` with the
 result of the computation applied to the value referenced by `*ptr` and
 the given operand. Memory is affected according to the value of `order`.
 These operations are atomic read-modify-write
 operations [[intro.races]].
 *Returns:* Atomically, the value referenced by `*ptr` immediately before
 the effects.
+*Remarks:* Except for `fetch_max` and `fetch_min`, for signed integer
+types the result is as if the object value and parameters were converted
+to their corresponding unsigned types, the computation performed on
+those types, and the result converted back to the signed type.
 [*Note 1*: There are no undefined results arising from the
 computation. — *end note*]
+For `fetch_max` and `fetch_min`, the maximum and minimum computation is
+performed as if by `max` and `min` algorithms [[alg.min.max]],
+respectively, with the object value and the first parameter as the
+arguments.
 ``` cpp
+constexpr void store_key(value_type operand,
+                         memory_order order = memory_order::seq_cst) const noexcept;
 ```
+*Preconditions:* `order` is `memory_order::relaxed`,
+`memory_order::release`, or `memory_order::seq_cst`.
+*Effects:* Atomically replaces the value referenced by `*ptr` with the
+result of the computation applied to the value referenced by `*ptr` and
+the given `operand`. Memory is affected according to the value of
+`order`. These operations are atomic modify-write
+operations [[atomics.order]].
+*Remarks:* Except for `store_max` and `store_min`, for signed integer
+types, the result is as if `*ptr` and parameters were converted to their
+corresponding unsigned types, the computation performed on those types,
+and the result converted back to the signed type.
+[*Note 2*: There are no undefined results arising from the
+computation. — *end note*]
+For `store_max` and `store_min`, the maximum and minimum computation is
+performed as if by `max` and `min` algorithms [[alg.min.max]],
+respectively, with `*ptr` and the first parameter as the arguments.
+``` cpp
+constexpr value_type operator op=(value_type operand) const noexcept;
+```
+*Constraints:* `is_const_v<`*`integral-type`*`>` is `false`.
 *Effects:* Equivalent to:
 `return fetch_`*`key`*`(operand) `*`op`*` operand;`
 #### Specializations for floating-point types <a id="atomics.ref.float">[[atomics.ref.float]]</a>
 There are specializations of the `atomic_ref` class template for all
+floating-point types. For each such type `floating-point-type`, the
+specialization `atomic_ref<floating-point-type>` provides additional
+atomic operations appropriate to floating-point types.
+The program is ill-formed if `is_always_lock_free` is `false` and
+`is_volatile_v<floating-point-type>` is `true`.
 ``` cpp
 namespace std {
   template<> struct atomic_ref<floating-point-type> {
   private:
     floating-point-type* ptr;   // exposition only
   public:
+    using value_type = remove_cv_t<floating-point-type>;
     using difference_type = value_type;
     static constexpr size_t required_alignment = implementation-defined  // required alignment for atomic_ref type's operations;
     static constexpr bool is_always_lock_free = implementation-defined  // whether a given atomic_ref type's operations are always lock free;
     bool is_lock_free() const noexcept;
+ constexpr explicit atomic_ref(floating-point-type&);
+ constexpr atomic_ref(const atomic_ref&) noexcept;
     atomic_ref& operator=(const atomic_ref&) = delete;
+ constexpr void store(value_type,
+                         memory_order = memory_order::seq_cst) const noexcept;
+ constexpr value_type operator=(value_type) const noexcept;
+ constexpr value_type load(memory_order = memory_order::seq_cst) const noexcept;
+    constexpr operator value_type() const noexcept;
+ constexpr value_type exchange(value_type,
                                   memory_order = memory_order::seq_cst) const noexcept;
+ constexpr bool compare_exchange_weak(value_type&, value_type,
                                          memory_order, memory_order) const noexcept;
+ constexpr bool compare_exchange_strong(value_type&, value_type,
                                            memory_order, memory_order) const noexcept;
+ constexpr bool compare_exchange_weak(value_type&, value_type,
+                                         memory_order = memory_order::seq_cst) const noexcept;
+    constexpr bool compare_exchange_strong(value_type&, value_type,
+                                           memory_order = memory_order::seq_cst) const noexcept;
+    constexpr value_type fetch_add(value_type,
+                                   memory_order = memory_order::seq_cst) const noexcept;
+    constexpr value_type fetch_sub(value_type,
+                                   memory_order = memory_order::seq_cst) const noexcept;
+    constexpr value_type fetch_max(value_type,
                                    memory_order = memory_order::seq_cst) const noexcept;
+ constexpr value_type fetch_min(value_type,
+                                   memory_order = memory_order::seq_cst) const noexcept;
+    constexpr value_type fetch_fmaximum(value_type,
+                                        memory_order = memory_order::seq_cst) const noexcept;
+    constexpr value_type fetch_fminimum(value_type,
+                                        memory_order = memory_order::seq_cst) const noexcept;
+    constexpr value_type fetch_fmaximum_num(value_type,
+                                            memory_order = memory_order::seq_cst) const noexcept;
+    constexpr value_type fetch_fminimum_num(value_type,
                                             memory_order = memory_order::seq_cst) const noexcept;
+ constexpr void store_add(value_type, memory_order = memory_order::seq_cst) const noexcept;
+    constexpr void store_sub(value_type, memory_order = memory_order::seq_cst) const noexcept;
+    constexpr void store_max(value_type, memory_order = memory_order::seq_cst) const noexcept;
+    constexpr void store_min(value_type, memory_order = memory_order::seq_cst) const noexcept;
+    constexpr void store_fmaximum(value_type,
                                   memory_order = memory_order::seq_cst) const noexcept;
+ constexpr void store_fminimum(value_type,
+                                  memory_order = memory_order::seq_cst) const noexcept;
+    constexpr void store_fmaximum_num(value_type,
+                                      memory_order = memory_order::seq_cst) const noexcept;
+    constexpr void store_fminimum_num(value_type,
                                       memory_order = memory_order::seq_cst) const noexcept;
+ constexpr value_type operator+=(value_type) const noexcept;
+ constexpr value_type operator-=(value_type) const noexcept;
+ constexpr void wait(value_type,
+                        memory_order = memory_order::seq_cst) const noexcept;
+ constexpr void notify_one() const noexcept;
+    constexpr void notify_all() const noexcept;
+    constexpr floating-point-type* address() const noexcept;
   };
 }
 ```
 Descriptions are provided below only for members that differ from the
 primary template.
 The following operations perform arithmetic computations. The
 correspondence among key, operator, and computation is specified in
+[[atomic.types.int.comp]], except for the keys `max`, `min`, `fmaximum`,
+`fminimum`, `fmaximum_num`, and `fminimum_num`, which are specified
+below.
 ``` cpp
+constexpr value_type fetch_key(value_type operand,
                           memory_order order = memory_order::seq_cst) const noexcept;
 ```
+*Constraints:* `is_const_v<`*`floating-point-type`*`>` is `false`.
 *Effects:* Atomically replaces the value referenced by `*ptr` with the
 result of the computation applied to the value referenced by `*ptr` and
 the given operand. Memory is affected according to the value of `order`.
 These operations are atomic read-modify-write
 operations [[intro.races]].
 *Remarks:* If the result is not a representable value for its
 type [[expr.pre]], the result is unspecified, but the operations
 otherwise have no undefined behavior. Atomic arithmetic operations on
 *`floating-point-type`* should conform to the
+`std::numeric_limits<value_type>` traits associated with the
+floating-point type [[limits.syn]]. The floating-point
 environment [[cfenv]] for atomic arithmetic operations on
 *`floating-point-type`* may be different than the calling thread’s
 floating-point environment.
+- For `fetch_fmaximum` and `fetch_fminimum`, the maximum and minimum
+  computation is performed as if by `fmaximum` and `fminimum`,
+  respectively, with `*ptr` and the first parameter as the arguments.
+- For `fetch_fmaximum_num` and `fetch_fminimum_num`, the maximum and
+  minimum computation is performed as if by `fmaximum_num` and
+  `fminimum_num`, respectively, with `*ptr` and the first parameter as
+  the arguments.
+- For `fetch_max` and `fetch_min`, the maximum and minimum computation
+  is performed as if by `fmaximum_num` and `fminimum_num`, respectively,
+  with `*ptr` and the first parameter as the arguments, except that:
+  - If both arguments are NaN, an unspecified NaN value is stored at
+    `*ptr`.
+  - If exactly one argument is a NaN, either the other argument or an
+    unspecified NaN value is stored at `*ptr`; it is unspecified which.
+  - If the arguments are differently signed zeros, which of these values
+    is stored at `*ptr` is unspecified.
+*Recommended practice:* The implementation of `fetch_max` and
+`fetch_min` should treat negative zero as smaller than positive zero.
 ``` cpp
+constexpr void store_key(value_type operand,
+                          memory_order order = memory_order::seq_cst) const noexcept;
 ```
+*Preconditions:* `order` is `memory_order::relaxed`,
+`memory_order::release`, or `memory_order::seq_cst`.
+*Effects:* Atomically replaces the value referenced by `*ptr` with the
+result of the computation applied to the value referenced by `*ptr` and
+the given `operand`. Memory is affected according to the value of
+`order`. These operations are atomic modify-write
+operations [[atomics.order]].
+*Remarks:* If the result is not a representable value for its
+type [[expr.pre]], the result is unspecified, but the operations
+otherwise have no undefined behavior. Atomic arithmetic operations on
+*`floating-point-type`* should conform to the
+`numeric_limits<`*`floating-point-type`*`>` traits associated with the
+floating-point type [[limits.syn]]. The floating-point
+environment [[cfenv]] for atomic arithmetic operations on
+*`floating-point-type`* may be different than the calling thread’s
+floating-point environment. The arithmetic rules of floating-point
+atomic modify-write operations may be different from operations on
+floating-point types or atomic floating-point types.
+[*Note 1*: Tree reductions are permitted for atomic modify-write
+operations. — *end note*]
+- For `store_fmaximum` and `store_fminimum`, the maximum and minimum
+  computation is performed as if by `fmaximum` and `fminimum`,
+  respectively, with `*ptr` and the first parameter as the arguments.
+- For `store_fmaximum_num` and `store_fminimum_num`, the maximum and
+  minimum computation is performed as if by `fmaximum_num `and
+  `fminimum_num`, respectively, with `*ptr` and the first parameter as
+  the arguments.
+- For `store_max` and `store_min`, the maximum and minimum computation
+  is performed as if by `fmaximum_num` and `fminimum_num`, respectively,
+  with `*ptr` and the first parameter as the arguments, except that:
+  - If both arguments are NaN, an unspecified NaN value is stored at
+    `*ptr`.
+  - If exactly one argument is a NaN, either the other argument or an
+    unspecified NaN value is stored at `*ptr`, it is unspecified which.
+  - If the arguments are differently signed zeros, which of these values
+    is stored at `*ptr` is unspecified.
+*Recommended practice:* The implementation of `store_max` and
+`store_min` should treat negative zero as smaller than positive zero.
+``` cpp
+constexpr value_type operator op=(value_type operand) const noexcept;
+```
+*Constraints:* `is_const_v<`*`floating-point-type`*`>` is `false`.
 *Effects:* Equivalent to:
 `return fetch_`*`key`*`(operand) `*`op`*` operand;`
+#### Specialization for pointers <a id="atomics.ref.pointer">[[atomics.ref.pointer]]</a>
+There are specializations of the `atomic_ref` class template for all
+pointer-to-object types. For each such type `pointer-type`, the
+specialization `atomic_ref<pointer-type>` provides additional atomic
+operations appropriate to pointer types.
+The program is ill-formed if `is_always_lock_free` is `false` and
+`is_volatile_v<pointer-type>` is `true`.
 ``` cpp
 namespace std {
+  template<> struct atomic_ref<pointer-type> {
   private:
+ pointer-type* ptr;        // exposition only
   public:
+    using value_type = remove_cv_t<pointer-type>;
     using difference_type = ptrdiff_t;
     static constexpr size_t required_alignment = implementation-defined  // required alignment for atomic_ref type's operations;
     static constexpr bool is_always_lock_free = implementation-defined  // whether a given atomic_ref type's operations are always lock free;
     bool is_lock_free() const noexcept;
+ constexpr explicit atomic_ref(pointer-type&);
+ constexpr atomic_ref(const atomic_ref&) noexcept;
     atomic_ref& operator=(const atomic_ref&) = delete;
+ constexpr void store(value_type, memory_order = memory_order::seq_cst) const noexcept;
+ constexpr value_type operator=(value_type) const noexcept;
+ constexpr value_type load(memory_order = memory_order::seq_cst) const noexcept;
+ constexpr operator value_type() const noexcept;
+ constexpr value_type exchange(value_type,
+                                  memory_order = memory_order::seq_cst) const noexcept;
+    constexpr bool compare_exchange_weak(value_type&, value_type,
                                          memory_order, memory_order) const noexcept;
+ constexpr bool compare_exchange_strong(value_type&, value_type,
                                            memory_order, memory_order) const noexcept;
+ constexpr bool compare_exchange_weak(value_type&, value_type,
+                                         memory_order = memory_order::seq_cst) const noexcept;
+    constexpr bool compare_exchange_strong(value_type&, value_type,
+                                           memory_order = memory_order::seq_cst) const noexcept;
+    constexpr value_type fetch_add(difference_type,
+                                   memory_order = memory_order::seq_cst) const noexcept;
+    constexpr value_type fetch_sub(difference_type,
                                    memory_order = memory_order::seq_cst) const noexcept;
+ constexpr value_type fetch_max(value_type,
+                                   memory_order = memory_order::seq_cst) const noexcept;
+    constexpr value_type fetch_min(value_type,
                                    memory_order = memory_order::seq_cst) const noexcept;
+ constexpr void store_add(difference_type,
+ memory_order = memory_order::seq_cst) const noexcept;
+    constexpr void store_sub(difference_type,
+                             memory_order = memory_order::seq_cst) const noexcept;
+    constexpr void store_max(value_type,
+                             memory_order = memory_order::seq_cst) const noexcept;
+    constexpr void store_min(value_type,
+                             memory_order = memory_order::seq_cst) const noexcept;
+ constexpr value_type operator++(int) const noexcept;
+ constexpr value_type operator--(int) const noexcept;
+ constexpr value_type operator++() const noexcept;
+ constexpr value_type operator--() const noexcept;
+ constexpr value_type operator+=(difference_type) const noexcept;
+ constexpr value_type operator-=(difference_type) const noexcept;
+ constexpr void wait(value_type, memory_order = memory_order::seq_cst) const noexcept;
+ constexpr void notify_one() const noexcept;
+ constexpr void notify_all() const noexcept;
+    constexpr pointer-type* address() const noexcept;
   };
 }
 ```
 Descriptions are provided below only for members that differ from the
 The following operations perform arithmetic computations. The
 correspondence among key, operator, and computation is specified in
 [[atomic.types.pointer.comp]].
 ``` cpp
+constexpr value_type fetch_key(\seeabovenc operand,
+                               memory_order order = memory_order::seq_cst) const noexcept;
 ```
+*Constraints:* `is_const_v<`*`pointer-type`*`>` is `false`.
+*Mandates:* `remove_pointer_t<`*`pointer-type`*`>` is a complete object
+type.
 *Effects:* Atomically replaces the value referenced by `*ptr` with the
 result of the computation applied to the value referenced by `*ptr` and
 the given operand. Memory is affected according to the value of `order`.
 These operations are atomic read-modify-write
 the effects.
 *Remarks:* The result may be an undefined address, but the operations
 otherwise have no undefined behavior.
+For `fetch_max` and `fetch_min`, the maximum and minimum computation is
+performed as if by `max` and `min` algorithms [[alg.min.max]],
+respectively, with the object value and the first parameter as the
+arguments.
+[*Note 1*: If the pointers point to different complete objects (or
+subobjects thereof), the `<` operator does not establish a strict weak
+ordering ([[cpp17.lessthancomparable]], [[expr.rel]]). — *end note*]
 ``` cpp
+constexpr void store_key(\seeabovenc operand,
+                         memory_order order = memory_order::seq_cst) const noexcept;
 ```
+*Mandates:* `remove_pointer_t<`*`pointer-type`*`>` is a complete object
+type.
+*Preconditions:* `order` is `memory_order::relaxed`,
+`memory_order::release`, or `memory_order::seq_cst`.
+*Effects:* Atomically replaces the value referenced by `*ptr` with the
+result of the computation applied to the value referenced by `*ptr` and
+the given `operand`. Memory is affected according to the value of
+`order`. These operations are atomic modify-write
+operations [[atomics.order]].
+*Remarks:* The result may be an undefined address, but the operations
+otherwise have no undefined behavior. For `store_max` and `store_min`,
+the `maximum` and `minimum` computation is performed as if by `max` and
+`min` algorithms [[alg.min.max]], respectively, with `*ptr` and the
+first parameter as the arguments.
+[*Note 2*: If the pointers point to different complete objects (or
+subobjects thereof), the `<` operator does not establish a strict weak
+ordering ([[cpp17.lessthancomparable]], [[expr.rel]]). — *end note*]
+``` cpp
+constexpr value_type operator op=(difference_type operand) const noexcept;
+```
+*Constraints:* `is_const_v<`*`pointer-type`*`>` is `false`.
 *Effects:* Equivalent to:
 `return fetch_`*`key`*`(operand) `*`op`*` operand;`
 #### Member operators common to integers and pointers to objects <a id="atomics.ref.memop">[[atomics.ref.memop]]</a>
+Let `referred-type` be `pointer-type` for the specializations in
+[[atomics.ref.pointer]] and be `integral-type` for the specializations
+in [[atomics.ref.int]].
 ``` cpp
+constexpr value_type operator++(int) const noexcept;
 ```
+*Constraints:* `is_const_v<`*`referred-type`*`>` is `false`.
 *Effects:* Equivalent to: `return fetch_add(1);`
 ``` cpp
+constexpr value_type operator--(int) const noexcept;
 ```
+*Constraints:* `is_const_v<`*`referred-type`*`>` is `false`.
 *Effects:* Equivalent to: `return fetch_sub(1);`
 ``` cpp
+constexpr value_type operator++() const noexcept;
 ```
+*Constraints:* `is_const_v<`*`referred-type`*`>` is `false`.
 *Effects:* Equivalent to: `return fetch_add(1) + 1;`
 ``` cpp
+constexpr value_type operator--() const noexcept;
 ```
+*Constraints:* `is_const_v<`*`referred-type`*`>` is `false`.
 *Effects:* Equivalent to: `return fetch_sub(1) - 1;`
 ### Class template `atomic` <a id="atomics.types.generic">[[atomics.types.generic]]</a>
 #### General <a id="atomics.types.generic.general">[[atomics.types.generic.general]]</a>
     atomic(const atomic&) = delete;
     atomic& operator=(const atomic&) = delete;
     atomic& operator=(const atomic&) volatile = delete;
     T load(memory_order = memory_order::seq_cst) const volatile noexcept;
+ constexpr T load(memory_order = memory_order::seq_cst) const noexcept;
     operator T() const volatile noexcept;
+ constexpr operator T() const noexcept;
     void store(T, memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr void store(T, memory_order = memory_order::seq_cst) noexcept;
     T operator=(T) volatile noexcept;
+ constexpr T operator=(T) noexcept;
     T exchange(T, memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr T exchange(T, memory_order = memory_order::seq_cst) noexcept;
     bool compare_exchange_weak(T&, T, memory_order, memory_order) volatile noexcept;
+ constexpr bool compare_exchange_weak(T&, T, memory_order, memory_order) noexcept;
     bool compare_exchange_strong(T&, T, memory_order, memory_order) volatile noexcept;
+ constexpr bool compare_exchange_strong(T&, T, memory_order, memory_order) noexcept;
     bool compare_exchange_weak(T&, T, memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr bool compare_exchange_weak(T&, T, memory_order = memory_order::seq_cst) noexcept;
     bool compare_exchange_strong(T&, T, memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr bool compare_exchange_strong(T&, T, memory_order = memory_order::seq_cst) noexcept;
     void wait(T, memory_order = memory_order::seq_cst) const volatile noexcept;
+ constexpr void wait(T, memory_order = memory_order::seq_cst) const noexcept;
     void notify_one() volatile noexcept;
+ constexpr void notify_one() noexcept;
     void notify_all() volatile noexcept;
+ constexpr void notify_all() noexcept;
   };
 }
 ```
 The template argument for `T` shall meet the *Cpp17CopyConstructible*
 of
 - `is_trivially_copyable_v<T>`,
 - `is_copy_constructible_v<T>`,
 - `is_move_constructible_v<T>`,
+- `is_copy_assignable_v<T>`,
+- `is_move_assignable_v<T>`, or
+- `is_same_v<T, remove_cv_t<T>>`,
 is `false`.
 [*Note 1*: Type arguments that are not also statically initializable
 can be difficult to use. — *end note*]
+The specialization `atomic<bool>` is a standard-layout struct. It has a
+trivial destructor.
 [*Note 2*: The representation of an atomic specialization need not have
 the same size and alignment requirement as its corresponding argument
 type. — *end note*]
 ``` cpp
 constexpr atomic() noexcept(is_nothrow_default_constructible_v<T>);
 ```
+*Constraints:* `is_default_constructible_v<T>` is `true`.
 *Effects:* Initializes the atomic object with the value of `T()`.
 Initialization is not an atomic operation [[intro.multithread]].
 ``` cpp
 consistent with the value of `is_always_lock_free` for the same
 type. — *end note*]
 ``` cpp
 void store(T desired, memory_order order = memory_order::seq_cst) volatile noexcept;
+constexpr void store(T desired, memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
+*Preconditions:* `order` is `memory_order::relaxed`,
+`memory_order::release`, or `memory_order::seq_cst`.
 *Effects:* Atomically replaces the value pointed to by `this` with the
 value of `desired`. Memory is affected according to the value of
 `order`.
 ``` cpp
 T operator=(T desired) volatile noexcept;
+constexpr T operator=(T desired) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
 *Returns:* `desired`.
 ``` cpp
 T load(memory_order order = memory_order::seq_cst) const volatile noexcept;
+constexpr T load(memory_order order = memory_order::seq_cst) const noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
+*Preconditions:* `order` is `memory_order::relaxed`,
+`memory_order::acquire`, or `memory_order::seq_cst`.
 *Effects:* Memory is affected according to the value of `order`.
 *Returns:* Atomically returns the value pointed to by `this`.
 ``` cpp
 operator T() const volatile noexcept;
+constexpr operator T() const noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
 *Effects:* Equivalent to: `return load();`
 ``` cpp
 T exchange(T desired, memory_order order = memory_order::seq_cst) volatile noexcept;
+constexpr T exchange(T desired, memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
 before the effects.
 ``` cpp
 bool compare_exchange_weak(T& expected, T desired,
                            memory_order success, memory_order failure) volatile noexcept;
+constexpr bool compare_exchange_weak(T& expected, T desired,
                            memory_order success, memory_order failure) noexcept;
 bool compare_exchange_strong(T& expected, T desired,
                              memory_order success, memory_order failure) volatile noexcept;
+constexpr bool compare_exchange_strong(T& expected, T desired,
                              memory_order success, memory_order failure) noexcept;
 bool compare_exchange_weak(T& expected, T desired,
                            memory_order order = memory_order::seq_cst) volatile noexcept;
+constexpr bool compare_exchange_weak(T& expected, T desired,
                            memory_order order = memory_order::seq_cst) noexcept;
 bool compare_exchange_strong(T& expected, T desired,
                              memory_order order = memory_order::seq_cst) volatile noexcept;
+constexpr bool compare_exchange_strong(T& expected, T desired,
                              memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
+*Preconditions:* `failure` is `memory_order::relaxed`,
+`memory_order::acquire`, or `memory_order::seq_cst`.
 *Effects:* Retrieves the value in `expected`. It then atomically
 compares the value representation of the value pointed to by `this` for
 equality with that previously retrieved from `expected`, and if true,
 replaces the value pointed to by `this` with that in `desired`. If and
 [*Note 6*: Under cases where the `memcpy` and `memcmp` semantics of the
 compare-and-exchange operations apply, the comparisons can fail for
 values that compare equal with `operator==` if the value representation
 has trap bits or alternate representations of the same value. Notably,
+on implementations conforming to ISO/IEC 60559, floating-point `-0.0`
+and `+0.0` will not compare equal with `memcmp` but will compare equal
+with `operator==`, and NaNs with the same payload will compare equal
+with `memcmp` but will not compare equal with
 `operator==`. — *end note*]
 [*Note 7*:
 Because compare-and-exchange acts on an object’s value representation,
 — *end note*]
 ``` cpp
 void wait(T old, memory_order order = memory_order::seq_cst) const volatile noexcept;
+constexpr void wait(T old, memory_order order = memory_order::seq_cst) const noexcept;
 ```
+*Preconditions:* `order` is `memory_order::relaxed`,
+`memory_order::acquire`, or `memory_order::seq_cst`.
 *Effects:* Repeatedly performs the following steps, in order:
 - Evaluates `load(order)` and compares its value representation for
   equality against that of `old`.
 *Remarks:* This function is an atomic waiting
 operation [[atomics.wait]].
 ``` cpp
 void notify_one() volatile noexcept;
+constexpr void notify_one() noexcept;
 ```
 *Effects:* Unblocks the execution of at least one atomic waiting
 operation that is eligible to be unblocked [[atomics.wait]] by this
 call, if any such atomic waiting operations exist.
 *Remarks:* This function is an atomic notifying
 operation [[atomics.wait]].
 ``` cpp
 void notify_all() volatile noexcept;
+constexpr void notify_all() noexcept;
 ```
 *Effects:* Unblocks the execution of all atomic waiting operations that
 are eligible to be unblocked [[atomics.wait]] by this call.
     atomic(const atomic&) = delete;
     atomic& operator=(const atomic&) = delete;
     atomic& operator=(const atomic&) volatile = delete;
     void store(integral-type, memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr void store(integral-type, memory_order = memory_order::seq_cst) noexcept;
     integral-type operator=(integral-type) volatile noexcept;
+ constexpr integral-type operator=(integral-type) noexcept;
     integral-type load(memory_order = memory_order::seq_cst) const volatile noexcept;
+ constexpr integral-type load(memory_order = memory_order::seq_cst) const noexcept;
     operator integral-type() const volatile noexcept;
+ constexpr operator integral-type() const noexcept;
     integral-type exchange(integral-type,
                            memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr integral-type exchange(integral-type,
                            memory_order = memory_order::seq_cst) noexcept;
     bool compare_exchange_weak(integral-type&, integral-type,
                                memory_order, memory_order) volatile noexcept;
+ constexpr bool compare_exchange_weak(integral-type&, integral-type,
                                memory_order, memory_order) noexcept;
     bool compare_exchange_strong(integral-type&, integral-type,
                                  memory_order, memory_order) volatile noexcept;
+ constexpr bool compare_exchange_strong(integral-type&, integral-type,
                                  memory_order, memory_order) noexcept;
     bool compare_exchange_weak(integral-type&, integral-type,
                                memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr bool compare_exchange_weak(integral-type&, integral-type,
                                memory_order = memory_order::seq_cst) noexcept;
     bool compare_exchange_strong(integral-type&, integral-type,
                                  memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr bool compare_exchange_strong(integral-type&, integral-type,
                                  memory_order = memory_order::seq_cst) noexcept;
     integral-type fetch_add(integral-type,
                             memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr integral-type fetch_add(integral-type,
                             memory_order = memory_order::seq_cst) noexcept;
     integral-type fetch_sub(integral-type,
                             memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr integral-type fetch_sub(integral-type,
                             memory_order = memory_order::seq_cst) noexcept;
     integral-type fetch_and(integral-type,
                             memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr integral-type fetch_and(integral-type,
                             memory_order = memory_order::seq_cst) noexcept;
     integral-type fetch_or(integral-type,
                             memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr integral-type fetch_or(integral-type,
                             memory_order = memory_order::seq_cst) noexcept;
     integral-type fetch_xor(integral-type,
                             memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr integral-type fetch_xor(integral-type,
+                            memory_order = memory_order::seq_cst) noexcept;
+    integral-type fetch_max(integral-type,
+                            memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr integral-type fetch_max(integral-type,
+                            memory_order = memory_order::seq_cst) noexcept;
+    integral-type fetch_min(integral-type,
+                            memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr integral-type fetch_min(integral-type,
+                            memory_order = memory_order::seq_cst) noexcept;
+    void store_add(integral-type,
+                   memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr void store_add(integral-type,
+                             memory_order = memory_order::seq_cst) noexcept;
+    void store_sub(integral-type,
+                   memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr void store_sub(integral-type,
+                             memory_order = memory_order::seq_cst) noexcept;
+    void store_and(integral-type,
+                   memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr void store_and(integral-type,
+                             memory_order = memory_order::seq_cst) noexcept;
+    void store_or(integral-type,
+                  memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr void store_or(integral-type,
+                            memory_order = memory_order::seq_cst) noexcept;
+    void store_xor(integral-type,
+                   memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr void store_xor(integral-type,
+                             memory_order = memory_order::seq_cst) noexcept;
+    void store_max(integral-type,
+                   memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr void store_max(integral-type,
+                             memory_order = memory_order::seq_cst) noexcept;
+    void store_min(integral-type,
+                   memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr void store_min(integral-type,
                              memory_order = memory_order::seq_cst) noexcept;
     integral-type operator++(int) volatile noexcept;
+ constexpr integral-type operator++(int) noexcept;
     integral-type operator--(int) volatile noexcept;
+ constexpr integral-type operator--(int) noexcept;
     integral-type operator++() volatile noexcept;
+ constexpr integral-type operator++() noexcept;
     integral-type operator--() volatile noexcept;
+ constexpr integral-type operator--() noexcept;
     integral-type operator+=(integral-type) volatile noexcept;
+ constexpr integral-type operator+=(integral-type) noexcept;
     integral-type operator-=(integral-type) volatile noexcept;
+ constexpr integral-type operator-=(integral-type) noexcept;
     integral-type operator&=(integral-type) volatile noexcept;
+ constexpr integral-type operator&=(integral-type) noexcept;
     integral-type operator|=(integral-type) volatile noexcept;
+ constexpr integral-type operator|=(integral-type) noexcept;
     integral-type operator^=(integral-type) volatile noexcept;
+ constexpr integral-type operator^=(integral-type) noexcept;
     void wait(integral-type, memory_order = memory_order::seq_cst) const volatile noexcept;
+ constexpr void wait(integral-type, memory_order = memory_order::seq_cst) const noexcept;
     void notify_one() volatile noexcept;
+ constexpr void notify_one() noexcept;
     void notify_all() volatile noexcept;
+ constexpr void notify_all() noexcept;
   };
 }
 ```
 The atomic integral specializations are standard-layout structs. They
 [[atomic.types.int.comp]].
 **Table: Atomic arithmetic computations** <a id="atomic.types.int.comp">[atomic.types.int.comp]</a>
 |       |     |             |       |     |                      |
+| ----- | --- | ----------- | ----- | --- | -------------------- |
+| `add` | `+` | addition | `and` | `&` | bitwise and          |
+| `sub` | `-` | subtraction | `or` | `|` | bitwise inclusive or |
+| `max` |     | maximum     | `xor` | `^` | bitwise exclusive or |
+| `min` |     | minimum     |       |     |                      |
 ``` cpp
+integral-type fetch_key(integral-type operand,
+ memory_order order = memory_order::seq_cst) volatile noexcept;
+constexpr integral-type fetch_key(integral-type operand,
+                                   memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
 operations [[intro.multithread]].
 *Returns:* Atomically, the value pointed to by `this` immediately before
 the effects.
+*Remarks:* Except for `fetch_max` and `fetch_min`, for signed integer
+types the result is as if the object value and parameters were converted
+to their corresponding unsigned types, the computation performed on
+those types, and the result converted back to the signed type.
 [*Note 1*: There are no undefined results arising from the
 computation. — *end note*]
+For `fetch_max` and `fetch_min`, the maximum and minimum computation is
+performed as if by `max` and `min` algorithms [[alg.min.max]],
+respectively, with the object value and the first parameter as the
+arguments.
 ``` cpp
+void store_key(integral-type operand,
+                memory_order order = memory_order::seq_cst) volatile noexcept;
+constexpr void store_key(integral-type operand,
+                          memory_order order = memory_order::seq_cst) noexcept;
+```
+*Constraints:* For the `volatile` overload of this function,
+`is_always_lock_free` is `true`.
+*Preconditions:* `order` is `memory_order::relaxed`,
+`memory_order::release`, or `memory_order::seq_cst`.
+*Effects:* Atomically replaces the value pointed to by `this` with the
+result of the computation applied to the value pointed to by `this` and
+the given `operand`. Memory is affected according to the value of
+`order`. These operations are atomic modify-write
+operations [[atomics.order]].
+*Remarks:* Except for `store_max` and `store_min`, for signed integer
+types, the result is as if the value pointed to by `this` and parameters
+were converted to their corresponding unsigned types, the computation
+performed on those types, and the result converted back to the signed
+type.
+[*Note 2*: There are no undefined results arising from the
+computation. — *end note*]
+For `store_max` and `store_min`, the maximum and minimum computation is
+performed as if by `max` and `min` algorithms [[alg.min.max]],
+respectively, with the value pointed to by `this` and the first
+parameter as the arguments.
+``` cpp
+integral-type operator op=(integral-type operand) volatile noexcept;
+constexpr integral-type operator op=(integral-type operand) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
     atomic(const atomic&) = delete;
     atomic& operator=(const atomic&) = delete;
     atomic& operator=(const atomic&) volatile = delete;
     void store(floating-point-type, memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr void store(floating-point-type, memory_order = memory_order::seq_cst) noexcept;
     floating-point-type operator=(floating-point-type) volatile noexcept;
+ constexpr floating-point-type operator=(floating-point-type) noexcept;
     floating-point-type load(memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr floating-point-type load(memory_order = memory_order::seq_cst) noexcept;
     operator floating-point-type() volatile noexcept;
+ constexpr operator floating-point-type() noexcept;
     floating-point-type exchange(floating-point-type,
                                  memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr floating-point-type exchange(floating-point-type,
                                            memory_order = memory_order::seq_cst) noexcept;
     bool compare_exchange_weak(floating-point-type&, floating-point-type,
                                memory_order, memory_order) volatile noexcept;
+ constexpr bool compare_exchange_weak(floating-point-type&, floating-point-type,
                                          memory_order, memory_order) noexcept;
     bool compare_exchange_strong(floating-point-type&, floating-point-type,
                                  memory_order, memory_order) volatile noexcept;
+ constexpr bool compare_exchange_strong(floating-point-type&, floating-point-type,
                                            memory_order, memory_order) noexcept;
     bool compare_exchange_weak(floating-point-type&, floating-point-type,
                                memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr bool compare_exchange_weak(floating-point-type&, floating-point-type,
                                          memory_order = memory_order::seq_cst) noexcept;
     bool compare_exchange_strong(floating-point-type&, floating-point-type,
                                  memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr bool compare_exchange_strong(floating-point-type&, floating-point-type,
                                            memory_order = memory_order::seq_cst) noexcept;
     floating-point-type fetch_add(floating-point-type,
                                   memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr floating-point-type fetch_add(floating-point-type,
                                             memory_order = memory_order::seq_cst) noexcept;
     floating-point-type fetch_sub(floating-point-type,
                                   memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr floating-point-type fetch_sub(floating-point-type,
+                                            memory_order = memory_order::seq_cst) noexcept;
+    floating-point-type fetch_max(floating-point-type,
+                                  memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr floating-point-type fetch_max(floating-point-type,
+                                            memory_order = memory_order::seq_cst) noexcept;
+    floating-point-type fetch_min(floating-point-type,
+                                  memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr floating-poin-typet fetch_min(floating-point-type,
+                                            memory_order = memory_order::seq_cst) noexcept;
+    floating-point-type fetch_fmaximum(floating-point-type,
+                                       memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr floating-point-type fetch_fmaximum(floating-point-type,
+                                                 memory_order = memory_order::seq_cst) noexcept;
+    floating-point-type fetch_fminimum(floating-point-type,
+                                       memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr floating-point-type fetch_fminimum(floating-point-type,
+                                                 memory_order = memory_order::seq_cst) noexcept;
+    floating-point-type fetch_fmaximum_num(
+      floating-point-type, memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr floating-point-type fetch_fmaximum_num(
+      floating-point-type, memory_order = memory_order::seq_cst) noexcept;
+    floating-point-type fetch_fminimum_num(
+      floating-point-type, memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr floating-point-type fetch_fminimum_num(
+      floating-point-type, memory_order = memory_order::seq_cst) noexcept;
+    void store_add(floating-point-type,
+                   memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr void store_add(floating-point-type,
+                             memory_order = memory_order::seq_cst) noexcept;
+    void store_sub(floating-point-type,
+                   memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr void store_sub(floating-point-type,
+                             memory_order = memory_order::seq_cst) noexcept;
+    void store_max(floating-point-type,
+                   memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr void store_max(floating-point-type,
+                             memory_order = memory_order::seq_cst) noexcept;
+    void store_min(floating-point-type,
+                   memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr void store_min(floating-point-type,
+                             memory_order = memory_order::seq_cst) noexcept;
+    void store_fmaximum(floating-point-type,
+                        memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr void store_fmaximum(floating-point-type,
+                                  memory_order = memory_order::seq_cst) noexcept;
+    void store_fminimum(floating-point-type,
+                        memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr void store_fminimum(floating-point-type,
+                                  memory_order = memory_order::seq_cst) noexcept;
+    void store_fmaximum_num(floating-point-type,
+                            memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr void store_fmaximum_num(floating-point-type,
+                                      memory_order = memory_order::seq_cst) noexcept;
+    void store_fminimum_num(floating-point-type,
+                            memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr void store_fminimum_num(floating-point-type,
                                       memory_order = memory_order::seq_cst) noexcept;
     floating-point-type operator+=(floating-point-type) volatile noexcept;
+ constexpr floating-point-type operator+=(floating-point-type) noexcept;
     floating-point-type operator-=(floating-point-type) volatile noexcept;
+ constexpr floating-point-type operator-=(floating-point-type) noexcept;
     void wait(floating-point-type, memory_order = memory_order::seq_cst) const volatile noexcept;
+ constexpr void wait(floating-point-type,
+                        memory_order = memory_order::seq_cst) const noexcept;
     void notify_one() volatile noexcept;
+ constexpr void notify_one() noexcept;
     void notify_all() volatile noexcept;
+ constexpr void notify_all() noexcept;
   };
 }
 ```
 The atomic floating-point specializations are standard-layout structs.
 Descriptions are provided below only for members that differ from the
 primary template.
 The following operations perform arithmetic addition and subtraction
 computations. The correspondence among key, operator, and computation is
+specified in [[atomic.types.int.comp]], except for the keys `max`,
+`min`, `fmaximum`, `fminimum`, `fmaximum_num`, and `fminimum_num`, which
+are specified below.
 ``` cpp
+floating-point-type fetch_key(floating-point-type operand,
+ memory_order order = memory_order::seq_cst) volatile noexcept;
+constexpr floating-point-type fetch_key(floating-point-type operand,
+                                        memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
 the floating-point type [[limits.syn]]. The floating-point
 environment [[cfenv]] for atomic arithmetic operations on
 *`floating-point-type`* may be different than the calling thread’s
 floating-point environment.
+- For `fetch_fmaximum` and `fetch_fminimum`, the maximum and minimum
+  computation is performed as if by `fmaximum` and `fminimum`,
+  respectively, with the value pointed to by `this` and the first
+  parameter as the arguments.
+- For `fetch_fmaximum_num` and `fetch_fminimum_num`, the maximum and
+  minimum computation is performed as if by `fmaximum_num` and
+  `fminimum_num`, respectively, with the value pointed to by `this` and
+  the first parameter as the arguments.
+- For `fetch_max` and `fetch_min`, the maximum and minimum computation
+  is performed as if by `fmaximum_num` and `fminimum_num`, respectively,
+  with the value pointed to by `this` and the first parameter as the
+  arguments, except that:
+  - If both arguments are NaN, an unspecified NaN value replaces the
+    value pointed to by `this`.
+  - If exactly one argument is a NaN, either the other argument or an
+    unspecified NaN value replaces the value pointed to by `this`; it is
+    unspecified which.
+  - If the arguments are differently signed zeros, which of these values
+    replaces the value pointed to by this is unspecified.
+*Recommended practice:* The implementation of `fetch_max` and
+`fetch_min` should treat negative zero as smaller than positive zero.
 ``` cpp
+void store_key(floating-point-type operand,
+               memory_order order = memory_order::seq_cst) volatile noexcept;
+constexpr void store_key(floating-point-type operand,
+                         memory_order order = memory_order::seq_cst) noexcept;
+```
+*Constraints:* For the `volatile` overload of this function,
+`is_always_lock_free` is `true`.
+*Preconditions:* `order` is `memory_order::relaxed`,
+`memory_order::release`, or `memory_order::seq_cst`.
+*Effects:* Atomically replaces the value pointed to by `this` with the
+result of the computation applied to the value pointed to by `this` and
+the given operand. Memory is affected according to the value of `order`.
+These operations are atomic modify-write operations [[atomics.order]].
+*Remarks:* If the result is not a representable value for its
+type [[expr.pre]] the result is unspecified, but the operations
+otherwise have no undefined behavior. Atomic arithmetic operations on
+*`floating-point-type`* should conform to the
+`numeric_limits<`*`floating-point-type`*`>` traits associated with the
+floating-point type [[limits.syn]]. The floating-point
+environment [[cfenv]] for atomic arithmetic operations on
+*`floating-point-type`* may be different than the calling thread’s
+floating-point environment. The arithmetic rules of floating-point
+atomic modify-write operations may be different from operations on
+floating-point types or atomic floating-point types.
+[*Note 1*: Tree reductions are permitted for atomic modify-write
+operations. — *end note*]
+- For `store_fmaximum` and `store_fminimum`, the maximum and minimum
+  computation is performed as if by `fmaximum` and `fminimum`,
+  respectively, with the value pointed to by `this` and the first
+  parameter as the arguments.
+- For `store_fmaximum_num` and `store_fminimum_num`, the maximum and
+  minimum computation is performed as if by `fmaximum_num` and
+  `fminimum_num`, respectively, with the value pointed to by `this` and
+  the first parameter as the arguments.
+- For `store_max` and `store_min`, the maximum and minimum computation
+  is performed as if by `fmaximum_num` and `fminimum_num`, respectively,
+  with the value pointed to by `this` and the first parameter as the
+  arguments, except that:
+  - If both arguments are NaN, an unspecified NaN value replaces the
+    value pointed to by `this`.
+  - If exactly one argument is a NaN, either the other argument or an
+    unspecified NaN value replaces the value pointed to by `this`; it is
+    unspecified which.
+  - If the arguments are differently signed zeros, which of these values
+    replaces the value pointed to by `this` is unspecified.
+*Recommended practice:* The implementation of `store_max` and
+`store_min` should treat negative zero as smaller than positive zero.
+``` cpp
+floating-point-type operator op=(floating-point-type operand) volatile noexcept;
+constexpr floating-point-type operator op=(floating-point-type operand) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
     atomic(const atomic&) = delete;
     atomic& operator=(const atomic&) = delete;
     atomic& operator=(const atomic&) volatile = delete;
     void store(T*, memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr void store(T*, memory_order = memory_order::seq_cst) noexcept;
     T* operator=(T*) volatile noexcept;
+ constexpr T* operator=(T*) noexcept;
     T* load(memory_order = memory_order::seq_cst) const volatile noexcept;
+ constexpr T* load(memory_order = memory_order::seq_cst) const noexcept;
     operator T*() const volatile noexcept;
+ constexpr operator T*() const noexcept;
     T* exchange(T*, memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr T* exchange(T*, memory_order = memory_order::seq_cst) noexcept;
     bool compare_exchange_weak(T*&, T*, memory_order, memory_order) volatile noexcept;
+ constexpr bool compare_exchange_weak(T*&, T*, memory_order, memory_order) noexcept;
     bool compare_exchange_strong(T*&, T*, memory_order, memory_order) volatile noexcept;
+ constexpr bool compare_exchange_strong(T*&, T*, memory_order, memory_order) noexcept;
     bool compare_exchange_weak(T*&, T*,
                                memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr bool compare_exchange_weak(T*&, T*,
                                memory_order = memory_order::seq_cst) noexcept;
     bool compare_exchange_strong(T*&, T*,
                                  memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr bool compare_exchange_strong(T*&, T*,
                                  memory_order = memory_order::seq_cst) noexcept;
     T* fetch_add(ptrdiff_t, memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr T* fetch_add(ptrdiff_t, memory_order = memory_order::seq_cst) noexcept;
     T* fetch_sub(ptrdiff_t, memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr T* fetch_sub(ptrdiff_t, memory_order = memory_order::seq_cst) noexcept;
+    T* fetch_max(T*, memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr T* fetch_max(T*, memory_order = memory_order::seq_cst) noexcept;
+    T* fetch_min(T*, memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr T* fetch_min(T*, memory_order = memory_order::seq_cst) noexcept;
+    void store_add(ptrdiff_t, memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr void store_add(ptrdiff_t, memory_order = memory_order::seq_cst) noexcept;
+    void store_sub(ptrdiff_t, memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr void store_sub(ptrdiff_t, memory_order = memory_order::seq_cst) noexcept;
+    void store_max(T*, memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr void store_max(T*, memory_order = memory_order::seq_cst) noexcept;
+    void store_min(T*, memory_order = memory_order::seq_cst) volatile noexcept;
+    constexpr void store_min(T*, memory_order = memory_order::seq_cst) noexcept;
     T* operator++(int) volatile noexcept;
+ constexpr T* operator++(int) noexcept;
     T* operator--(int) volatile noexcept;
+ constexpr T* operator--(int) noexcept;
     T* operator++() volatile noexcept;
+ constexpr T* operator++() noexcept;
     T* operator--() volatile noexcept;
+ constexpr T* operator--() noexcept;
     T* operator+=(ptrdiff_t) volatile noexcept;
+ constexpr T* operator+=(ptrdiff_t) noexcept;
     T* operator-=(ptrdiff_t) volatile noexcept;
+ constexpr T* operator-=(ptrdiff_t) noexcept;
     void wait(T*, memory_order = memory_order::seq_cst) const volatile noexcept;
+ constexpr void wait(T*, memory_order = memory_order::seq_cst) const noexcept;
     void notify_one() volatile noexcept;
+ constexpr void notify_one() noexcept;
     void notify_all() volatile noexcept;
+ constexpr void notify_all() noexcept;
   };
 }
 ```
 There is a partial specialization of the `atomic` class template for
 **Table: Atomic pointer computations** <a id="atomic.types.pointer.comp">[atomic.types.pointer.comp]</a>
 |       |     |          |       |     |             |
 | ----- | --- | -------- | ----- | --- | ----------- |
 | `add` | `+` | addition | `sub` | `-` | subtraction |
+| `max` |     | maximum  | `min` |     | minimum     |
 ``` cpp
+T* fetch_key(\seeabovenc operand, memory_order order = memory_order::seq_cst) volatile noexcept;
+constexpr T* fetch_key(\seeabovenc operand, memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
 the effects.
 *Remarks:* The result may be an undefined address, but the operations
 otherwise have no undefined behavior.
+For `fetch_max` and `fetch_min`, the maximum and minimum computation is
+performed as if by `max` and `min` algorithms [[alg.min.max]],
+respectively, with the object value and the first parameter as the
+arguments.
+[*Note 2*: If the pointers point to different complete objects (or
+subobjects thereof), the `<` operator does not establish a strict weak
+ordering ([[cpp17.lessthancomparable]], [[expr.rel]]). — *end note*]
+``` cpp
+void store_key(\seeabovenc operand, memory_order order = memory_order::seq_cst) volatile noexcept;
+constexpr void store_key(\seeabovenc operand, memory_order order = memory_order::seq_cst) noexcept;
+```
+*Constraints:* For the `volatile` overload of this function,
+`is_always_lock_free` is `true`.
+*Mandates:* `T` is a complete object type.
+[*Note 3*: Pointer arithmetic on `void*` or function pointers is
+ill-formed. — *end note*]
+*Effects:* Atomically replaces the value pointed to by `this` with the
+result of the computation applied to the value pointed to by `this` and
+the given `operand`. Memory is affected according to the value of
+`order`. These operations are atomic modify-write
+operations [[atomics.order]].
+*Remarks:* The result may be an undefined address, but the operations
+otherwise have no undefined behavior. For `store_max` and `store_min`,
+the maximum and minimum computation is performed as if by `max` and
+`min` algorithms [[alg.min.max]], respectively, with the value pointed
+to by `this` and the first parameter as the arguments.
+[*Note 4*: If the pointers point to different complete objects (or
+subobjects thereof), the `<` operator does not establish a strict weak
+ordering ([[cpp17.lessthancomparable]], [[expr.rel]]). — *end note*]
 ``` cpp
 T* operator op=(ptrdiff_t operand) volatile noexcept;
+constexpr T* operator op=(ptrdiff_t operand) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
 #### Member operators common to integers and pointers to objects <a id="atomics.types.memop">[[atomics.types.memop]]</a>
 ``` cpp
 value_type operator++(int) volatile noexcept;
+constexpr value_type operator++(int) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
 *Effects:* Equivalent to: `return fetch_add(1);`
 ``` cpp
 value_type operator--(int) volatile noexcept;
+constexpr value_type operator--(int) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
 *Effects:* Equivalent to: `return fetch_sub(1);`
 ``` cpp
 value_type operator++() volatile noexcept;
+constexpr value_type operator++() noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
 *Effects:* Equivalent to: `return fetch_add(1) + 1;`
 ``` cpp
 value_type operator--() volatile noexcept;
+constexpr value_type operator--() noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
     static constexpr bool is_always_lock_free = implementation-defined  // whether a given atomic type's operations are always lock free;
     bool is_lock_free() const noexcept;
     constexpr atomic() noexcept;
     constexpr atomic(nullptr_t) noexcept : atomic() { }
+ constexpr atomic(shared_ptr<T> desired) noexcept;
     atomic(const atomic&) = delete;
     void operator=(const atomic&) = delete;
+ constexpr shared_ptr<T> load(memory_order order = memory_order::seq_cst) const noexcept;
+ constexpr operator shared_ptr<T>() const noexcept;
+ constexpr void store(shared_ptr<T> desired,
+                         memory_order order = memory_order::seq_cst) noexcept;
+    constexpr void operator=(shared_ptr<T> desired) noexcept;
+    constexpr void operator=(nullptr_t) noexcept;
+ constexpr shared_ptr<T> exchange(shared_ptr<T> desired,
                                      memory_order order = memory_order::seq_cst) noexcept;
+ constexpr bool compare_exchange_weak(shared_ptr<T>& expected, shared_ptr<T> desired,
                                          memory_order success, memory_order failure) noexcept;
+ constexpr bool compare_exchange_strong(shared_ptr<T>& expected, shared_ptr<T> desired,
                                            memory_order success, memory_order failure) noexcept;
+ constexpr bool compare_exchange_weak(shared_ptr<T>& expected, shared_ptr<T> desired,
                                          memory_order order = memory_order::seq_cst) noexcept;
+ constexpr bool compare_exchange_strong(shared_ptr<T>& expected, shared_ptr<T> desired,
                                            memory_order order = memory_order::seq_cst) noexcept;
+ constexpr void wait(shared_ptr<T> old,
+                        memory_order order = memory_order::seq_cst) const noexcept;
+ constexpr void notify_one() noexcept;
+    constexpr void notify_all() noexcept;
   private:
     shared_ptr<T> p;            // exposition only
   };
 }
 ``` cpp
 constexpr atomic() noexcept;
 ```
+*Effects:* Value-initializes `p`.
 ``` cpp
+constexpr atomic(shared_ptr<T> desired) noexcept;
 ```
 *Effects:* Initializes the object with the value `desired`.
 Initialization is not an atomic operation [[intro.multithread]].
 `memory_order::relaxed` operations on a suitable atomic pointer
 variable, and then immediately accessing `A` in the receiving thread.
 This results in undefined behavior. — *end note*]
 ``` cpp
+constexpr void store(shared_ptr<T> desired, memory_order order = memory_order::seq_cst) noexcept;
 ```
+*Preconditions:* `order` is `memory_order::relaxed`,
+`memory_order::release`, or `memory_order::seq_cst`.
 *Effects:* Atomically replaces the value pointed to by `this` with the
 value of `desired` as if by `p.swap(desired)`. Memory is affected
 according to the value of `order`.
 ``` cpp
+constexpr void operator=(shared_ptr<T> desired) noexcept;
 ```
 *Effects:* Equivalent to `store(desired)`.
 ``` cpp
+constexpr void operator=(nullptr_t) noexcept;
 ```
+*Effects:* Equivalent to `store(nullptr)`.
+``` cpp
+constexpr shared_ptr<T> load(memory_order order = memory_order::seq_cst) const noexcept;
+```
+*Preconditions:* `order` is `memory_order::relaxed`,
+`memory_order::acquire`, or `memory_order::seq_cst`.
 *Effects:* Memory is affected according to the value of `order`.
 *Returns:* Atomically returns `p`.
 ``` cpp
+constexpr operator shared_ptr<T>() const noexcept;
 ```
 *Effects:* Equivalent to: `return load();`
 ``` cpp
+constexpr shared_ptr<T> exchange(shared_ptr<T> desired,
+                                 memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Effects:* Atomically replaces `p` with `desired` as if by
 `p.swap(desired)`. Memory is affected according to the value of `order`.
 This is an atomic read-modify-write operation [[intro.races]].
 *Returns:* Atomically returns the value of `p` immediately before the
 effects.
 ``` cpp
+constexpr bool compare_exchange_weak(shared_ptr<T>& expected, shared_ptr<T> desired,
                                      memory_order success, memory_order failure) noexcept;
+constexpr bool compare_exchange_strong(shared_ptr<T>& expected, shared_ptr<T> desired,
                                        memory_order success, memory_order failure) noexcept;
 ```
+*Preconditions:* `failure` is `memory_order::relaxed`,
+`memory_order::acquire`, or `memory_order::seq_cst`.
 *Effects:* If `p` is equivalent to `expected`, assigns `desired` to `p`
 and has synchronization semantics corresponding to the value of
 `success`, otherwise assigns `p` to `expected` and has synchronization
 semantics corresponding to the value of `failure`.
 corresponding to the write to `expected` is part of the atomic
 operation. The write to `expected` itself is not required to be part of
 the atomic operation.
 ``` cpp
+constexpr bool compare_exchange_weak(shared_ptr<T>& expected, shared_ptr<T> desired,
                                      memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Effects:* Equivalent to:
 `memory_order::acq_rel` shall be replaced by the value
 `memory_order::acquire` and a value of `memory_order::release` shall be
 replaced by the value `memory_order::relaxed`.
 ``` cpp
+constexpr bool compare_exchange_strong(shared_ptr<T>& expected, shared_ptr<T> desired,
                                        memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Effects:* Equivalent to:
 `memory_order::acq_rel` shall be replaced by the value
 `memory_order::acquire` and a value of `memory_order::release` shall be
 replaced by the value `memory_order::relaxed`.
 ``` cpp
+constexpr void wait(shared_ptr<T> old, memory_order order = memory_order::seq_cst) const noexcept;
 ```
+*Preconditions:* `order` is `memory_order::relaxed`,
+`memory_order::acquire`, or `memory_order::seq_cst`.
 *Effects:* Repeatedly performs the following steps, in order:
 - Evaluates `load(order)` and compares it to `old`.
 - If the two are not equivalent, returns.
 *Remarks:* Two `shared_ptr` objects are equivalent if they store the
 same pointer and either share ownership or are both empty. This function
 is an atomic waiting operation [[atomics.wait]].
 ``` cpp
+constexpr void notify_one() noexcept;
 ```
 *Effects:* Unblocks the execution of at least one atomic waiting
 operation that is eligible to be unblocked [[atomics.wait]] by this
 call, if any such atomic waiting operations exist.
 *Remarks:* This function is an atomic notifying
 operation [[atomics.wait]].
 ``` cpp
+constexpr void notify_all() noexcept;
 ```
 *Effects:* Unblocks the execution of all atomic waiting operations that
 are eligible to be unblocked [[atomics.wait]] by this call.
     static constexpr bool is_always_lock_free = implementation-defined  // whether a given atomic type's operations are always lock free;
     bool is_lock_free() const noexcept;
     constexpr atomic() noexcept;
+ constexpr atomic(weak_ptr<T> desired) noexcept;
     atomic(const atomic&) = delete;
     void operator=(const atomic&) = delete;
+ constexpr weak_ptr<T> load(memory_order order = memory_order::seq_cst) const noexcept;
+ constexpr operator weak_ptr<T>() const noexcept;
+ constexpr void store(weak_ptr<T> desired,
+                         memory_order order = memory_order::seq_cst) noexcept;
+    constexpr void operator=(weak_ptr<T> desired) noexcept;
+ constexpr weak_ptr<T> exchange(weak_ptr<T> desired,
                                    memory_order order = memory_order::seq_cst) noexcept;
+ constexpr bool compare_exchange_weak(weak_ptr<T>& expected, weak_ptr<T> desired,
                                          memory_order success, memory_order failure) noexcept;
+ constexpr bool compare_exchange_strong(weak_ptr<T>& expected, weak_ptr<T> desired,
                                            memory_order success, memory_order failure) noexcept;
+ constexpr bool compare_exchange_weak(weak_ptr<T>& expected, weak_ptr<T> desired,
                                          memory_order order = memory_order::seq_cst) noexcept;
+ constexpr bool compare_exchange_strong(weak_ptr<T>& expected, weak_ptr<T> desired,
                                            memory_order order = memory_order::seq_cst) noexcept;
+ constexpr void wait(weak_ptr<T> old,
+                        memory_order order = memory_order::seq_cst) const noexcept;
+ constexpr void notify_one() noexcept;
+    constexpr void notify_all() noexcept;
   private:
     weak_ptr<T> p;              // exposition only
   };
 }
 ``` cpp
 constexpr atomic() noexcept;
 ```
+*Effects:* Value-initializes `p`.
 ``` cpp
+constexpr atomic(weak_ptr<T> desired) noexcept;
 ```
 *Effects:* Initializes the object with the value `desired`.
 Initialization is not an atomic operation [[intro.multithread]].
 `memory_order::relaxed` operations on a suitable atomic pointer
 variable, and then immediately accessing `A` in the receiving thread.
 This results in undefined behavior. — *end note*]
 ``` cpp
+constexpr void store(weak_ptr<T> desired, memory_order order = memory_order::seq_cst) noexcept;
 ```
+*Preconditions:* `order` is `memory_order::relaxed`,
+`memory_order::release`, or `memory_order::seq_cst`.
 *Effects:* Atomically replaces the value pointed to by `this` with the
 value of `desired` as if by `p.swap(desired)`. Memory is affected
 according to the value of `order`.
 ``` cpp
+constexpr void operator=(weak_ptr<T> desired) noexcept;
 ```
 *Effects:* Equivalent to `store(desired)`.
 ``` cpp
+constexpr weak_ptr<T> load(memory_order order = memory_order::seq_cst) const noexcept;
 ```
+*Preconditions:* `order` is `memory_order::relaxed`,
+`memory_order::acquire`, or `memory_order::seq_cst`.
 *Effects:* Memory is affected according to the value of `order`.
 *Returns:* Atomically returns `p`.
 ``` cpp
+constexpr operator weak_ptr<T>() const noexcept;
 ```
 *Effects:* Equivalent to: `return load();`
 ``` cpp
+constexpr weak_ptr<T> exchange(weak_ptr<T> desired,
+                               memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Effects:* Atomically replaces `p` with `desired` as if by
 `p.swap(desired)`. Memory is affected according to the value of `order`.
 This is an atomic read-modify-write operation [[intro.races]].
 *Returns:* Atomically returns the value of `p` immediately before the
 effects.
 ``` cpp
+constexpr bool compare_exchange_weak(weak_ptr<T>& expected, weak_ptr<T> desired,
                                      memory_order success, memory_order failure) noexcept;
+constexpr bool compare_exchange_strong(weak_ptr<T>& expected, weak_ptr<T> desired,
                                        memory_order success, memory_order failure) noexcept;
 ```
+*Preconditions:* `failure` is `memory_order::relaxed`,
+`memory_order::acquire`, or `memory_order::seq_cst`.
 *Effects:* If `p` is equivalent to `expected`, assigns `desired` to `p`
 and has synchronization semantics corresponding to the value of
 `success`, otherwise assigns `p` to `expected` and has synchronization
 semantics corresponding to the value of `failure`.
 corresponding to the write to `expected` is part of the atomic
 operation. The write to `expected` itself is not required to be part of
 the atomic operation.
 ``` cpp
+constexpr bool compare_exchange_weak(weak_ptr<T>& expected, weak_ptr<T> desired,
                                      memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Effects:* Equivalent to:
 `memory_order::acq_rel` shall be replaced by the value
 `memory_order::acquire` and a value of `memory_order::release` shall be
 replaced by the value `memory_order::relaxed`.
 ``` cpp
+constexpr bool compare_exchange_strong(weak_ptr<T>& expected, weak_ptr<T> desired,
                                        memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Effects:* Equivalent to:
 `memory_order::acq_rel` shall be replaced by the value
 `memory_order::acquire` and a value of `memory_order::release` shall be
 replaced by the value `memory_order::relaxed`.
 ``` cpp
+constexpr void wait(weak_ptr<T> old, memory_order order = memory_order::seq_cst) const noexcept;
 ```
+*Preconditions:* `order` is `memory_order::relaxed`,
+`memory_order::acquire`, or `memory_order::seq_cst`.
 *Effects:* Repeatedly performs the following steps, in order:
 - Evaluates `load(order)` and compares it to `old`.
 - If the two are not equivalent, returns.
 *Remarks:* Two `weak_ptr` objects are equivalent if they store the same
 pointer and either share ownership or are both empty. This function is
 an atomic waiting operation [[atomics.wait]].
 ``` cpp
+constexpr void notify_one() noexcept;
 ```
 *Effects:* Unblocks the execution of at least one atomic waiting
 operation that is eligible to be unblocked [[atomics.wait]] by this
 call, if any such atomic waiting operations exist.
 *Remarks:* This function is an atomic notifying
 operation [[atomics.wait]].
 ``` cpp
+constexpr void notify_all() noexcept;
 ```
 *Effects:* Unblocks the execution of all atomic waiting operations that
 are eligible to be unblocked [[atomics.wait]] by this call.
     atomic_flag(const atomic_flag&) = delete;
     atomic_flag& operator=(const atomic_flag&) = delete;
     atomic_flag& operator=(const atomic_flag&) volatile = delete;
     bool test(memory_order = memory_order::seq_cst) const volatile noexcept;
+ constexpr bool test(memory_order = memory_order::seq_cst) const noexcept;
     bool test_and_set(memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr bool test_and_set(memory_order = memory_order::seq_cst) noexcept;
     void clear(memory_order = memory_order::seq_cst) volatile noexcept;
+ constexpr void clear(memory_order = memory_order::seq_cst) noexcept;
     void wait(bool, memory_order = memory_order::seq_cst) const volatile noexcept;
+ constexpr void wait(bool, memory_order = memory_order::seq_cst) const noexcept;
     void notify_one() volatile noexcept;
+ constexpr void notify_one() noexcept;
     void notify_all() volatile noexcept;
+ constexpr void notify_all() noexcept;
   };
 }
 ```
 The `atomic_flag` type provides the classic test-and-set functionality.
 *Effects:* Initializes `*this` to the clear state.
 ``` cpp
 bool atomic_flag_test(const volatile atomic_flag* object) noexcept;
+constexpr bool atomic_flag_test(const atomic_flag* object) noexcept;
 bool atomic_flag_test_explicit(const volatile atomic_flag* object,
                                memory_order order) noexcept;
+constexpr bool atomic_flag_test_explicit(const atomic_flag* object,
                                memory_order order) noexcept;
 bool atomic_flag::test(memory_order order = memory_order::seq_cst) const volatile noexcept;
+constexpr bool atomic_flag::test(memory_order order = memory_order::seq_cst) const noexcept;
 ```
 For `atomic_flag_test`, let `order` be `memory_order::seq_cst`.
+*Preconditions:* `order` is `memory_order::relaxed`,
+`memory_order::acquire`, or `memory_order::seq_cst`.
 *Effects:* Memory is affected according to the value of `order`.
 *Returns:* Atomically returns the value pointed to by `object` or
 `this`.
 ``` cpp
 bool atomic_flag_test_and_set(volatile atomic_flag* object) noexcept;
+constexpr bool atomic_flag_test_and_set(atomic_flag* object) noexcept;
 bool atomic_flag_test_and_set_explicit(volatile atomic_flag* object, memory_order order) noexcept;
+constexpr bool atomic_flag_test_and_set_explicit(atomic_flag* object, memory_order order) noexcept;
 bool atomic_flag::test_and_set(memory_order order = memory_order::seq_cst) volatile noexcept;
+constexpr bool atomic_flag::test_and_set(memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Effects:* Atomically sets the value pointed to by `object` or by `this`
 to `true`. Memory is affected according to the value of `order`. These
 operations are atomic read-modify-write
 *Returns:* Atomically, the value of the object immediately before the
 effects.
 ``` cpp
 void atomic_flag_clear(volatile atomic_flag* object) noexcept;
+constexpr void atomic_flag_clear(atomic_flag* object) noexcept;
 void atomic_flag_clear_explicit(volatile atomic_flag* object, memory_order order) noexcept;
+constexpr void atomic_flag_clear_explicit(atomic_flag* object, memory_order order) noexcept;
 void atomic_flag::clear(memory_order order = memory_order::seq_cst) volatile noexcept;
+constexpr void atomic_flag::clear(memory_order order = memory_order::seq_cst) noexcept;
 ```
+*Preconditions:* `order` is `memory_order::relaxed`,
+`memory_order::release`, or `memory_order::seq_cst`.
 *Effects:* Atomically sets the value pointed to by `object` or by `this`
 to `false`. Memory is affected according to the value of `order`.
 ``` cpp
 void atomic_flag_wait(const volatile atomic_flag* object, bool old) noexcept;
+constexpr void atomic_flag_wait(const atomic_flag* object, bool old) noexcept;
 void atomic_flag_wait_explicit(const volatile atomic_flag* object,
                                bool old, memory_order order) noexcept;
+constexpr void atomic_flag_wait_explicit(const atomic_flag* object,
                                bool old, memory_order order) noexcept;
 void atomic_flag::wait(bool old, memory_order order =
                                    memory_order::seq_cst) const volatile noexcept;
+constexpr void atomic_flag::wait(bool old, memory_order order =
                                    memory_order::seq_cst) const noexcept;
 ```
 For `atomic_flag_wait`, let `order` be `memory_order::seq_cst`. Let
 `flag` be `object` for the non-member functions and `this` for the
 member functions.
+*Preconditions:* `order` is `memory_order::relaxed`,
+`memory_order::acquire`, or `memory_order::seq_cst`.
 *Effects:* Repeatedly performs the following steps, in order:
 - Evaluates `flag->test(order) != old`.
 - If the result of that evaluation is `true`, returns.
 *Remarks:* This function is an atomic waiting
 operation [[atomics.wait]].
 ``` cpp
 void atomic_flag_notify_one(volatile atomic_flag* object) noexcept;
+constexpr void atomic_flag_notify_one(atomic_flag* object) noexcept;
 void atomic_flag::notify_one() volatile noexcept;
+constexpr void atomic_flag::notify_one() noexcept;
 ```
 *Effects:* Unblocks the execution of at least one atomic waiting
 operation that is eligible to be unblocked [[atomics.wait]] by this
 call, if any such atomic waiting operations exist.
 *Remarks:* This function is an atomic notifying
 operation [[atomics.wait]].
 ``` cpp
 void atomic_flag_notify_all(volatile atomic_flag* object) noexcept;
+constexpr void atomic_flag_notify_all(atomic_flag* object) noexcept;
 void atomic_flag::notify_all() volatile noexcept;
+constexpr void atomic_flag::notify_all() noexcept;
 ```
 *Effects:* Unblocks the execution of all atomic waiting operations that
 are eligible to be unblocked [[atomics.wait]] by this call.
 Fences can have acquire semantics, release semantics, or both. A fence
 with acquire semantics is called an *acquire fence*. A fence with
 release semantics is called a *release fence*.
 A release fence A synchronizes with an acquire fence B if there exist
+atomic operations X and Y, where Y is not an atomic modify-write
+operation [[atomics.order]], both operating on some atomic object M,
+such that A is sequenced before X, X modifies M, Y is sequenced before
+B, and Y reads the value written by X or a value written by any side
+effect in the hypothetical release sequence X would head if it were a
+release operation.
 A release fence A synchronizes with an atomic operation B that performs
 an acquire operation on an atomic object M if there exists an atomic
 operation X such that A is sequenced before X, X modifies M, and B reads
 the value written by X or a value written by any side effect in the
 operation X on M such that X is sequenced before B and reads the value
 written by A or a value written by any side effect in the release
 sequence headed by A.
 ``` cpp
+extern "C" constexpr void atomic_thread_fence(memory_order order) noexcept;
 ```
 *Effects:* Depending on the value of `order`, this operation:
 - has no effects, if `order == memory_order::relaxed`;
+- is an acquire fence, if `order == memory_order::acquire`;
 - is a release fence, if `order == memory_order::release`;
 - is both an acquire fence and a release fence, if
   `order == memory_order::acq_rel`;
 - is a sequentially consistent acquire and release fence, if
   `order == memory_order::seq_cst`.
 ``` cpp
+extern "C" constexpr void atomic_signal_fence(memory_order order) noexcept;
 ```
 *Effects:* Equivalent to `atomic_thread_fence(order)`, except that the
 resulting ordering constraints are established only between a thread and
 a signal handler executed in the same thread.
 namespace std {
   // [thread.mutex.class], class mutex
   class mutex;
   // [thread.mutex.recursive], class recursive_mutex
   class recursive_mutex;
+  // [thread.timedmutex.class], class timed_mutex
   class timed_mutex;
   // [thread.timedmutex.recursive], class recursive_timed_mutex
   class recursive_timed_mutex;
   struct defer_lock_t { explicit defer_lock_t() = default; };
 }
 ```
 ### Mutex requirements <a id="thread.mutex.requirements">[[thread.mutex.requirements]]</a>
+#### General <a id="thread.mutex.requirements.general">[[thread.mutex.requirements.general]]</a>
 A mutex object facilitates protection against data races and allows safe
 synchronization of data between execution agents
 [[thread.req.lockable]]. An execution agent *owns* a mutex from the time
 it successfully calls one of the lock functions until it calls unlock.
 released ownership with a call to `unlock()`.
 [*Note 4*: After a thread `A` has called `unlock()`, releasing a mutex,
 it is possible for another thread `B` to lock the same mutex, observe
 that it is no longer in use, unlock it, and destroy it, before thread
+`A` appears to have returned from its unlock call. Conforming
+implementations handle such scenarios correctly, as long as thread `A`
+does not access the mutex after the unlock call returns. These cases
 typically occur when a reference-counted object contains a mutex that is
 used to protect the reference count. — *end note*]
 The class `mutex` meets all of the mutex requirements
 [[thread.mutex.requirements]]. It is a standard-layout class
 of type `system_error`. A thread shall call `unlock()` once for each
 level of ownership acquired by calls to `lock()` and `try_lock()`. Only
 when all levels of ownership have been released may ownership be
 acquired by another thread.
+The behavior of a program is undefined if
 - it destroys a `recursive_mutex` object owned by any thread or
 - a thread terminates while owning a `recursive_mutex` object.
 #### Timed mutex types <a id="thread.timedmutex.requirements">[[thread.timedmutex.requirements]]</a>
 The class `timed_mutex` meets all of the timed mutex requirements
 [[thread.timedmutex.requirements]]. It is a standard-layout class
 [[class.prop]].
+The behavior of a program is undefined if
 - it destroys a `timed_mutex` object owned by any thread,
 - a thread that owns a `timed_mutex` object calls `lock()`,
   `try_lock()`, `try_lock_for()`, or `try_lock_until()` on that object,
   or
 `unlock()` once for each level of ownership acquired by calls to
 `lock()`, `try_lock()`, `try_lock_for()`, and `try_lock_until()`. Only
 when all levels of ownership have been released may ownership of the
 object be acquired by another thread.
+The behavior of a program is undefined if
 - it destroys a `recursive_timed_mutex` object owned by any thread, or
 - a thread terminates while owning a `recursive_timed_mutex` object.
 #### Shared mutex types <a id="thread.sharedmutex.requirements">[[thread.sharedmutex.requirements]]</a>
 The class `shared_mutex` meets all of the shared mutex requirements
 [[thread.sharedmutex.requirements]]. It is a standard-layout class
 [[class.prop]].
+The behavior of a program is undefined if
 - it destroys a `shared_mutex` object owned by any thread,
 - a thread attempts to recursively gain any ownership of a
   `shared_mutex`, or
 - a thread terminates while possessing any ownership of a
 The class `shared_timed_mutex` meets all of the shared timed mutex
 requirements [[thread.sharedtimedmutex.requirements]]. It is a
 standard-layout class [[class.prop]].
+The behavior of a program is undefined if
 - it destroys a `shared_timed_mutex` object owned by any thread,
 - a thread attempts to recursively gain any ownership of a
   `shared_timed_mutex`, or
 - a thread terminates while possessing any ownership of a
     unique_lock(const unique_lock&) = delete;
     unique_lock& operator=(const unique_lock&) = delete;
     unique_lock(unique_lock&& u) noexcept;
+    unique_lock& operator=(unique_lock&& u) noexcept;
     // [thread.lock.unique.locking], locking
     void lock();
     bool try_lock();
 *Ensures:* `pm == u_p.pm` and `owns == u_p.owns` (where `u_p` is the
 state of `u` just prior to this construction), `u.pm == 0` and
 `u.owns == false`.
 ``` cpp
+unique_lock& operator=(unique_lock&& u) noexcept;
 ```
+*Effects:* Equivalent to: `unique_lock(std::move(u)).swap(*this)`
+*Returns:* `*this`.
 ``` cpp
 ~unique_lock();
 ```
 ``` cpp
 shared_lock& operator=(shared_lock&& sl) noexcept;
 ```
+*Effects:* Equivalent to: `shared_lock(std::move(sl)).swap(*this)`
+*Returns:* `*this`.
 ##### Locking <a id="thread.lock.shared.locking">[[thread.lock.shared.locking]]</a>
 ``` cpp
 void lock();
 *Mandates:* `is_invocable_v<Callable, Args...>` is `true`.
 *Effects:* An execution of `call_once` that does not call its `func` is
 a *passive* execution. An execution of `call_once` that calls its `func`
+is an *active* execution. An active execution evaluates *INVOKE*(
 std::forward\<Callable\>(func),
 std::forward\<Args\>(args)...) [[func.require]]. If such a call to
 `func` throws an exception the execution is *exceptional*, otherwise it
 is *returning*. An exceptional execution propagates the exception to the
 caller of `call_once`. Among all executions of `call_once` for any given
   supplied by all concurrently waiting (via `wait`, `wait_for`, or
   `wait_until`) threads.
 *Effects:* Transfers ownership of the lock associated with `lk` into
 internal storage and schedules `cond` to be notified when the current
+thread exits, after all objects with thread storage duration associated
 with the current thread have been destroyed. This notification is
 equivalent to:
 ``` cpp
 lk.unlock();
 [*Note 1*: The supplied lock is held until the thread exits, which
 might cause deadlock due to lock ordering issues. — *end note*]
 [*Note 2*: It is the user’s responsibility to ensure that waiting
+threads do not incorrectly assume that the thread has finished if they
 experience spurious wakeups. This typically requires that the condition
 being waited for is satisfied while holding the lock on `lk`, and that
 this lock is not released and reacquired prior to calling
 `notify_all_at_thread_exit`. — *end note*]
 ### Class `condition_variable_any` <a id="thread.condition.condvarany">[[thread.condition.condvarany]]</a>
 #### General <a id="thread.condition.condvarany.general">[[thread.condition.condvarany.general]]</a>
+In [[thread.condition.condvarany]], template arguments for template
+parameters named `Lock` shall meet the *Cpp17BasicLockable* requirements
+[[thread.req.lockable.basic]].
 [*Note 1*: All of the standard mutex types meet this requirement. If a
 type other than one of the standard mutex types or a `unique_lock`
 wrapper for a standard mutex type is used with `condition_variable_any`,
 any necessary synchronization is assumed to be in place with respect to
     ~barrier();
     barrier(const barrier&) = delete;
     barrier& operator=(const barrier&) = delete;
+    arrival_token arrive(ptrdiff_t update = 1);
     void wait(arrival_token&& arrival) const;
     void arrive_and_wait();
     void arrive_and_drop();
 *Throws:* Any exception thrown by `CompletionFunction`’s move
 constructor.
 ``` cpp
+arrival_token arrive(ptrdiff_t update = 1);
 ```
 *Preconditions:* `update > 0` is `true`, and `update` is less than or
 equal to the expected count for the current barrier phase.
   template<> class promise<void>;
   template<class R>
     void swap(promise<R>& x, promise<R>& y) noexcept;
   // [futures.unique.future], class template future
   template<class R> class future;
   template<class R> class future<R&>;
   template<> class future<void>;
   template<class R, class... ArgTypes>
     void swap(packaged_task<R(ArgTypes...)>&, packaged_task<R(ArgTypes...)>&) noexcept;
   // [futures.async], function template async
   template<class F, class... Args>
+    future<invoke_result_t<decay_t<F>, decay_t<Args>...>>
       async(F&& f, Args&&... args);
   template<class F, class... Args>
+    future<invoke_result_t<decay_t<F>, decay_t<Args>...>>
       async(launch policy, F&& f, Args&&... args);
 }
 ```
 The `enum` type `launch` is a bitmask type [[bitmask.types]] with
 An *asynchronous provider* is an object that provides a result to a
 shared state. The result of a shared state is set by respective
 functions on the asynchronous provider.
+[*Example 1*: Promises and tasks are examples of asynchronous
+providers. — *end example*]
 The means of setting the result of a shared state is specified in the
 description of those classes and functions that create such a state
 object.
 [[basic.stc.thread]] is sequenced before making that shared state ready.
 Access to the result of the same shared state may conflict
 [[intro.multithread]].
+[*Note 3*: This explicitly specifies that the result of the shared
 state is visible in the objects that reference this state in the sense
 of data race avoidance [[res.on.data.races]]. For example, concurrent
 accesses through references returned by `shared_future::get()`
 [[futures.shared.future]] must either use read-only operations or
 provide additional synchronization. — *end note*]
     // setting the result with deferred notification
     void set_value_at_thread_exit(see below);
     void set_exception_at_thread_exit(exception_ptr p);
   };
 }
 ```
 For the primary template, `R` shall be an object type that meets the
 *Cpp17Destructible* requirements.
 The `set_value`, `set_exception`, `set_value_at_thread_exit`, and
 `set_exception_at_thread_exit` member functions behave as though they
 acquire a single mutex associated with the promise object while updating
 the promise object.
 ``` cpp
 promise();
 template<class Allocator>
   promise(allocator_arg_t, const Allocator& a);
 ```
 void promise<void>::set_value_at_thread_exit();
 ```
 *Effects:* Stores the value `r` in the shared state without making that
 state ready immediately. Schedules that state to be made ready when the
+current thread exits, after all objects with thread storage duration
 associated with the current thread have been destroyed.
 *Throws:*
 - `future_error` if its shared state already has a stored value or
 *Preconditions:* `p` is not null.
 *Effects:* Stores the exception pointer `p` in the shared state without
 making that state ready immediately. Schedules that state to be made
+ready when the current thread exits, after all objects with thread
+storage duration associated with the current thread have been destroyed.
 *Throws:* `future_error` if an error condition occurs.
 *Error conditions:*
 [*Note 1*: Member functions of `future` do not synchronize with
 themselves or with member functions of `shared_future`. — *end note*]
 The effect of calling any member function other than the destructor, the
+move assignment operator, `share`, or `valid` on a `future` object for
 which `valid() == false` is undefined.
 [*Note 2*: It is valid to move from a future object for which
 `valid() == false`. — *end note*]
 [*Note 1*: Member functions of `shared_future` do not synchronize with
 themselves, but they synchronize with the shared state. — *end note*]
 The effect of calling any member function other than the destructor, the
+move assignment operator, the copy assignment operator, or `valid()` on
 a `shared_future` object for which `valid() == false` is undefined.
 [*Note 2*: It is valid to copy or move from a `shared_future` object
 for which `valid()` is `false`. — *end note*]
 potentially in a new thread and provides the result of the function in a
 `future` object with which it shares a shared state.
 ``` cpp
 template<class F, class... Args>
+  future<invoke_result_t<decay_t<F>, decay_t<Args>...>>
     async(F&& f, Args&&... args);
 template<class F, class... Args>
+  future<invoke_result_t<decay_t<F>, decay_t<Args>...>>
     async(launch policy, F&& f, Args&&... args);
 ```
 *Mandates:* The following are all `true`:
   public:
     // construction and destruction
     packaged_task() noexcept;
     template<class F>
       explicit packaged_task(F&& f);
+    template<class F, class Allocator>
+      explicit packaged_task(allocator_arg_t, const Allocator& a, F&& f);
     ~packaged_task();
     // no copy
     packaged_task(const packaged_task&) = delete;
     packaged_task& operator=(const packaged_task&) = delete;
 ``` cpp
 template<class F>
   explicit packaged_task(F&& f);
 ```
+*Effects:* Equivalent to
+`packaged_task(allocator_arg, allocator<int>(), std::forward<F>(f))`.
+``` cpp
+template<class F, class Allocator>
+  explicit packaged_task(allocator_arg_t, const Allocator& a, F&& f);
+```
 *Constraints:* `remove_cvref_t<F>` is not the same type as
 `packaged_task<R(ArgTypes...)>`.
+*Mandates:* `is_invocable_r_v<R, decay_t<F>&, ArgTypes...>` is `true`.
+*Preconditions:* `Allocator` meets the *Cpp17Allocator*
+requirements [[allocator.requirements.general]].
+*Effects:* Let `A2` be
+`allocator_traits<Allocator>::rebind_alloc<`*`unspecified`*`>` and let
+`a2` be an object of type `A2` initialized with `A2(a)`. Constructs a
+new `packaged_task` object with a stored task of type `decay_t<F>` and a
+shared state. Initializes the object’s stored task with
+`std::forward<F>(f)`. Uses `a2` to allocate storage for the shared state
+and stores a copy of `a2` in the shared state.
+*Throws:* Any exceptions thrown by the initialization of the stored
+task. If storage for the shared state cannot be allocated, any exception
+thrown by `A2::allocate`.
 ``` cpp
 template<class F> packaged_task(F) -> packaged_task<see below>;
 ```
 in `args...`. If the task returns normally, the return value is stored
 as the asynchronous result in the shared state of `*this`, otherwise the
 exception thrown by the task is stored. In either case, this is done
 without making that state ready [[futures.state]] immediately. Schedules
 the shared state to be made ready when the current thread exits, after
+all objects with thread storage duration associated with the current
 thread have been destroyed.
 *Throws:* `future_error` if an error condition occurs.
 *Error conditions:*
 ``` cpp
 void reset();
 ```
+*Effects:* Equivalent to:
+``` cpp
+if (!valid()) {
+  throw future_error(future_errc::no_state);
+}
+*this = packaged_task(allocator_arg, a, std::move(f));
+```
+where `f` is the task stored in `*this` and `a` is the allocator stored
+in the shared state.
 [*Note 2*: This constructs a new shared state for `*this`. The old
 state is abandoned [[futures.state]]. — *end note*]
 *Throws:*
+- Any exception thrown by the `packaged_task` constructor.
 - `future_error` with an error condition of `no_state` if `*this` has no
   shared state.
 #### Globals <a id="futures.task.nonmembers">[[futures.task.nonmembers]]</a>
   void swap(packaged_task<R(ArgTypes...)>& x, packaged_task<R(ArgTypes...)>& y) noexcept;
 ```
 *Effects:* As if by `x.swap(y)`.
+## Safe reclamation <a id="saferecl">[[saferecl]]</a>
+### General <a id="saferecl.general">[[saferecl.general]]</a>
+Subclause [[saferecl]] contains safe-reclamation techniques, which are
+most frequently used to straightforwardly resolve access-deletion races.
+### Read-copy update (RCU) <a id="saferecl.rcu">[[saferecl.rcu]]</a>
+#### General <a id="saferecl.rcu.general">[[saferecl.rcu.general]]</a>
+RCU is a synchronization mechanism that can be used for linked data
+structures that are frequently read, but seldom updated. RCU does not
+provide mutual exclusion, but instead allows the user to schedule
+specified actions such as deletion at some later time.
+A class type `T` is *rcu-protectable* if it has exactly one base class
+of type `rcu_obj_base<T, D>` for some `D`, and that base is public and
+non-virtual, and it has no base classes of type `rcu_obj_base<X, Y>` for
+any other combination `X`, `Y`. An object is rcu-protectable if it is of
+rcu-protectable type.
+An invocation of `unlock` U on an `rcu_domain dom` corresponds to an
+invocation of `lock` L on `dom` if L is sequenced before U and either
+- no other invocation of `lock` on `dom` is sequenced after L and before
+  U, or
+- every invocation of `unlock` U2 on `dom` such that L is sequenced
+  before U2 and U2 is sequenced before U corresponds to an invocation of
+  `lock` L2 on `dom` such that L is sequenced before L2 and L2 is
+  sequenced before U2.
+[*Note 1*: This pairs nested locks and unlocks on a given domain in
+each thread. — *end note*]
+A *region of RCU protection* on a domain `dom` starts with a `lock` L on
+`dom` and ends with its corresponding `unlock` U.
+Given a region of RCU protection R on a domain `dom` and given an
+evaluation E that scheduled another evaluation F in `dom`, if E does not
+strongly happen before the start of R, the end of R strongly happens
+before evaluating F.
+The evaluation of a scheduled evaluation is potentially concurrent with
+any other scheduled evaluation. Each scheduled evaluation is evaluated
+at most once.
+#### Header `<rcu>` synopsis <a id="rcu.syn">[[rcu.syn]]</a>
+``` cpp
+namespace std {
+  // [saferecl.rcu.base], class template rcu_obj_base
+  template<class T, class D = default_delete<T>> class rcu_obj_base;
+  // [saferecl.rcu.domain], class rcu_domain
+  class rcu_domain;
+  // [saferecl.rcu.domain.func], non-member functions
+  rcu_domain& rcu_default_domain() noexcept;
+  void rcu_synchronize(rcu_domain& dom = rcu_default_domain()) noexcept;
+  void rcu_barrier(rcu_domain& dom = rcu_default_domain()) noexcept;
+  template<class T, class D = default_delete<T>>
+    void rcu_retire(T* p, D d = D(), rcu_domain& dom = rcu_default_domain());
+}
+```
+#### Class template `rcu_obj_base` <a id="saferecl.rcu.base">[[saferecl.rcu.base]]</a>
+Objects of type `T` to be protected by RCU inherit from a specialization
+`rcu_obj_base<T, D>` for some `D`.
+``` cpp
+namespace std {
+  template<class T, class D = default_delete<T>>
+  class rcu_obj_base {
+  public:
+    void retire(D d = D(), rcu_domain& dom = rcu_default_domain()) noexcept;
+  protected:
+    rcu_obj_base() = default;
+    rcu_obj_base(const rcu_obj_base&) = default;
+    rcu_obj_base(rcu_obj_base&&) = default;
+    rcu_obj_base& operator=(const rcu_obj_base&) = default;
+    rcu_obj_base& operator=(rcu_obj_base&&) = default;
+    ~rcu_obj_base() = default;
+  private:
+    D deleter;            // exposition only
+  };
+}
+```
+The behavior of a program that adds specializations for `rcu_obj_base`
+is undefined.
+`T` may be an incomplete type. It shall be complete before any member of
+the resulting specialization of `rcu_obj_base` is referenced.
+`D` shall be a function object type [[function.objects]] for which,
+given a value `d` of type `D` and a value `ptr` of type `T*`, the
+expression `d(ptr)` is valid.
+`D` shall meet the requirements for *Cpp17DefaultConstructible* and
+*Cpp17MoveAssignable*.
+If `D` is trivially copyable, all specializations of
+`rcu_obj_base<T, D>` are trivially copyable.
+``` cpp
+void retire(D d = D(), rcu_domain& dom = rcu_default_domain()) noexcept;
+```
+*Mandates:* `T` is an rcu-protectable type.
+*Preconditions:* `*this` is a base class subobject of an object `x` of
+type `T`. The member function `rcu_obj_base<T, D>::retire` was not
+invoked on `x` before. The assignment to *deleter* does not exit via an
+exception.
+*Effects:* Evaluates *`deleter`*` = std::move(d)` and schedules the
+evaluation of the expression *`deleter`*`( addressof(x))` in the domain
+`dom`; the behavior is undefined if that evaluation exits via an
+exception. May invoke scheduled evaluations in `dom`.
+[*Note 1*: If such evaluations acquire resources held across any
+invocation of `retire` on `dom`, deadlock can occur. — *end note*]
+#### Class `rcu_domain` <a id="saferecl.rcu.domain">[[saferecl.rcu.domain]]</a>
+##### General <a id="saferecl.rcu.domain.general">[[saferecl.rcu.domain.general]]</a>
+``` cpp
+namespace std {
+  class rcu_domain {
+  public:
+    rcu_domain(const rcu_domain&) = delete;
+    rcu_domain& operator=(const rcu_domain&) = delete;
+    void lock() noexcept;
+    bool try_lock() noexcept;
+    void unlock() noexcept;
+  };
+}
+```
+This class meets the requirements of *Cpp17Lockable*
+[[thread.req.lockable.req]] and provides regions of RCU protection.
+[*Example 1*:
+``` cpp
+std::scoped_lock<rcu_domain> rlock(rcu_default_domain());
+```
+— *end example*]
+The functions `lock` and `unlock` establish (possibly nested) regions of
+RCU protection.
+##### Member functions <a id="saferecl.rcu.domain.members">[[saferecl.rcu.domain.members]]</a>
+``` cpp
+void lock() noexcept;
+```
+*Effects:* Opens a region of RCU protection.
+*Remarks:* Calls to `lock` do not introduce a data race [[intro.races]]
+involving `*this`.
+``` cpp
+bool try_lock() noexcept;
+```
+*Effects:* Equivalent to `lock()`.
+*Returns:* `true`.
+``` cpp
+void unlock() noexcept;
+```
+*Preconditions:* A call to `lock` that opened an unclosed region of RCU
+protection is sequenced before the call to `unlock`.
+*Effects:* Closes the unclosed region of RCU protection that was most
+recently opened. May invoke scheduled evaluations in `*this`.
+[*Note 1*: If such evaluations acquire resources held across any
+invocation of `unlock` on `*this`, deadlock can occur. — *end note*]
+*Remarks:* Calls to `unlock` do not introduce a data race involving
+`*this`.
+[*Note 2*: Evaluation of scheduled evaluations can still cause a data
+race. — *end note*]
+##### Non-member functions <a id="saferecl.rcu.domain.func">[[saferecl.rcu.domain.func]]</a>
+``` cpp
+rcu_domain& rcu_default_domain() noexcept;
+```
+*Returns:* A reference to a static-duration object of type `rcu_domain`.
+A reference to the same object is returned every time this function is
+called.
+``` cpp
+void rcu_synchronize(rcu_domain& dom = rcu_default_domain()) noexcept;
+```
+*Effects:* If the call to `rcu_synchronize` does not strongly happen
+before the lock opening an RCU protection region `R` on `dom`, blocks
+until the `unlock` closing `R` happens.
+*Synchronization:* The `unlock` closing `R` strongly happens before the
+return from `rcu_synchronize`.
+``` cpp
+void rcu_barrier(rcu_domain& dom = rcu_default_domain()) noexcept;
+```
+*Effects:* May evaluate any scheduled evaluations in `dom`. For any
+evaluation that happens before the call to `rcu_barrier` and that
+schedules an evaluation E in `dom`, blocks until E has been evaluated.
+*Synchronization:* The evaluation of any such E strongly happens before
+the return from `rcu_barrier`.
+[*Note 3*: A call to `rcu_barrier` does not imply a call to
+`rcu_synchronize` and vice versa. — *end note*]
+``` cpp
+template<class T, class D = default_delete<T>>
+void rcu_retire(T* p, D d = D(), rcu_domain& dom = rcu_default_domain());
+```
+*Mandates:* `is_move_constructible_v<D>` is `true` and the expression
+`d(p)` is well-formed.
+*Preconditions:* `D` meets the *Cpp17MoveConstructible* and
+*Cpp17Destructible* requirements.
+*Effects:* May allocate memory. It is unspecified whether the memory
+allocation is performed by invoking `operator new`. Initializes an
+object `d1` of type `D` from `std::move(d)`. Schedules the evaluation of
+`d1(p)` in the domain `dom`; the behavior is undefined if that
+evaluation exits via an exception. May invoke scheduled evaluations in
+`dom`.
+[*Note 4*: If `rcu_retire` exits via an exception, no evaluation is
+scheduled. — *end note*]
+*Throws:* `bad_alloc` or any exception thrown by the initialization of
+`d1`.
+[*Note 5*: If scheduled evaluations acquire resources held across any
+invocation of `rcu_retire` on `dom`, deadlock can occur. — *end note*]
+### Hazard pointers <a id="saferecl.hp">[[saferecl.hp]]</a>
+#### General <a id="saferecl.hp.general">[[saferecl.hp.general]]</a>
+A hazard pointer is a single-writer multi-reader pointer that can be
+owned by at most one thread at any time. Only the owner of the hazard
+pointer can set its value, while any number of threads may read its
+value. The owner thread sets the value of a hazard pointer to point to
+an object in order to indicate to concurrent threads—which may delete
+such an object—that the object is not yet safe to delete.
+A class type `T` is *hazard-protectable* if it has exactly one base
+class of type `hazard_pointer_obj_base<T, D>` for some `D`, that base is
+public and non-virtual, and it has no base classes of type
+`hazard_pointer_obj_base<T2, D2>` for any other combination `T2`, `D2`.
+An object is *hazard-protectable* if it is of hazard-protectable type.
+The time span between creation and destruction of a hazard pointer h is
+partitioned into a series of *protection epochs*; in each protection
+epoch, h either is *associated with* a hazard-protectable object, or is
+*unassociated*. Upon creation, a hazard pointer is unassociated.
+Changing the association (possibly to the same object) initiates a new
+protection epoch and ends the preceding one.
+An object `x` of hazard-protectable type `T` is *retired* with a deleter
+of type `D` when the member function
+`hazard_pointer_obj_base<T, D>::retire` is invoked on `x`. Any given
+object `x` shall be retired at most once.
+A retired object `x` is *reclaimed* by invoking its deleter with a
+pointer to `x`; the behavior is undefined if that invocation exits via
+an exception.
+A hazard-protectable object `x` is *possibly-reclaimable* with respect
+to an evaluation A if
+- `x` is not reclaimed; and
+- `x` is retired in an evaluation R and A does not happen before R; and
+- for all hazard pointers h and for every protection epoch E of h during
+  which h is associated with `x`:
+  - if the beginning of E happens before R, the end of E strongly
+    happens before A; and
+  - if E began by an evaluation of `try_protect` with argument `src`,
+    label its atomic load operation L. If there exists an atomic
+    modification B on `src` such that L observes a modification that is
+    modification-ordered before B, and B happens before `x` is retired,
+    the end of E strongly happens before A. \[*Note 1*: In typical use,
+    a store to `src` sequenced before retiring `x` will be such an
+    atomic operation B. — *end note*]
+  \[*Note 2*: The latter two conditions convey the informal notion that
+  a protection epoch that began before retiring `x`, as implied either
+  by the happens-before relation or the coherence order of some source,
+  delays the reclamation of `x`. — *end note*]
+The number of possibly-reclaimable objects has an unspecified bound.
+[*Note 3*: The bound can be a function of the number of hazard
+pointers, the number of threads that retire objects, and the number of
+threads that use hazard pointers. — *end note*]
+[*Example 1*:
+The following example shows how hazard pointers allow updates to be
+carried out in the presence of concurrent readers. The object of type
+`hazard_pointer` in `print_name` protects the object `*ptr` from being
+reclaimed by `ptr->retire` until the end of the protection epoch.
+``` cpp
+struct Name : public hazard_pointer_obj_base<Name> { /* details */ };
+atomic<Name*> name;
+// called often and in parallel!
+void print_name() {
+  hazard_pointer h = make_hazard_pointer();
+  Name* ptr = h.protect(name);          // Protection epoch starts
+  // ... safe to access *ptr
+}                                       // Protection epoch ends.
+// called rarely, but possibly concurrently with print_name
+void update_name(Name* new_name) {
+  Name* ptr = name.exchange(new_name);
+  ptr->retire();
+}
+```
+— *end example*]
+#### Header `<hazard_pointer>` synopsis <a id="hazard.pointer.syn">[[hazard.pointer.syn]]</a>
+``` cpp
+namespace std {
+  // [saferecl.hp.base], class template hazard_pointer_obj_base
+  template<class T, class D = default_delete<T>> class hazard_pointer_obj_base;
+  // [saferecl.hp.holder], class hazard_pointer
+  class hazard_pointer;
+  // [saferecl.hp.holder.nonmem], non-member functions
+  hazard_pointer make_hazard_pointer();
+  void swap(hazard_pointer&, hazard_pointer&) noexcept;
+}
+```
+#### Class template `hazard_pointer_obj_base` <a id="saferecl.hp.base">[[saferecl.hp.base]]</a>
+``` cpp
+namespace std {
+  template<class T, class D = default_delete<T>>
+  class hazard_pointer_obj_base {
+  public:
+    void retire(D d = D()) noexcept;
+  protected:
+    hazard_pointer_obj_base() = default;
+    hazard_pointer_obj_base(const hazard_pointer_obj_base&) = default;
+    hazard_pointer_obj_base(hazard_pointer_obj_base&&) = default;
+    hazard_pointer_obj_base& operator=(const hazard_pointer_obj_base&) = default;
+    hazard_pointer_obj_base& operator=(hazard_pointer_obj_base&&) = default;
+    ~hazard_pointer_obj_base() = default;
+  private:
+    D deleter;      // exposition only
+  };
+}
+```
+`D` shall be a function object type [[func.require]] for which, given a
+value `d` of type `D` and a value `ptr` of type `T*`, the expression
+`d(ptr)` is valid.
+The behavior of a program that adds specializations for
+`hazard_pointer_obj_base` is undefined.
+`D` shall meet the requirements for *Cpp17DefaultConstructible* and
+*Cpp17MoveAssignable*.
+`T` may be an incomplete type. It shall be complete before any member of
+the resulting specialization of `hazard_pointer_obj_base` is referenced.
+``` cpp
+void retire(D d = D()) noexcept;
+```
+*Mandates:* `T` is a hazard-protectable type.
+*Preconditions:* `*this` is a base class subobject of an object `x` of
+type `T`. `x` is not retired. Move-assigning `d` to `deleter` does not
+exit via an exception.
+*Effects:* Move-assigns `d` to `deleter`, thereby setting it as the
+deleter of `x`, then retires `x`. May reclaim possibly-reclaimable
+objects.
+#### Class `hazard_pointer` <a id="saferecl.hp.holder">[[saferecl.hp.holder]]</a>
+##### General <a id="saferecl.hp.holder.general">[[saferecl.hp.holder.general]]</a>
+``` cpp
+namespace std {
+  class hazard_pointer {
+  public:
+    hazard_pointer() noexcept;
+    hazard_pointer(hazard_pointer&&) noexcept;
+    hazard_pointer& operator=(hazard_pointer&&) noexcept;
+    ~hazard_pointer();
+    bool empty() const noexcept;
+    template<class T> T* protect(const atomic<T*>& src) noexcept;
+    template<class T> bool try_protect(T*& ptr, const atomic<T*>& src) noexcept;
+    template<class T> void reset_protection(const T* ptr) noexcept;
+    void reset_protection(nullptr_t = nullptr) noexcept;
+    void swap(hazard_pointer&) noexcept;
+  };
+}
+```
+An object of type `hazard_pointer` is either empty or *owns* a hazard
+pointer. Each hazard pointer is owned by exactly one object of type
+`hazard_pointer`.
+[*Note 1*: An empty `hazard_pointer` object is different from a
+`hazard_pointer` object that owns an unassociated hazard pointer. An
+empty `hazard_pointer` object does not own any hazard
+pointers. — *end note*]
+##### Constructors, destructor, and assignment <a id="saferecl.hp.holder.ctor">[[saferecl.hp.holder.ctor]]</a>
+``` cpp
+hazard_pointer() noexcept;
+```
+*Ensures:* `*this` is empty.
+``` cpp
+hazard_pointer(hazard_pointer&& other) noexcept;
+```
+*Ensures:* If `other` is empty, `*this` is empty. Otherwise, `*this`
+owns the hazard pointer originally owned by `other`; `other` is empty.
+``` cpp
+~hazard_pointer();
+```
+*Effects:* If `*this` is not empty, destroys the hazard pointer owned by
+`*this`, thereby ending its current protection epoch.
+``` cpp
+hazard_pointer& operator=(hazard_pointer&& other) noexcept;
+```
+*Effects:* If `this == &other` is `true`, no effect. Otherwise, if
+`*this` is not empty, destroys the hazard pointer owned by `*this`,
+thereby ending its current protection epoch.
+*Ensures:* If `other` was empty, `*this` is empty. Otherwise, `*this`
+owns the hazard pointer originally owned by `other`. If `this != &other`
+is `true`, `other` is empty.
+*Returns:* `*this`.
+##### Member functions <a id="saferecl.hp.holder.mem">[[saferecl.hp.holder.mem]]</a>
+``` cpp
+bool empty() const noexcept;
+```
+*Returns:* `true` if and only if `*this` is empty.
+``` cpp
+template<class T> T* protect(const atomic<T*>& src) noexcept;
+```
+*Effects:* Equivalent to:
+``` cpp
+T* ptr = src.load(memory_order::relaxed);
+while (!try_protect(ptr, src)) {}
+return ptr;
+```
+``` cpp
+template<class T> bool try_protect(T*& ptr, const atomic<T*>& src) noexcept;
+```
+*Mandates:* `T` is a hazard-protectable type.
+*Preconditions:* `*this` is not empty.
+*Effects:* Performs the following steps in order:
+- Initializes a variable `old` of type `T*` with the value of `ptr`.
+- Evaluates `reset_protection(old)`.
+- Assigns the value of `src.load(memory_order::acquire)` to `ptr`.
+- If `old == ptr` is `false`, evaluates `reset_protection()`.
+*Returns:* `old == ptr`.
+``` cpp
+template<class T> void reset_protection(const T* ptr) noexcept;
+```
+*Mandates:* `T` is a hazard-protectable type.
+*Preconditions:* `*this` is not empty.
+*Effects:* If `ptr` is a null pointer value, invokes
+`reset_protection()`. Otherwise, associates the hazard pointer owned by
+`*this` with `*ptr`, thereby ending the current protection epoch.
+*Complexity:* Constant.
+``` cpp
+void reset_protection(nullptr_t = nullptr) noexcept;
+```
+*Preconditions:* `*this` is not empty.
+*Ensures:* The hazard pointer owned by `*this` is unassociated.
+*Complexity:* Constant.
+``` cpp
+void swap(hazard_pointer& other) noexcept;
+```
+*Effects:* Swaps the hazard pointer ownership of this object with that
+of `other`.
+[*Note 1*: The owned hazard pointers, if any, remain unchanged during
+the swap and continue to be associated with the respective objects that
+they were protecting before the swap, if any. No protection epochs are
+ended or initiated. — *end note*]
+*Complexity:* Constant.
+##### Non-member functions <a id="saferecl.hp.holder.nonmem">[[saferecl.hp.holder.nonmem]]</a>
+``` cpp
+hazard_pointer make_hazard_pointer();
+```
+*Effects:* Constructs a hazard pointer.
+*Returns:* A `hazard_pointer` object that owns the newly-constructed
+hazard pointer.
+*Throws:* May throw `bad_alloc` if memory for the hazard pointer could
+not be allocated.
+``` cpp
+void swap(hazard_pointer& a, hazard_pointer& b) noexcept;
+```
+*Effects:* Equivalent to `a.swap(b)`.
 <!-- Link reference definitions -->
+[alg.min.max]: algorithms.md#alg.min.max
 [alg.sorting]: algorithms.md#alg.sorting
 [allocator.requirements.general]: library.md#allocator.requirements.general
 [atomic.types.int.comp]: #atomic.types.int.comp
 [atomic.types.pointer.comp]: #atomic.types.pointer.comp
 [atomics]: #atomics
 [atomics.wait]: #atomics.wait
 [barrier.syn]: #barrier.syn
 [basic.align]: basic.md#basic.align
 [basic.fundamental]: basic.md#basic.fundamental
 [basic.life]: basic.md#basic.life
+[basic.stc.general]: basic.md#basic.stc.general
 [basic.stc.thread]: basic.md#basic.stc.thread
 [bitmask.types]: library.md#bitmask.types
 [cfenv]: numerics.md#cfenv
 [class.prop]: class.md#class.prop
 [compliance]: library.md#compliance
 [concept.booleantestable]: concepts.md#concept.booleantestable
 [condition.variable.syn]: #condition.variable.syn
 [conv.rval]: expr.md#conv.rval
 [cpp17.defaultconstructible]: #cpp17.defaultconstructible
 [cpp17.destructible]: #cpp17.destructible
+[cpp17.lessthancomparable]: #cpp17.lessthancomparable
 [cpp17.moveassignable]: #cpp17.moveassignable
 [cpp17.moveconstructible]: #cpp17.moveconstructible
 [defns.block]: intro.md#defns.block
 [except.terminate]: except.md#except.terminate
 [expr.pre]: expr.md#expr.pre
+[expr.rel]: expr.md#expr.rel
+[format.string.std]: text.md#format.string.std
 [func.invoke]: utilities.md#func.invoke
 [func.require]: utilities.md#func.require
 [function.objects]: utilities.md#function.objects
 [future.syn]: #future.syn
 [futures]: #futures
 [futures.task]: #futures.task
 [futures.task.general]: #futures.task.general
 [futures.task.members]: #futures.task.members
 [futures.task.nonmembers]: #futures.task.nonmembers
 [futures.unique.future]: #futures.unique.future
+[hazard.pointer.syn]: #hazard.pointer.syn
 [intro.multithread]: basic.md#intro.multithread
 [intro.progress]: basic.md#intro.progress
 [intro.races]: basic.md#intro.races
 [latch.syn]: #latch.syn
 [limits.syn]: support.md#limits.syn
 [mutex.syn]: #mutex.syn
+[rcu.syn]: #rcu.syn
 [res.on.data.races]: library.md#res.on.data.races
 [res.on.exception.handling]: library.md#res.on.exception.handling
+[saferecl]: #saferecl
+[saferecl.general]: #saferecl.general
+[saferecl.hp]: #saferecl.hp
+[saferecl.hp.base]: #saferecl.hp.base
+[saferecl.hp.general]: #saferecl.hp.general
+[saferecl.hp.holder]: #saferecl.hp.holder
+[saferecl.hp.holder.ctor]: #saferecl.hp.holder.ctor
+[saferecl.hp.holder.general]: #saferecl.hp.holder.general
+[saferecl.hp.holder.mem]: #saferecl.hp.holder.mem
+[saferecl.hp.holder.nonmem]: #saferecl.hp.holder.nonmem
+[saferecl.rcu]: #saferecl.rcu
+[saferecl.rcu.base]: #saferecl.rcu.base
+[saferecl.rcu.domain]: #saferecl.rcu.domain
+[saferecl.rcu.domain.func]: #saferecl.rcu.domain.func
+[saferecl.rcu.domain.general]: #saferecl.rcu.domain.general
+[saferecl.rcu.domain.members]: #saferecl.rcu.domain.members
+[saferecl.rcu.general]: #saferecl.rcu.general
 [semaphore.syn]: #semaphore.syn
 [shared.mutex.syn]: #shared.mutex.syn
 [stdatomic.h.syn]: #stdatomic.h.syn
 [stopcallback]: #stopcallback
 [stopcallback.cons]: #stopcallback.cons
 [stopcallback.general]: #stopcallback.general
+[stopcallback.inplace]: #stopcallback.inplace
+[stopcallback.inplace.cons]: #stopcallback.inplace.cons
+[stopcallback.inplace.general]: #stopcallback.inplace.general
 [stopsource]: #stopsource
 [stopsource.cons]: #stopsource.cons
 [stopsource.general]: #stopsource.general
+[stopsource.inplace]: #stopsource.inplace
+[stopsource.inplace.cons]: #stopsource.inplace.cons
+[stopsource.inplace.general]: #stopsource.inplace.general
+[stopsource.inplace.mem]: #stopsource.inplace.mem
 [stopsource.mem]: #stopsource.mem
 [stoptoken]: #stoptoken
+[stoptoken.concepts]: #stoptoken.concepts
 [stoptoken.general]: #stoptoken.general
+[stoptoken.inplace]: #stoptoken.inplace
+[stoptoken.inplace.general]: #stoptoken.inplace.general
+[stoptoken.inplace.mem]: #stoptoken.inplace.mem
 [stoptoken.mem]: #stoptoken.mem
+[stoptoken.never]: #stoptoken.never
 [syserr]: diagnostics.md#syserr
 [syserr.syserr]: diagnostics.md#syserr.syserr
 [term.padding.bits]: basic.md#term.padding.bits
 [term.unevaluated.operand]: expr.md#term.unevaluated.operand
 [thread]: #thread

Diff to HTML by rtfpessoa