[support] - C++20 → C++23

Files changed (1) hide show

tmp/tmpkc5dc9ki/{from.md → to.md} +682 -365

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

@@ -15,14 +15,14 @@ support for exception processing, support for initializer lists, and
 other runtime support, as summarized in [[support.summary]].
 **Table: Language support library summary** <a id="support.summary">[support.summary]</a>
 | Subclause               |                           | Header                                             |
-| ---------------------- | ------------------------- | -------------------------------------------------- |
 | [[support.types]]       | Common definitions        | `<cstddef>`, `<cstdlib>`                           |
 | [[support.limits]]      | Implementation properties | `<cfloat>`, `<climits>`, `<limits>`, `<version>`   |
-| [[cstdint]] | Integer types | `<cstdint>` |
 | [[support.start.term]]  | Start and termination     | `<cstdlib>`                                        |
 | [[support.dynamic]]     | Dynamic memory management | `<new>`                                            |
 | [[support.rtti]]        | Type identification       | `<typeinfo>`                                       |
 | [[support.srcloc]]      | Source location           | `<source_location>`                                |
 | [[support.exception]]   | Exception handling        | `<exception>`                                      |
@@ -35,10 +35,11 @@ other runtime support, as summarized in [[support.summary]].
 ## Common definitions <a id="support.types">[[support.types]]</a>
 ### Header `<cstddef>` synopsis <a id="cstddef.syn">[[cstddef.syn]]</a>
 ``` cpp
 namespace std {
   using ptrdiff_t = see below;
   using size_t = see below;
   using max_align_t = see below;
   using nullptr_t = decltype(nullptr);
@@ -79,17 +80,17 @@ See also: ISO C 7.19
 ### Header `<cstdlib>` synopsis <a id="cstdlib.syn">[[cstdlib.syn]]</a>
 ``` cpp
 namespace std {
-  using size_t = see below;
   using div_t = see below;
   using ldiv_t = see below;
   using lldiv_t = see below;
 }
-#define NULL see below
 #define EXIT_FAILURE see below
 #define EXIT_SUCCESS see below
 #define RAND_MAX see below
 #define MB_CUR_MAX see below
@@ -99,18 +100,18 @@ namespace std {
   extern "C++" using atexit-handler = void();                           // exposition only
   extern "C" using c-compare-pred = int(const void*, const void*);      // exposition only
   extern "C++" using compare-pred = int(const void*, const void*);      // exposition only
   // [support.start.term], start and termination
-  [[noreturn]] void abort() noexcept;
-  int atexit(c-atexit-handler* func) noexcept;
-  int atexit(atexit-handler* func) noexcept;
-  int at_quick_exit(c-atexit-handler* func) noexcept;
-  int at_quick_exit(atexit-handler* func) noexcept;
-  [[noreturn]] void exit(int status);
-  [[noreturn]] void _Exit(int status) noexcept;
-  [[noreturn]] void quick_exit(int status) noexcept;
   char* getenv(const char* name);
   int system(const char* string);
   // [c.malloc], C library memory allocation
@@ -150,25 +151,23 @@ namespace std {
   // [c.math.rand], low-quality random number generation
   int rand();
   void srand(unsigned int seed);
   // [c.math.abs], absolute values
-  int abs(int j);
-  long int abs(long int j);
-  long long int abs(long long int j);
- float abs(float j);
-  double abs(double j);
-  long double abs(long double j);
-  long int labs(long int j);
-  long long int llabs(long long int j);
-  div_t div(int numer, int denom);
-  ldiv_t div(long int numer, long int denom); // see [library.c]
-  lldiv_t div(long long int numer, long long int denom); // see [library.c]
-  ldiv_t ldiv(long int numer, long int denom);
-  lldiv_t lldiv(long long int numer, long long int denom);
 }
 ```
 The contents and meaning of the header `<cstdlib>` are the same as the C
 standard library header `<stdlib.h>`, except that it does not declare
@@ -190,41 +189,43 @@ expression, and it has the characteristics described in
 [*Note 1*: Although `nullptr`’s address cannot be taken, the address of
 another `nullptr_t` object that is an lvalue can be
 taken. — *end note*]
-The macro `NULL` is an *implementation-defined* null pointer constant.
-[^1]
 See also: ISO C 7.19
 ### Sizes, alignments, and offsets <a id="support.types.layout">[[support.types.layout]]</a>
 The macro `offsetof(type, member-designator)` has the same semantics as
 the corresponding macro in the C standard library header `<stddef.h>`,
 but accepts a restricted set of `type` arguments in this document. Use
 of the `offsetof` macro with a `type` other than a standard-layout class
-[[class.prop]] is conditionally-supported.[^2] The expression
-`offsetof(type, member-designator)` is never type-dependent
-[[temp.dep.expr]] and it is value-dependent [[temp.dep.constexpr]] if
-and only if `type` is dependent. The result of applying the `offsetof`
-macro to a static data member or a function member is undefined. No
-operation invoked by the `offsetof` macro shall throw an exception and
-`noexcept(offsetof(type, member-designator))` shall be `true`.
 The type `ptrdiff_t` is an *implementation-defined* signed integer type
 that can hold the difference of two subscripts in an array object, as
 described in  [[expr.add]].
 The type `size_t` is an *implementation-defined* unsigned integer type
 that is large enough to contain the size in bytes of any object
 [[expr.sizeof]].
-[*Note 1*: It is recommended that implementations choose types for
 `ptrdiff_t` and `size_t` whose integer conversion ranks [[conv.rank]]
 are no greater than that of `signed long int` unless a larger size is
-necessary to contain all the possible values. — *end note*]
 The type `max_align_t` is a trivial standard-layout type whose alignment
 requirement is at least as great as that of every scalar type, and whose
 alignment requirement is supported in every context [[basic.align]].
@@ -358,70 +359,94 @@ about the C++ standard library (e.g., version number and release date).
 Each of the macros defined in `<version>` is also defined after
 inclusion of any member of the set of library headers indicated in the
 corresponding comment in this synopsis.
-[*Note 1*: Future versions of this International Standard might replace
-the values of these macros with greater values. — *end note*]
 ``` cpp
 #define __cpp_lib_addressof_constexpr               201603L // also in <memory>
 #define __cpp_lib_allocator_traits_is_always_equal  201411L
   // also in <memory>, <scoped_allocator>, <string>, <deque>, <forward_list>, <list>, <vector>,
   // <map>, <set>, <unordered_map>, <unordered_set>
 #define __cpp_lib_any                               201606L // also in <any>
 #define __cpp_lib_apply                             201603L // also in <tuple>
 #define __cpp_lib_array_constexpr                   201811L // also in <iterator>, <array>
 #define __cpp_lib_as_const                          201510L // also in <utility>
 #define __cpp_lib_assume_aligned                    201811L // also in <memory>
 #define __cpp_lib_atomic_flag_test                  201907L // also in <atomic>
 #define __cpp_lib_atomic_float                      201711L // also in <atomic>
 #define __cpp_lib_atomic_is_always_lock_free        201603L // also in <atomic>
 #define __cpp_lib_atomic_lock_free_type_aliases     201907L // also in <atomic>
 #define __cpp_lib_atomic_ref                        201806L // also in <atomic>
 #define __cpp_lib_atomic_shared_ptr                 201711L // also in <memory>
 #define __cpp_lib_atomic_value_initialization       201911L // also in <atomic>, <memory>
 #define __cpp_lib_atomic_wait                       201907L // also in <atomic>
-#define __cpp_lib_barrier                           201907L // also in <barrier>
 #define __cpp_lib_bind_front                        201907L // also in <functional>
 #define __cpp_lib_bit_cast                          201806L // also in <bit>
 #define __cpp_lib_bitops                            201907L // also in <bit>
 #define __cpp_lib_bool_constant                     201505L // also in <type_traits>
 #define __cpp_lib_bounded_array_traits              201902L // also in <type_traits>
 #define __cpp_lib_boyer_moore_searcher              201603L // also in <functional>
 #define __cpp_lib_byte                              201603L // also in <cstddef>
 #define __cpp_lib_char8_t                           201907L
   // also in <atomic>, <filesystem>, <istream>, <limits>, <locale>, <ostream>, <string>, <string_view>
 #define __cpp_lib_chrono                            201907L // also in <chrono>
 #define __cpp_lib_chrono_udls                       201304L // also in <chrono>
 #define __cpp_lib_clamp                             201603L // also in <algorithm>
 #define __cpp_lib_complex_udls                      201309L // also in <complex>
-#define __cpp_lib_concepts                          202002L // also in <concepts>
-#define __cpp_lib_constexpr_algorithms              201806L // also in <algorithm>
 #define __cpp_lib_constexpr_complex                 201711L // also in <complex>
 #define __cpp_lib_constexpr_dynamic_alloc           201907L // also in <memory>
 #define __cpp_lib_constexpr_functional              201907L // also in <functional>
 #define __cpp_lib_constexpr_iterator                201811L // also in <iterator>
-#define __cpp_lib_constexpr_memory                  201811L // also in <memory>
 #define __cpp_lib_constexpr_numeric                 201911L // also in <numeric>
 #define __cpp_lib_constexpr_string                  201907L // also in <string>
 #define __cpp_lib_constexpr_string_view             201811L // also in <string_view>
 #define __cpp_lib_constexpr_tuple                   201811L // also in <tuple>
 #define __cpp_lib_constexpr_utility                 201811L // also in <utility>
 #define __cpp_lib_constexpr_vector                  201907L // also in <vector>
 #define __cpp_lib_coroutine                         201902L // also in <coroutine>
 #define __cpp_lib_destroying_delete                 201806L // also in <new>
 #define __cpp_lib_enable_shared_from_this           201603L // also in <memory>
 #define __cpp_lib_endian                            201907L // also in <bit>
 #define __cpp_lib_erase_if                          202002L
   // also in <string>, <deque>, <forward_list>, <list>, <vector>, <map>, <set>, <unordered_map>,
   // <unordered_set>
 #define __cpp_lib_exchange_function                 201304L // also in <utility>
 #define __cpp_lib_execution                         201902L // also in <execution>
 #define __cpp_lib_filesystem                        201703L // also in <filesystem>
-#define __cpp_lib_format                            201907L // also in <format>
 #define __cpp_lib_gcd_lcm                           201606L // also in <numeric>
 #define __cpp_lib_generic_associative_lookup        201304L // also in <map>, <set>
 #define __cpp_lib_generic_unordered_lookup          201811L
   // also in <unordered_map>, <unordered_set>
 #define __cpp_lib_hardware_interference_size        201703L // also in <new>
 #define __cpp_lib_has_unique_object_representations 201606L // also in <type_traits>
@@ -432,18 +457,22 @@ the values of these macros with greater values. — *end note*]
 #define __cpp_lib_integer_comparison_functions      202002L // also in <utility>
 #define __cpp_lib_integer_sequence                  201304L // also in <utility>
 #define __cpp_lib_integral_constant_callable        201304L // also in <type_traits>
 #define __cpp_lib_interpolate                       201902L // also in <cmath>, <numeric>
 #define __cpp_lib_invoke                            201411L // also in <functional>
 #define __cpp_lib_is_aggregate                      201703L // also in <type_traits>
 #define __cpp_lib_is_constant_evaluated             201811L // also in <type_traits>
 #define __cpp_lib_is_final                          201402L // also in <type_traits>
 #define __cpp_lib_is_invocable                      201703L // also in <type_traits>
 #define __cpp_lib_is_layout_compatible              201907L // also in <type_traits>
 #define __cpp_lib_is_nothrow_convertible            201806L // also in <type_traits>
 #define __cpp_lib_is_null_pointer                   201309L // also in <type_traits>
 #define __cpp_lib_is_pointer_interconvertible       201907L // also in <type_traits>
 #define __cpp_lib_is_swappable                      201603L // also in <type_traits>
 #define __cpp_lib_jthread                           201911L // also in <stop_token>, <thread>
 #define __cpp_lib_latch                             201907L // also in <latch>
 #define __cpp_lib_launder                           201606L // also in <new>
 #define __cpp_lib_list_remove_return_type           201806L // also in <forward_list>, <list>
@@ -452,68 +481,102 @@ the values of these macros with greater values. — *end note*]
 #define __cpp_lib_make_reverse_iterator             201402L // also in <iterator>
 #define __cpp_lib_make_unique                       201304L // also in <memory>
 #define __cpp_lib_map_try_emplace                   201411L // also in <map>
 #define __cpp_lib_math_constants                    201907L // also in <numbers>
 #define __cpp_lib_math_special_functions            201603L // also in <cmath>
 #define __cpp_lib_memory_resource                   201603L // also in <memory_resource>
 #define __cpp_lib_node_extract                      201606L
   // also in <map>, <set>, <unordered_map>, <unordered_set>
 #define __cpp_lib_nonmember_container_access        201411L
   // also in <array>, <deque>, <forward_list>, <iterator>, <list>, <map>, <regex>, <set>, <string>,
   // <unordered_map>, <unordered_set>, <vector>
 #define __cpp_lib_not_fn                            201603L // also in <functional>
 #define __cpp_lib_null_iterators                    201304L // also in <iterator>
-#define __cpp_lib_optional                          201606L // also in <optional>
 #define __cpp_lib_parallel_algorithm                201603L // also in <algorithm>, <numeric>
-#define __cpp_lib_polymorphic_allocator             201902L // also in <memory>
 #define __cpp_lib_quoted_string_io                  201304L // also in <iomanip>
-#define __cpp_lib_ranges                            201911L
   // also in <algorithm>, <functional>, <iterator>, <memory>, <ranges>
 #define __cpp_lib_raw_memory_algorithms             201606L // also in <memory>
 #define __cpp_lib_remove_cvref                      201711L // also in <type_traits>
 #define __cpp_lib_result_of_sfinae                  201210L // also in <functional>, <type_traits>
 #define __cpp_lib_robust_nonmodifying_seq_ops       201304L // also in <algorithm>
 #define __cpp_lib_sample                            201603L // also in <algorithm>
 #define __cpp_lib_scoped_lock                       201703L // also in <mutex>
 #define __cpp_lib_semaphore                         201907L // also in <semaphore>
 #define __cpp_lib_shared_mutex                      201505L // also in <shared_mutex>
 #define __cpp_lib_shared_ptr_arrays                 201707L // also in <memory>
 #define __cpp_lib_shared_ptr_weak_type              201606L // also in <memory>
 #define __cpp_lib_shared_timed_mutex                201402L // also in <shared_mutex>
-#define __cpp_lib_shift                             201806L // also in <algorithm>
 #define __cpp_lib_smart_ptr_for_overwrite           202002L // also in <memory>
 #define __cpp_lib_source_location                   201907L // also in <source_location>
 #define __cpp_lib_span                              202002L // also in <span>
 #define __cpp_lib_ssize                             201902L // also in <iterator>
 #define __cpp_lib_starts_ends_with                  201711L // also in <string>, <string_view>
 #define __cpp_lib_string_udls                       201304L // also in <string>
 #define __cpp_lib_string_view                       201803L // also in <string>, <string_view>
 #define __cpp_lib_syncbuf                           201803L // also in <syncstream>
 #define __cpp_lib_three_way_comparison              201907L // also in <compare>
 #define __cpp_lib_to_address                        201711L // also in <memory>
 #define __cpp_lib_to_array                          201907L // also in <array>
 #define __cpp_lib_to_chars                          201611L // also in <charconv>
 #define __cpp_lib_transformation_trait_aliases      201304L // also in <type_traits>
 #define __cpp_lib_transparent_operators             201510L // also in <memory>, <functional>
 #define __cpp_lib_tuple_element_t                   201402L // also in <tuple>
 #define __cpp_lib_tuples_by_type                    201304L // also in <utility>, <tuple>
 #define __cpp_lib_type_identity                     201806L // also in <type_traits>
 #define __cpp_lib_type_trait_variable_templates     201510L // also in <type_traits>
 #define __cpp_lib_uncaught_exceptions               201411L // also in <exception>
 #define __cpp_lib_unordered_map_try_emplace         201411L // also in <unordered_map>
 #define __cpp_lib_unwrap_ref                        201811L // also in <type_traits>
-#define __cpp_lib_variant                           201606L // also in <variant>
 #define __cpp_lib_void_t                            201411L // also in <type_traits>
 ```
 ### Header `<limits>` synopsis <a id="limits.syn">[[limits.syn]]</a>
 ``` cpp
 namespace std {
-  // [fp.style], floating-point type properties
   enum float_round_style;
-  enum float_denorm_style;
   // [numeric.limits], class template numeric_limits
   template<class T> class numeric_limits;
   template<class T> class numeric_limits<const T>;
@@ -543,13 +606,11 @@ namespace std {
   template<> class numeric_limits<double>;
   template<> class numeric_limits<long double>;
 }
 ```
-### Floating-point type properties <a id="fp.style">[[fp.style]]</a>
-#### Type `float_round_style` <a id="round.style">[[round.style]]</a>
 ``` cpp
 namespace std {
   enum float_round_style {
     round_indeterminate       = -1,
@@ -570,32 +631,14 @@ values:
   representable value
 - `round_toward_infinity` if the rounding style is toward infinity
 - `round_toward_neg_infinity` if the rounding style is toward negative
   infinity
-#### Type `float_denorm_style` <a id="denorm.style">[[denorm.style]]</a>
-``` cpp
-namespace std {
-  enum float_denorm_style {
-    denorm_indeterminate = -1,
-    denorm_absent = 0,
-    denorm_present = 1
-  };
-}
-```
-The presence or absence of subnormal numbers (variable number of
-exponent bits) is characterized by the values:
-- `denorm_indeterminate` if it cannot be determined whether or not the
-  type allows subnormal values
-- `denorm_absent` if the type does not allow subnormal values
-- `denorm_present` if the type does allow subnormal values
 ### Class template `numeric_limits` <a id="numeric.limits">[[numeric.limits]]</a>
 The `numeric_limits` class template provides a C++ program with
 information about various properties of the implementation’s
 representation of the arithmetic types.
 ``` cpp
@@ -623,12 +666,10 @@ namespace std {
     static constexpr int  max_exponent10 = 0;
     static constexpr bool has_infinity = false;
     static constexpr bool has_quiet_NaN = false;
     static constexpr bool has_signaling_NaN = false;
-    static constexpr float_denorm_style has_denorm = denorm_absent;
-    static constexpr bool has_denorm_loss = false;
     static constexpr T infinity() noexcept { return T(); }
     static constexpr T quiet_NaN() noexcept { return T(); }
     static constexpr T signaling_NaN() noexcept { return T(); }
     static constexpr T denorm_min() noexcept { return T(); }
@@ -645,12 +686,16 @@ namespace std {
 For all members declared `static` `constexpr` in the `numeric_limits`
 template, specializations shall define these values in such a way that
 they are usable as constant expressions.
-The default `numeric_limits<T>` template shall have all members, but
-with 0 or `false` values.
 Specializations shall be provided for each arithmetic type, both
 floating-point and integer, including `bool`. The member
 `is_specialized` shall be `true` for all such specializations of
 `numeric_limits`.
@@ -842,96 +887,82 @@ Number”.[^17]
 Meaningful for all floating-point types.
 Shall be `true` for all specializations in which `is_iec559 != false`.
-``` cpp
-static constexpr float_denorm_style has_denorm;
-```
-`denorm_present` if the type allows subnormal values (variable number of
-exponent bits)[^18], `denorm_absent` if the type does not allow
-subnormal values, and `denorm_indeterminate` if it is indeterminate at
-compile time whether the type allows subnormal values.
-Meaningful for all floating-point types.
-``` cpp
-static constexpr bool has_denorm_loss;
-```
-`true` if loss of accuracy is detected as a denormalization loss, rather
-than as an inexact result.[^19]
 ``` cpp
 static constexpr T infinity() noexcept;
 ```
-Representation of positive infinity, if available.[^20]
 Meaningful for all specializations for which `has_infinity != false`.
 Required in specializations for which `is_iec559 != false`.
 ``` cpp
 static constexpr T quiet_NaN() noexcept;
 ```
-Representation of a quiet “Not a Number”, if available.[^21]
 Meaningful for all specializations for which `has_quiet_NaN != false`.
 Required in specializations for which `is_iec559 != false`.
 ``` cpp
 static constexpr T signaling_NaN() noexcept;
 ```
-Representation of a signaling “Not a Number”, if available.[^22]
 Meaningful for all specializations for which
 `has_signaling_NaN != false`. Required in specializations for which
 `is_iec559 != false`.
 ``` cpp
 static constexpr T denorm_min() noexcept;
 ```
-Minimum positive subnormal value.[^23]
 Meaningful for all floating-point types.
-In specializations for which `has_denorm == false`, returns the minimum
-positive normalized value.
 ``` cpp
 static constexpr bool is_iec559;
 ```
-`true` if and only if the type adheres to ISO/IEC/IEEE 60559.[^24]
 Meaningful for all floating-point types.
 ``` cpp
 static constexpr bool is_bounded;
 ```
-`true` if the set of values representable by the type is finite.[^25]
-[*Note 1*: All fundamental types [[basic.fundamental]] are bounded.
 This member would be `false` for arbitrary precision
 types. — *end note*]
 Meaningful for all specializations.
 ``` cpp
 static constexpr bool is_modulo;
 ```
-`true` if the type is modulo.[^26] A type is modulo if, for any
-operation involving `+`, `-`, or `*` on values of that type whose result
-would fall outside the range \[`min()`, `max()`\], the value returned
-differs from the true value by an integer multiple of
-`max() - min() + 1`.
 [*Example 1*: `is_modulo` is `false` for signed integer
 types [[basic.fundamental]] unless an implementation, as an extension to
 this document, defines signed integer overflow to
 wrap. — *end example*]
@@ -941,27 +972,27 @@ Meaningful for all specializations.
 ``` cpp
 static constexpr bool traps;
 ```
 `true` if, at the start of the program, there exists a value of the type
-that would cause an arithmetic operation using that value to trap.[^27]
 Meaningful for all specializations.
 ``` cpp
 static constexpr bool tinyness_before;
 ```
-`true` if tinyness is detected before rounding.[^28]
 Meaningful for all floating-point types.
 ``` cpp
 static constexpr float_round_style round_style;
 ```
-The rounding style for the type.[^29]
 Meaningful for all floating-point types. Specializations for integer
 types shall return `round_toward_zero`.
 #### `numeric_limits` specializations <a id="numeric.special">[[numeric.special]]</a>
@@ -1001,12 +1032,10 @@ namespace std {
     static constexpr int max_exponent10 = + 38;
     static constexpr bool has_infinity             = true;
     static constexpr bool has_quiet_NaN            = true;
     static constexpr bool has_signaling_NaN        = true;
-    static constexpr float_denorm_style has_denorm = denorm_absent;
-    static constexpr bool has_denorm_loss          = false;
     static constexpr float infinity()      noexcept { return value; }
     static constexpr float quiet_NaN()     noexcept { return value; }
     static constexpr float signaling_NaN() noexcept { return value; }
     static constexpr float denorm_min()    noexcept { return min(); }
@@ -1052,12 +1081,10 @@ namespace std {
      static constexpr int  max_exponent10 = 0;
      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
-     static constexpr float_denorm_style has_denorm = denorm_absent;
-     static constexpr bool has_denorm_loss = false;
      static constexpr bool infinity() noexcept { return 0; }
      static constexpr bool quiet_NaN() noexcept { return 0; }
      static constexpr bool signaling_NaN() noexcept { return 0; }
      static constexpr bool denorm_min() noexcept { return 0; }
@@ -1073,10 +1100,11 @@ namespace std {
 ```
 ### Header `<climits>` synopsis <a id="climits.syn">[[climits.syn]]</a>
 ``` cpp
 #define CHAR_BIT see below
 #define SCHAR_MIN see below
 #define SCHAR_MAX see below
 #define UCHAR_MAX see below
 #define CHAR_MIN see below
@@ -1097,19 +1125,20 @@ namespace std {
 ```
 The header `<climits>` defines all macros the same as the C standard
 library header `<limits.h>`.
-[*Note 1*: The types of the constants defined by macros in `<climits>`
-are not required to match the types to which the macros
-refer. — *end note*]
 See also: ISO C 5.2.4.2.1
 ### Header `<cfloat>` synopsis <a id="cfloat.syn">[[cfloat.syn]]</a>
 ``` cpp
 #define FLT_ROUNDS see below
 #define FLT_EVAL_METHOD see below
 #define FLT_HAS_SUBNORM see below
 #define DBL_HAS_SUBNORM see below
 #define LDBL_HAS_SUBNORM see below
@@ -1153,76 +1182,144 @@ See also: ISO C 5.2.4.2.1
 The header `<cfloat>` defines all macros the same as the C standard
 library header `<float.h>`.
 See also: ISO C 5.2.4.2.2
-## Integer types <a id="cstdint">[[cstdint]]</a>
 ### Header `<cstdint>` synopsis <a id="cstdint.syn">[[cstdint.syn]]</a>
 ``` cpp
 namespace std {
   using int8_t         = signed integer type;   // optional
   using int16_t        = signed integer type;   // optional
   using int32_t        = signed integer type;   // optional
   using int64_t        = signed integer type;   // optional
   using int_fast8_t    = signed integer type;
   using int_fast16_t   = signed integer type;
   using int_fast32_t   = signed integer type;
   using int_fast64_t   = signed integer type;
   using int_least8_t   = signed integer type;
   using int_least16_t  = signed integer type;
   using int_least32_t  = signed integer type;
   using int_least64_t  = signed integer type;
   using intmax_t       = signed integer type;
   using intptr_t       = signed integer type;   // optional
   using uint8_t        = unsigned integer type; // optional
   using uint16_t       = unsigned integer type; // optional
   using uint32_t       = unsigned integer type; // optional
   using uint64_t       = unsigned integer type; // optional
   using uint_fast8_t   = unsigned integer type;
   using uint_fast16_t  = unsigned integer type;
   using uint_fast32_t  = unsigned integer type;
   using uint_fast64_t  = unsigned integer type;
   using uint_least8_t  = unsigned integer type;
   using uint_least16_t = unsigned integer type;
   using uint_least32_t = unsigned integer type;
   using uint_least64_t = unsigned integer type;
   using uintmax_t      = unsigned integer type;
   using uintptr_t      = unsigned integer type; // optional
 }
-```
-The header also defines numerous macros of the form:
-``` cpp
-INT_[FAST LEAST]{8 16 32 64}_MIN
-  [U]INT_[FAST LEAST]{8 16 32 64}_MAX
-  INT{MAX PTR}_MIN
-  [U]INT{MAX PTR}_MAX
-  {PTRDIFF SIG_ATOMIC WCHAR WINT}{_MAX _MIN}
-  SIZE_MAX
-```
-plus function macros of the form:
-``` cpp
-[U]INT{8 16 32 64 MAX}_C
 ```
 The header defines all types and macros the same as the C standard
 library header `<stdint.h>`.
 See also: ISO C 7.20
 ## Startup and termination <a id="support.start.term">[[support.start.term]]</a>
 [*Note 1*: The header `<cstdlib>` declares the functions described in
 this subclause. — *end note*]
@@ -1276,26 +1373,25 @@ succeeds, nonzero if it fails.
 *Effects:*
 - First, objects with thread storage duration and associated with the
   current thread are destroyed. Next, objects with static storage
   duration are destroyed and functions registered by calling `atexit`
-  are called.[^30] See  [[basic.start.term]] for the order of
   destructions and calls. (Objects with automatic storage duration are
-  not destroyed as a result of calling `exit()`.)[^31] If control leaves
- a registered function called by `exit` because the function does not
- provide a handler for a thrown exception, the function
-  `std::terminate` shall be called [[except.terminate]].
 - Next, all open C streams (as mediated by the function signatures
   declared in `<cstdio>`) with unwritten buffered data are flushed, all
   open C streams are closed, and all files created by calling
   `tmpfile()` are removed.
 - Finally, control is returned to the host environment. If `status` is
   zero or `EXIT_SUCCESS`, an *implementation-defined* form of the status
   *successful termination* is returned. If `status` is `EXIT_FAILURE`,
   an *implementation-defined* form of the status *unsuccessful
   termination* is returned. Otherwise the status returned is
-  *implementation-defined*. [^32]
 ``` cpp
 int at_quick_exit(c-atexit-handler* f) noexcept;
 int at_quick_exit(atexit-handler* f) noexcept;
 ```
@@ -1306,15 +1402,15 @@ is unspecified whether a call to `at_quick_exit()` that does not happen
 before [[intro.multithread]] all calls to `quick_exit` will succeed.
 [*Note 2*: The `at_quick_exit()` functions do not introduce a data
 race [[res.on.data.races]]. — *end note*]
-[*Note 3*: The order of registration may be indeterminate if
 `at_quick_exit` was called from more than one thread. — *end note*]
 [*Note 4*: The `at_quick_exit` registrations are distinct from the
-`atexit` registrations, and applications may need to call both
 registration functions with the same argument. — *end note*]
 *Implementation limits:* The implementation shall support the
 registration of at least 32 functions.
@@ -1326,18 +1422,17 @@ registration of at least 32 functions.
 *Effects:* Functions registered by calls to `at_quick_exit` are called
 in the reverse order of their registration, except that a function shall
 be called after any previously registered functions that had already
 been called at the time it was registered. Objects shall not be
-destroyed as a result of calling `quick_exit`. If control leaves a
-registered function called by `quick_exit` because the function does not
-provide a handler for a thrown exception, the function `std::terminate`
-shall be called.
 [*Note 5*: A function registered via `at_quick_exit` is invoked by the
 thread that calls `quick_exit`, which can be a different thread than the
-one that registered it, so registered functions should not rely on the
 identity of objects with thread storage duration. — *end note*]
 After calling registered functions, `quick_exit` shall call
 `_Exit(status)`.
@@ -1346,17 +1441,20 @@ when the functions registered with `at_quick_exit` are.
 See also: ISO C 7.22.4
 ## Dynamic memory management <a id="support.dynamic">[[support.dynamic]]</a>
 The header `<new>` defines several functions that manage the allocation
 of dynamic storage in a program. It also defines components for
 reporting storage management errors.
 ### Header `<new>` synopsis <a id="new.syn">[[new.syn]]</a>
 ``` cpp
 namespace std {
   // [alloc.errors], storage allocation errors
   class bad_alloc;
   class bad_array_new_length;
@@ -1421,10 +1519,12 @@ void  operator delete  (void* ptr, void*) noexcept;
 void operator delete[](void* ptr, void*) noexcept;
 ```
 ### Storage allocation and deallocation <a id="new.delete">[[new.delete]]</a>
 Except where otherwise specified, the provisions of
 [[basic.stc.dynamic]] apply to the library versions of `operator new`
 and `operator
 delete`. If the value of an alignment argument passed to any of these
 functions is not a valid alignment value, the behavior is undefined.
@@ -1505,10 +1605,23 @@ void operator delete(void* ptr) noexcept;
 void operator delete(void* ptr, std::size_t size) noexcept;
 void operator delete(void* ptr, std::align_val_t alignment) noexcept;
 void operator delete(void* ptr, std::size_t size, std::align_val_t alignment) noexcept;
 ```
 *Effects:* The deallocation functions [[basic.stc.dynamic.deallocation]]
 called by a *delete-expression*[[expr.delete]] to render the value of
 `ptr` invalid.
 *Replaceable:* A C++ program may define functions with any of these
@@ -1518,31 +1631,14 @@ by the C++ standard library.
 If a function without a `size` parameter is defined, the program should
 also define the corresponding function with a `size` parameter. If a
 function with a `size` parameter is defined, the program shall also
 define the corresponding version without the `size` parameter.
-[*Note 1*: The default behavior below may change in the future, which
 will require replacing both deallocation functions when replacing the
 allocation function. — *end note*]
-*Preconditions:* `ptr` is a null pointer or its value represents the
-address of a block of memory allocated by an earlier call to a (possibly
-replaced) `operator new(std::size_t)` or
-`operator new(std::size_t, std::align_val_t)` which has not been
-invalidated by an intervening call to `operator delete`.
-*Preconditions:* If an implementation has strict pointer
-safety [[basic.stc.dynamic.safety]] then `ptr` is a safely-derived
-pointer.
-*Preconditions:* If the `alignment` parameter is not present, `ptr` was
-returned by an allocation function without an `alignment` parameter. If
-present, the `alignment` argument is equal to the `alignment` argument
-passed to the allocation function that returned `ptr`. If present, the
-`size` argument is equal to the `size` argument passed to the allocation
-function that returned `ptr`.
 *Required behavior:* A call to an `operator delete` with a `size`
 parameter may be changed to a call to the corresponding
 `operator delete` without a `size` parameter, without affecting memory
 allocation.
@@ -1568,34 +1664,30 @@ reclaimed storage will be allocated by subsequent calls to
 ``` cpp
 void operator delete(void* ptr, const std::nothrow_t&) noexcept;
 void operator delete(void* ptr, std::align_val_t alignment, const std::nothrow_t&) noexcept;
 ```
 *Effects:* The deallocation functions [[basic.stc.dynamic.deallocation]]
 called by the implementation to render the value of `ptr` invalid when
 the constructor invoked from a nothrow placement version of the
 *new-expression* throws an exception.
 *Replaceable:* A C++ program may define functions with either of these
 function signatures, and thereby displace the default versions defined
 by the C++ standard library.
-*Preconditions:* `ptr` is a null pointer or its value represents the
-address of a block of memory allocated by an earlier call to a (possibly
-replaced) `operator new(std::size_t)` or
-`operator new(std::size_t, std::align_val_t)` which has not been
-invalidated by an intervening call to `operator delete`.
-*Preconditions:* If an implementation has strict pointer
-safety [[basic.stc.dynamic.safety]] then `ptr` is a safely-derived
-pointer.
-*Preconditions:* If the `alignment` parameter is not present, `ptr` was
-returned by an allocation function without an `alignment` parameter. If
-present, the `alignment` argument is equal to the `alignment` argument
-passed to the allocation function that returned `ptr`.
 *Default behavior:* Calls `operator delete(ptr)`, or
 `operator delete(ptr, alignment)`, respectively.
 #### Array forms <a id="new.delete.array">[[new.delete.array]]</a>
@@ -1605,11 +1697,11 @@ passed to the allocation function that returned `ptr`.
 ```
 *Effects:* The allocation functions [[basic.stc.dynamic.allocation]]
 called by the array form of a *new-expression*[[expr.new]] to allocate
 `size` bytes of storage. The second form is called for a type with
-new-extended alignment, and the first form is called otherwise. [^33]
 *Replaceable:* A C++ program may define functions with either of these
 function signatures, and thereby displace the default versions defined
 by the C++ standard library.
@@ -1651,10 +1743,23 @@ void operator delete[](void* ptr) noexcept;
 void operator delete[](void* ptr, std::size_t size) noexcept;
 void operator delete[](void* ptr, std::align_val_t alignment) noexcept;
 void operator delete[](void* ptr, std::size_t size, std::align_val_t alignment) noexcept;
 ```
 *Effects:* The deallocation functions [[basic.stc.dynamic.deallocation]]
 called by the array form of a *delete-expression* to render the value of
 `ptr` invalid.
 *Replaceable:* A C++ program may define functions with any of these
@@ -1664,31 +1769,14 @@ by the C++ standard library.
 If a function without a `size` parameter is defined, the program should
 also define the corresponding function with a `size` parameter. If a
 function with a `size` parameter is defined, the program shall also
 define the corresponding version without the `size` parameter.
-[*Note 1*: The default behavior below may change in the future, which
 will require replacing both deallocation functions when replacing the
 allocation function. — *end note*]
-*Preconditions:* `ptr` is a null pointer or its value represents the
-address of a block of memory allocated by an earlier call to a (possibly
-replaced) `operator new[](std::size_t)` or
-`operator new[](std::size_t, std::align_val_t)` which has not been
-invalidated by an intervening call to `operator delete[]`.
-*Preconditions:* If an implementation has strict pointer
-safety [[basic.stc.dynamic.safety]] then `ptr` is a safely-derived
-pointer.
-*Preconditions:* If the `alignment` parameter is not present, `ptr` was
-returned by an allocation function without an `alignment` parameter. If
-present, the `alignment` argument is equal to the `alignment` argument
-passed to the allocation function that returned `ptr`. If present, the
-`size` argument is equal to the `size` argument passed to the allocation
-function that returned `ptr`.
 *Required behavior:* A call to an `operator delete[]` with a `size`
 parameter may be changed to a call to the corresponding
 `operator delete[]` without a `size` parameter, without affecting memory
 allocation.
@@ -1705,34 +1793,30 @@ function.
 ``` cpp
 void operator delete[](void* ptr, const std::nothrow_t&) noexcept;
 void operator delete[](void* ptr, std::align_val_t alignment, const std::nothrow_t&) noexcept;
 ```
 *Effects:* The deallocation functions [[basic.stc.dynamic.deallocation]]
 called by the implementation to render the value of `ptr` invalid when
 the constructor invoked from a nothrow placement version of the array
 *new-expression* throws an exception.
 *Replaceable:* A C++ program may define functions with either of these
 function signatures, and thereby displace the default versions defined
 by the C++ standard library.
-*Preconditions:* `ptr` is a null pointer or its value represents the
-address of a block of memory allocated by an earlier call to a (possibly
-replaced) `operator new[](std::size_t)` or
-`operator new[](std::size_t, std::align_val_t)` which has not been
-invalidated by an intervening call to `operator delete[]`.
-*Preconditions:* If an implementation has strict pointer
-safety [[basic.stc.dynamic.safety]] then `ptr` is a safely-derived
-pointer.
-*Preconditions:* If the `alignment` parameter is not present, `ptr` was
-returned by an allocation function without an `alignment` parameter. If
-present, the `alignment` argument is equal to the `alignment` argument
-passed to the allocation function that returned `ptr`.
 *Default behavior:* Calls `operator delete[](ptr)`, or
 `operator delete[](ptr, alignment)`, respectively.
 #### Non-allocating forms <a id="new.delete.placement">[[new.delete.placement]]</a>
@@ -1772,28 +1856,20 @@ Something* p = new (place) Something();
 void operator delete(void* ptr, void*) noexcept;
 ```
 *Effects:* Intentionally performs no action.
-*Preconditions:* If an implementation has strict pointer
-safety [[basic.stc.dynamic.safety]] then `ptr` is a safely-derived
-pointer.
 *Remarks:* Default function called when any part of the initialization
 in a placement *new-expression* that invokes the library’s non-array
 placement operator new terminates by throwing an exception [[expr.new]].
 ``` cpp
 void operator delete[](void* ptr, void*) noexcept;
 ```
 *Effects:* Intentionally performs no action.
-*Preconditions:* If an implementation has strict pointer
-safety [[basic.stc.dynamic.safety]] then `ptr` is a safely-derived
-pointer.
 *Remarks:* Default function called when any part of the initialization
 in a placement *new-expression* that invokes the library’s array
 placement operator new terminates by throwing an exception [[expr.new]].
 #### Data races <a id="new.delete.dataraces">[[new.delete.dataraces]]</a>
@@ -1891,11 +1967,11 @@ new_handler set_new_handler(new_handler new_p) noexcept;
 new_handler get_new_handler() noexcept;
 ```
 *Returns:* The current `new_handler`.
-[*Note 1*: This may be a null pointer value. — *end note*]
 ### Pointer optimization barrier <a id="ptr.launder">[[ptr.launder]]</a>
 ``` cpp
 template<class T> [[nodiscard]] constexpr T* launder(T* p) noexcept;
@@ -1904,22 +1980,18 @@ template<class T> [[nodiscard]] constexpr T* launder(T* p) noexcept;
 *Mandates:* `!is_function_v<T> && !is_void_v<T>` is `true`.
 *Preconditions:* `p` represents the address *A* of a byte in memory. An
 object *X* that is within its lifetime [[basic.life]] and whose type is
 similar [[conv.qual]] to `T` is located at the address *A*. All bytes of
-storage that would be reachable through the result are reachable through
-`p` (see below).
-*Returns:* A value of type `T*` that points to `X`.
 *Remarks:* An invocation of this function may be used in a core constant
-expression whenever the value of its argument may be used in a core
-constant expression. A byte of storage *b* is reachable through a
-pointer value that points to an object *Y* if there is an object *Z*,
-pointer-interconvertible with *Y*, such that *b* is within the storage
-occupied by *Z*, or the immediately-enclosing array object if *Z* is an
-array element.
 [*Note 1*: If a new object is created in storage occupied by an
 existing object of the same type, a pointer to the original object can
 be used to refer to the new object unless its complete object is a const
 object or it is a base class subobject; in the latter cases, this
@@ -1986,17 +2058,20 @@ static_assert(sizeof(together) <= hardware_constructive_interference_size);
 — *end example*]
 ## Type identification <a id="support.rtti">[[support.rtti]]</a>
 The header `<typeinfo>` defines a type associated with type information
 generated by the implementation. It also defines two types for reporting
 dynamic type identification errors.
 ### Header `<typeinfo>` synopsis <a id="typeinfo.syn">[[typeinfo.syn]]</a>
 ``` cpp
 namespace std {
   class type_info;
   class bad_cast;
   class bad_typeid;
 }
@@ -2007,11 +2082,11 @@ namespace std {
 ``` cpp
 namespace std {
   class type_info {
   public:
     virtual ~type_info();
-    bool operator==(const type_info& rhs) const noexcept;
     bool before(const type_info& rhs) const noexcept;
     size_t hash_code() const noexcept;
     const char* name() const noexcept;
     type_info(const type_info&) = delete;                   // cannot be copied
@@ -2026,11 +2101,11 @@ a pointer to a name for the type, and an encoded value suitable for
 comparing two types for equality or collating order. The names, encoding
 rule, and collating sequence for types are all unspecified and may
 differ between programs.
 ``` cpp
-bool operator==(const type_info& rhs) const noexcept;
 ```
 *Effects:* Compares the current object with `rhs`.
 *Returns:* `true` if the two values describe the same type.
@@ -2061,11 +2136,11 @@ const char* name() const noexcept;
 *Returns:* An *implementation-defined* NTBS.
 *Remarks:* The message may be a null-terminated multibyte
 string [[multibyte.strings]], suitable for conversion and display as a
-`wstring` ([[string.classes]], [[locale.codecvt]]).
 ### Class `bad_cast` <a id="bad.cast">[[bad.cast]]</a>
 ``` cpp
 namespace std {
@@ -2115,17 +2190,20 @@ const char* what() const noexcept override;
 The header `<source_location>` defines the class `source_location` that
 provides a means to obtain source location information.
 ``` cpp
 namespace std {
   struct source_location;
 }
 ```
 ### Class `source_location` <a id="support.srcloc.class">[[support.srcloc.class]]</a>
 ``` cpp
 namespace std {
   struct source_location {
     // source location construction
     static consteval source_location current() noexcept;
@@ -2145,13 +2223,13 @@ namespace std {
   };
 }
 ```
 The type `source_location` meets the *Cpp17DefaultConstructible*,
-*Cpp17CopyConstructible*, *Cpp17CopyAssignable*, and *Cpp17Destructible*
-requirements [[utility.arg.requirements]]. Lvalues of type
-`source_location` are swappable [[swappable.requirements]]. All of the
 following conditions are `true`:
 - `is_nothrow_move_constructible_v<source_location>`
 - `is_nothrow_move_assignable_v<source_location>`
 - `is_nothrow_swappable_v<source_location>`
@@ -2184,11 +2262,11 @@ static consteval source_location current() noexcept;
 *Returns:*
 - When invoked by a function call whose *postfix-expression* is a
   (possibly parenthesized) *id-expression* naming `current`, returns a
-  `source_location` with an implementation-defined value. The value
   should be affected by `#line` [[cpp.line]] in the same manner as for
   \_\_LINE\_\_ and \_\_FILE\_\_. The values of the exposition-only data
   members of the returned `source_location` object are indicated in
   [[support.srcloc.current]].
 - Otherwise, when invoked in some other way, returns a `source_location`
@@ -2233,11 +2311,12 @@ void g() {
 ``` cpp
 constexpr source_location() noexcept;
 ```
-The data members are initialized with valid but unspecified values.
 #### Observers <a id="support.srcloc.obs">[[support.srcloc.obs]]</a>
 ``` cpp
 constexpr uint_least32_t line() const noexcept;
@@ -2263,16 +2342,19 @@ constexpr const char* function_name() const noexcept;
 *Returns:* `function_name_`.
 ## Exception handling <a id="support.exception">[[support.exception]]</a>
 The header `<exception>` defines several types and functions related to
 the handling of exceptions in a C++ program.
 ### Header `<exception>` synopsis <a id="exception.syn">[[exception.syn]]</a>
 ``` cpp
 namespace std {
   class exception;
   class bad_exception;
   class nested_exception;
@@ -2348,11 +2430,11 @@ virtual const char* what() const noexcept;
 *Returns:* An *implementation-defined* NTBS.
 *Remarks:* The message may be a null-terminated multibyte
 string [[multibyte.strings]], suitable for conversion and display as a
-`wstring` ([[string.classes]], [[locale.codecvt]]). The return value
 remains valid until the exception object from which it is obtained is
 destroyed or a non-`const` member function of the exception object is
 called.
 ### Class `bad_exception` <a id="bad.exception">[[bad.exception]]</a>
@@ -2384,11 +2466,11 @@ const char* what() const noexcept override;
 ``` cpp
 using terminate_handler = void (*)();
 ```
-The type of a *handler function* to be called by `std::terminate()` when
 terminating exception processing.
 *Required behavior:* A `terminate_handler` shall terminate execution of
 the program without returning to the caller.
@@ -2402,43 +2484,43 @@ terminate_handler set_terminate(terminate_handler f) noexcept;
 ```
 *Effects:* Establishes the function designated by `f` as the current
 handler function for terminating exception processing.
 *Remarks:* It is unspecified whether a null pointer value designates the
 default `terminate_handler`.
-*Returns:* The previous `terminate_handler`.
 #### `get_terminate` <a id="get.terminate">[[get.terminate]]</a>
 ``` cpp
 terminate_handler get_terminate() noexcept;
 ```
 *Returns:* The current `terminate_handler`.
-[*Note 1*: This may be a null pointer value. — *end note*]
 #### `terminate` <a id="terminate">[[terminate]]</a>
 ``` cpp
 [[noreturn]] void terminate() noexcept;
 ```
-*Remarks:* Called by the implementation when exception handling must be
-abandoned for any of several reasons [[except.terminate]]. May also be
-called directly by the program.
 *Effects:* Calls a `terminate_handler` function. It is unspecified which
 `terminate_handler` function will be called if an exception is active
 during a call to `set_terminate`. Otherwise calls the current
 `terminate_handler` function.
 [*Note 1*: A default `terminate_handler` is always considered a
 callable handler in this context. — *end note*]
 ### `uncaught_exceptions` <a id="uncaught.exceptions">[[uncaught.exceptions]]</a>
 ``` cpp
 int uncaught_exceptions() noexcept;
 ```
@@ -2466,22 +2548,22 @@ The default constructor of `exception_ptr` produces the null value of
 the type.
 `exception_ptr` shall not be implicitly convertible to any arithmetic,
 enumeration, or pointer type.
-[*Note 1*: An implementation might use a reference-counted smart
-pointer as `exception_ptr`. — *end note*]
 For purposes of determining the presence of a data race, operations on
 `exception_ptr` objects shall access and modify only the `exception_ptr`
 objects themselves and not the exceptions they refer to. Use of
 `rethrow_exception` on `exception_ptr` objects that refer to the same
 exception object shall not introduce a data race.
 [*Note 2*: If `rethrow_exception` rethrows the same exception object
 (rather than a copy), concurrent access to that rethrown exception
-object may introduce a data race. Changes in the number of
 `exception_ptr` objects that refer to a particular exception do not
 introduce a data race. — *end note*]
 ``` cpp
 exception_ptr current_exception() noexcept;
@@ -2503,21 +2585,29 @@ creates a new copy each time it is called. — *end note*]
 If the attempt to copy the current exception object throws an exception,
 the function returns an `exception_ptr` object that refers to the thrown
 exception or, if this is not possible, to an instance of
 `bad_exception`.
-[*Note 4*: The copy constructor of the thrown exception may also fail,
 so the implementation is allowed to substitute a `bad_exception` object
 to avoid infinite recursion. — *end note*]
 ``` cpp
 [[noreturn]] void rethrow_exception(exception_ptr p);
 ```
 *Preconditions:* `p` is not a null pointer.
-*Throws:* The exception object to which `p` refers.
 ``` cpp
 template<class E> exception_ptr make_exception_ptr(E e) noexcept;
 ```
@@ -2613,18 +2703,21 @@ if (auto p = dynamic_cast<const nested_exception*>(addressof(e)))
   p->rethrow_nested();
 ```
 ## Initializer lists <a id="support.initlist">[[support.initlist]]</a>
 The header `<initializer_list>` defines a class template and several
 support functions related to list-initialization (see
-[[dcl.init.list]]). All functions specified in this subclause are
 signal-safe [[support.signal]].
 ### Header `<initializer_list>` synopsis <a id="initializer.list.syn">[[initializer.list.syn]]</a>
 ``` cpp
 namespace std {
   template<class E> class initializer_list {
   public:
     using value_type      = E;
     using reference       = const E&;
@@ -2712,10 +2805,11 @@ template<class E> constexpr const E* end(initializer_list<E> il) noexcept;
 The header `<compare>` specifies types, objects, and functions for use
 primarily in connection with the three-way comparison operator
 [[expr.spaceship]].
 ``` cpp
 namespace std {
   // [cmp.categories], comparison category types
   class partial_ordering;
   class weak_ordering;
   class strong_ordering;
@@ -2772,13 +2866,11 @@ collectively termed the *comparison category types*. Each is specified
 in terms of an exposition-only data member named `value` whose value
 typically corresponds to that of an enumerator from one of the following
 exposition-only enumerations:
 ``` cpp
-enum class eq { equal = 0, equivalent = equal,
-                nonequal = 1, nonequivalent = nonequal };   // exposition only
-enum class ord { less = -1, greater = 1 };                  // exposition only
 enum class ncmp { unordered = -127 };                                     // exposition only
 ```
 [*Note 1*: The type `strong_ordering` corresponds to the term total
 ordering in mathematics. — *end note*]
@@ -2805,24 +2897,22 @@ where `f` denotes a function that reads only comparison-salient state
 that is accessible via the argument’s public const members.
 #### Class `partial_ordering` <a id="cmp.partialord">[[cmp.partialord]]</a>
 The `partial_ordering` type is typically used as the result type of a
-three-way comparison operator [[expr.spaceship]] that (a) admits all of
-the six two-way comparison operators ([[expr.rel]], [[expr.eq]]), (b)
-does not imply substitutability, and (c) permits two values to be
-incomparable. [^34]
 ``` cpp
 namespace std {
   class partial_ordering {
     int value;          // exposition only
     bool is_ordered;    // exposition only
     // exposition-only constructors
-    constexpr explicit
-      partial_ordering(eq v) noexcept : value(int(v)), is_ordered(true) {}      // exposition only
     constexpr explicit
       partial_ordering(ord v) noexcept : value(int(v)), is_ordered(true) {}     // exposition only
     constexpr explicit
       partial_ordering(ncmp v) noexcept : value(int(v)), is_ordered(false) {}   // exposition only
@@ -2848,11 +2938,11 @@ namespace std {
     friend constexpr partial_ordering operator<=>(unspecified, partial_ordering v) noexcept;
   };
   // valid values' definitions
   inline constexpr partial_ordering partial_ordering::less(ord::less);
-  inline constexpr partial_ordering partial_ordering::equivalent(eq::equivalent);
   inline constexpr partial_ordering partial_ordering::greater(ord::greater);
   inline constexpr partial_ordering partial_ordering::unordered(ncmp::unordered);
 }
 ```
@@ -2889,21 +2979,20 @@ constexpr partial_ordering operator<=>(unspecified, partial_ordering v) noexcept
 `v < 0 ? partial_ordering::greater : v > 0 ? partial_ordering::less : v`.
 #### Class `weak_ordering` <a id="cmp.weakord">[[cmp.weakord]]</a>
 The `weak_ordering` type is typically used as the result type of a
-three-way comparison operator [[expr.spaceship]] that (a) admits all of
-the six two-way comparison operators ([[expr.rel]], [[expr.eq]]), and
-(b) does not imply substitutability.
 ``` cpp
 namespace std {
   class weak_ordering {
     int value;  // exposition only
     // exposition-only constructors
-    constexpr explicit weak_ordering(eq v) noexcept : value(int(v)) {}  // exposition only
     constexpr explicit weak_ordering(ord v) noexcept : value(int(v)) {} // exposition only
   public:
     // valid values
     static const weak_ordering less;
@@ -2928,11 +3017,11 @@ namespace std {
     friend constexpr weak_ordering operator<=>(unspecified, weak_ordering v) noexcept;
   };
   // valid values' definitions
   inline constexpr weak_ordering weak_ordering::less(ord::less);
-  inline constexpr weak_ordering weak_ordering::equivalent(eq::equivalent);
   inline constexpr weak_ordering weak_ordering::greater(ord::greater);
 }
 ```
 ``` cpp
@@ -2980,21 +3069,20 @@ constexpr weak_ordering operator<=>(unspecified, weak_ordering v) noexcept;
 `v < 0 ? weak_ordering::greater : v > 0 ? weak_ordering::less : v`.
 #### Class `strong_ordering` <a id="cmp.strongord">[[cmp.strongord]]</a>
 The `strong_ordering` type is typically used as the result type of a
-three-way comparison operator [[expr.spaceship]] that (a) admits all of
-the six two-way comparison operators ([[expr.rel]], [[expr.eq]]), and
-(b) does imply substitutability.
 ``` cpp
 namespace std {
   class strong_ordering {
     int value;  // exposition only
     // exposition-only constructors
-    constexpr explicit strong_ordering(eq v) noexcept : value(int(v)) {}    // exposition only
     constexpr explicit strong_ordering(ord v) noexcept : value(int(v)) {}   // exposition only
   public:
     // valid values
     static const strong_ordering less;
@@ -3021,12 +3109,12 @@ namespace std {
     friend constexpr strong_ordering operator<=>(unspecified, strong_ordering v) noexcept;
   };
   // valid values' definitions
   inline constexpr strong_ordering strong_ordering::less(ord::less);
-  inline constexpr strong_ordering strong_ordering::equal(eq::equal);
-  inline constexpr strong_ordering strong_ordering::equivalent(eq::equivalent);
   inline constexpr strong_ordering strong_ordering::greater(ord::greater);
 }
 ```
 ``` cpp
@@ -3108,11 +3196,11 @@ pack, or `void` if any element of `Ts` is not a comparison category
 type.
 [*Note 1*: This is `std::strong_ordering` if the expansion is
 empty. — *end note*]
-### Concept `three_way_comparable` <a id="cmp.concept">[[cmp.concept]]</a>
 ``` cpp
 template<class T, class Cat>
   concept compares-as =                 // exposition only
     same_as<common_comparison_category_t<T, Cat>, Cat>;
@@ -3168,32 +3256,37 @@ and `Cat` model `three_way_comparable<T, Cat>` only if:
 ``` cpp
 template<class T, class U, class Cat = partial_ordering>
   concept three_way_comparable_with =
     three_way_comparable<T, Cat> &&
     three_way_comparable<U, Cat> &&
- common_reference_with<const remove_reference_t<T>&, const remove_reference_t<U>&> &&
     three_way_comparable<
       common_reference_t<const remove_reference_t<T>&, const remove_reference_t<U>&>, Cat> &&
     weakly-equality-comparable-with<T, U> &&
     partially-ordered-with<T, U> &&
     requires(const remove_reference_t<T>& t, const remove_reference_t<U>& u) {
       { t <=> u } -> compares-as<Cat>;
       { u <=> t } -> compares-as<Cat>;
     };
 ```
-Let `t` and `u` be lvalues of types `const remove_reference_t<T>` and
-`const remove_reference_t<U>`, respectively. Let `C` be
 `common_reference_t<const remove_reference_t<T>&, const remove_reference_t<U>&>`.
-`T`, `U`, and `Cat` model `three_way_comparable_with<T, U, Cat>` only
-if:
 - `t <=> u` and `u <=> t` have the same domain,
 - `((t <=> u) <=> 0)` and `(0 <=> (u <=> t))` are equal,
 - `(t <=> u == 0) == bool(t == u)` is `true`,
 - `(t <=> u != 0) == bool(t != u)` is `true`,
-- `Cat(t <=> u) == Cat(C(t) <=> C(u))` is `true`,
 - `(t <=> u < 0) == bool(t < u)` is `true`,
 - `(t <=> u > 0) == bool(t > u)` is `true`,
 - `(t <=> u <= 0) == bool(t <= u)` is `true`,
 - `(t <=> u >= 0) == bool(t >= u)` is `true`, and
 - if `Cat` is convertible to `strong_ordering`, `T` and `U` model
@@ -3216,38 +3309,41 @@ member `type`.
 ### Comparison algorithms <a id="cmp.alg">[[cmp.alg]]</a>
 The name `strong_order` denotes a customization point object
 [[customization.point.object]]. Given subexpressions `E` and `F`, the
 expression `strong_order(E, F)` is expression-equivalent
-[[defns.expression-equivalent]] to the following:
 - If the decayed types of `E` and `F` differ, `strong_order(E, F)` is
   ill-formed.
 - Otherwise, `strong_ordering(strong_order(E, F))` if it is a
-  well-formed expression with overload resolution performed in a context
- that does not include a declaration of `std::strong_order`.
 - Otherwise, if the decayed type `T` of `E` is a floating-point type,
   yields a value of type `strong_ordering` that is consistent with the
   ordering observed by `T`’s comparison operators, and if
   `numeric_limits<T>::is_iec559` is `true`, is additionally consistent
   with the `totalOrder` operation as specified in ISO/IEC/IEEE 60559.
 - Otherwise, `strong_ordering(compare_three_way()(E, F))` if it is a
   well-formed expression.
-- Otherwise, `strong_order(E, F)` is ill-formed. \[*Note 1*: This case
-  can result in substitution failure when `strong_order(E, F)` appears
-  in the immediate context of a template instantiation. — *end note*]
 The name `weak_order` denotes a customization point object
 [[customization.point.object]]. Given subexpressions `E` and `F`, the
 expression `weak_order(E, F)` is expression-equivalent
-[[defns.expression-equivalent]] to the following:
 - If the decayed types of `E` and `F` differ, `weak_order(E, F)` is
   ill-formed.
 - Otherwise, `weak_ordering(weak_order(E, F))` if it is a well-formed
-  expression with overload resolution performed in a context that does
- not include a declaration of `std::weak_order`.
 - Otherwise, if the decayed type `T` of `E` is a floating-point type,
   yields a value of type `weak_ordering` that is consistent with the
   ordering observed by `T`’s comparison operators and `strong_order`,
   and if `numeric_limits<T>::is_iec559` is `true`, is additionally
   consistent with the following equivalence classes, ordered from lesser
@@ -3263,99 +3359,121 @@ expression `weak_order(E, F)` is expression-equivalent
   - together, all positive NaN values.
 - Otherwise, `weak_ordering(compare_three_way()(E, F))` if it is a
   well-formed expression.
 - Otherwise, `weak_ordering(strong_order(E, F))` if it is a well-formed
   expression.
-- Otherwise, `weak_order(E, F)` is ill-formed. \[*Note 2*: This case can
-  result in substitution failure when `std::weak_order(E, F)` appears in
-  the immediate context of a template instantiation. — *end note*]
 The name `partial_order` denotes a customization point object
 [[customization.point.object]]. Given subexpressions `E` and `F`, the
 expression `partial_order(E, F)` is expression-equivalent
-[[defns.expression-equivalent]] to the following:
 - If the decayed types of `E` and `F` differ, `partial_order(E, F)` is
   ill-formed.
 - Otherwise, `partial_ordering(partial_order(E, F))` if it is a
-  well-formed expression with overload resolution performed in a context
- that does not include a declaration of `std::partial_order`.
 - Otherwise, `partial_ordering(compare_three_way()(E, F))` if it is a
   well-formed expression.
 - Otherwise, `partial_ordering(weak_order(E, F))` if it is a well-formed
   expression.
-- Otherwise, `partial_order(E, F)` is ill-formed. \[*Note 3*: This case
-  can result in substitution failure when `std::partial_order(E, F)`
-  appears in the immediate context of a template
 instantiation. — *end note*]
 The name `compare_strong_order_fallback` denotes a customization point
-object [[customization.point.object]]. Given subexpressions `E` and F,
 the expression `compare_strong_order_fallback(E, F)` is
-expression-equivalent [[defns.expression-equivalent]] to:
 - If the decayed types of `E` and `F` differ,
   `compare_strong_order_fallback(E, F)` is ill-formed.
 - Otherwise, `strong_order(E, F)` if it is a well-formed expression.
 - Otherwise, if the expressions `E == F` and `E < F` are both
-  well-formed and convertible to `bool`,
   ``` cpp
   E == F ? strong_ordering::equal :
   E < F  ? strong_ordering::less :
            strong_ordering::greater
   ```
   except that `E` and `F` are evaluated only once.
 - Otherwise, `compare_strong_order_fallback(E, F)` is ill-formed.
 The name `compare_weak_order_fallback` denotes a customization point
 object [[customization.point.object]]. Given subexpressions `E` and `F`,
 the expression `compare_weak_order_fallback(E, F)` is
-expression-equivalent [[defns.expression-equivalent]] to:
 - If the decayed types of `E` and `F` differ,
   `compare_weak_order_fallback(E, F)` is ill-formed.
 - Otherwise, `weak_order(E, F)` if it is a well-formed expression.
 - Otherwise, if the expressions `E == F` and `E < F` are both
-  well-formed and convertible to `bool`,
   ``` cpp
   E == F ? weak_ordering::equivalent :
   E < F  ? weak_ordering::less :
            weak_ordering::greater
   ```
   except that `E` and `F` are evaluated only once.
 - Otherwise, `compare_weak_order_fallback(E, F)` is ill-formed.
 The name `compare_partial_order_fallback` denotes a customization point
 object [[customization.point.object]]. Given subexpressions `E` and `F`,
 the expression `compare_partial_order_fallback(E, F)` is
-expression-equivalent [[defns.expression-equivalent]] to:
 - If the decayed types of `E` and `F` differ,
   `compare_partial_order_fallback(E, F)` is ill-formed.
 - Otherwise, `partial_order(E, F)` if it is a well-formed expression.
-- Otherwise, if the expressions `E == F` and `E < F` are both
-  well-formed and convertible to `bool`,
   ``` cpp
   E == F ? partial_ordering::equivalent :
   E < F  ? partial_ordering::less :
   F < E  ? partial_ordering::greater :
            partial_ordering::unordered
   ```
   except that `E` and `F` are evaluated only once.
 - Otherwise, `compare_partial_order_fallback(E, F)` is ill-formed.
 ## Coroutines <a id="support.coroutine">[[support.coroutine]]</a>
 The header `<coroutine>` defines several types providing compile and
 run-time support for coroutines in a C++ program.
 ### Header `<coroutine>` synopsis <a id="coroutine.syn">[[coroutine.syn]]</a>
 ``` cpp
 #include <compare>              // see [compare.syn]
 namespace std {
   // [coroutine.traits], coroutine traits
   template<class R, class... ArgTypes>
@@ -3387,13 +3505,15 @@ namespace std {
 }
 ```
 ### Coroutine traits <a id="coroutine.traits">[[coroutine.traits]]</a>
-This subclause defines requirements on classes representing *coroutine
-traits*, and defines the class template `coroutine_traits` that meets
-those requirements.
 #### Class template `coroutine_traits` <a id="coroutine.traits.primary">[[coroutine.traits.primary]]</a>
 The header `<coroutine>` defines the primary template `coroutine_traits`
 such that if `ArgTypes` is a parameter pack of types and if the
@@ -3410,10 +3530,12 @@ Otherwise, `coroutine_traits<R,ArgTypes...>` has no members.
 Program-defined specializations of this template shall define a publicly
 accessible nested type named `promise_type`.
 ### Class template `coroutine_handle` <a id="coroutine.handle">[[coroutine.handle]]</a>
 ``` cpp
 namespace std {
   template<>
   struct coroutine_handle<void>
   {
@@ -3438,30 +3560,49 @@ namespace std {
   private:
     void* ptr;  // exposition only
   };
   template<class Promise>
-  struct coroutine_handle : coroutine_handle<>
   {
     // [coroutine.handle.con], construct/reset
- using coroutine_handle<>::coroutine_handle;
     static coroutine_handle from_promise(Promise&);
     coroutine_handle& operator=(nullptr_t) noexcept;
     // [coroutine.handle.export.import], export/import
     static constexpr coroutine_handle from_address(void* addr);
     // [coroutine.handle.promise], promise access
     Promise& promise() const;
   };
 }
 ```
 An object of type `coroutine_handle<T>` is called a *coroutine handle*
 and can be used to refer to a suspended or executing coroutine. A
-default-constructed `coroutine_handle` object does not refer to any
-coroutine.
 If a program declares an explicit or partial specialization of
 `coroutine_handle`, the behavior is undefined.
 #### Construct/reset <a id="coroutine.handle.con">[[coroutine.handle.con]]</a>
@@ -3477,36 +3618,54 @@ constexpr coroutine_handle(nullptr_t) noexcept;
 static coroutine_handle from_promise(Promise& p);
 ```
 *Preconditions:* `p` is a reference to a promise object of a coroutine.
-*Returns:* A coroutine handle `h` referring to the coroutine.
 *Ensures:* `addressof(h.promise()) == addressof(p)`.
 ``` cpp
 coroutine_handle& operator=(nullptr_t) noexcept;
 ```
 *Ensures:* `address() == nullptr`.
 *Returns:* `*this`.
 #### Export/import <a id="coroutine.handle.export.import">[[coroutine.handle.export.import]]</a>
 ``` cpp
 constexpr void* address() const noexcept;
 ```
 *Returns:* `ptr`.
 ``` cpp
 static constexpr coroutine_handle<> coroutine_handle<>::from_address(void* addr);
 static constexpr coroutine_handle<Promise> coroutine_handle<Promise>::from_address(void* addr);
 ```
-*Preconditions:* `addr` was obtained via a prior call to `address`.
 *Ensures:* `from_address(address()) == *this`.
 #### Observers <a id="coroutine.handle.observers">[[coroutine.handle.observers]]</a>
@@ -3527,19 +3686,19 @@ point, otherwise `false`.
 #### Resumption <a id="coroutine.handle.resumption">[[coroutine.handle.resumption]]</a>
 Resuming a coroutine via `resume`, `operator()`, or `destroy` on an
 execution agent other than the one on which it was suspended has
-implementation-defined behavior unless each execution agent either is an
-instance of `std::thread` or `std::jthread`, or is the thread that
 executes `main`.
 [*Note 1*: A coroutine that is resumed on a different execution agent
 should avoid relying on consistent thread identity throughout, such as
 holding a mutex object across a suspend point. — *end note*]
-[*Note 2*: A concurrent resumption of the coroutine may result in a
 data race. — *end note*]
 ``` cpp
 void operator()() const;
 void resume() const;
@@ -3604,12 +3763,15 @@ coroutine referred to by `noop_coroutine_handle` [[coroutine.syn]].
 #### Class `coroutine_handle<noop_coroutine_promise>` <a id="coroutine.handle.noop">[[coroutine.handle.noop]]</a>
 ``` cpp
 namespace std {
   template<>
-  struct coroutine_handle<noop_coroutine_promise> : coroutine_handle<>
   {
     // [coroutine.handle.noop.observers], observers
     constexpr explicit operator bool() const noexcept;
     constexpr bool done() const noexcept;
     // [coroutine.handle.noop.resumption], resumption
@@ -3622,14 +3784,24 @@ namespace std {
     // [coroutine.handle.noop.address], address
     constexpr void* address() const noexcept;
   private:
     coroutine_handle(unspecified);
   };
 }
 ```
 ##### Observers <a id="coroutine.handle.noop.observers">[[coroutine.handle.noop.observers]]</a>
 ``` cpp
 constexpr explicit operator bool() const noexcept;
 ```
@@ -3705,15 +3877,17 @@ namespace std {
   };
 }
 ```
 [*Note 1*: The types `suspend_never` and `suspend_always` can be used
-to indicate that an *await-expression* should either never suspend or
-always suspend, and in either case not produce a value. — *end note*]
 ## Other runtime support <a id="support.runtime">[[support.runtime]]</a>
 Headers `<csetjmp>` (nonlocal jumps), `<csignal>` (signal handling),
 `<cstdarg>` (variable arguments), and `<cstdlib>` (runtime environment
 `getenv`, `system`), provide further compatibility with C code.
 Calls to the function `getenv` [[cstdlib.syn]] shall not introduce a
@@ -3730,10 +3904,11 @@ shall behave as if no library function other than `locale::global` calls
 the `setlocale` function.
 ### Header `<cstdarg>` synopsis <a id="cstdarg.syn">[[cstdarg.syn]]</a>
 ``` cpp
 namespace std {
   using va_list = see below;
 }
 #define va_arg(V, P) see below
@@ -3741,21 +3916,24 @@ namespace std {
 #define va_end(V) see below
 #define va_start(V, P) see below
 ```
 The contents of the header `<cstdarg>` are the same as the C standard
-library header `<stdarg.h>`, with the following changes: The
-restrictions that ISO C places on the second parameter to the `va_start`
-macro in header `<stdarg.h>` are different in this document. The
-parameter `parmN` is the rightmost parameter in the variable parameter
-list of the function definition (the one just before the `...`).[^35] If
-the parameter `parmN` is a pack expansion [[temp.variadic]] or an entity
-resulting from a lambda capture [[expr.prim.lambda]], the program is
-ill-formed, no diagnostic required. If the parameter `parmN` is of a
-reference type, or of a type that is not compatible with the type that
-results when passing an argument for which there is no parameter, the
-behavior is undefined.
 See also: ISO C 7.16.1.1
 ### Header `<csetjmp>` synopsis <a id="csetjmp.syn">[[csetjmp.syn]]</a>
@@ -3816,10 +3994,13 @@ invocation of the signal handler so installed.
 A *plain lock-free atomic operation* is an invocation of a function `f`
 from [[atomics]], such that:
 - `f` is the function `atomic_is_lock_free()`, or
 - `f` is the member function `is_lock_free()`, or
 - `f` is a non-static member function invoked on an object `A`, such
   that `A.is_lock_free()` yields `true`, or
 - `f` is a non-member function, and for every pointer-to-atomic argument
   `A` passed to `f`, `atomic_is_lock_free(A)` yields `true`.
@@ -3833,12 +4014,11 @@ An evaluation is *signal-safe* unless it includes one of the following:
 - an access to an object with thread storage duration;
 - a `dynamic_cast` expression;
 - throwing of an exception;
 - control entering a *try-block* or *function-try-block*;
 - initialization of a variable with static storage duration requiring
-  dynamic initialization ([[basic.start.dynamic]], [[stmt.dcl]]) [^36];
-  or
 - waiting for the completion of the initialization of a variable with
   static storage duration [[stmt.dcl]].
 A signal handler invocation has undefined behavior if it includes an
 evaluation that is not signal-safe.
@@ -3847,31 +4027,146 @@ The function `signal` is signal-safe if it is invoked with the first
 argument equal to the signal number corresponding to the signal that
 caused the invocation of the handler.
 See also: ISO C 7.14
 <!-- Link reference definitions -->
 [alg.c.library]: algorithms.md#alg.c.library
 [alloc.errors]: #alloc.errors
-[atomics]: atomics.md#atomics
 [bad.alloc]: #bad.alloc
 [bad.cast]: #bad.cast
 [bad.exception]: #bad.exception
 [bad.typeid]: #bad.typeid
 [basic.align]: basic.md#basic.align
-[basic.def.odr]: basic.md#basic.def.odr
 [basic.fundamental]: basic.md#basic.fundamental
 [basic.life]: basic.md#basic.life
 [basic.start.dynamic]: basic.md#basic.start.dynamic
 [basic.start.term]: basic.md#basic.start.term
 [basic.stc.dynamic]: basic.md#basic.stc.dynamic
 [basic.stc.dynamic.allocation]: basic.md#basic.stc.dynamic.allocation
 [basic.stc.dynamic.deallocation]: basic.md#basic.stc.dynamic.deallocation
-[basic.stc.dynamic.safety]: basic.md#basic.stc.dynamic.safety
 [c.locales]: localization.md#c.locales
-[c.malloc]: utilities.md#c.malloc
 [c.math.abs]: numerics.md#c.math.abs
 [c.math.rand]: numerics.md#c.math.rand
 [c.mb.wcs]: strings.md#c.mb.wcs
 [cfloat.syn]: #cfloat.syn
 [class.mem]: class.md#class.mem
 [class.prop]: class.md#class.prop
@@ -3887,22 +4182,28 @@ See also: ISO C 7.14
 [cmp.result]: #cmp.result
 [cmp.strongord]: #cmp.strongord
 [cmp.weakord]: #cmp.weakord
 [compare.syn]: #compare.syn
 [complex]: numerics.md#complex
 [concept.totallyordered]: concepts.md#concept.totallyordered
 [constraints]: library.md#constraints
 [conv.ptr]: expr.md#conv.ptr
 [conv.qual]: expr.md#conv.qual
 [conv.rank]: basic.md#conv.rank
 [coroutine.handle]: #coroutine.handle
 [coroutine.handle.compare]: #coroutine.handle.compare
 [coroutine.handle.con]: #coroutine.handle.con
 [coroutine.handle.export.import]: #coroutine.handle.export.import
 [coroutine.handle.hash]: #coroutine.handle.hash
 [coroutine.handle.noop]: #coroutine.handle.noop
 [coroutine.handle.noop.address]: #coroutine.handle.noop.address
 [coroutine.handle.noop.observers]: #coroutine.handle.noop.observers
 [coroutine.handle.noop.promise]: #coroutine.handle.noop.promise
 [coroutine.handle.noop.resumption]: #coroutine.handle.noop.resumption
 [coroutine.handle.observers]: #coroutine.handle.observers
 [coroutine.handle.promise]: #coroutine.handle.promise
@@ -3910,27 +4211,26 @@ See also: ISO C 7.14
 [coroutine.noop]: #coroutine.noop
 [coroutine.noop.coroutine]: #coroutine.noop.coroutine
 [coroutine.promise.noop]: #coroutine.promise.noop
 [coroutine.syn]: #coroutine.syn
 [coroutine.traits]: #coroutine.traits
 [coroutine.traits.primary]: #coroutine.traits.primary
 [coroutine.trivial.awaitables]: #coroutine.trivial.awaitables
 [cpp.line]: cpp.md#cpp.line
 [cpp17.nullablepointer]: #cpp17.nullablepointer
 [csetjmp.syn]: #csetjmp.syn
 [csignal.syn]: #csignal.syn
 [cstdarg.syn]: #cstdarg.syn
 [cstddef.syn]: #cstddef.syn
-[cstdint]: #cstdint
 [cstdint.syn]: #cstdint.syn
 [cstdlib.syn]: #cstdlib.syn
 [customization.point.object]: library.md#customization.point.object
 [dcl.fct.def.coroutine]: dcl.md#dcl.fct.def.coroutine
 [dcl.fct.default]: dcl.md#dcl.fct.default
 [dcl.init.list]: dcl.md#dcl.init.list
-[defns.expression-equivalent]: library.md#defns.expression-equivalent
-[denorm.style]: #denorm.style
 [except.handle]: except.md#except.handle
 [except.nested]: #except.nested
 [except.spec]: except.md#except.spec
 [except.terminate]: except.md#except.terminate
 [except.uncaught]: except.md#except.uncaught
@@ -3948,56 +4248,75 @@ See also: ISO C 7.14
 [expr.prim.lambda]: expr.md#expr.prim.lambda
 [expr.rel]: expr.md#expr.rel
 [expr.sizeof]: expr.md#expr.sizeof
 [expr.spaceship]: expr.md#expr.spaceship
 [expr.typeid]: expr.md#expr.typeid
-[fp.style]: #fp.style
 [get.new.handler]: #get.new.handler
 [get.terminate]: #get.terminate
 [hardware.interference]: #hardware.interference
 [initializer.list.syn]: #initializer.list.syn
 [intro.multithread]: basic.md#intro.multithread
 [library.c]: library.md#library.c
 [limits.syn]: #limits.syn
 [locale.codecvt]: localization.md#locale.codecvt
 [multibyte.strings]: library.md#multibyte.strings
 [new.badlength]: #new.badlength
 [new.delete]: #new.delete
 [new.delete.array]: #new.delete.array
 [new.delete.dataraces]: #new.delete.dataraces
 [new.delete.placement]: #new.delete.placement
 [new.delete.single]: #new.delete.single
 [new.handler]: #new.handler
 [new.syn]: #new.syn
 [numeric.limits]: #numeric.limits
 [numeric.limits.members]: #numeric.limits.members
 [numeric.special]: #numeric.special
 [propagation]: #propagation
 [ptr.launder]: #ptr.launder
 [res.on.data.races]: library.md#res.on.data.races
 [round.style]: #round.style
 [set.new.handler]: #set.new.handler
 [set.terminate]: #set.terminate
 [source.location.syn]: #source.location.syn
 [stmt.dcl]: stmt.md#stmt.dcl
 [string.classes]: strings.md#string.classes
 [support]: #support
 [support.coroutine]: #support.coroutine
 [support.dynamic]: #support.dynamic
 [support.exception]: #support.exception
 [support.general]: #support.general
 [support.initlist]: #support.initlist
 [support.initlist.access]: #support.initlist.access
 [support.initlist.cons]: #support.initlist.cons
 [support.initlist.range]: #support.initlist.range
 [support.limits]: #support.limits
 [support.limits.general]: #support.limits.general
 [support.rtti]: #support.rtti
 [support.runtime]: #support.runtime
 [support.signal]: #support.signal
 [support.srcloc]: #support.srcloc
 [support.srcloc.class]: #support.srcloc.class
 [support.srcloc.cons]: #support.srcloc.cons
 [support.srcloc.current]: #support.srcloc.current
 [support.srcloc.obs]: #support.srcloc.obs
 [support.start.term]: #support.start.term
 [support.summary]: #support.summary
@@ -4008,12 +4327,14 @@ See also: ISO C 7.14
 [swappable.requirements]: library.md#swappable.requirements
 [temp.deduct]: temp.md#temp.deduct
 [temp.dep.constexpr]: temp.md#temp.dep.constexpr
 [temp.dep.expr]: temp.md#temp.dep.expr
 [temp.variadic]: temp.md#temp.variadic
 [terminate]: #terminate
 [terminate.handler]: #terminate.handler
 [type.info]: #type.info
 [typeinfo.syn]: #typeinfo.syn
 [uncaught.exceptions]: #uncaught.exceptions
 [unord.hash]: utilities.md#unord.hash
 [utility.arg.requirements]: library.md#utility.arg.requirements
@@ -4036,11 +4357,11 @@ See also: ISO C 7.14
 [^7]: Equivalent to `FLT_DIG`, `DBL_DIG`, `LDBL_DIG`.
 [^8]: Equivalent to `FLT_RADIX`.
-[^9]: Distinguishes types with bases other than 2 (e.g. BCD).
 [^10]: Equivalent to `FLT_EPSILON`, `DBL_EPSILON`, `LDBL_EPSILON`.
 [^11]: Rounding error is described in LIA-1 Section 5.2.4 and Annex C
     Rationale Section C.5.2.4 — Rounding and rounding constants.
@@ -4059,52 +4380,48 @@ See also: ISO C 7.14
 [^17]: Required by LIA-1.
 [^18]: Required by LIA-1.
-[^19]: See ISO/IEC/IEEE 60559.
 [^20]: Required by LIA-1.
 [^21]: Required by LIA-1.
-[^22]: Required by LIA-1.
 [^23]: Required by LIA-1.
-[^24]: ISO/IEC/IEEE 60559:2011 is the same as IEEE 754-2008.
 [^25]: Required by LIA-1.
-[^26]: Required by LIA-1.
-[^27]: Required by LIA-1.
-[^28]: Refer to ISO/IEC/IEEE 60559. Required by LIA-1.
-[^29]: Equivalent to `FLT_ROUNDS`. Required by LIA-1.
-[^30]: A function is called for every time it is registered.
-[^31]: Objects with automatic storage duration are all destroyed in a
     program whose `main` function [[basic.start.main]] contains no
     objects with automatic storage duration and executes the call to
     `exit()`. Control can be transferred directly to such a `main`
     function by throwing an exception that is caught in `main`.
-[^32]: The macros `EXIT_FAILURE` and `EXIT_SUCCESS` are defined in
     `<cstdlib>`.
-[^33]: It is not the direct responsibility of `operator new[]` or
     `operator delete[]` to note the repetition count or element size of
     the array. Those operations are performed elsewhere in the array
-    `new` and `delete` expressions. The array `new` expression, may,
     however, increase the `size` argument to `operator new[]` to obtain
     space to store supplemental information.
-[^34]: That is, `a < b`, `a == b`, and `a > b` might all be `false`.
-[^35]: Note that `va_start` is required to work as specified even if
     unary `operator&` is overloaded for the type of `parmN`.
-[^36]: Such initialization might occur because it is the first odr-use
-    [[basic.def.odr]] of that variable.

 other runtime support, as summarized in [[support.summary]].
 **Table: Language support library summary** <a id="support.summary">[support.summary]</a>
 | Subclause               |                           | Header                                             |
+| ----------------------- | ------------------------- | -------------------------------------------------- |
 | [[support.types]]       | Common definitions        | `<cstddef>`, `<cstdlib>`                           |
 | [[support.limits]]      | Implementation properties | `<cfloat>`, `<climits>`, `<limits>`, `<version>`   |
+| [[support.arith.types]] | Arithmetic types | `<cstdint>`, `<stdfloat>`                          |
 | [[support.start.term]]  | Start and termination     | `<cstdlib>`                                        |
 | [[support.dynamic]]     | Dynamic memory management | `<new>`                                            |
 | [[support.rtti]]        | Type identification       | `<typeinfo>`                                       |
 | [[support.srcloc]]      | Source location           | `<source_location>`                                |
 | [[support.exception]]   | Exception handling        | `<exception>`                                      |
 ## Common definitions <a id="support.types">[[support.types]]</a>
 ### Header `<cstddef>` synopsis <a id="cstddef.syn">[[cstddef.syn]]</a>
 ``` cpp
+// all freestanding
 namespace std {
   using ptrdiff_t = see below;
   using size_t = see below;
   using max_align_t = see below;
   using nullptr_t = decltype(nullptr);
 ### Header `<cstdlib>` synopsis <a id="cstdlib.syn">[[cstdlib.syn]]</a>
 ``` cpp
 namespace std {
+  using size_t = see below;                                             // freestanding
   using div_t = see below;
   using ldiv_t = see below;
   using lldiv_t = see below;
 }
+#define NULL see below                                                  // freestanding
 #define EXIT_FAILURE see below
 #define EXIT_SUCCESS see below
 #define RAND_MAX see below
 #define MB_CUR_MAX see below
   extern "C++" using atexit-handler = void();                           // exposition only
   extern "C" using c-compare-pred = int(const void*, const void*);      // exposition only
   extern "C++" using compare-pred = int(const void*, const void*);      // exposition only
   // [support.start.term], start and termination
+  [[noreturn]] void abort() noexcept;                                   // freestanding
+  int atexit(c-atexit-handler* func) noexcept;                          // freestanding
+  int atexit(atexit-handler* func) noexcept;                            // freestanding
+  int at_quick_exit(c-atexit-handler* func) noexcept;                   // freestanding
+  int at_quick_exit(atexit-handler* func) noexcept;                     // freestanding
+  [[noreturn]] void exit(int status);                                   // freestanding
+  [[noreturn]] void _Exit(int status) noexcept;                         // freestanding
+  [[noreturn]] void quick_exit(int status) noexcept;                    // freestanding
   char* getenv(const char* name);
   int system(const char* string);
   // [c.malloc], C library memory allocation
   // [c.math.rand], low-quality random number generation
   int rand();
   void srand(unsigned int seed);
   // [c.math.abs], absolute values
+ constexpr int abs(int j);
+ constexpr long int abs(long int j);
+ constexpr long long int abs(long long int j);
+ constexpr floating-point-type abs(floating-point-type j);
+ constexpr long int labs(long int j);
+ constexpr long long int llabs(long long int j);
+ constexpr div_t div(int numer, int denom);
+ constexpr ldiv_t div(long int numer, long int denom); // see [library.c]
+ constexpr lldiv_t div(long long int numer, long long int denom); // see [library.c]
+ constexpr ldiv_t ldiv(long int numer, long int denom);
+ constexpr lldiv_t lldiv(long long int numer, long long int denom);
 }
 ```
 The contents and meaning of the header `<cstdlib>` are the same as the C
 standard library header `<stdlib.h>`, except that it does not declare
 [*Note 1*: Although `nullptr`’s address cannot be taken, the address of
 another `nullptr_t` object that is an lvalue can be
 taken. — *end note*]
+The macro `NULL` is an *implementation-defined* null pointer
+constant.[^1]
 See also: ISO C 7.19
 ### Sizes, alignments, and offsets <a id="support.types.layout">[[support.types.layout]]</a>
 The macro `offsetof(type, member-designator)` has the same semantics as
 the corresponding macro in the C standard library header `<stddef.h>`,
 but accepts a restricted set of `type` arguments in this document. Use
 of the `offsetof` macro with a `type` other than a standard-layout class
+[[class.prop]] is conditionally-supported.[^2]
+The expression `offsetof(type, member-designator)` is never
+type-dependent [[temp.dep.expr]] and it is value-dependent
+[[temp.dep.constexpr]] if and only if `type` is dependent. The result of
+applying the `offsetof` macro to a static data member or a function
+member is undefined. No operation invoked by the `offsetof` macro shall
+throw an exception and `noexcept(offsetof(type, member-designator))`
+shall be `true`.
 The type `ptrdiff_t` is an *implementation-defined* signed integer type
 that can hold the difference of two subscripts in an array object, as
 described in  [[expr.add]].
 The type `size_t` is an *implementation-defined* unsigned integer type
 that is large enough to contain the size in bytes of any object
 [[expr.sizeof]].
+*Recommended practice:* An implementation should choose types for
 `ptrdiff_t` and `size_t` whose integer conversion ranks [[conv.rank]]
 are no greater than that of `signed long int` unless a larger size is
+necessary to contain all the possible values.
 The type `max_align_t` is a trivial standard-layout type whose alignment
 requirement is at least as great as that of every scalar type, and whose
 alignment requirement is supported in every context [[basic.align]].
 Each of the macros defined in `<version>` is also defined after
 inclusion of any member of the set of library headers indicated in the
 corresponding comment in this synopsis.
+[*Note 1*: Future revisions of C++ might replace the values of these
+macros with greater values. — *end note*]
 ``` cpp
 #define __cpp_lib_addressof_constexpr               201603L // also in <memory>
+#define __cpp_lib_algorithm_iterator_requirements   202207L
+  // also in <algorithm>, <numeric>, <memory>
+#define __cpp_lib_allocate_at_least                 202302L // also in <memory>
 #define __cpp_lib_allocator_traits_is_always_equal  201411L
   // also in <memory>, <scoped_allocator>, <string>, <deque>, <forward_list>, <list>, <vector>,
   // <map>, <set>, <unordered_map>, <unordered_set>
+#define __cpp_lib_adaptor_iterator_pair_constructor 202106L // also in <stack>, <queue>
 #define __cpp_lib_any                               201606L // also in <any>
 #define __cpp_lib_apply                             201603L // also in <tuple>
 #define __cpp_lib_array_constexpr                   201811L // also in <iterator>, <array>
 #define __cpp_lib_as_const                          201510L // also in <utility>
+#define __cpp_lib_associative_heterogeneous_erasure 202110L
+  // also in <map>, <set>, <unordered_map>, <unordered_set>
 #define __cpp_lib_assume_aligned                    201811L // also in <memory>
 #define __cpp_lib_atomic_flag_test                  201907L // also in <atomic>
 #define __cpp_lib_atomic_float                      201711L // also in <atomic>
 #define __cpp_lib_atomic_is_always_lock_free        201603L // also in <atomic>
 #define __cpp_lib_atomic_lock_free_type_aliases     201907L // also in <atomic>
 #define __cpp_lib_atomic_ref                        201806L // also in <atomic>
 #define __cpp_lib_atomic_shared_ptr                 201711L // also in <memory>
 #define __cpp_lib_atomic_value_initialization       201911L // also in <atomic>, <memory>
 #define __cpp_lib_atomic_wait                       201907L // also in <atomic>
+#define __cpp_lib_barrier                           202302L // also in <barrier>
+#define __cpp_lib_bind_back                         202202L // also in <functional>
 #define __cpp_lib_bind_front                        201907L // also in <functional>
 #define __cpp_lib_bit_cast                          201806L // also in <bit>
 #define __cpp_lib_bitops                            201907L // also in <bit>
 #define __cpp_lib_bool_constant                     201505L // also in <type_traits>
 #define __cpp_lib_bounded_array_traits              201902L // also in <type_traits>
 #define __cpp_lib_boyer_moore_searcher              201603L // also in <functional>
 #define __cpp_lib_byte                              201603L // also in <cstddef>
+#define __cpp_lib_byteswap                          202110L // also in <bit>
 #define __cpp_lib_char8_t                           201907L
   // also in <atomic>, <filesystem>, <istream>, <limits>, <locale>, <ostream>, <string>, <string_view>
 #define __cpp_lib_chrono                            201907L // also in <chrono>
 #define __cpp_lib_chrono_udls                       201304L // also in <chrono>
 #define __cpp_lib_clamp                             201603L // also in <algorithm>
+#define __cpp_lib_common_reference                  202302L // also in <type_traits>
+#define __cpp_lib_common_reference_wrapper          202302L // also in <functional>
 #define __cpp_lib_complex_udls                      201309L // also in <complex>
+#define __cpp_lib_concepts                          202207L // also in <concepts>, <compare>
+#define __cpp_lib_constexpr_algorithms              201806L // also in <algorithm>, <utility>
+#define __cpp_lib_constexpr_bitset                  202207L // also in <bitset>
+#define __cpp_lib_constexpr_charconv                202207L // also in <charconv>
+#define __cpp_lib_constexpr_cmath                   202202L // also in <cmath>, <cstdlib>
 #define __cpp_lib_constexpr_complex                 201711L // also in <complex>
 #define __cpp_lib_constexpr_dynamic_alloc           201907L // also in <memory>
 #define __cpp_lib_constexpr_functional              201907L // also in <functional>
 #define __cpp_lib_constexpr_iterator                201811L // also in <iterator>
+#define __cpp_lib_constexpr_memory                  202202L // also in <memory>
 #define __cpp_lib_constexpr_numeric                 201911L // also in <numeric>
 #define __cpp_lib_constexpr_string                  201907L // also in <string>
 #define __cpp_lib_constexpr_string_view             201811L // also in <string_view>
 #define __cpp_lib_constexpr_tuple                   201811L // also in <tuple>
+#define __cpp_lib_constexpr_typeinfo                202106L // also in <typeinfo>
 #define __cpp_lib_constexpr_utility                 201811L // also in <utility>
 #define __cpp_lib_constexpr_vector                  201907L // also in <vector>
+#define __cpp_lib_containers_ranges                 202202L
+  // also in <vector>, <list>, <forward_list>, <map>, <set>, <unordered_map>, <unordered_set>,
+  // <deque>, <queue>, <stack>, <string>
 #define __cpp_lib_coroutine                         201902L // also in <coroutine>
 #define __cpp_lib_destroying_delete                 201806L // also in <new>
 #define __cpp_lib_enable_shared_from_this           201603L // also in <memory>
 #define __cpp_lib_endian                            201907L // also in <bit>
 #define __cpp_lib_erase_if                          202002L
   // also in <string>, <deque>, <forward_list>, <list>, <vector>, <map>, <set>, <unordered_map>,
   // <unordered_set>
 #define __cpp_lib_exchange_function                 201304L // also in <utility>
 #define __cpp_lib_execution                         201902L // also in <execution>
+#define __cpp_lib_expected                          202211L // also in <expected>
 #define __cpp_lib_filesystem                        201703L // also in <filesystem>
+#define __cpp_lib_flat_map                          202207L // also in <flat_map>
+#define __cpp_lib_flat_set                          202207L // also in <flat_set>
+#define __cpp_lib_format                            202207L // also in <format>
+#define __cpp_lib_format_ranges                     202207L // also in <format>
+#define __cpp_lib_formatters                        202302L // also in <stacktrace>, <thread>
+#define __cpp_lib_forward_like                      202207L // also in <utility>
 #define __cpp_lib_gcd_lcm                           201606L // also in <numeric>
+#define __cpp_lib_generator                         202207L // also in <generator>
 #define __cpp_lib_generic_associative_lookup        201304L // also in <map>, <set>
 #define __cpp_lib_generic_unordered_lookup          201811L
   // also in <unordered_map>, <unordered_set>
 #define __cpp_lib_hardware_interference_size        201703L // also in <new>
 #define __cpp_lib_has_unique_object_representations 201606L // also in <type_traits>
 #define __cpp_lib_integer_comparison_functions      202002L // also in <utility>
 #define __cpp_lib_integer_sequence                  201304L // also in <utility>
 #define __cpp_lib_integral_constant_callable        201304L // also in <type_traits>
 #define __cpp_lib_interpolate                       201902L // also in <cmath>, <numeric>
 #define __cpp_lib_invoke                            201411L // also in <functional>
+#define __cpp_lib_invoke_r                          202106L // also in <functional>
+#define __cpp_lib_ios_noreplace                     202207L // also in <ios>
 #define __cpp_lib_is_aggregate                      201703L // also in <type_traits>
 #define __cpp_lib_is_constant_evaluated             201811L // also in <type_traits>
 #define __cpp_lib_is_final                          201402L // also in <type_traits>
+#define __cpp_lib_is_implicit_lifetime              202302L // also in <type_traits>
 #define __cpp_lib_is_invocable                      201703L // also in <type_traits>
 #define __cpp_lib_is_layout_compatible              201907L // also in <type_traits>
 #define __cpp_lib_is_nothrow_convertible            201806L // also in <type_traits>
 #define __cpp_lib_is_null_pointer                   201309L // also in <type_traits>
 #define __cpp_lib_is_pointer_interconvertible       201907L // also in <type_traits>
+#define __cpp_lib_is_scoped_enum                    202011L // also in <type_traits>
 #define __cpp_lib_is_swappable                      201603L // also in <type_traits>
 #define __cpp_lib_jthread                           201911L // also in <stop_token>, <thread>
 #define __cpp_lib_latch                             201907L // also in <latch>
 #define __cpp_lib_launder                           201606L // also in <new>
 #define __cpp_lib_list_remove_return_type           201806L // also in <forward_list>, <list>
 #define __cpp_lib_make_reverse_iterator             201402L // also in <iterator>
 #define __cpp_lib_make_unique                       201304L // also in <memory>
 #define __cpp_lib_map_try_emplace                   201411L // also in <map>
 #define __cpp_lib_math_constants                    201907L // also in <numbers>
 #define __cpp_lib_math_special_functions            201603L // also in <cmath>
+#define __cpp_lib_mdspan                            202207L // also in <mdspan>
 #define __cpp_lib_memory_resource                   201603L // also in <memory_resource>
+#define __cpp_lib_modules                           202207L
+#define __cpp_lib_move_iterator_concept             202207L // also in <iterator>
+#define __cpp_lib_move_only_function                202110L // also in <functional>
 #define __cpp_lib_node_extract                      201606L
   // also in <map>, <set>, <unordered_map>, <unordered_set>
 #define __cpp_lib_nonmember_container_access        201411L
   // also in <array>, <deque>, <forward_list>, <iterator>, <list>, <map>, <regex>, <set>, <string>,
   // <unordered_map>, <unordered_set>, <vector>
 #define __cpp_lib_not_fn                            201603L // also in <functional>
 #define __cpp_lib_null_iterators                    201304L // also in <iterator>
+#define __cpp_lib_optional                          202110L // also in <optional>
+#define __cpp_lib_out_ptr                           202106L // also in <memory>
 #define __cpp_lib_parallel_algorithm                201603L // also in <algorithm>, <numeric>
+#define __cpp_lib_polymorphic_allocator             201902L // also in <memory_resource>
+#define __cpp_lib_print                             202207L // also in <print>, <ostream>
 #define __cpp_lib_quoted_string_io                  201304L // also in <iomanip>
+#define __cpp_lib_ranges                            202302L
   // also in <algorithm>, <functional>, <iterator>, <memory>, <ranges>
+#define __cpp_lib_ranges_as_const                   202207L // also in <ranges>
+#define __cpp_lib_ranges_as_rvalue                  202207L // also in <ranges>
+#define __cpp_lib_ranges_cartesian_product          202207L // also in <ranges>
+#define __cpp_lib_ranges_chunk                      202202L // also in <ranges>
+#define __cpp_lib_ranges_chunk_by                   202202L // also in <ranges>
+#define __cpp_lib_ranges_contains                   202207L // also in <algorithm>
+#define __cpp_lib_ranges_enumerate                  202302L // also in <ranges>, <version>
+#define __cpp_lib_ranges_find_last                  202207L // also in <algorithm>
+#define __cpp_lib_ranges_fold                       202207L // also in <algorithm>
+#define __cpp_lib_ranges_iota                       202202L // also in <numeric>
+#define __cpp_lib_ranges_join_with                  202202L // also in <ranges>
+#define __cpp_lib_ranges_repeat                     202207L // also in <ranges>
+#define __cpp_lib_ranges_slide                      202202L // also in <ranges>
+#define __cpp_lib_ranges_starts_ends_with           202106L // also in <algorithm>
+#define __cpp_lib_ranges_stride                     202207L // also in <ranges>
+#define __cpp_lib_ranges_to_container               202202L // also in <ranges>
+#define __cpp_lib_ranges_zip                        202110L // also in <ranges>, <tuple>, <utility>
 #define __cpp_lib_raw_memory_algorithms             201606L // also in <memory>
+#define __cpp_lib_reference_from_temporary          202202L // also in <type_traits>
 #define __cpp_lib_remove_cvref                      201711L // also in <type_traits>
 #define __cpp_lib_result_of_sfinae                  201210L // also in <functional>, <type_traits>
 #define __cpp_lib_robust_nonmodifying_seq_ops       201304L // also in <algorithm>
 #define __cpp_lib_sample                            201603L // also in <algorithm>
 #define __cpp_lib_scoped_lock                       201703L // also in <mutex>
 #define __cpp_lib_semaphore                         201907L // also in <semaphore>
 #define __cpp_lib_shared_mutex                      201505L // also in <shared_mutex>
 #define __cpp_lib_shared_ptr_arrays                 201707L // also in <memory>
 #define __cpp_lib_shared_ptr_weak_type              201606L // also in <memory>
 #define __cpp_lib_shared_timed_mutex                201402L // also in <shared_mutex>
+#define __cpp_lib_shift                             202202L // also in <algorithm>
 #define __cpp_lib_smart_ptr_for_overwrite           202002L // also in <memory>
 #define __cpp_lib_source_location                   201907L // also in <source_location>
 #define __cpp_lib_span                              202002L // also in <span>
+#define __cpp_lib_spanstream                        202106L // also in <spanstream>
 #define __cpp_lib_ssize                             201902L // also in <iterator>
+#define __cpp_lib_stacktrace                        202011L // also in <stacktrace>
+#define __cpp_lib_start_lifetime_as                 202207L // also in <memory>
 #define __cpp_lib_starts_ends_with                  201711L // also in <string>, <string_view>
+#define __cpp_lib_stdatomic_h                       202011L // also in <stdatomic.h>
+#define __cpp_lib_string_contains                   202011L // also in <string>, <string_view>
+#define __cpp_lib_string_resize_and_overwrite       202110L // also in <string>
 #define __cpp_lib_string_udls                       201304L // also in <string>
 #define __cpp_lib_string_view                       201803L // also in <string>, <string_view>
 #define __cpp_lib_syncbuf                           201803L // also in <syncstream>
 #define __cpp_lib_three_way_comparison              201907L // also in <compare>
 #define __cpp_lib_to_address                        201711L // also in <memory>
 #define __cpp_lib_to_array                          201907L // also in <array>
 #define __cpp_lib_to_chars                          201611L // also in <charconv>
+#define __cpp_lib_to_underlying                     202102L // also in <utility>
 #define __cpp_lib_transformation_trait_aliases      201304L // also in <type_traits>
 #define __cpp_lib_transparent_operators             201510L // also in <memory>, <functional>
+#define __cpp_lib_tuple_like                        202207L
+  // also in <utility>, <tuple>, <map>, <unordered_map>
 #define __cpp_lib_tuple_element_t                   201402L // also in <tuple>
 #define __cpp_lib_tuples_by_type                    201304L // also in <utility>, <tuple>
 #define __cpp_lib_type_identity                     201806L // also in <type_traits>
 #define __cpp_lib_type_trait_variable_templates     201510L // also in <type_traits>
 #define __cpp_lib_uncaught_exceptions               201411L // also in <exception>
 #define __cpp_lib_unordered_map_try_emplace         201411L // also in <unordered_map>
+#define __cpp_lib_unreachable                       202202L // also in <utility>
 #define __cpp_lib_unwrap_ref                        201811L // also in <type_traits>
+#define __cpp_lib_variant                           202106L // also in <variant>
 #define __cpp_lib_void_t                            201411L // also in <type_traits>
 ```
 ### Header `<limits>` synopsis <a id="limits.syn">[[limits.syn]]</a>
 ``` cpp
+// all freestanding
 namespace std {
+  // [round.style], enumeration float_round_style
   enum float_round_style;
   // [numeric.limits], class template numeric_limits
   template<class T> class numeric_limits;
   template<class T> class numeric_limits<const T>;
   template<> class numeric_limits<double>;
   template<> class numeric_limits<long double>;
 }
 ```
+### Enum `float_round_style` <a id="round.style">[[round.style]]</a>
 ``` cpp
 namespace std {
   enum float_round_style {
     round_indeterminate       = -1,
   representable value
 - `round_toward_infinity` if the rounding style is toward infinity
 - `round_toward_neg_infinity` if the rounding style is toward negative
   infinity
 ### Class template `numeric_limits` <a id="numeric.limits">[[numeric.limits]]</a>
+#### General <a id="numeric.limits.general">[[numeric.limits.general]]</a>
 The `numeric_limits` class template provides a C++ program with
 information about various properties of the implementation’s
 representation of the arithmetic types.
 ``` cpp
     static constexpr int  max_exponent10 = 0;
     static constexpr bool has_infinity = false;
     static constexpr bool has_quiet_NaN = false;
     static constexpr bool has_signaling_NaN = false;
     static constexpr T infinity() noexcept { return T(); }
     static constexpr T quiet_NaN() noexcept { return T(); }
     static constexpr T signaling_NaN() noexcept { return T(); }
     static constexpr T denorm_min() noexcept { return T(); }
 For all members declared `static` `constexpr` in the `numeric_limits`
 template, specializations shall define these values in such a way that
 they are usable as constant expressions.
+For the `numeric_limits` primary template, all data members are
+value-initialized and all member functions return a value-initialized
+object.
+[*Note 1*: This means all members have zero or `false` values unless
+`numeric_limits` is specialized for a type. — *end note*]
 Specializations shall be provided for each arithmetic type, both
 floating-point and integer, including `bool`. The member
 `is_specialized` shall be `true` for all such specializations of
 `numeric_limits`.
 Meaningful for all floating-point types.
 Shall be `true` for all specializations in which `is_iec559 != false`.
 ``` cpp
 static constexpr T infinity() noexcept;
 ```
+Representation of positive infinity, if available.[^18]
 Meaningful for all specializations for which `has_infinity != false`.
 Required in specializations for which `is_iec559 != false`.
 ``` cpp
 static constexpr T quiet_NaN() noexcept;
 ```
+Representation of a quiet “Not a Number”, if available.[^19]
 Meaningful for all specializations for which `has_quiet_NaN != false`.
 Required in specializations for which `is_iec559 != false`.
 ``` cpp
 static constexpr T signaling_NaN() noexcept;
 ```
+Representation of a signaling “Not a Number”, if available.[^20]
 Meaningful for all specializations for which
 `has_signaling_NaN != false`. Required in specializations for which
 `is_iec559 != false`.
 ``` cpp
 static constexpr T denorm_min() noexcept;
 ```
+Minimum positive subnormal value, if available.[^21]
+Otherwise, minimum positive normalized value.
 Meaningful for all floating-point types.
 ``` cpp
 static constexpr bool is_iec559;
 ```
+`true` if and only if the type adheres to ISO/IEC/IEEE 60559.[^22]
+[*Note 1*: The value is `true` for any of the types `float16_t`,
+`float32_t`, `float64_t`, or `float128_t`, if
+present [[basic.extended.fp]]. — *end note*]
 Meaningful for all floating-point types.
 ``` cpp
 static constexpr bool is_bounded;
 ```
+`true` if the set of values representable by the type is finite.[^23]
+[*Note 2*: All fundamental types [[basic.fundamental]] are bounded.
 This member would be `false` for arbitrary precision
 types. — *end note*]
 Meaningful for all specializations.
 ``` cpp
 static constexpr bool is_modulo;
 ```
+`true` if the type is modulo.[^24]
+A type is modulo if, for any operation involving `+`, `-`, or `*` on
+values of that type whose result would fall outside the range \[`min()`,
+`max()`\], the value returned differs from the true value by an integer
+multiple of `max() - min() + 1`.
 [*Example 1*: `is_modulo` is `false` for signed integer
 types [[basic.fundamental]] unless an implementation, as an extension to
 this document, defines signed integer overflow to
 wrap. — *end example*]
 ``` cpp
 static constexpr bool traps;
 ```
 `true` if, at the start of the program, there exists a value of the type
+that would cause an arithmetic operation using that value to trap.[^25]
 Meaningful for all specializations.
 ``` cpp
 static constexpr bool tinyness_before;
 ```
+`true` if tinyness is detected before rounding.[^26]
 Meaningful for all floating-point types.
 ``` cpp
 static constexpr float_round_style round_style;
 ```
+The rounding style for the type.[^27]
 Meaningful for all floating-point types. Specializations for integer
 types shall return `round_toward_zero`.
 #### `numeric_limits` specializations <a id="numeric.special">[[numeric.special]]</a>
     static constexpr int max_exponent10 = + 38;
     static constexpr bool has_infinity             = true;
     static constexpr bool has_quiet_NaN            = true;
     static constexpr bool has_signaling_NaN        = true;
     static constexpr float infinity()      noexcept { return value; }
     static constexpr float quiet_NaN()     noexcept { return value; }
     static constexpr float signaling_NaN() noexcept { return value; }
     static constexpr float denorm_min()    noexcept { return min(); }
      static constexpr int  max_exponent10 = 0;
      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr bool infinity() noexcept { return 0; }
      static constexpr bool quiet_NaN() noexcept { return 0; }
      static constexpr bool signaling_NaN() noexcept { return 0; }
      static constexpr bool denorm_min() noexcept { return 0; }
 ```
 ### Header `<climits>` synopsis <a id="climits.syn">[[climits.syn]]</a>
 ``` cpp
+// all freestanding
 #define CHAR_BIT see below
 #define SCHAR_MIN see below
 #define SCHAR_MAX see below
 #define UCHAR_MAX see below
 #define CHAR_MIN see below
 ```
 The header `<climits>` defines all macros the same as the C standard
 library header `<limits.h>`.
+[*Note 1*: Except for `CHAR_BIT` and `MB_LEN_MAX`, a macro referring to
+an integer type `T` defines a constant whose type is the promoted type
+of `T` [[conv.prom]]. — *end note*]
 See also: ISO C 5.2.4.2.1
 ### Header `<cfloat>` synopsis <a id="cfloat.syn">[[cfloat.syn]]</a>
 ``` cpp
+// all freestanding
 #define FLT_ROUNDS see below
 #define FLT_EVAL_METHOD see below
 #define FLT_HAS_SUBNORM see below
 #define DBL_HAS_SUBNORM see below
 #define LDBL_HAS_SUBNORM see below
 The header `<cfloat>` defines all macros the same as the C standard
 library header `<float.h>`.
 See also: ISO C 5.2.4.2.2
+## Arithmetic types <a id="support.arith.types">[[support.arith.types]]</a>
 ### Header `<cstdint>` synopsis <a id="cstdint.syn">[[cstdint.syn]]</a>
+The header `<cstdint>` supplies integer types having specified widths,
+and macros that specify limits of integer types.
 ``` cpp
+// all freestanding
 namespace std {
   using int8_t         = signed integer type;   // optional
   using int16_t        = signed integer type;   // optional
   using int32_t        = signed integer type;   // optional
   using int64_t        = signed integer type;   // optional
+  using intN_t         = see below;             // optional
   using int_fast8_t    = signed integer type;
   using int_fast16_t   = signed integer type;
   using int_fast32_t   = signed integer type;
   using int_fast64_t   = signed integer type;
+  using int_fastN_t    = see below;             // optional
   using int_least8_t   = signed integer type;
   using int_least16_t  = signed integer type;
   using int_least32_t  = signed integer type;
   using int_least64_t  = signed integer type;
+  using int_leastN_t   = see below;             // optional
   using intmax_t       = signed integer type;
   using intptr_t       = signed integer type;   // optional
   using uint8_t        = unsigned integer type; // optional
   using uint16_t       = unsigned integer type; // optional
   using uint32_t       = unsigned integer type; // optional
   using uint64_t       = unsigned integer type; // optional
+  using uintN_t        = see below;             // optional
   using uint_fast8_t   = unsigned integer type;
   using uint_fast16_t  = unsigned integer type;
   using uint_fast32_t  = unsigned integer type;
   using uint_fast64_t  = unsigned integer type;
+  using uint_fastN_t   = see below;             // optional
   using uint_least8_t  = unsigned integer type;
   using uint_least16_t = unsigned integer type;
   using uint_least32_t = unsigned integer type;
   using uint_least64_t = unsigned integer type;
+  using uint_leastN_t  = see below;             // optional
   using uintmax_t      = unsigned integer type;
   using uintptr_t      = unsigned integer type; // optional
 }
+#define INTN_MIN         see below
+#define INTN_MAX         see below
+#define UINTN_MAX        see below
+#define INT_FASTN_MIN    see below
+#define INT_FASTN_MAX    see below
+#define UINT_FASTN_MAX   see below
+#define INT_LEASTN_MIN   see below
+#define INT_LEASTN_MAX   see below
+#define UINT_LEASTN_MAX  see below
+#define INTMAX_MIN       see below
+#define INTMAX_MAX       see below
+#define UINTMAX_MAX      see below
+#define INTPTR_MIN       see below              // optional
+#define INTPTR_MAX       see below              // optional
+#define UINTPTR_MAX      see below              // optional
+#define PTRDIFF_MIN      see below
+#define PTRDIFF_MAX      see below
+#define SIZE_MAX         see below
+#define SIG_ATOMIC_MIN   see below
+#define SIG_ATOMIC_MAX   see below
+#define WCHAR_MIN        see below
+#define WCHAR_MAX        see below
+#define WINT_MIN         see below
+#define WINT_MAX         see below
+#define INTN_C(value)    see below
+#define UINTN_C(value)   see below
+#define INTMAX_C(value)  see below
+#define UINTMAX_C(value) see below
 ```
 The header defines all types and macros the same as the C standard
 library header `<stdint.h>`.
 See also: ISO C 7.20
+All types that use the placeholder *N* are optional when *N* is not `8`,
+`16`, `32`, or `64`. The exact-width types `intN_t` and `uintN_t` for
+*N* = `8`, `16`, `32`, and `64` are also optional; however, if an
+implementation defines integer types with the corresponding width and no
+padding bits, it defines the corresponding *typedef-name*s. Each of the
+macros listed in this subclause is defined if and only if the
+implementation defines the corresponding *typedef-name*.
+[*Note 1*: The macros `INTN_C` and `UINTN_C` correspond to the
+*typedef-name*s `int_leastN_t` and `uint_leastN_t`,
+respectively. — *end note*]
+### Header `<stdfloat>` synopsis <a id="stdfloat.syn">[[stdfloat.syn]]</a>
+The header `<stdfloat>` defines type aliases for the optional extended
+floating-point types that are specified in [[basic.extended.fp]].
+``` cpp
+namespace std {
+  #if defined(__STDCPP_FLOAT16_T__)
+    using float16_t  = implementation-defined;  // see [basic.extended.fp]
+  #endif
+  #if defined(__STDCPP_FLOAT32_T__)
+    using float32_t  = implementation-defined;  // see [basic.extended.fp]
+  #endif
+  #if defined(__STDCPP_FLOAT64_T__)
+    using float64_t  = implementation-defined;  // see [basic.extended.fp]
+  #endif
+  #if defined(__STDCPP_FLOAT128_T__)
+    using float128_t = implementation-defined; // see [basic.extended.fp]
+  #endif
+  #if defined(__STDCPP_BFLOAT16_T__)
+    using bfloat16_t = implementation-defined; // see [basic.extended.fp]
+  #endif
+}
+```
 ## Startup and termination <a id="support.start.term">[[support.start.term]]</a>
 [*Note 1*: The header `<cstdlib>` declares the functions described in
 this subclause. — *end note*]
 *Effects:*
 - First, objects with thread storage duration and associated with the
   current thread are destroyed. Next, objects with static storage
   duration are destroyed and functions registered by calling `atexit`
+  are called.[^28] See  [[basic.start.term]] for the order of
   destructions and calls. (Objects with automatic storage duration are
+  not destroyed as a result of calling `exit()`.)[^29] If a registered
+  function invoked by `exit` exits via an exception, the function
+ `std::terminate` is invoked [[except.terminate]].
 - Next, all open C streams (as mediated by the function signatures
   declared in `<cstdio>`) with unwritten buffered data are flushed, all
   open C streams are closed, and all files created by calling
   `tmpfile()` are removed.
 - Finally, control is returned to the host environment. If `status` is
   zero or `EXIT_SUCCESS`, an *implementation-defined* form of the status
   *successful termination* is returned. If `status` is `EXIT_FAILURE`,
   an *implementation-defined* form of the status *unsuccessful
   termination* is returned. Otherwise the status returned is
+  *implementation-defined*.[^30]
 ``` cpp
 int at_quick_exit(c-atexit-handler* f) noexcept;
 int at_quick_exit(atexit-handler* f) noexcept;
 ```
 before [[intro.multithread]] all calls to `quick_exit` will succeed.
 [*Note 2*: The `at_quick_exit()` functions do not introduce a data
 race [[res.on.data.races]]. — *end note*]
+[*Note 3*: The order of registration could be indeterminate if
 `at_quick_exit` was called from more than one thread. — *end note*]
 [*Note 4*: The `at_quick_exit` registrations are distinct from the
+`atexit` registrations, and applications might need to call both
 registration functions with the same argument. — *end note*]
 *Implementation limits:* The implementation shall support the
 registration of at least 32 functions.
 *Effects:* Functions registered by calls to `at_quick_exit` are called
 in the reverse order of their registration, except that a function shall
 be called after any previously registered functions that had already
 been called at the time it was registered. Objects shall not be
+destroyed as a result of calling `quick_exit`. If a registered function
+invoked by `quick_exit` exits via an exception, the function
+`std::terminate` is invoked [[except.terminate]].
 [*Note 5*: A function registered via `at_quick_exit` is invoked by the
 thread that calls `quick_exit`, which can be a different thread than the
+one that registered it, so registered functions cannot rely on the
 identity of objects with thread storage duration. — *end note*]
 After calling registered functions, `quick_exit` shall call
 `_Exit(status)`.
 See also: ISO C 7.22.4
 ## Dynamic memory management <a id="support.dynamic">[[support.dynamic]]</a>
+### General <a id="support.dynamic.general">[[support.dynamic.general]]</a>
 The header `<new>` defines several functions that manage the allocation
 of dynamic storage in a program. It also defines components for
 reporting storage management errors.
 ### Header `<new>` synopsis <a id="new.syn">[[new.syn]]</a>
 ``` cpp
+// all freestanding
 namespace std {
   // [alloc.errors], storage allocation errors
   class bad_alloc;
   class bad_array_new_length;
 void operator delete[](void* ptr, void*) noexcept;
 ```
 ### Storage allocation and deallocation <a id="new.delete">[[new.delete]]</a>
+#### General <a id="new.delete.general">[[new.delete.general]]</a>
 Except where otherwise specified, the provisions of
 [[basic.stc.dynamic]] apply to the library versions of `operator new`
 and `operator
 delete`. If the value of an alignment argument passed to any of these
 functions is not a valid alignment value, the behavior is undefined.
 void operator delete(void* ptr, std::size_t size) noexcept;
 void operator delete(void* ptr, std::align_val_t alignment) noexcept;
 void operator delete(void* ptr, std::size_t size, std::align_val_t alignment) noexcept;
 ```
+*Preconditions:* `ptr` is a null pointer or its value represents the
+address of a block of memory allocated by an earlier call to a (possibly
+replaced) `operator new(std::size_t)` or
+`operator new(std::size_t, std::align_val_t)` which has not been
+invalidated by an intervening call to `operator delete`.
+If the `alignment` parameter is not present, `ptr` was returned by an
+allocation function without an `alignment` parameter. If present, the
+`alignment` argument is equal to the `alignment` argument passed to the
+allocation function that returned `ptr`. If present, the `size` argument
+is equal to the `size` argument passed to the allocation function that
+returned `ptr`.
 *Effects:* The deallocation functions [[basic.stc.dynamic.deallocation]]
 called by a *delete-expression*[[expr.delete]] to render the value of
 `ptr` invalid.
 *Replaceable:* A C++ program may define functions with any of these
 If a function without a `size` parameter is defined, the program should
 also define the corresponding function with a `size` parameter. If a
 function with a `size` parameter is defined, the program shall also
 define the corresponding version without the `size` parameter.
+[*Note 1*: The default behavior below might change in the future, which
 will require replacing both deallocation functions when replacing the
 allocation function. — *end note*]
 *Required behavior:* A call to an `operator delete` with a `size`
 parameter may be changed to a call to the corresponding
 `operator delete` without a `size` parameter, without affecting memory
 allocation.
 ``` cpp
 void operator delete(void* ptr, const std::nothrow_t&) noexcept;
 void operator delete(void* ptr, std::align_val_t alignment, const std::nothrow_t&) noexcept;
 ```
+*Preconditions:* `ptr` is a null pointer or its value represents the
+address of a block of memory allocated by an earlier call to a (possibly
+replaced) `operator new(std::size_t)` or
+`operator new(std::size_t, std::align_val_t)` which has not been
+invalidated by an intervening call to `operator delete`.
+If the `alignment` parameter is not present, `ptr` was returned by an
+allocation function without an `alignment` parameter. If present, the
+`alignment` argument is equal to the `alignment` argument passed to the
+allocation function that returned `ptr`.
 *Effects:* The deallocation functions [[basic.stc.dynamic.deallocation]]
 called by the implementation to render the value of `ptr` invalid when
 the constructor invoked from a nothrow placement version of the
 *new-expression* throws an exception.
 *Replaceable:* A C++ program may define functions with either of these
 function signatures, and thereby displace the default versions defined
 by the C++ standard library.
 *Default behavior:* Calls `operator delete(ptr)`, or
 `operator delete(ptr, alignment)`, respectively.
 #### Array forms <a id="new.delete.array">[[new.delete.array]]</a>
 ```
 *Effects:* The allocation functions [[basic.stc.dynamic.allocation]]
 called by the array form of a *new-expression*[[expr.new]] to allocate
 `size` bytes of storage. The second form is called for a type with
+new-extended alignment, and the first form is called otherwise.[^31]
 *Replaceable:* A C++ program may define functions with either of these
 function signatures, and thereby displace the default versions defined
 by the C++ standard library.
 void operator delete[](void* ptr, std::size_t size) noexcept;
 void operator delete[](void* ptr, std::align_val_t alignment) noexcept;
 void operator delete[](void* ptr, std::size_t size, std::align_val_t alignment) noexcept;
 ```
+*Preconditions:* `ptr` is a null pointer or its value represents the
+address of a block of memory allocated by an earlier call to a (possibly
+replaced) `operator new[](std::size_t)` or
+`operator new[](std::size_t, std::align_val_t)` which has not been
+invalidated by an intervening call to `operator delete[]`.
+If the `alignment` parameter is not present, `ptr` was returned by an
+allocation function without an `alignment` parameter. If present, the
+`alignment` argument is equal to the `alignment` argument passed to the
+allocation function that returned `ptr`. If present, the `size` argument
+is equal to the `size` argument passed to the allocation function that
+returned `ptr`.
 *Effects:* The deallocation functions [[basic.stc.dynamic.deallocation]]
 called by the array form of a *delete-expression* to render the value of
 `ptr` invalid.
 *Replaceable:* A C++ program may define functions with any of these
 If a function without a `size` parameter is defined, the program should
 also define the corresponding function with a `size` parameter. If a
 function with a `size` parameter is defined, the program shall also
 define the corresponding version without the `size` parameter.
+[*Note 1*: The default behavior below might change in the future, which
 will require replacing both deallocation functions when replacing the
 allocation function. — *end note*]
 *Required behavior:* A call to an `operator delete[]` with a `size`
 parameter may be changed to a call to the corresponding
 `operator delete[]` without a `size` parameter, without affecting memory
 allocation.
 ``` cpp
 void operator delete[](void* ptr, const std::nothrow_t&) noexcept;
 void operator delete[](void* ptr, std::align_val_t alignment, const std::nothrow_t&) noexcept;
 ```
+*Preconditions:* `ptr` is a null pointer or its value represents the
+address of a block of memory allocated by an earlier call to a (possibly
+replaced) `operator new[](std::size_t)` or
+`operator new[](std::size_t, std::align_val_t)` which has not been
+invalidated by an intervening call to `operator delete[]`.
+If the `alignment` parameter is not present, `ptr` was returned by an
+allocation function without an `alignment` parameter. If present, the
+`alignment` argument is equal to the `alignment` argument passed to the
+allocation function that returned `ptr`.
 *Effects:* The deallocation functions [[basic.stc.dynamic.deallocation]]
 called by the implementation to render the value of `ptr` invalid when
 the constructor invoked from a nothrow placement version of the array
 *new-expression* throws an exception.
 *Replaceable:* A C++ program may define functions with either of these
 function signatures, and thereby displace the default versions defined
 by the C++ standard library.
 *Default behavior:* Calls `operator delete[](ptr)`, or
 `operator delete[](ptr, alignment)`, respectively.
 #### Non-allocating forms <a id="new.delete.placement">[[new.delete.placement]]</a>
 void operator delete(void* ptr, void*) noexcept;
 ```
 *Effects:* Intentionally performs no action.
 *Remarks:* Default function called when any part of the initialization
 in a placement *new-expression* that invokes the library’s non-array
 placement operator new terminates by throwing an exception [[expr.new]].
 ``` cpp
 void operator delete[](void* ptr, void*) noexcept;
 ```
 *Effects:* Intentionally performs no action.
 *Remarks:* Default function called when any part of the initialization
 in a placement *new-expression* that invokes the library’s array
 placement operator new terminates by throwing an exception [[expr.new]].
 #### Data races <a id="new.delete.dataraces">[[new.delete.dataraces]]</a>
 new_handler get_new_handler() noexcept;
 ```
 *Returns:* The current `new_handler`.
+[*Note 1*: This can be a null pointer value. — *end note*]
 ### Pointer optimization barrier <a id="ptr.launder">[[ptr.launder]]</a>
 ``` cpp
 template<class T> [[nodiscard]] constexpr T* launder(T* p) noexcept;
 *Mandates:* `!is_function_v<T> && !is_void_v<T>` is `true`.
 *Preconditions:* `p` represents the address *A* of a byte in memory. An
 object *X* that is within its lifetime [[basic.life]] and whose type is
 similar [[conv.qual]] to `T` is located at the address *A*. All bytes of
+storage that would be reachable through [[basic.compound]] the result
+are reachable through `p`.
+*Returns:* A value of type `T*` that points to *X*.
 *Remarks:* An invocation of this function may be used in a core constant
+expression if and only if the (converted) value of its argument may be
+used in place of the function invocation.
 [*Note 1*: If a new object is created in storage occupied by an
 existing object of the same type, a pointer to the original object can
 be used to refer to the new object unless its complete object is a const
 object or it is a base class subobject; in the latter cases, this
 — *end example*]
 ## Type identification <a id="support.rtti">[[support.rtti]]</a>
+### General <a id="support.rtti.general">[[support.rtti.general]]</a>
 The header `<typeinfo>` defines a type associated with type information
 generated by the implementation. It also defines two types for reporting
 dynamic type identification errors.
 ### Header `<typeinfo>` synopsis <a id="typeinfo.syn">[[typeinfo.syn]]</a>
 ``` cpp
+// all freestanding
 namespace std {
   class type_info;
   class bad_cast;
   class bad_typeid;
 }
 ``` cpp
 namespace std {
   class type_info {
   public:
     virtual ~type_info();
+ constexpr bool operator==(const type_info& rhs) const noexcept;
     bool before(const type_info& rhs) const noexcept;
     size_t hash_code() const noexcept;
     const char* name() const noexcept;
     type_info(const type_info&) = delete;                   // cannot be copied
 comparing two types for equality or collating order. The names, encoding
 rule, and collating sequence for types are all unspecified and may
 differ between programs.
 ``` cpp
+constexpr bool operator==(const type_info& rhs) const noexcept;
 ```
 *Effects:* Compares the current object with `rhs`.
 *Returns:* `true` if the two values describe the same type.
 *Returns:* An *implementation-defined* NTBS.
 *Remarks:* The message may be a null-terminated multibyte
 string [[multibyte.strings]], suitable for conversion and display as a
+`wstring` [[string.classes]], [[locale.codecvt]].
 ### Class `bad_cast` <a id="bad.cast">[[bad.cast]]</a>
 ``` cpp
 namespace std {
 The header `<source_location>` defines the class `source_location` that
 provides a means to obtain source location information.
 ``` cpp
+// all freestanding
 namespace std {
   struct source_location;
 }
 ```
 ### Class `source_location` <a id="support.srcloc.class">[[support.srcloc.class]]</a>
+#### General <a id="support.srcloc.class.general">[[support.srcloc.class.general]]</a>
 ``` cpp
 namespace std {
   struct source_location {
     // source location construction
     static consteval source_location current() noexcept;
   };
 }
 ```
 The type `source_location` meets the *Cpp17DefaultConstructible*,
+*Cpp17CopyConstructible*, *Cpp17CopyAssignable*, *Cpp17Swappable*, and
+*Cpp17Destructible* requirements
+[[utility.arg.requirements]], [[swappable.requirements]]. All of the
 following conditions are `true`:
 - `is_nothrow_move_constructible_v<source_location>`
 - `is_nothrow_move_assignable_v<source_location>`
 - `is_nothrow_swappable_v<source_location>`
 *Returns:*
 - When invoked by a function call whose *postfix-expression* is a
   (possibly parenthesized) *id-expression* naming `current`, returns a
+  `source_location` with an *implementation-defined* value. The value
   should be affected by `#line` [[cpp.line]] in the same manner as for
   \_\_LINE\_\_ and \_\_FILE\_\_. The values of the exposition-only data
   members of the returned `source_location` object are indicated in
   [[support.srcloc.current]].
 - Otherwise, when invoked in some other way, returns a `source_location`
 ``` cpp
 constexpr source_location() noexcept;
 ```
+*Effects:* The data members are initialized with valid but unspecified
+values.
 #### Observers <a id="support.srcloc.obs">[[support.srcloc.obs]]</a>
 ``` cpp
 constexpr uint_least32_t line() const noexcept;
 *Returns:* `function_name_`.
 ## Exception handling <a id="support.exception">[[support.exception]]</a>
+### General <a id="support.exception.general">[[support.exception.general]]</a>
 The header `<exception>` defines several types and functions related to
 the handling of exceptions in a C++ program.
 ### Header `<exception>` synopsis <a id="exception.syn">[[exception.syn]]</a>
 ``` cpp
+// all freestanding
 namespace std {
   class exception;
   class bad_exception;
   class nested_exception;
 *Returns:* An *implementation-defined* NTBS.
 *Remarks:* The message may be a null-terminated multibyte
 string [[multibyte.strings]], suitable for conversion and display as a
+`wstring` [[string.classes]], [[locale.codecvt]]. The return value
 remains valid until the exception object from which it is obtained is
 destroyed or a non-`const` member function of the exception object is
 called.
 ### Class `bad_exception` <a id="bad.exception">[[bad.exception]]</a>
 ``` cpp
 using terminate_handler = void (*)();
 ```
+The type of a *handler function* to be invoked by `terminate` when
 terminating exception processing.
 *Required behavior:* A `terminate_handler` shall terminate execution of
 the program without returning to the caller.
 ```
 *Effects:* Establishes the function designated by `f` as the current
 handler function for terminating exception processing.
+*Returns:* The previous `terminate_handler`.
 *Remarks:* It is unspecified whether a null pointer value designates the
 default `terminate_handler`.
 #### `get_terminate` <a id="get.terminate">[[get.terminate]]</a>
 ``` cpp
 terminate_handler get_terminate() noexcept;
 ```
 *Returns:* The current `terminate_handler`.
+[*Note 1*: This can be a null pointer value. — *end note*]
 #### `terminate` <a id="terminate">[[terminate]]</a>
 ``` cpp
 [[noreturn]] void terminate() noexcept;
 ```
 *Effects:* Calls a `terminate_handler` function. It is unspecified which
 `terminate_handler` function will be called if an exception is active
 during a call to `set_terminate`. Otherwise calls the current
 `terminate_handler` function.
 [*Note 1*: A default `terminate_handler` is always considered a
 callable handler in this context. — *end note*]
+*Remarks:* Called by the implementation when exception handling must be
+abandoned for any of several reasons [[except.terminate]]. May also be
+called directly by the program.
 ### `uncaught_exceptions` <a id="uncaught.exceptions">[[uncaught.exceptions]]</a>
 ``` cpp
 int uncaught_exceptions() noexcept;
 ```
 the type.
 `exception_ptr` shall not be implicitly convertible to any arithmetic,
 enumeration, or pointer type.
+[*Note 1*: An implementation can use a reference-counted smart pointer
+as `exception_ptr`. — *end note*]
 For purposes of determining the presence of a data race, operations on
 `exception_ptr` objects shall access and modify only the `exception_ptr`
 objects themselves and not the exceptions they refer to. Use of
 `rethrow_exception` on `exception_ptr` objects that refer to the same
 exception object shall not introduce a data race.
 [*Note 2*: If `rethrow_exception` rethrows the same exception object
 (rather than a copy), concurrent access to that rethrown exception
+object can introduce a data race. Changes in the number of
 `exception_ptr` objects that refer to a particular exception do not
 introduce a data race. — *end note*]
 ``` cpp
 exception_ptr current_exception() noexcept;
 If the attempt to copy the current exception object throws an exception,
 the function returns an `exception_ptr` object that refers to the thrown
 exception or, if this is not possible, to an instance of
 `bad_exception`.
+[*Note 4*: The copy constructor of the thrown exception can also fail,
 so the implementation is allowed to substitute a `bad_exception` object
 to avoid infinite recursion. — *end note*]
 ``` cpp
 [[noreturn]] void rethrow_exception(exception_ptr p);
 ```
 *Preconditions:* `p` is not a null pointer.
+*Effects:* Let u be the exception object to which `p` refers, or a copy
+of that exception object. It is unspecified whether a copy is made, and
+memory for the copy is allocated in an unspecified way.
+- If allocating memory to form u fails, throws an instance of
+  `bad_alloc`;
+- otherwise, if copying the exception to which `p` refers to form u
+  throws an exception, throws that exception;
+- otherwise, throws u.
 ``` cpp
 template<class E> exception_ptr make_exception_ptr(E e) noexcept;
 ```
   p->rethrow_nested();
 ```
 ## Initializer lists <a id="support.initlist">[[support.initlist]]</a>
+### General <a id="support.initlist.general">[[support.initlist.general]]</a>
 The header `<initializer_list>` defines a class template and several
 support functions related to list-initialization (see
+[[dcl.init.list]]). All functions specified in [[support.initlist]] are
 signal-safe [[support.signal]].
 ### Header `<initializer_list>` synopsis <a id="initializer.list.syn">[[initializer.list.syn]]</a>
 ``` cpp
+// all freestanding
 namespace std {
   template<class E> class initializer_list {
   public:
     using value_type      = E;
     using reference       = const E&;
 The header `<compare>` specifies types, objects, and functions for use
 primarily in connection with the three-way comparison operator
 [[expr.spaceship]].
 ``` cpp
+// all freestanding
 namespace std {
   // [cmp.categories], comparison category types
   class partial_ordering;
   class weak_ordering;
   class strong_ordering;
 in terms of an exposition-only data member named `value` whose value
 typically corresponds to that of an enumerator from one of the following
 exposition-only enumerations:
 ``` cpp
+enum class ord { equal = 0, equivalent = equal, less = -1, greater = 1 }; // exposition only
 enum class ncmp { unordered = -127 };                                     // exposition only
 ```
 [*Note 1*: The type `strong_ordering` corresponds to the term total
 ordering in mathematics. — *end note*]
 that is accessible via the argument’s public const members.
 #### Class `partial_ordering` <a id="cmp.partialord">[[cmp.partialord]]</a>
 The `partial_ordering` type is typically used as the result type of a
+three-way comparison operator [[expr.spaceship]] for a type that admits
+all of the six two-way comparison operators [[expr.rel]], [[expr.eq]],
+for which equality need not imply substitutability, and that permits two
+values to be incomparable.[^32]
 ``` cpp
 namespace std {
   class partial_ordering {
     int value;          // exposition only
     bool is_ordered;    // exposition only
     // exposition-only constructors
     constexpr explicit
       partial_ordering(ord v) noexcept : value(int(v)), is_ordered(true) {}     // exposition only
     constexpr explicit
       partial_ordering(ncmp v) noexcept : value(int(v)), is_ordered(false) {}   // exposition only
     friend constexpr partial_ordering operator<=>(unspecified, partial_ordering v) noexcept;
   };
   // valid values' definitions
   inline constexpr partial_ordering partial_ordering::less(ord::less);
+  inline constexpr partial_ordering partial_ordering::equivalent(ord::equivalent);
   inline constexpr partial_ordering partial_ordering::greater(ord::greater);
   inline constexpr partial_ordering partial_ordering::unordered(ncmp::unordered);
 }
 ```
 `v < 0 ? partial_ordering::greater : v > 0 ? partial_ordering::less : v`.
 #### Class `weak_ordering` <a id="cmp.weakord">[[cmp.weakord]]</a>
 The `weak_ordering` type is typically used as the result type of a
+three-way comparison operator [[expr.spaceship]] for a type that admits
+all of the six two-way comparison operators [[expr.rel]], [[expr.eq]]
+and for which equality need not imply substitutability.
 ``` cpp
 namespace std {
   class weak_ordering {
     int value;  // exposition only
     // exposition-only constructors
     constexpr explicit weak_ordering(ord v) noexcept : value(int(v)) {} // exposition only
   public:
     // valid values
     static const weak_ordering less;
     friend constexpr weak_ordering operator<=>(unspecified, weak_ordering v) noexcept;
   };
   // valid values' definitions
   inline constexpr weak_ordering weak_ordering::less(ord::less);
+  inline constexpr weak_ordering weak_ordering::equivalent(ord::equivalent);
   inline constexpr weak_ordering weak_ordering::greater(ord::greater);
 }
 ```
 ``` cpp
 `v < 0 ? weak_ordering::greater : v > 0 ? weak_ordering::less : v`.
 #### Class `strong_ordering` <a id="cmp.strongord">[[cmp.strongord]]</a>
 The `strong_ordering` type is typically used as the result type of a
+three-way comparison operator [[expr.spaceship]] for a type that admits
+all of the six two-way comparison operators [[expr.rel]], [[expr.eq]]
+and for which equality does imply substitutability.
 ``` cpp
 namespace std {
   class strong_ordering {
     int value;  // exposition only
     // exposition-only constructors
     constexpr explicit strong_ordering(ord v) noexcept : value(int(v)) {}   // exposition only
   public:
     // valid values
     static const strong_ordering less;
     friend constexpr strong_ordering operator<=>(unspecified, strong_ordering v) noexcept;
   };
   // valid values' definitions
   inline constexpr strong_ordering strong_ordering::less(ord::less);
+  inline constexpr strong_ordering strong_ordering::equal(ord::equal);
+  inline constexpr strong_ordering strong_ordering::equivalent(ord::equivalent);
   inline constexpr strong_ordering strong_ordering::greater(ord::greater);
 }
 ```
 ``` cpp
 type.
 [*Note 1*: This is `std::strong_ordering` if the expansion is
 empty. — *end note*]
+### Concept <a id="cmp.concept">[[cmp.concept]]</a>
 ``` cpp
 template<class T, class Cat>
   concept compares-as =                 // exposition only
     same_as<common_comparison_category_t<T, Cat>, Cat>;
 ``` cpp
 template<class T, class U, class Cat = partial_ordering>
   concept three_way_comparable_with =
     three_way_comparable<T, Cat> &&
     three_way_comparable<U, Cat> &&
+ comparison-common-type-with<T, U> &&
     three_way_comparable<
       common_reference_t<const remove_reference_t<T>&, const remove_reference_t<U>&>, Cat> &&
     weakly-equality-comparable-with<T, U> &&
     partially-ordered-with<T, U> &&
     requires(const remove_reference_t<T>& t, const remove_reference_t<U>& u) {
       { t <=> u } -> compares-as<Cat>;
       { u <=> t } -> compares-as<Cat>;
     };
 ```
+Let `t` and `t2` be lvalues denoting distinct equal objects of types
+`const remove_reference_t<T>` and `remove_cvref_t<T>`, respectively, and
+let `u` and `u2` be lvalues denoting distinct equal objects of types
+`const remove_reference_t<U>` and `remove_cvref_t<U>`, respectively. Let
+`C` be
 `common_reference_t<const remove_reference_t<T>&, const remove_reference_t<U>&>`.
+Let `CONVERT_TO_LVALUE<C>(E)` be defined as in
+[[concepts.compare.general]]. `T`, `U`, and `Cat` model
+`three_way_comparable_with<T, U, Cat>` only if:
 - `t <=> u` and `u <=> t` have the same domain,
 - `((t <=> u) <=> 0)` and `(0 <=> (u <=> t))` are equal,
 - `(t <=> u == 0) == bool(t == u)` is `true`,
 - `(t <=> u != 0) == bool(t != u)` is `true`,
+- `Cat(t <=> u) == Cat(CONVERT_TO_LVALUE<C>(t2) <=>
+  CONVERT_TO_LVALUE<C>(u2))` is `true`,
 - `(t <=> u < 0) == bool(t < u)` is `true`,
 - `(t <=> u > 0) == bool(t > u)` is `true`,
 - `(t <=> u <= 0) == bool(t <= u)` is `true`,
 - `(t <=> u >= 0) == bool(t >= u)` is `true`, and
 - if `Cat` is convertible to `strong_ordering`, `T` and `U` model
 ### Comparison algorithms <a id="cmp.alg">[[cmp.alg]]</a>
 The name `strong_order` denotes a customization point object
 [[customization.point.object]]. Given subexpressions `E` and `F`, the
 expression `strong_order(E, F)` is expression-equivalent
+[[defns.expression.equivalent]] to the following:
 - If the decayed types of `E` and `F` differ, `strong_order(E, F)` is
   ill-formed.
 - Otherwise, `strong_ordering(strong_order(E, F))` if it is a
+  well-formed expression where the meaning of `strong_order` is
+ established as-if by performing argument-dependent lookup only
+  [[basic.lookup.argdep]].
 - Otherwise, if the decayed type `T` of `E` is a floating-point type,
   yields a value of type `strong_ordering` that is consistent with the
   ordering observed by `T`’s comparison operators, and if
   `numeric_limits<T>::is_iec559` is `true`, is additionally consistent
   with the `totalOrder` operation as specified in ISO/IEC/IEEE 60559.
 - Otherwise, `strong_ordering(compare_three_way()(E, F))` if it is a
   well-formed expression.
+- Otherwise, `strong_order(E, F)` is ill-formed.
+[*Note 1*: Ill-formed cases above result in substitution failure when
+`strong_order(E, F)` appears in the immediate context of a template
+instantiation. — *end note*]
 The name `weak_order` denotes a customization point object
 [[customization.point.object]]. Given subexpressions `E` and `F`, the
 expression `weak_order(E, F)` is expression-equivalent
+[[defns.expression.equivalent]] to the following:
 - If the decayed types of `E` and `F` differ, `weak_order(E, F)` is
   ill-formed.
 - Otherwise, `weak_ordering(weak_order(E, F))` if it is a well-formed
+  expression where the meaning of `weak_order` is established as-if by
+ performing argument-dependent lookup only [[basic.lookup.argdep]].
 - Otherwise, if the decayed type `T` of `E` is a floating-point type,
   yields a value of type `weak_ordering` that is consistent with the
   ordering observed by `T`’s comparison operators and `strong_order`,
   and if `numeric_limits<T>::is_iec559` is `true`, is additionally
   consistent with the following equivalence classes, ordered from lesser
   - together, all positive NaN values.
 - Otherwise, `weak_ordering(compare_three_way()(E, F))` if it is a
   well-formed expression.
 - Otherwise, `weak_ordering(strong_order(E, F))` if it is a well-formed
   expression.
+- Otherwise, `weak_order(E, F)` is ill-formed.
+[*Note 2*: Ill-formed cases above result in substitution failure when
+`weak_order(E, F)` appears in the immediate context of a template
+instantiation. — *end note*]
 The name `partial_order` denotes a customization point object
 [[customization.point.object]]. Given subexpressions `E` and `F`, the
 expression `partial_order(E, F)` is expression-equivalent
+[[defns.expression.equivalent]] to the following:
 - If the decayed types of `E` and `F` differ, `partial_order(E, F)` is
   ill-formed.
 - Otherwise, `partial_ordering(partial_order(E, F))` if it is a
+  well-formed expression where the meaning of `partial_order` is
+ established as-if by performing argument-dependent lookup only
+  [[basic.lookup.argdep]].
 - Otherwise, `partial_ordering(compare_three_way()(E, F))` if it is a
   well-formed expression.
 - Otherwise, `partial_ordering(weak_order(E, F))` if it is a well-formed
   expression.
+- Otherwise, `partial_order(E, F)` is ill-formed.
+[*Note 3*: Ill-formed cases above result in substitution failure when
+`partial_order(E, F)` appears in the immediate context of a template
 instantiation. — *end note*]
 The name `compare_strong_order_fallback` denotes a customization point
+object [[customization.point.object]]. Given subexpressions `E` and `F`,
 the expression `compare_strong_order_fallback(E, F)` is
+expression-equivalent [[defns.expression.equivalent]] to:
 - If the decayed types of `E` and `F` differ,
   `compare_strong_order_fallback(E, F)` is ill-formed.
 - Otherwise, `strong_order(E, F)` if it is a well-formed expression.
 - Otherwise, if the expressions `E == F` and `E < F` are both
+  well-formed and each of `decltype(E == F)` and `decltype(E < F)`
+  models `boolean-testable`,
   ``` cpp
   E == F ? strong_ordering::equal :
   E < F  ? strong_ordering::less :
            strong_ordering::greater
   ```
   except that `E` and `F` are evaluated only once.
 - Otherwise, `compare_strong_order_fallback(E, F)` is ill-formed.
+[*Note 4*: Ill-formed cases above result in substitution failure when
+`compare_strong_order_fallback(E, F)` appears in the immediate context
+of a template instantiation. — *end note*]
 The name `compare_weak_order_fallback` denotes a customization point
 object [[customization.point.object]]. Given subexpressions `E` and `F`,
 the expression `compare_weak_order_fallback(E, F)` is
+expression-equivalent [[defns.expression.equivalent]] to:
 - If the decayed types of `E` and `F` differ,
   `compare_weak_order_fallback(E, F)` is ill-formed.
 - Otherwise, `weak_order(E, F)` if it is a well-formed expression.
 - Otherwise, if the expressions `E == F` and `E < F` are both
+  well-formed and each of `decltype(E == F)` and `decltype(E < F)`
+  models `boolean-testable`,
   ``` cpp
   E == F ? weak_ordering::equivalent :
   E < F  ? weak_ordering::less :
            weak_ordering::greater
   ```
   except that `E` and `F` are evaluated only once.
 - Otherwise, `compare_weak_order_fallback(E, F)` is ill-formed.
+[*Note 5*: Ill-formed cases above result in substitution failure when
+`compare_weak_order_fallback(E, F)` appears in the immediate context of
+a template instantiation. — *end note*]
 The name `compare_partial_order_fallback` denotes a customization point
 object [[customization.point.object]]. Given subexpressions `E` and `F`,
 the expression `compare_partial_order_fallback(E, F)` is
+expression-equivalent [[defns.expression.equivalent]] to:
 - If the decayed types of `E` and `F` differ,
   `compare_partial_order_fallback(E, F)` is ill-formed.
 - Otherwise, `partial_order(E, F)` if it is a well-formed expression.
+- Otherwise, if the expressions `E == F`, `E < F`, and `F < E` are all
+  well-formed and each of `decltype(E == F)` and `decltype(E < F)`
+  models `boolean-testable`,
   ``` cpp
   E == F ? partial_ordering::equivalent :
   E < F  ? partial_ordering::less :
   F < E  ? partial_ordering::greater :
            partial_ordering::unordered
   ```
   except that `E` and `F` are evaluated only once.
 - Otherwise, `compare_partial_order_fallback(E, F)` is ill-formed.
+[*Note 6*: Ill-formed cases above result in substitution failure when
+`compare_partial_order_fallback(E, F)` appears in the immediate context
+of a template instantiation. — *end note*]
 ## Coroutines <a id="support.coroutine">[[support.coroutine]]</a>
+### General <a id="support.coroutine.general">[[support.coroutine.general]]</a>
 The header `<coroutine>` defines several types providing compile and
 run-time support for coroutines in a C++ program.
 ### Header `<coroutine>` synopsis <a id="coroutine.syn">[[coroutine.syn]]</a>
 ``` cpp
+// all freestanding
 #include <compare>              // see [compare.syn]
 namespace std {
   // [coroutine.traits], coroutine traits
   template<class R, class... ArgTypes>
 }
 ```
 ### Coroutine traits <a id="coroutine.traits">[[coroutine.traits]]</a>
+#### General <a id="coroutine.traits.general">[[coroutine.traits.general]]</a>
+Subclause [[coroutine.traits]] defines requirements on classes
+representing *coroutine traits*, and defines the class template
+`coroutine_traits` that meets those requirements.
 #### Class template `coroutine_traits` <a id="coroutine.traits.primary">[[coroutine.traits.primary]]</a>
 The header `<coroutine>` defines the primary template `coroutine_traits`
 such that if `ArgTypes` is a parameter pack of types and if the
 Program-defined specializations of this template shall define a publicly
 accessible nested type named `promise_type`.
 ### Class template `coroutine_handle` <a id="coroutine.handle">[[coroutine.handle]]</a>
+#### General <a id="coroutine.handle.general">[[coroutine.handle.general]]</a>
 ``` cpp
 namespace std {
   template<>
   struct coroutine_handle<void>
   {
   private:
     void* ptr;  // exposition only
   };
   template<class Promise>
+  struct coroutine_handle
   {
     // [coroutine.handle.con], construct/reset
+ constexpr coroutine_handle() noexcept;
+    constexpr coroutine_handle(nullptr_t) noexcept;
     static coroutine_handle from_promise(Promise&);
     coroutine_handle& operator=(nullptr_t) noexcept;
     // [coroutine.handle.export.import], export/import
+    constexpr void* address() const noexcept;
     static constexpr coroutine_handle from_address(void* addr);
+    // [coroutine.handle.conv], conversion
+    constexpr operator coroutine_handle<>() const noexcept;
+    // [coroutine.handle.observers], observers
+    constexpr explicit operator bool() const noexcept;
+    bool done() const;
+    // [coroutine.handle.resumption], resumption
+    void operator()() const;
+    void resume() const;
+    void destroy() const;
     // [coroutine.handle.promise], promise access
     Promise& promise() const;
+  private:
+    void* ptr;  // exposition only
   };
 }
 ```
 An object of type `coroutine_handle<T>` is called a *coroutine handle*
 and can be used to refer to a suspended or executing coroutine. A
+`coroutine_handle` object whose member `address()` returns a null
+pointer value does not refer to any coroutine. Two `coroutine_handle`
+objects refer to the same coroutine if and only if their member
+`address()` returns the same non-null value.
 If a program declares an explicit or partial specialization of
 `coroutine_handle`, the behavior is undefined.
 #### Construct/reset <a id="coroutine.handle.con">[[coroutine.handle.con]]</a>
 static coroutine_handle from_promise(Promise& p);
 ```
 *Preconditions:* `p` is a reference to a promise object of a coroutine.
 *Ensures:* `addressof(h.promise()) == addressof(p)`.
+*Returns:* A coroutine handle `h` referring to the coroutine.
 ``` cpp
 coroutine_handle& operator=(nullptr_t) noexcept;
 ```
 *Ensures:* `address() == nullptr`.
 *Returns:* `*this`.
+#### Conversion <a id="coroutine.handle.conv">[[coroutine.handle.conv]]</a>
+``` cpp
+constexpr operator coroutine_handle<>() const noexcept;
+```
+*Effects:* Equivalent to:
+`return coroutine_handle<>::from_address(address());`
 #### Export/import <a id="coroutine.handle.export.import">[[coroutine.handle.export.import]]</a>
 ``` cpp
 constexpr void* address() const noexcept;
 ```
 *Returns:* `ptr`.
 ``` cpp
 static constexpr coroutine_handle<> coroutine_handle<>::from_address(void* addr);
+```
+*Preconditions:* `addr` was obtained via a prior call to `address` on an
+object whose type is a specialization of `coroutine_handle`.
+*Ensures:* `from_address(address()) == *this`.
+``` cpp
 static constexpr coroutine_handle<Promise> coroutine_handle<Promise>::from_address(void* addr);
 ```
+*Preconditions:* `addr` was obtained via a prior call to `address` on an
+object of type cv `coroutine_handle<Promise>`.
 *Ensures:* `from_address(address()) == *this`.
 #### Observers <a id="coroutine.handle.observers">[[coroutine.handle.observers]]</a>
 #### Resumption <a id="coroutine.handle.resumption">[[coroutine.handle.resumption]]</a>
 Resuming a coroutine via `resume`, `operator()`, or `destroy` on an
 execution agent other than the one on which it was suspended has
+*implementation-defined* behavior unless each execution agent either is
+an instance of `std::thread` or `std::jthread`, or is the thread that
 executes `main`.
 [*Note 1*: A coroutine that is resumed on a different execution agent
 should avoid relying on consistent thread identity throughout, such as
 holding a mutex object across a suspend point. — *end note*]
+[*Note 2*: A concurrent resumption of the coroutine can result in a
 data race. — *end note*]
 ``` cpp
 void operator()() const;
 void resume() const;
 #### Class `coroutine_handle<noop_coroutine_promise>` <a id="coroutine.handle.noop">[[coroutine.handle.noop]]</a>
 ``` cpp
 namespace std {
   template<>
+  struct coroutine_handle<noop_coroutine_promise>
   {
+    // [coroutine.handle.noop.conv], conversion
+    constexpr operator coroutine_handle<>() const noexcept;
     // [coroutine.handle.noop.observers], observers
     constexpr explicit operator bool() const noexcept;
     constexpr bool done() const noexcept;
     // [coroutine.handle.noop.resumption], resumption
     // [coroutine.handle.noop.address], address
     constexpr void* address() const noexcept;
   private:
     coroutine_handle(unspecified);
+    void* ptr;  // exposition only
   };
 }
 ```
+##### Conversion <a id="coroutine.handle.noop.conv">[[coroutine.handle.noop.conv]]</a>
+``` cpp
+constexpr operator coroutine_handle<>() const noexcept;
+```
+*Effects:* Equivalent to:
+`return coroutine_handle<>::from_address(address());`
 ##### Observers <a id="coroutine.handle.noop.observers">[[coroutine.handle.noop.observers]]</a>
 ``` cpp
 constexpr explicit operator bool() const noexcept;
 ```
   };
 }
 ```
 [*Note 1*: The types `suspend_never` and `suspend_always` can be used
+to indicate that an *await-expression* either never suspends or always
+suspends, and in either case does not produce a value. — *end note*]
 ## Other runtime support <a id="support.runtime">[[support.runtime]]</a>
+### General <a id="support.runtime.general">[[support.runtime.general]]</a>
 Headers `<csetjmp>` (nonlocal jumps), `<csignal>` (signal handling),
 `<cstdarg>` (variable arguments), and `<cstdlib>` (runtime environment
 `getenv`, `system`), provide further compatibility with C code.
 Calls to the function `getenv` [[cstdlib.syn]] shall not introduce a
 the `setlocale` function.
 ### Header `<cstdarg>` synopsis <a id="cstdarg.syn">[[cstdarg.syn]]</a>
 ``` cpp
+// all freestanding
 namespace std {
   using va_list = see below;
 }
 #define va_arg(V, P) see below
 #define va_end(V) see below
 #define va_start(V, P) see below
 ```
 The contents of the header `<cstdarg>` are the same as the C standard
+library header `<stdarg.h>`, with the following changes:
+- In lieu of the default argument promotions specified in ISO C 6.5.2.2,
+ the definition in  [[expr.call]] applies.
+- The restrictions that ISO C places on the second parameter to the
+ `va_start` macro in header `<stdarg.h>` are different in this
+  document. The parameter `parmN` is the rightmost parameter in the
+  variable parameter list of the function definition (the one just
+  before the `...`).[^33] If the parameter `parmN` is a pack expansion
+  [[temp.variadic]] or an entity resulting from a lambda capture
+  [[expr.prim.lambda]], the program is ill-formed, no diagnostic
+  required. If the parameter `parmN` is of a reference type, or of a
+  type that is not compatible with the type that results when passing an
+  argument for which there is no parameter, the behavior is undefined.
 See also: ISO C 7.16.1.1
 ### Header `<csetjmp>` synopsis <a id="csetjmp.syn">[[csetjmp.syn]]</a>
 A *plain lock-free atomic operation* is an invocation of a function `f`
 from [[atomics]], such that:
 - `f` is the function `atomic_is_lock_free()`, or
 - `f` is the member function `is_lock_free()`, or
+- `f` is a non-static member function of class `atomic_flag`, or
+- `f` is a non-member function, and the first parameter of `f` has type
+  cv `atomic_flag*`, or
 - `f` is a non-static member function invoked on an object `A`, such
   that `A.is_lock_free()` yields `true`, or
 - `f` is a non-member function, and for every pointer-to-atomic argument
   `A` passed to `f`, `atomic_is_lock_free(A)` yields `true`.
 - an access to an object with thread storage duration;
 - a `dynamic_cast` expression;
 - throwing of an exception;
 - control entering a *try-block* or *function-try-block*;
 - initialization of a variable with static storage duration requiring
+  dynamic initialization [[basic.start.dynamic]], [[stmt.dcl]][^34] ; or
 - waiting for the completion of the initialization of a variable with
   static storage duration [[stmt.dcl]].
 A signal handler invocation has undefined behavior if it includes an
 evaluation that is not signal-safe.
 argument equal to the signal number corresponding to the signal that
 caused the invocation of the handler.
 See also: ISO C 7.14
+## C headers <a id="support.c.headers">[[support.c.headers]]</a>
+### General <a id="support.c.headers.general">[[support.c.headers.general]]</a>
+For compatibility with the C standard library, the C++ standard library
+provides the *C headers* shown in [[c.headers]]. The intended use of
+these headers is for interoperability only. It is possible that C++
+source files need to include one of these headers in order to be valid
+ISO C. Source files that are not intended to also be valid ISO C should
+not use any of the C headers.
+[*Note 1*: The C headers either have no effect, such as `<stdbool.h>`
+and `<stdalign.h>`, or otherwise the corresponding header of the form
+`<cname>` provides the same facilities and assuredly defines them in
+namespace `std`. — *end note*]
+[*Example 1*:
+The following source file is both valid C++ and valid ISO C. Viewed as
+C++, it declares a function with C language linkage; viewed as C it
+simply declares a function (and provides a prototype).
+``` cpp
+#include <stdbool.h>    // for bool in C, no effect in C++{}
+#include <stddef.h>     // for size_t
+#ifdef __cplusplus      // see [cpp.predefined]
+extern "C"              // see [dcl.link]
+#endif
+void f(bool b[], size_t n);
+```
+— *end example*]
+### Header `<complex.h>` synopsis <a id="complex.h.syn">[[complex.h.syn]]</a>
+``` cpp
+#include <complex>
+```
+The header `<complex.h>` behaves as if it simply includes the header
+`<complex>`.
+[*Note 1*: Names introduced by `<complex>` in namespace `std` are not
+placed into the global namespace scope by `<complex.h>`. — *end note*]
+### Header `<iso646.h>` synopsis <a id="iso646.h.syn">[[iso646.h.syn]]</a>
+The C++ header `<iso646.h>` is empty.
+[*Note 1*: `and`, `and_eq`, `bitand`, `bitor`, `compl`, `not_eq`,
+`not`, `or`, `or_eq`, `xor`, and `xor_eq` are keywords in C++
+[[lex.key]]. — *end note*]
+### Header `<stdalign.h>` synopsis <a id="stdalign.h.syn">[[stdalign.h.syn]]</a>
+The contents of the C++ header `<stdalign.h>` are the same as the C
+standard library header `<stdalign.h>`, with the following changes: The
+header `<stdalign.h>` does not define a macro named `alignas`.
+See also: ISO C 7.15
+### Header `<stdbool.h>` synopsis <a id="stdbool.h.syn">[[stdbool.h.syn]]</a>
+The contents of the C++ header `<stdbool.h>` are the same as the C
+standard library header `<stdbool.h>`, with the following changes: The
+header `<stdbool.h>` does not define macros named `bool`, `true`, or
+`false`.
+See also: ISO C 7.18
+### Header `<tgmath.h>` synopsis <a id="tgmath.h.syn">[[tgmath.h.syn]]</a>
+``` cpp
+#include <cmath>
+#include <complex>
+```
+The header `<tgmath.h>` behaves as if it simply includes the headers
+`<cmath>` and `<complex>`.
+[*Note 1*: The overloads provided in C by type-generic macros are
+already provided in `<complex>` and `<cmath>` by “sufficient” additional
+overloads. — *end note*]
+[*Note 2*: Names introduced by `<cmath>` or `<complex>` in namespace
+`std` are not placed into the global namespace scope by
+`<tgmath.h>`. — *end note*]
+### Other C headers <a id="support.c.headers.other">[[support.c.headers.other]]</a>
+Every C header other than `<complex.h>`, `<iso646.h>`, `<stdalign.h>`,
+`<stdatomic.h>`, `<stdbool.h>`, and `<tgmath.h>`, each of which has a
+name of the form `<name.h>`, behaves as if each name placed in the
+standard library namespace by the corresponding `<cname>` header is
+placed within the global namespace scope, except for the functions
+described in [[sf.cmath]], the `std::lerp` function overloads
+[[c.math.lerp]], the declaration of `std::byte` [[cstddef.syn]], and the
+functions and function templates described in [[support.types.byteops]].
+It is unspecified whether these names are first declared or defined
+within namespace scope [[basic.scope.namespace]] of the namespace `std`
+and are then injected into the global namespace scope by explicit
+*using-declaration*s [[namespace.udecl]].
+[*Example 1*: The header `<cstdlib>` assuredly provides its
+declarations and definitions within the namespace `std`. It may also
+provide these names within the global namespace. The header `<stdlib.h>`
+assuredly provides the same declarations and definitions within the
+global namespace, much as in the C Standard. It may also provide these
+names within the namespace `std`. — *end example*]
 <!-- Link reference definitions -->
 [alg.c.library]: algorithms.md#alg.c.library
 [alloc.errors]: #alloc.errors
+[atomics]: thread.md#atomics
 [bad.alloc]: #bad.alloc
 [bad.cast]: #bad.cast
 [bad.exception]: #bad.exception
 [bad.typeid]: #bad.typeid
 [basic.align]: basic.md#basic.align
+[basic.compound]: basic.md#basic.compound
+[basic.extended.fp]: basic.md#basic.extended.fp
 [basic.fundamental]: basic.md#basic.fundamental
 [basic.life]: basic.md#basic.life
+[basic.lookup.argdep]: basic.md#basic.lookup.argdep
+[basic.scope.namespace]: basic.md#basic.scope.namespace
 [basic.start.dynamic]: basic.md#basic.start.dynamic
 [basic.start.term]: basic.md#basic.start.term
 [basic.stc.dynamic]: basic.md#basic.stc.dynamic
 [basic.stc.dynamic.allocation]: basic.md#basic.stc.dynamic.allocation
 [basic.stc.dynamic.deallocation]: basic.md#basic.stc.dynamic.deallocation
+[c.headers]: #c.headers
 [c.locales]: localization.md#c.locales
+[c.malloc]: mem.md#c.malloc
 [c.math.abs]: numerics.md#c.math.abs
+[c.math.lerp]: numerics.md#c.math.lerp
 [c.math.rand]: numerics.md#c.math.rand
 [c.mb.wcs]: strings.md#c.mb.wcs
 [cfloat.syn]: #cfloat.syn
 [class.mem]: class.md#class.mem
 [class.prop]: class.md#class.prop
 [cmp.result]: #cmp.result
 [cmp.strongord]: #cmp.strongord
 [cmp.weakord]: #cmp.weakord
 [compare.syn]: #compare.syn
 [complex]: numerics.md#complex
+[complex.h.syn]: #complex.h.syn
 [concept.totallyordered]: concepts.md#concept.totallyordered
+[concepts.compare.general]: concepts.md#concepts.compare.general
 [constraints]: library.md#constraints
+[conv.prom]: expr.md#conv.prom
 [conv.ptr]: expr.md#conv.ptr
 [conv.qual]: expr.md#conv.qual
 [conv.rank]: basic.md#conv.rank
 [coroutine.handle]: #coroutine.handle
 [coroutine.handle.compare]: #coroutine.handle.compare
 [coroutine.handle.con]: #coroutine.handle.con
+[coroutine.handle.conv]: #coroutine.handle.conv
 [coroutine.handle.export.import]: #coroutine.handle.export.import
+[coroutine.handle.general]: #coroutine.handle.general
 [coroutine.handle.hash]: #coroutine.handle.hash
 [coroutine.handle.noop]: #coroutine.handle.noop
 [coroutine.handle.noop.address]: #coroutine.handle.noop.address
+[coroutine.handle.noop.conv]: #coroutine.handle.noop.conv
 [coroutine.handle.noop.observers]: #coroutine.handle.noop.observers
 [coroutine.handle.noop.promise]: #coroutine.handle.noop.promise
 [coroutine.handle.noop.resumption]: #coroutine.handle.noop.resumption
 [coroutine.handle.observers]: #coroutine.handle.observers
 [coroutine.handle.promise]: #coroutine.handle.promise
 [coroutine.noop]: #coroutine.noop
 [coroutine.noop.coroutine]: #coroutine.noop.coroutine
 [coroutine.promise.noop]: #coroutine.promise.noop
 [coroutine.syn]: #coroutine.syn
 [coroutine.traits]: #coroutine.traits
+[coroutine.traits.general]: #coroutine.traits.general
 [coroutine.traits.primary]: #coroutine.traits.primary
 [coroutine.trivial.awaitables]: #coroutine.trivial.awaitables
 [cpp.line]: cpp.md#cpp.line
 [cpp17.nullablepointer]: #cpp17.nullablepointer
 [csetjmp.syn]: #csetjmp.syn
 [csignal.syn]: #csignal.syn
 [cstdarg.syn]: #cstdarg.syn
 [cstddef.syn]: #cstddef.syn
 [cstdint.syn]: #cstdint.syn
 [cstdlib.syn]: #cstdlib.syn
 [customization.point.object]: library.md#customization.point.object
 [dcl.fct.def.coroutine]: dcl.md#dcl.fct.def.coroutine
 [dcl.fct.default]: dcl.md#dcl.fct.default
 [dcl.init.list]: dcl.md#dcl.init.list
+[defns.expression.equivalent]: intro.md#defns.expression.equivalent
 [except.handle]: except.md#except.handle
 [except.nested]: #except.nested
 [except.spec]: except.md#except.spec
 [except.terminate]: except.md#except.terminate
 [except.uncaught]: except.md#except.uncaught
 [expr.prim.lambda]: expr.md#expr.prim.lambda
 [expr.rel]: expr.md#expr.rel
 [expr.sizeof]: expr.md#expr.sizeof
 [expr.spaceship]: expr.md#expr.spaceship
 [expr.typeid]: expr.md#expr.typeid
 [get.new.handler]: #get.new.handler
 [get.terminate]: #get.terminate
 [hardware.interference]: #hardware.interference
 [initializer.list.syn]: #initializer.list.syn
 [intro.multithread]: basic.md#intro.multithread
+[iso646.h.syn]: #iso646.h.syn
+[lex.key]: lex.md#lex.key
 [library.c]: library.md#library.c
 [limits.syn]: #limits.syn
 [locale.codecvt]: localization.md#locale.codecvt
 [multibyte.strings]: library.md#multibyte.strings
+[namespace.udecl]: dcl.md#namespace.udecl
 [new.badlength]: #new.badlength
 [new.delete]: #new.delete
 [new.delete.array]: #new.delete.array
 [new.delete.dataraces]: #new.delete.dataraces
+[new.delete.general]: #new.delete.general
 [new.delete.placement]: #new.delete.placement
 [new.delete.single]: #new.delete.single
 [new.handler]: #new.handler
 [new.syn]: #new.syn
 [numeric.limits]: #numeric.limits
+[numeric.limits.general]: #numeric.limits.general
 [numeric.limits.members]: #numeric.limits.members
 [numeric.special]: #numeric.special
 [propagation]: #propagation
 [ptr.launder]: #ptr.launder
 [res.on.data.races]: library.md#res.on.data.races
 [round.style]: #round.style
 [set.new.handler]: #set.new.handler
 [set.terminate]: #set.terminate
+[sf.cmath]: numerics.md#sf.cmath
 [source.location.syn]: #source.location.syn
+[stdalign.h.syn]: #stdalign.h.syn
+[stdbool.h.syn]: #stdbool.h.syn
+[stdfloat.syn]: #stdfloat.syn
 [stmt.dcl]: stmt.md#stmt.dcl
 [string.classes]: strings.md#string.classes
 [support]: #support
+[support.arith.types]: #support.arith.types
+[support.c.headers]: #support.c.headers
+[support.c.headers.general]: #support.c.headers.general
+[support.c.headers.other]: #support.c.headers.other
 [support.coroutine]: #support.coroutine
+[support.coroutine.general]: #support.coroutine.general
 [support.dynamic]: #support.dynamic
+[support.dynamic.general]: #support.dynamic.general
 [support.exception]: #support.exception
+[support.exception.general]: #support.exception.general
 [support.general]: #support.general
 [support.initlist]: #support.initlist
 [support.initlist.access]: #support.initlist.access
 [support.initlist.cons]: #support.initlist.cons
+[support.initlist.general]: #support.initlist.general
 [support.initlist.range]: #support.initlist.range
 [support.limits]: #support.limits
 [support.limits.general]: #support.limits.general
 [support.rtti]: #support.rtti
+[support.rtti.general]: #support.rtti.general
 [support.runtime]: #support.runtime
+[support.runtime.general]: #support.runtime.general
 [support.signal]: #support.signal
 [support.srcloc]: #support.srcloc
 [support.srcloc.class]: #support.srcloc.class
+[support.srcloc.class.general]: #support.srcloc.class.general
 [support.srcloc.cons]: #support.srcloc.cons
 [support.srcloc.current]: #support.srcloc.current
 [support.srcloc.obs]: #support.srcloc.obs
 [support.start.term]: #support.start.term
 [support.summary]: #support.summary
 [swappable.requirements]: library.md#swappable.requirements
 [temp.deduct]: temp.md#temp.deduct
 [temp.dep.constexpr]: temp.md#temp.dep.constexpr
 [temp.dep.expr]: temp.md#temp.dep.expr
 [temp.variadic]: temp.md#temp.variadic
+[term.odr.use]: basic.md#term.odr.use
 [terminate]: #terminate
 [terminate.handler]: #terminate.handler
+[tgmath.h.syn]: #tgmath.h.syn
 [type.info]: #type.info
 [typeinfo.syn]: #typeinfo.syn
 [uncaught.exceptions]: #uncaught.exceptions
 [unord.hash]: utilities.md#unord.hash
 [utility.arg.requirements]: library.md#utility.arg.requirements
 [^7]: Equivalent to `FLT_DIG`, `DBL_DIG`, `LDBL_DIG`.
 [^8]: Equivalent to `FLT_RADIX`.
+[^9]: Distinguishes types with bases other than 2 (e.g., BCD).
 [^10]: Equivalent to `FLT_EPSILON`, `DBL_EPSILON`, `LDBL_EPSILON`.
 [^11]: Rounding error is described in LIA-1 Section 5.2.4 and Annex C
     Rationale Section C.5.2.4 — Rounding and rounding constants.
 [^17]: Required by LIA-1.
 [^18]: Required by LIA-1.
+[^19]: Required by LIA-1.
 [^20]: Required by LIA-1.
 [^21]: Required by LIA-1.
+[^22]: ISO/IEC/IEEE 60559:2020 is the same as IEEE 754-2019.
 [^23]: Required by LIA-1.
+[^24]: Required by LIA-1.
 [^25]: Required by LIA-1.
+[^26]: Refer to ISO/IEC/IEEE 60559. Required by LIA-1.
+[^27]: Equivalent to `FLT_ROUNDS`. Required by LIA-1.
+[^28]: A function is called for every time it is registered.
+[^29]: Objects with automatic storage duration are all destroyed in a
     program whose `main` function [[basic.start.main]] contains no
     objects with automatic storage duration and executes the call to
     `exit()`. Control can be transferred directly to such a `main`
     function by throwing an exception that is caught in `main`.
+[^30]: The macros `EXIT_FAILURE` and `EXIT_SUCCESS` are defined in
     `<cstdlib>`.
+[^31]: It is not the direct responsibility of `operator new[]` or
     `operator delete[]` to note the repetition count or element size of
     the array. Those operations are performed elsewhere in the array
+    `new` and `delete` expressions. The array `new` expression, can,
     however, increase the `size` argument to `operator new[]` to obtain
     space to store supplemental information.
+[^32]: That is, `a < b`, `a == b`, and `a > b` might all be `false`.
+[^33]: Note that `va_start` is required to work as specified even if
     unary `operator&` is overloaded for the type of `parmN`.
+[^34]: Such initialization can occur because it is the first odr-use
+    [[term.odr.use]] of that variable.

Diff to HTML by rtfpessoa