[support] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpr10t1bgl/{from.md → to.md} +953 -388

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

@@ -9,25 +9,27 @@ declare these function signatures and define any related types.
 The following subclauses describe common type definitions used
 throughout the library, characteristics of the predefined types,
 functions supporting start and termination of a C++ program, support for
 dynamic memory management, support for dynamic type identification,
-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>`   |
 | [[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>`                                      |
 | [[support.initlist]]    | Initializer lists           | `<initializer_list>`                               |
 | [[cmp]]                 | Comparisons                 | `<compare>`                                        |
 | [[support.coroutine]]   | Coroutines                  | `<coroutine>`                                      |
 | [[support.runtime]]     | Other runtime support       | `<csetjmp>`, `<csignal>`, `<cstdarg>`, `<cstdlib>` |
@@ -70,29 +72,30 @@ namespace std {
 #define offsetof(P, D) see below
 ```
 The contents and meaning of the header `<cstddef>` are the same as the C
 standard library header `<stddef.h>`, except that it does not declare
-the type `wchar_t`, that it also declares the type `byte` and its
-associated operations [[support.types.byteops]], and as noted in
-[[support.types.nullptr]] and [[support.types.layout]].
-See also: ISO C 7.19
 ### 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
 namespace std {
   // Exposition-only function type aliases
@@ -116,18 +119,24 @@ namespace std {
   // [c.malloc], C library memory allocation
   void* aligned_alloc(size_t alignment, size_t size);
   void* calloc(size_t nmemb, size_t size);
   void free(void* ptr);
   void* malloc(size_t size);
   void* realloc(void* ptr, size_t size);
   double atof(const char* nptr);
   int atoi(const char* nptr);
   long int atol(const char* nptr);
   long long int atoll(const char* nptr);
   double strtod(const char* nptr, char** endptr);
   float strtof(const char* nptr, char** endptr);
   long double strtold(const char* nptr, char** endptr);
   long int strtol(const char* nptr, char** endptr, int base);
   long long int strtoll(const char* nptr, char** endptr, int base);
   unsigned long int strtoul(const char* nptr, char** endptr, int base);
@@ -139,49 +148,54 @@ namespace std {
   int wctomb(char* s, wchar_t wchar);
   size_t mbstowcs(wchar_t* pwcs, const char* s, size_t n);
   size_t wcstombs(char* s, const wchar_t* pwcs, size_t n);
   // [alg.c.library], C standard library algorithms
-  void* bsearch(const void* key, const void* base, size_t nmemb, size_t size,
                 c-compare-pred* compar);
-  void* bsearch(const void* key, const void* base, size_t nmemb, size_t size,
                 compare-pred* compar);
-  void qsort(void* base, size_t nmemb, size_t size, c-compare-pred* compar);
-  void qsort(void* base, size_t nmemb, size_t size, compare-pred* compar);
   // [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
-the type `wchar_t`, and except as noted in [[support.types.nullptr]],
 [[support.types.layout]], [[support.start.term]], [[c.malloc]],
 [[c.mb.wcs]], [[alg.c.library]], [[c.math.rand]], and [[c.math.abs]].
 [*Note 1*: Several functions have additional overloads in this
 document, but they have the same behavior as in the C standard library
 [[library.c]]. — *end note*]
-See also: ISO C 7.22
 ### Null pointers <a id="support.types.nullptr">[[support.types.nullptr]]</a>
 The type `nullptr_t` is a synonym for the type of a `nullptr`
 expression, and it has the characteristics described in
@@ -192,11 +206,11 @@ 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>`,
@@ -223,15 +237,17 @@ that is large enough to contain the size in bytes of any object
 *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]].
-See also: ISO C 7.19
 ### `byte` type operations <a id="support.types.byteops">[[support.types.byteops]]</a>
 ``` cpp
 template<class IntType>
@@ -359,217 +375,362 @@ 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 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_hypot                             201603L // also in <cmath>
 #define __cpp_lib_incomplete_container_elements     201505L
   // also in <forward_list>, <list>, <vector>
-#define __cpp_lib_int_pow2 202002L // also in <bit>
 #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_logical_traits                    201510L // also in <type_traits>
-#define __cpp_lib_make_from_tuple                   201606L // also in <tuple>
-#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 {
@@ -710,10 +871,13 @@ not have specializations.
 #### `numeric_limits` members <a id="numeric.limits.members">[[numeric.limits.members]]</a>
 Each member function defined in this subclause is signal-safe
 [[support.signal]].
 ``` cpp
 static constexpr T min() noexcept;
 ```
 Minimum finite value.[^3]
@@ -748,11 +912,11 @@ static constexpr int digits;
 Number of `radix` digits that can be represented without change.
 For integer types, the number of non-sign bits in the representation.
 For floating-point types, the number of `radix` digits in the
-mantissa.[^6]
 ``` cpp
 static constexpr int digits10;
 ```
@@ -929,11 +1093,11 @@ 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*]
@@ -1101,11 +1265,23 @@ namespace std {
 ### 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
 #define CHAR_MAX see below
@@ -1123,35 +1299,39 @@ namespace std {
 #define LLONG_MAX see below
 #define ULLONG_MAX 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
 #define FLT_RADIX see below
 #define FLT_MANT_DIG see below
 #define DBL_MANT_DIG see below
 #define LDBL_MANT_DIG see below
 #define FLT_DECIMAL_DIG see below
 #define DBL_DECIMAL_DIG see below
 #define LDBL_DECIMAL_DIG see below
-#define DECIMAL_DIG see below
 #define FLT_DIG see below
 #define DBL_DIG see below
 #define LDBL_DIG see below
 #define FLT_MIN_EXP see below
 #define DBL_MIN_EXP see below
@@ -1180,21 +1360,23 @@ 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
 ## 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
@@ -1238,50 +1420,68 @@ namespace std {
 }
 #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
@@ -1329,11 +1529,11 @@ this subclause. — *end note*]
 *Effects:* This function has the semantics specified in the C standard
 library.
 *Remarks:* The program is terminated without executing destructors for
-objects of automatic, thread, or static storage duration and without
 calling functions passed to `atexit()` [[basic.start.term]]. The
 function `_Exit` is signal-safe [[support.signal]].
 ``` cpp
 [[noreturn]] void abort() noexcept;
@@ -1437,11 +1637,11 @@ After calling registered functions, `quick_exit` shall call
 `_Exit(status)`.
 *Remarks:* The function `quick_exit` is signal-safe [[support.signal]]
 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>
 ### General <a id="support.dynamic.general">[[support.dynamic.general]]</a>
@@ -1477,46 +1677,45 @@ namespace std {
   using new_handler = void (*)();
   new_handler get_new_handler() noexcept;
   new_handler set_new_handler(new_handler new_p) noexcept;
   // [ptr.launder], pointer optimization barrier
-  template<class T> [[nodiscard]] constexpr T* launder(T* p) noexcept;
   // [hardware.interference], hardware interference size
   inline constexpr size_t hardware_destructive_interference_size = implementation-defined{};
   inline constexpr size_t hardware_constructive_interference_size = implementation-defined{};
 }
 // [new.delete], storage allocation and deallocation
-[[nodiscard]] void* operator new(std::size_t size);
-[[nodiscard]] void* operator new(std::size_t size, std::align_val_t alignment);
-[[nodiscard]] void* operator new(std::size_t size, const std::nothrow_t&) noexcept;
-[[nodiscard]] void* operator new(std::size_t size, std::align_val_t alignment,
-                                 const std::nothrow_t&) noexcept;
 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;
 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;
-[[nodiscard]] void* operator new[](std::size_t size);
-[[nodiscard]] void* operator new[](std::size_t size, std::align_val_t alignment);
-[[nodiscard]] void* operator new[](std::size_t size, const std::nothrow_t&) noexcept;
-[[nodiscard]] void* operator new[](std::size_t size, std::align_val_t alignment,
                      const std::nothrow_t&) noexcept;
 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;
 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;
-[[nodiscard]] void* operator new  (std::size_t size, void* ptr) noexcept;
-[[nodiscard]] void* operator new[](std::size_t size, void* ptr) noexcept;
 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>
@@ -1527,26 +1726,37 @@ 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.
 #### Single-object forms <a id="new.delete.single">[[new.delete.single]]</a>
 ``` cpp
-[[nodiscard]] void* operator new(std::size_t size);
-[[nodiscard]] void* operator new(std::size_t size, std::align_val_t alignment);
 ```
 *Effects:* The allocation functions [[basic.stc.dynamic.allocation]]
 called by 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.
-*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.
 *Required behavior:* Return a non-null pointer to suitably aligned
 storage [[basic.stc.dynamic]], or else throw a `bad_alloc` exception.
 This requirement is binding on any replacement versions of these
 functions.
@@ -1563,24 +1773,21 @@ functions.
   function [[new.handler]]. If the called function returns, the loop
   repeats.
 - The loop terminates when an attempt to allocate the requested storage
   is successful or when a called `new_handler` function does not return.
 ``` cpp
-[[nodiscard]] void* operator new(std::size_t size, const std::nothrow_t&) noexcept;
-[[nodiscard]] void* operator new(std::size_t size, std::align_val_t alignment,
-                                 const std::nothrow_t&) noexcept;
 ```
 *Effects:* Same as above, except that these are called by a placement
 version of a *new-expression* when a C++ program prefers a null pointer
 result as an error indication, instead of a `bad_alloc` 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.
 *Required behavior:* Return a non-null pointer to suitably aligned
 storage [[basic.stc.dynamic]], or else return a null pointer. Each of
 these nothrow versions of `operator new` returns a pointer obtained as
 if acquired from the (possibly replaced) corresponding non-placement
 function. This requirement is binding on any replacement versions of
@@ -1598,10 +1805,12 @@ T* p1 = new T;                  // throws bad_alloc if it fails
 T* p2 = new(nothrow) T;         // returns nullptr if it fails
 ```
 — *end example*]
 ``` cpp
 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;
@@ -1622,46 +1831,43 @@ 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
-function signatures, and thereby displace the default versions defined
-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 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.
-[*Note 2*: A conforming implementation is for
 `operator delete(void* ptr, std::size_t size)` to simply call
 `operator delete(ptr)`. — *end note*]
 *Default behavior:* The functions that have a `size` parameter forward
 their other parameters to the corresponding function without a `size`
 parameter.
-[*Note 3*: See the note in the above *Replaceable:*
 paragraph. — *end note*]
 *Default behavior:* If `ptr` is null, does nothing. Otherwise, reclaims
 the storage allocated by the earlier call to `operator new`.
 *Remarks:* It is unspecified under what conditions part or all of such
 reclaimed storage will be allocated by subsequent calls to
 `operator new` or any of `aligned_alloc`, `calloc`, `malloc`, or
-`realloc`, declared in `<cstdlib>`.
 ``` 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;
 ```
@@ -1680,54 +1886,45 @@ 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>
 ``` cpp
-[[nodiscard]] void* operator new[](std::size_t size);
-[[nodiscard]] void* operator new[](std::size_t size, std::align_val_t alignment);
 ```
 *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.
 *Required behavior:* Same as for the corresponding single-object forms.
 This requirement is binding on any replacement versions of these
 functions.
 *Default behavior:* Returns `operator new(size)`, or
 `operator new(size, alignment)`, respectively.
 ``` cpp
-[[nodiscard]] void* operator new[](std::size_t size, const std::nothrow_t&) noexcept;
-[[nodiscard]] void* operator new[](std::size_t size, std::align_val_t alignment,
-                                   const std::nothrow_t&) noexcept;
 ```
 *Effects:* Same as above, except that these are called by a placement
 version of a *new-expression* when a C++ program prefers a null pointer
 result as an error indication, instead of a `bad_alloc` 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.
 *Required behavior:* Return a non-null pointer to suitably aligned
 storage [[basic.stc.dynamic]], or else return a null pointer. Each of
 these nothrow versions of `operator new[]` returns a pointer obtained as
 if acquired from the (possibly replaced) corresponding non-placement
 function. This requirement is binding on any replacement versions of
@@ -1736,10 +1933,12 @@ these functions.
 *Default behavior:* Calls `operator new[](size)`, or
 `operator new[](size, alignment)`, respectively. If the call returns
 normally, returns the result of that call. Otherwise, returns a null
 pointer.
 ``` cpp
 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;
@@ -1760,38 +1959,36 @@ 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
-function signatures, and thereby displace the default versions defined
-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 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.
-[*Note 2*: A conforming implementation is for
 `operator delete[](void* ptr, std::size_t size)` to simply call
 `operator delete[](ptr)`. — *end note*]
 *Default behavior:* The functions that have a `size` parameter forward
 their other parameters to the corresponding function without a `size`
 parameter. The functions that do not have a `size` parameter forward
 their parameters to the corresponding `operator delete` (single-object)
 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;
 ```
@@ -1809,26 +2006,24 @@ 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>
 These functions are reserved; a C++ program may not define functions
 that displace the versions in the C++ standard library [[constraints]].
 The provisions of  [[basic.stc.dynamic]] do not apply to these reserved
 placement forms of `operator new` and `operator delete`.
 ``` cpp
-[[nodiscard]] void* operator new(std::size_t size, void* ptr) noexcept;
 ```
 *Returns:* `ptr`.
 *Remarks:* Intentionally performs no other action.
@@ -1843,11 +2038,11 @@ Something* p = new (place) Something();
 ```
 — *end example*]
 ``` cpp
-[[nodiscard]] void* operator new[](std::size_t size, void* ptr) noexcept;
 ```
 *Returns:* `ptr`.
 *Remarks:* Intentionally performs no other action.
@@ -1892,20 +2087,20 @@ before [[intro.multithread]] the next allocation (if any) in this order.
 ``` cpp
 namespace std {
   class bad_alloc : public exception {
   public:
     // see [exception] for the specification of the special member functions
-    const char* what() const noexcept override;
   };
 }
 ```
 The class `bad_alloc` defines the type of objects thrown as exceptions
 by the implementation to report a failure to allocate storage.
 ``` cpp
-const char* what() const noexcept override;
 ```
 *Returns:* An *implementation-defined* NTBS.
 #### Class `bad_array_new_length` <a id="new.badlength">[[new.badlength]]</a>
@@ -1913,22 +2108,22 @@ const char* what() const noexcept override;
 ``` cpp
 namespace std {
   class bad_array_new_length : public bad_alloc {
   public:
     // see [exception] for the specification of the special member functions
-    const char* what() const noexcept override;
   };
 }
 ```
 The class `bad_array_new_length` defines the type of objects thrown as
 exceptions by the implementation to report an attempt to allocate an
 array of size less than zero or greater than an *implementation-defined*
 limit [[expr.new]].
 ``` cpp
-const char* what() const noexcept override;
 ```
 *Returns:* An *implementation-defined* NTBS.
 #### Type `new_handler` <a id="new.handler">[[new.handler]]</a>
@@ -1972,11 +2167,11 @@ new_handler get_new_handler() noexcept;
 [*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
@@ -2062,11 +2257,13 @@ static_assert(sizeof(together) <= hardware_constructive_interference_size);
 ### 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
@@ -2087,12 +2284,12 @@ namespace std {
     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
-    type_info& operator=(const type_info&) = delete;        // cannot be copied
   };
 }
 ```
 The class `type_info` describes type information generated by the
@@ -2145,21 +2342,21 @@ string [[multibyte.strings]], suitable for conversion and display as a
 ``` cpp
 namespace std {
   class bad_cast : public exception {
   public:
     // see [exception] for the specification of the special member functions
-    const char* what() const noexcept override;
   };
 }
 ```
 The class `bad_cast` defines the type of objects thrown as exceptions by
 the implementation to report the execution of an invalid `dynamic_cast`
 expression [[expr.dynamic.cast]].
 ``` cpp
-const char* what() const noexcept override;
 ```
 *Returns:* An *implementation-defined* NTBS.
 ### Class `bad_typeid` <a id="bad.typeid">[[bad.typeid]]</a>
@@ -2167,25 +2364,134 @@ const char* what() const noexcept override;
 ``` cpp
 namespace std {
   class bad_typeid : public exception {
   public:
     // see [exception] for the specification of the special member functions
-    const char* what() const noexcept override;
   };
 }
 ```
 The class `bad_typeid` defines the type of objects thrown as exceptions
 by the implementation to report a null pointer in a `typeid` expression
 [[expr.typeid]].
 ``` cpp
-const char* what() const noexcept override;
 ```
 *Returns:* An *implementation-defined* NTBS.
 ## Source location <a id="support.srcloc">[[support.srcloc]]</a>
 ### Header `<source_location>` synopsis <a id="source.location.syn">[[source.location.syn]]</a>
 The header `<source_location>` defines the class `source_location` that
@@ -2271,11 +2577,11 @@ static consteval source_location current() noexcept;
   [[support.srcloc.current]].
 - Otherwise, when invoked in some other way, returns a `source_location`
   whose data members are initialized with valid but unspecified values.
 *Remarks:* Any call to `current` that appears as a default member
-initializer [[class.mem]], or as a subexpression thereof, should
 correspond to the location of the constructor definition or aggregate
 initialization that uses the default member initializer. Any call to
 `current` that appears as a default argument [[dcl.fct.default]], or as
 a subexpression thereof, should correspond to the location of the
 invocation of the function that uses the default argument [[expr.call]].
@@ -2361,45 +2667,48 @@ namespace std {
   using terminate_handler = void (*)();
   terminate_handler get_terminate() noexcept;
   terminate_handler set_terminate(terminate_handler f) noexcept;
   [[noreturn]] void terminate() noexcept;
-  int uncaught_exceptions() noexcept;
   using exception_ptr = unspecified;
-  exception_ptr current_exception() noexcept;
-  [[noreturn]] void rethrow_exception(exception_ptr p);
-  template<class E> exception_ptr make_exception_ptr(E e) noexcept;
-  template<class T> [[noreturn]] void throw_with_nested(T&& t);
-  template<class E> void rethrow_if_nested(const E& e);
 }
 ```
 ### Class `exception` <a id="exception">[[exception]]</a>
 ``` cpp
 namespace std {
   class exception {
   public:
-    exception() noexcept;
-    exception(const exception&) noexcept;
-    exception& operator=(const exception&) noexcept;
-    virtual ~exception();
-    virtual const char* what() const noexcept;
   };
 }
 ```
 The class `exception` defines the base class for the types of objects
 thrown as exceptions by C++ standard library components, and certain
 expressions, to report errors detected during program execution.
-Each standard library class `T` that derives from class `exception` has
-the following publicly accessible member functions, each of them having
-a non-throwing exception specification [[except.spec]]:
 - default constructor (unless the class synopsis shows other
   constructors)
 - copy constructor
 - copy assignment operator
@@ -2409,28 +2718,29 @@ postcondition: If two objects `lhs` and `rhs` both have dynamic type `T`
 and `lhs` is a copy of `rhs`, then `strcmp(lhs.what(), rhs.what())` is
 equal to `0`. The `what()` member function of each such `T` satisfies
 the constraints specified for `exception::what()` (see below).
 ``` cpp
-exception(const exception& rhs) noexcept;
-exception& operator=(const exception& rhs) noexcept;
 ```
 *Ensures:* If `*this` and `rhs` both have dynamic type `exception` then
 the value of the expression `strcmp(what(), rhs.what())` shall equal 0.
 ``` cpp
-virtual ~exception();
 ```
 *Effects:* Destroys an object of class `exception`.
 ``` cpp
-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
@@ -2442,22 +2752,22 @@ called.
 ``` cpp
 namespace std {
   class bad_exception : public exception {
   public:
     // see [exception] for the specification of the special member functions
-    const char* what() const noexcept override;
   };
 }
 ```
 The class `bad_exception` defines the type of the object referenced by
 the `exception_ptr` returned from a call to `current_exception`
 [[propagation]] when the currently active exception object fails to
 copy.
 ``` cpp
-const char* what() const noexcept override;
 ```
 *Returns:* An *implementation-defined* NTBS.
 ### Abnormal termination <a id="exception.terminate">[[exception.terminate]]</a>
@@ -2520,14 +2830,15 @@ 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;
 ```
-*Returns:* The number of uncaught exceptions [[except.uncaught]].
 *Remarks:* When `uncaught_exceptions() > 0`, throwing an exception can
 result in a call of the function `std::terminate` [[except.terminate]].
 ### Exception propagation <a id="propagation">[[propagation]]</a>
@@ -2554,21 +2865,23 @@ enumeration, or pointer type.
 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;
 ```
 *Returns:* An `exception_ptr` object that refers to the currently
 handled exception [[except.handle]] or a copy of the currently handled
 exception, or a null `exception_ptr` object if no exception is being
@@ -2586,15 +2899,15 @@ 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
@@ -2606,11 +2919,11 @@ memory for the copy is allocated in an unspecified way.
 - 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;
 ```
 *Effects:* Creates an `exception_ptr` object that refers to a copy of
 `e`, as if:
@@ -2623,28 +2936,43 @@ try {
 ```
 [*Note 5*: This function is provided for convenience and efficiency
 reasons. — *end note*]
 ### `nested_exception` <a id="except.nested">[[except.nested]]</a>
 ``` cpp
 namespace std {
   class nested_exception {
   public:
-    nested_exception() noexcept;
-    nested_exception(const nested_exception&) noexcept = default;
-    nested_exception& operator=(const nested_exception&) noexcept = default;
-    virtual ~nested_exception() = default;
     // access functions
-    [[noreturn]] void rethrow_nested() const;
-    exception_ptr nested_ptr() const noexcept;
   };
-  template<class T> [[noreturn]] void throw_with_nested(T&& t);
-  template<class E> void rethrow_if_nested(const E& e);
 }
 ```
 The class `nested_exception` is designed for use as a mixin through
 multiple inheritance. It captures the currently handled exception and
@@ -2653,33 +2981,33 @@ stores it for later use.
 [*Note 1*: `nested_exception` has a virtual destructor to make it a
 polymorphic class. Its presence can be tested for with
 `dynamic_cast`. — *end note*]
 ``` cpp
-nested_exception() noexcept;
 ```
 *Effects:* The constructor calls `current_exception()` and stores the
 returned value.
 ``` cpp
-[[noreturn]] void rethrow_nested() const;
 ```
 *Effects:* If `nested_ptr()` returns a null pointer, the function calls
 the function `std::terminate`. Otherwise, it throws the stored exception
 captured by `*this`.
 ``` cpp
-exception_ptr nested_ptr() const noexcept;
 ```
 *Returns:* The stored exception captured by this `nested_exception`
 object.
 ``` cpp
-template<class T> [[noreturn]] void throw_with_nested(T&& t);
 ```
 Let `U` be `decay_t<T>`.
 *Preconditions:* `U` meets the *Cpp17CopyConstructible* requirements.
@@ -2689,11 +3017,11 @@ Let `U` be `decay_t<T>`.
 is `true`, an exception of unspecified type that is publicly derived
 from both `U` and `nested_exception` and constructed from
 `std::forward<T>(t)`, otherwise `std::forward<T>(t)`.
 ``` cpp
-template<class E> void rethrow_if_nested(const E& e);
 ```
 *Effects:* If `E` is not a polymorphic class type, or if
 `nested_exception` is an inaccessible or ambiguous base class of `E`,
 there is no effect. Otherwise, performs:
@@ -2701,10 +3029,192 @@ there is no effect. Otherwise, performs:
 ``` cpp
 if (auto p = dynamic_cast<const nested_exception*>(addressof(e)))
   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
@@ -2744,11 +3254,11 @@ An object of type `initializer_list<E>` provides access to an array of
 objects of type `const E`.
 [*Note 1*: A pair of pointers or a pointer plus a length would be
 obvious representations for `initializer_list`. `initializer_list` is
 used to implement initializer lists as specified in  [[dcl.init.list]].
-Copying an initializer list does not copy the underlying
 elements. — *end note*]
 If an explicit specialization or partial specialization of
 `initializer_list` is declared, the program is ill-formed.
@@ -2826,11 +3336,11 @@ namespace std {
   template<class... Ts>
   struct common_comparison_category {
     using type = see below;
   };
   template<class... Ts>
-    using common_comparison_category_t = typename common_comparison_category<Ts...>::type;
   // [cmp.concept], concept three_way_comparable
   template<class T, class Cat = partial_ordering>
     concept three_way_comparable = see below;
   template<class T, class U, class Cat = partial_ordering>
@@ -2838,11 +3348,11 @@ namespace std {
   // [cmp.result], result of three-way comparison
   template<class T, class U = T> struct compare_three_way_result;
   template<class T, class U = T>
-    using compare_three_way_result_t = typename compare_three_way_result<T, U>::type;
   // [comparisons.three.way], class compare_three_way
   struct compare_three_way;
   // [cmp.alg], comparison algorithms
@@ -2852,10 +3362,17 @@ namespace std {
     inline constexpr unspecified partial_order = unspecified;
     inline constexpr unspecified compare_strong_order_fallback = unspecified;
     inline constexpr unspecified compare_weak_order_fallback = unspecified;
     inline constexpr unspecified compare_partial_order_fallback = unspecified;
   }
 }
 ```
 ### Comparison category types <a id="cmp.categories">[[cmp.categories]]</a>
@@ -2889,12 +3406,12 @@ meets this requirement.
 — *end example*]
 In this context, the behavior of a program that supplies an argument
 other than a literal `0` is undefined.
-For the purposes of subclause [[cmp.categories]], *substitutability* is
-the property that `f(a) == f(b)` is `true` whenever `a == b` is `true`,
 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>
@@ -2906,17 +3423,17 @@ 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
   public:
     // valid values
     static const partial_ordering less;
     static const partial_ordering equivalent;
@@ -2952,20 +3469,20 @@ constexpr bool operator< (partial_ordering v, unspecified) noexcept;
 constexpr bool operator> (partial_ordering v, unspecified) noexcept;
 constexpr bool operator<=(partial_ordering v, unspecified) noexcept;
 constexpr bool operator>=(partial_ordering v, unspecified) noexcept;
 ```
-*Returns:* For `operator`, `v.is_ordered && v.value 0`.
 ``` cpp
 constexpr bool operator< (unspecified, partial_ordering v) noexcept;
 constexpr bool operator> (unspecified, partial_ordering v) noexcept;
 constexpr bool operator<=(unspecified, partial_ordering v) noexcept;
 constexpr bool operator>=(unspecified, partial_ordering v) noexcept;
 ```
-*Returns:* For `operator`, `v.is_ordered && 0 v.value`.
 ``` cpp
 constexpr partial_ordering operator<=>(partial_ordering v, unspecified) noexcept;
 ```
@@ -3042,20 +3559,20 @@ constexpr bool operator< (weak_ordering v, unspecified) noexcept;
 constexpr bool operator> (weak_ordering v, unspecified) noexcept;
 constexpr bool operator<=(weak_ordering v, unspecified) noexcept;
 constexpr bool operator>=(weak_ordering v, unspecified) noexcept;
 ```
-*Returns:* `v.value 0` for `operator`.
 ``` cpp
 constexpr bool operator< (unspecified, weak_ordering v) noexcept;
 constexpr bool operator> (unspecified, weak_ordering v) noexcept;
 constexpr bool operator<=(unspecified, weak_ordering v) noexcept;
 constexpr bool operator>=(unspecified, weak_ordering v) noexcept;
 ```
-*Returns:* `0 v.value` for `operator`.
 ``` cpp
 constexpr weak_ordering operator<=>(weak_ordering v, unspecified) noexcept;
 ```
@@ -3147,20 +3664,20 @@ constexpr bool operator< (strong_ordering v, unspecified) noexcept;
 constexpr bool operator> (strong_ordering v, unspecified) noexcept;
 constexpr bool operator<=(strong_ordering v, unspecified) noexcept;
 constexpr bool operator>=(strong_ordering v, unspecified) noexcept;
 ```
-*Returns:* `v.value 0` for `operator`.
 ``` cpp
 constexpr bool operator< (unspecified, strong_ordering v) noexcept;
 constexpr bool operator> (unspecified, strong_ordering v) noexcept;
 constexpr bool operator<=(unspecified, strong_ordering v) noexcept;
 constexpr bool operator>=(unspecified, strong_ordering v) noexcept;
 ```
-*Returns:* `0 v.value` for `operator`.
 ``` cpp
 constexpr strong_ordering operator<=>(strong_ordering v, unspecified) noexcept;
 ```
@@ -3219,14 +3736,14 @@ template<class T, class U>
     };
 ```
 Let `t` and `u` be lvalues of types `const remove_reference_t<T>` and
 `const remove_reference_t<U>`, respectively. `T` and `U` model
-`partially-ordered-with<T, U>` only if:
 - `t < u`, `t <= u`, `t > u`, `t >= u`, `u < t`, `u <= t`, `u > t`, and
-  `u >= t` have the same domain.
 - `bool(t < u) == bool(u > t)` is `true`,
 - `bool(u < t) == bool(t > u)` is `true`,
 - `bool(t <= u) == bool(u >= t)` is `true`, and
 - `bool(u <= t) == bool(t >= u)` is `true`.
@@ -3239,11 +3756,11 @@ template<class T, class Cat = partial_ordering>
       { a <=> b } -> compares-as<Cat>;
     };
 ```
 Let `a` and `b` be lvalues of type `const remove_reference_t<T>`. `T`
-and `Cat` model `three_way_comparable<T, Cat>` only if:
 - `(a <=> b == 0) == bool(a == b)` is `true`,
 - `(a <=> b != 0) == bool(a != b)` is `true`,
 - `((a <=> b) <=> 0)` and `(0 <=> (b <=> a))` are equal,
 - `(a <=> b < 0) == bool(a < b)` is `true`,
@@ -3275,11 +3792,11 @@ 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`,
@@ -3321,11 +3838,11 @@ expression `strong_order(E, F)` is expression-equivalent
   [[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
@@ -3443,12 +3960,12 @@ 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
@@ -3459,10 +3976,42 @@ expression-equivalent [[defns.expression.equivalent]] to:
 [*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
@@ -3520,11 +4069,11 @@ such that if `ArgTypes` is a parameter pack of types and if the
 *qualified-id* `R::promise_type` is valid and denotes a type
 [[temp.deduct]], then `coroutine_traits<R, ArgTypes...>` has the
 following publicly accessible member:
 ``` cpp
-using promise_type = typename R::promise_type;
 ```
 Otherwise, `coroutine_traits<R, ArgTypes...>` has no members.
 Program-defined specializations of this template shall define a publicly
@@ -3760,10 +4309,12 @@ struct noop_coroutine_promise {};
 The class `noop_coroutine_promise` defines the promise type for the
 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>
   {
@@ -3905,41 +4456,39 @@ 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_copy(VDST, VSRC) 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>
 ``` cpp
 namespace std {
   using jmp_buf = see below;
   [[noreturn]] void longjmp(jmp_buf env, int val);
 }
@@ -4014,11 +4563,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]][^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.
@@ -4035,32 +4584,32 @@ See also: ISO C 7.14
 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>
@@ -4084,23 +4633,20 @@ The C++ header `<iso646.h>` is empty.
 [[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>
@@ -4119,39 +4665,44 @@ overloads. — *end note*]
 `<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
@@ -4159,18 +4710,18 @@ names within the namespace `std`. — *end example*]
 [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
 [class.spaceship]: class.md#class.spaceship
 [climits.syn]: #climits.syn
 [cmp]: #cmp
 [cmp.alg]: #cmp.alg
@@ -4181,15 +4732,17 @@ names within the namespace `std`. — *end example*]
 [cmp.partialord]: #cmp.partialord
 [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
@@ -4200,10 +4753,11 @@ names within the namespace `std`. — *end example*]
 [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
@@ -4231,37 +4785,40 @@ names within the namespace `std`. — *end example*]
 [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
 [exception]: #exception
 [exception.syn]: #exception.syn
 [exception.terminate]: #exception.terminate
 [expr.add]: expr.md#expr.add
 [expr.await]: expr.md#expr.await
 [expr.call]: expr.md#expr.call
 [expr.context]: expr.md#expr.context
 [expr.delete]: expr.md#expr.delete
 [expr.dynamic.cast]: expr.md#expr.dynamic.cast
 [expr.eq]: expr.md#expr.eq
 [expr.new]: expr.md#expr.new
-[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
@@ -4291,10 +4848,14 @@ names within the namespace `std`. — *end example*]
 [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
@@ -4323,21 +4884,27 @@ names within the namespace `std`. — *end example*]
 [support.types]: #support.types
 [support.types.byteops]: #support.types.byteops
 [support.types.layout]: #support.types.layout
 [support.types.nullptr]: #support.types.nullptr
 [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
 [version.syn]: #version.syn
 [^1]: Possible definitions include `0` and `0L`, but not `(void*)0`.
@@ -4361,12 +4928,13 @@ names within the namespace `std`. — *end example*]
 [^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.
 [^12]: Equivalent to `FLT_MIN_EXP`, `DBL_MIN_EXP`, `LDBL_MIN_EXP`.
 [^13]: Equivalent to `FLT_MIN_10_EXP`, `DBL_MIN_10_EXP`,
     `LDBL_MIN_10_EXP`.
@@ -4374,33 +4942,33 @@ names within the namespace `std`. — *end example*]
 [^14]: Equivalent to `FLT_MAX_EXP`, `DBL_MAX_EXP`, `LDBL_MAX_EXP`.
 [^15]: Equivalent to `FLT_MAX_10_EXP`, `DBL_MAX_10_EXP`,
     `LDBL_MAX_10_EXP`.
-[^16]: Required by LIA-1.
-[^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
@@ -4418,10 +4986,7 @@ names within the namespace `std`. — *end example*]
     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.

 The following subclauses describe common type definitions used
 throughout the library, characteristics of the predefined types,
 functions supporting start and termination of a C++ program, support for
 dynamic memory management, support for dynamic type identification,
+support for contract-violation handling, 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>`   |
 | [[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>`, `<typeindex>`                        |
 | [[support.srcloc]]      | Source location             | `<source_location>`                                |
 | [[support.exception]]   | Exception handling          | `<exception>`                                      |
+| [[support.contract]]    | Contract-violation handling | `<contracts>`                                      |
 | [[support.initlist]]    | Initializer lists           | `<initializer_list>`                               |
 | [[cmp]]                 | Comparisons                 | `<compare>`                                        |
 | [[support.coroutine]]   | Coroutines                  | `<coroutine>`                                      |
 | [[support.runtime]]     | Other runtime support       | `<csetjmp>`, `<csignal>`, `<cstdarg>`, `<cstdlib>` |
 #define offsetof(P, D) see below
 ```
 The contents and meaning of the header `<cstddef>` are the same as the C
 standard library header `<stddef.h>`, except that it does not declare
+the type `wchar_t`, that it does not define the macro `unreachable`,
+that it also declares the type `byte` and its associated operations
+[[support.types.byteops]], and as noted in [[support.types.nullptr]] and
+[[support.types.layout]].
+See also: ISO C 7.21
 ### Header `<cstdlib>` synopsis <a id="cstdlib.syn">[[cstdlib.syn]]</a>
 ``` cpp
 namespace std {
   using size_t = see below;                                             // freestanding
+  using div_t = see below;                                              // freestanding
+  using ldiv_t = see below;                                             // freestanding
+  using lldiv_t = see below;                                            // freestanding
 }
 #define NULL see below                                                  // freestanding
+#define EXIT_FAILURE see below                                          // freestanding
+#define EXIT_SUCCESS see below                                          // freestanding
 #define RAND_MAX see below
 #define MB_CUR_MAX see below
 namespace std {
   // Exposition-only function type aliases
   // [c.malloc], C library memory allocation
   void* aligned_alloc(size_t alignment, size_t size);
   void* calloc(size_t nmemb, size_t size);
   void free(void* ptr);
+  void free_sized(void* ptr, size_t size);
+  void free_aligned_sized(void* ptr, size_t alignment, size_t size);
   void* malloc(size_t size);
   void* realloc(void* ptr, size_t size);
+  size_t memalignment(const void* p);                                   // freestanding
   double atof(const char* nptr);
   int atoi(const char* nptr);
   long int atol(const char* nptr);
   long long int atoll(const char* nptr);
   double strtod(const char* nptr, char** endptr);
+  int strfromd(char* s, size_t n, const char* format, double fp);
+  int strfromf(char* s, size_t n, const char* format, float fp);
+  int strfroml(char* s, size_t n, const char* format, long double fp);
   float strtof(const char* nptr, char** endptr);
   long double strtold(const char* nptr, char** endptr);
   long int strtol(const char* nptr, char** endptr, int base);
   long long int strtoll(const char* nptr, char** endptr, int base);
   unsigned long int strtoul(const char* nptr, char** endptr, int base);
   int wctomb(char* s, wchar_t wchar);
   size_t mbstowcs(wchar_t* pwcs, const char* s, size_t n);
   size_t wcstombs(char* s, const wchar_t* pwcs, size_t n);
   // [alg.c.library], C standard library algorithms
+  void* bsearch(const void* key, void* base, size_t nmemb, size_t size,         // freestanding
                 c-compare-pred* compar);
+  void* bsearch(const void* key, void* base, size_t nmemb, size_t size,         // freestanding
                 compare-pred* compar);
+ const void* bsearch(const void* key, const void* base, size_t nmemb,          // freestanding
+ size_t size, c-compare-pred* compar);
+  const void* bsearch(const void* key, const void* base, size_t nmemb,          // freestanding
+                      size_t size, compare-pred* compar);
+  void qsort(void* base, size_t nmemb, size_t size, c-compare-pred* compar);    // freestanding
+  void qsort(void* base, size_t nmemb, size_t size, compare-pred* compar);      // freestanding
   // [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);                                             // freestanding
+  constexpr long int abs(long int j);                                   // freestanding
+  constexpr long long int abs(long long int j);                         // freestanding
+  constexpr floating-point-type abs(floating-point-type j);            // freestanding-deleted
+  constexpr long int labs(long int j);                                  // freestanding
+  constexpr long long int llabs(long long int j);                       // freestanding
+  constexpr div_t div(int numer, int denom);                            // freestanding
+  constexpr ldiv_t div(long int numer, long int denom);                 // freestanding; see [library.c]
+  constexpr lldiv_t div(long long int numer, long long int denom);      // freestanding; see [library.c]
+  constexpr ldiv_t ldiv(long int numer, long int denom);                // freestanding
+  constexpr lldiv_t lldiv(long long int numer, long long int denom);    // freestanding
 }
 ```
 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
+the types `wchar_t` or `once_flag`, and does not declare the function
+`call_once`, and except as noted in [[support.types.nullptr]],
 [[support.types.layout]], [[support.start.term]], [[c.malloc]],
 [[c.mb.wcs]], [[alg.c.library]], [[c.math.rand]], and [[c.math.abs]].
 [*Note 1*: Several functions have additional overloads in this
 document, but they have the same behavior as in the C standard library
 [[library.c]]. — *end note*]
+See also: ISO C 7.24
 ### Null pointers <a id="support.types.nullptr">[[support.types.nullptr]]</a>
 The type `nullptr_t` is a synonym for the type of a `nullptr`
 expression, and it has the characteristics described in
 taken. — *end note*]
 The macro `NULL` is an *implementation-defined* null pointer
 constant.[^1]
+See also: ISO C 7.21
 ### 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>`,
 *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 trivially copyable 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]].
+`std::is_trivially_default_constructible_v<max_align_t>` is `true`.
+See also: ISO C 7.21
 ### `byte` type operations <a id="support.types.byteops">[[support.types.byteops]]</a>
 ``` cpp
 template<class IntType>
 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 this document might replace the values
+of these macros with greater values. — *end note*]
 ``` cpp
+#define __cpp_lib_adaptor_iterator_pair_constructor 202106L // also in <stack>, <queue>
+#define __cpp_lib_addressof_constexpr               201603L // freestanding, also in <memory>
+#define __cpp_lib_algorithm_default_value_type      202403L
+  // also in <algorithm>, <ranges>, <string>, <deque>, <list>, <forward_list>, <vector>
 #define __cpp_lib_algorithm_iterator_requirements   202207L
   // also in <algorithm>, <numeric>, <memory>
+#define __cpp_lib_aligned_accessor                  202411L // also in <mdspan>
 #define __cpp_lib_allocate_at_least                 202302L // also in <memory>
 #define __cpp_lib_allocator_traits_is_always_equal  201411L
+  // freestanding, 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                             202506L // freestanding, also in <tuple>, <type_traits>
 #define __cpp_lib_array_constexpr                   201811L // also in <iterator>, <array>
+#define __cpp_lib_as_const                          201510L // freestanding, also in <utility>
 #define __cpp_lib_associative_heterogeneous_erasure 202110L
   // also in <map>, <set>, <unordered_map>, <unordered_set>
+#define __cpp_lib_associative_heterogeneous_insertion 202306L
+ // also in <map>, <set>, <unordered_map>, <unordered_set>
+#define __cpp_lib_assume_aligned                    201811L // freestanding, also in <memory>
+#define __cpp_lib_atomic_flag_test                  201907L // freestanding, also in <atomic>
+#define __cpp_lib_atomic_float                      201711L // freestanding, also in <atomic>
+#define __cpp_lib_atomic_is_always_lock_free        201603L // freestanding, also in <atomic>
 #define __cpp_lib_atomic_lock_free_type_aliases     201907L // also in <atomic>
+#define __cpp_lib_atomic_min_max                    202506L // freestanding, also in <atomic>
+#define __cpp_lib_atomic_reductions                 202506L // freestanding, also in <atomic>
+#define __cpp_lib_atomic_ref                        202411L // freestanding, also in <atomic>
 #define __cpp_lib_atomic_shared_ptr                 201711L // also in <memory>
+#define __cpp_lib_atomic_value_initialization       201911L // freestanding, also in <atomic>, <memory>
+#define __cpp_lib_atomic_wait                       201907L // freestanding, also in <atomic>
 #define __cpp_lib_barrier                           202302L // also in <barrier>
+#define __cpp_lib_bind_back                         202306L // freestanding, also in <functional>
+#define __cpp_lib_bind_front                        202306L // freestanding, also in <functional>
+#define __cpp_lib_bit_cast                          201806L // freestanding, also in <bit>
+#define __cpp_lib_bitops                            201907L // freestanding, also in <bit>
+#define __cpp_lib_bitset                            202306L // also in <bitset>
+#define __cpp_lib_bool_constant                     201505L // freestanding, also in <type_traits>
+#define __cpp_lib_bounded_array_traits              201902L // freestanding, also in <type_traits>
 #define __cpp_lib_boyer_moore_searcher              201603L // also in <functional>
+#define __cpp_lib_byte                              201603L // freestanding, also in <cstddef>
+#define __cpp_lib_byteswap                          202110L // freestanding, also in <bit>
 #define __cpp_lib_char8_t                           201907L
+  // freestanding, also in <atomic>, <filesystem>, <istream>, <limits>, <locale>, <ostream>, <string>,
+ // <string_view>
+#define __cpp_lib_chrono                            202306L // 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 // freestanding, also in <type_traits>
+#define __cpp_lib_common_reference_wrapper          202302L // freestanding, also in <functional>
 #define __cpp_lib_complex_udls                      201309L // also in <complex>
+#define __cpp_lib_concepts                          202207L
+ // freestanding, also in <concepts>, <compare>
+#define __cpp_lib_constant_wrapper                  202506L // freestanding, also in <type_traits>
+#define __cpp_lib_constexpr_algorithms              202306L // also in <algorithm>, <utility>
+#define __cpp_lib_constexpr_atomic                  202411L // also in <atomic>
 #define __cpp_lib_constexpr_bitset                  202207L // also in <bitset>
+#define __cpp_lib_constexpr_charconv                202207L // freestanding, also in <charconv>
+#define __cpp_lib_constexpr_cmath                   202306L // also in <cmath>, <cstdlib>
+#define __cpp_lib_constexpr_complex                 202306L // also in <complex>
+#define __cpp_lib_constexpr_deque                   202502L // also in <deque>
 #define __cpp_lib_constexpr_dynamic_alloc           201907L // also in <memory>
+#define __cpp_lib_constexpr_exceptions 202502L
+ // also in <exception>, <stdexcept>, <expected>, <optional>, <variant>, and <format>
+#define __cpp_lib_constexpr_flat_map                202502L // also in <flat_map>
+#define __cpp_lib_constexpr_flat_set                202502L // also in <flat_set>
+#define __cpp_lib_constexpr_forward_list            202502L // also in <forward_list>
+#define __cpp_lib_constexpr_functional              201907L // freestanding, also in <functional>
+#define __cpp_lib_constexpr_inplace_vector          202502L // also in <inplace_vector>
+#define __cpp_lib_constexpr_iterator                201811L // freestanding, also in <iterator>
+#define __cpp_lib_constexpr_list                    202502L // also in <list>
+#define __cpp_lib_constexpr_map                     202502L // also in <map>
+#define __cpp_lib_constexpr_memory                  202506L // freestanding, also in <memory>
+#define __cpp_lib_constexpr_new                     202406L // freestanding, also in <new>
 #define __cpp_lib_constexpr_numeric                 201911L // also in <numeric>
+#define __cpp_lib_constexpr_queue                   202502L // also in <queue>
+#define __cpp_lib_constexpr_set                     202502L // also in <set>
+#define __cpp_lib_constexpr_stack                   202502L // also in <stack>
 #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 // freestanding, also in <tuple>
+#define __cpp_lib_constexpr_typeinfo                202106L // freestanding, also in <typeinfo>
+#define __cpp_lib_constexpr_unordered_map           202502L // also in <unordered_map>
+#define __cpp_lib_constexpr_unordered_set           202502L // also in <unordered_set>
+#define __cpp_lib_constexpr_utility                 201811L // freestanding, also in <utility>
 #define __cpp_lib_constexpr_vector                  201907L // also in <vector>
+#define __cpp_lib_constrained_equality              202411L // freestanding,
+  // also in <utility>, <tuple>, <optional>, <variant>, <expected>
 #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_contracts 202502L // freestanding, also in <contracts>
+#define __cpp_lib_copyable_function 202306L // also in <functional>
+#define __cpp_lib_coroutine                         201902L // freestanding, also in <coroutine>
+#define __cpp_lib_counting_scope                    202506L // also in <execution>
+#define __cpp_lib_debugging                         202403L // freestanding, also in <debugging>
+#define __cpp_lib_define_static                     202506L // freestanding, also in <meta>
+#define __cpp_lib_destroying_delete                 201806L // freestanding, also in <new>
 #define __cpp_lib_enable_shared_from_this           201603L // also in <memory>
+#define __cpp_lib_endian                            201907L // freestanding, 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_exception_ptr_cast                202506L // also in <exception>
+#define __cpp_lib_exchange_function                 201304L // freestanding, 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                            202311L // also in <format>
+#define __cpp_lib_format_path                       202506L // also in <filesystem>
 #define __cpp_lib_format_ranges                     202207L // also in <format>
+#define __cpp_lib_format_uchar                      202311L // also in <format>
 #define __cpp_lib_formatters                        202302L // also in <stacktrace>, <thread>
+#define __cpp_lib_forward_like                      202207L // freestanding, also in <utility>
+#define __cpp_lib_freestanding_algorithm            202502L // freestanding, also in <algorithm>
+#define __cpp_lib_freestanding_array                202311L // freestanding, also in <array>
+#define __cpp_lib_freestanding_char_traits          202306L // freestanding, also in <string>
+#define __cpp_lib_freestanding_charconv             202306L // freestanding, also in <charconv>
+#define __cpp_lib_freestanding_cstdlib              202306L // freestanding, also in <cstdlib>, <cmath>
+#define __cpp_lib_freestanding_cstring              202311L // freestanding, also in <cstring>
+#define __cpp_lib_freestanding_cwchar               202306L // freestanding, also in <cwchar>
+#define __cpp_lib_freestanding_errc                 202306L
+  // freestanding, also in <cerrno>, <system_error>
+#define __cpp_lib_freestanding_execution            202502L // freestanding, also in <execution>
+#define __cpp_lib_freestanding_expected             202311L // freestanding, also in <expected>
+#define __cpp_lib_freestanding_feature_test_macros  202306L // freestanding
+#define __cpp_lib_freestanding_functional           202306L // freestanding, also in <functional>
+#define __cpp_lib_freestanding_iterator             202306L // freestanding, also in <iterator>
+#define __cpp_lib_freestanding_mdspan               202311L // freestanding, also in <mdspan>
+#define __cpp_lib_freestanding_memory               202502L // freestanding, also in <memory>
+#define __cpp_lib_freestanding_numeric              202502L // freestanding, also in <numeric>
+#define __cpp_lib_freestanding_operator_new         see below // freestanding, also in <new>
+#define __cpp_lib_freestanding_optional             202506L // freestanding, also in <optional>
+#define __cpp_lib_freestanding_random               202502L // freestanding, also in <random>
+#define __cpp_lib_freestanding_ranges               202306L // freestanding, also in <ranges>
+#define __cpp_lib_freestanding_ratio                202306L // freestanding, also in <ratio>
+#define __cpp_lib_freestanding_string_view          202311L // freestanding, also in <string_view>
+#define __cpp_lib_freestanding_tuple                202306L // freestanding, also in <tuple>
+#define __cpp_lib_freestanding_utility              202306L // freestanding, also in <utility>
+#define __cpp_lib_freestanding_variant              202311L // freestanding, also in <variant>
+#define __cpp_lib_fstream_native_handle             202306L // also in <fstream>
+#define __cpp_lib_function_ref                      202306L // also in <functional>
 #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 // freestanding, also in <new>
+#define __cpp_lib_has_unique_object_representations 201606L // freestanding, also in <type_traits>
+#define __cpp_lib_hazard_pointer                    202306L // also in <hazard_pointer>
+#define __cpp_lib_hive                              202502L // also in <hive>
 #define __cpp_lib_hypot                             201603L // also in <cmath>
 #define __cpp_lib_incomplete_container_elements     201505L
   // also in <forward_list>, <list>, <vector>
+#define __cpp_lib_indirect 202502L // also in <memory>
+#define __cpp_lib_inplace_vector                    202406L // also in <inplace_vector>
+#define __cpp_lib_int_pow2                          202002L // freestanding, also in <bit>
 #define __cpp_lib_integer_comparison_functions      202002L // also in <utility>
+#define __cpp_lib_integer_sequence                  201304L // freestanding, also in <utility>
+#define __cpp_lib_integral_constant_callable        201304L // freestanding, also in <type_traits>
 #define __cpp_lib_interpolate                       201902L // also in <cmath>, <numeric>
+#define __cpp_lib_invoke                            201411L // freestanding, also in <functional>
+#define __cpp_lib_invoke_r                          202106L // freestanding, also in <functional>
 #define __cpp_lib_ios_noreplace                     202207L // also in <ios>
+#define __cpp_lib_is_aggregate                      201703L // freestanding, also in <type_traits>
+#define __cpp_lib_is_constant_evaluated             201811L // freestanding, also in <type_traits>
+#define __cpp_lib_is_final                          201402L // freestanding, also in <type_traits>
+#define __cpp_lib_is_implicit_lifetime              202302L // freestanding, also in <type_traits>
+#define __cpp_lib_is_invocable                      201703L // freestanding, also in <type_traits>
+#define __cpp_lib_is_layout_compatible              201907L // freestanding, also in <type_traits>
+#define __cpp_lib_is_nothrow_convertible            201806L // freestanding, also in <type_traits>
+#define __cpp_lib_is_null_pointer                   201309L // freestanding, also in <type_traits>
+#define __cpp_lib_is_pointer_interconvertible       201907L // freestanding, also in <type_traits>
+#define __cpp_lib_is_scoped_enum                    202011L // freestanding, also in <type_traits>
+#define __cpp_lib_is_sufficiently_aligned           202411L // also in <memory>
+#define __cpp_lib_is_swappable                      201603L // freestanding, also in <type_traits>
+#define __cpp_lib_is_virtual_base_of                202406L // freestanding, also in <type_traits>
+#define __cpp_lib_is_within_lifetime                202306L // freestanding, 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 // freestanding, also in <new>
+#define __cpp_lib_linalg                            202412L // also in <linalg>
 #define __cpp_lib_list_remove_return_type           201806L // also in <forward_list>, <list>
+#define __cpp_lib_logical_traits                    201510L // freestanding, also in <type_traits>
+#define __cpp_lib_make_from_tuple                   201606L // freestanding, also in <tuple>
+#define __cpp_lib_make_reverse_iterator             201402L // freestanding, 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                            202406L // freestanding, also in <mdspan>
 #define __cpp_lib_memory_resource                   201603L // also in <memory_resource>
+#define __cpp_lib_modules                           202207L // freestanding
+#define __cpp_lib_move_iterator_concept             202207L // freestanding, 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
+  // freestanding, also in <array>, <deque>, <forward_list>, <iterator>, <list>, <map>, <regex>, <set>,
+  // <string>, <unordered_map>, <unordered_set>, <vector>
+#define __cpp_lib_not_fn                            202306L // freestanding, also in <functional>
+#define __cpp_lib_null_iterators                    201304L // freestanding, also in <iterator>
+#define __cpp_lib_observable_checkpoint             202506L // freestanding, also in <utility>
+#define __cpp_lib_optional                          202506L // also in <optional>
+#define __cpp_lib_optional_range_support            202406L // freestanding, also in <optional>
+#define __cpp_lib_out_ptr                           202311L // freestanding, also in <memory>
+#define __cpp_lib_parallel_algorithm                202506L
+  // also in <algorithm>, <numeric>, <memory>
+#define __cpp_lib_parallel_scheduler                202506L // also in <execution>
+#define __cpp_lib_philox_engine                     202406L // also in <random>
+#define __cpp_lib_polymorphic                       202502L // also in <memory>
 #define __cpp_lib_polymorphic_allocator             201902L // also in <memory_resource>
+#define __cpp_lib_print                             202406L // also in <print>, <ostream>
 #define __cpp_lib_quoted_string_io                  201304L // also in <iomanip>
+#define __cpp_lib_ranges                            202406L
   // also in <algorithm>, <functional>, <iterator>, <memory>, <ranges>
+#define __cpp_lib_ranges_as_const                   202311L // freestanding, also in <ranges>
+#define __cpp_lib_ranges_as_rvalue                  202207L // freestanding, also in <ranges>
+#define __cpp_lib_ranges_cache_latest               202411L // freestanding, also in <ranges>
+#define __cpp_lib_ranges_cartesian_product          202207L // freestanding, also in <ranges>
+#define __cpp_lib_ranges_chunk                      202202L // freestanding, also in <ranges>
+#define __cpp_lib_ranges_chunk_by                   202202L // freestanding, also in <ranges>
+#define __cpp_lib_ranges_concat                     202403L // freestanding, also in <ranges>
 #define __cpp_lib_ranges_contains                   202207L // also in <algorithm>
+#define __cpp_lib_ranges_enumerate                  202302L // also in <ranges>
 #define __cpp_lib_ranges_find_last                  202207L // also in <algorithm>
 #define __cpp_lib_ranges_fold                       202207L // also in <algorithm>
+#define __cpp_lib_ranges_generate_random            202403L // also in <random>
+#define __cpp_lib_ranges_indices                    202506L // also in <ranges>
 #define __cpp_lib_ranges_iota                       202202L // also in <numeric>
+#define __cpp_lib_ranges_join_with                  202202L // freestanding, also in <ranges>
+#define __cpp_lib_ranges_repeat                     202207L // freestanding, also in <ranges>
+#define __cpp_lib_ranges_reserve_hint               202502L // also in <ranges>
+#define __cpp_lib_ranges_slide                      202202L // freestanding, also in <ranges>
 #define __cpp_lib_ranges_starts_ends_with           202106L // also in <algorithm>
+#define __cpp_lib_ranges_stride                     202207L // freestanding, also in <ranges>
+#define __cpp_lib_ranges_to_container               202202L // freestanding, also in <ranges>
+#define __cpp_lib_ranges_to_input                   202502L // freestanding, also in <ranges>
+#define __cpp_lib_ranges_zip                        202110L
+ // freestanding, also in <ranges>, <tuple>, <utility>
+#define __cpp_lib_ratio                             202306L // freestanding, also in <ratio>
+#define __cpp_lib_raw_memory_algorithms             202411L // also in <memory>
+#define __cpp_lib_rcu                               202306L // also in <rcu>
+#define __cpp_lib_reference_from_temporary          202202L // freestanding, also in <type_traits>
+#define __cpp_lib_reference_wrapper                 202403L // freestanding, also in <functional>
+#define __cpp_lib_reflection                        202506L // also in <meta>
+#define __cpp_lib_remove_cvref                      201711L // freestanding, also in <type_traits>
+#define __cpp_lib_result_of_sfinae                  201210L
+  // freestanding, 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_saturation_arithmetic             202311L // also in <numeric>
 #define __cpp_lib_scoped_lock                       201703L // also in <mutex>
 #define __cpp_lib_semaphore                         201907L // also in <semaphore>
+#define __cpp_lib_senders                           202506L // also in <execution>
 #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_simd                              202506L // also in <simd>
+#define __cpp_lib_simd_complex                      202502L // also in <simd>
+#define __cpp_lib_simd_permutations                 202506L // also in <simd>
 #define __cpp_lib_smart_ptr_for_overwrite           202002L // also in <memory>
+#define __cpp_lib_smart_ptr_owner_equality          202306L // also in <memory>
+#define __cpp_lib_source_location                   201907L // freestanding, also in <source_location>
+#define __cpp_lib_span                              202311L // freestanding, also in <span>
+#define __cpp_lib_span_initializer_list             202311L // freestanding, also in <span>
 #define __cpp_lib_spanstream                        202106L // also in <spanstream>
+#define __cpp_lib_ssize                             201902L // freestanding, also in <iterator>
+#define __cpp_lib_sstream_from_string_view          202306L // also in <sstream>
 #define __cpp_lib_stacktrace                        202011L // also in <stacktrace>
+#define __cpp_lib_start_lifetime_as                 202207L // freestanding, 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_subview                    202506L // also in <string>, <string_view>
 #define __cpp_lib_string_udls                       201304L // also in <string>
+#define __cpp_lib_string_view                       202403L // also in <string>, <string_view>
+#define __cpp_lib_submdspan                         202411L // freestanding, also in <mdspan>
 #define __cpp_lib_syncbuf                           201803L // also in <syncstream>
+#define __cpp_lib_task                              202506L // also in <execution>
+#define __cpp_lib_text_encoding                     202306L // also in <text_encoding>
+#define __cpp_lib_three_way_comparison              201907L // freestanding, also in <compare>
+#define __cpp_lib_to_address                        201711L // freestanding, also in <memory>
+#define __cpp_lib_to_array                          201907L // freestanding, also in <array>
+#define __cpp_lib_to_chars                          202306L // also in <charconv>
+#define __cpp_lib_to_string                         202306L // also in <string>
+#define __cpp_lib_to_underlying                     202102L // freestanding, also in <utility>
+#define __cpp_lib_transformation_trait_aliases      201304L // freestanding, also in <type_traits>
+#define __cpp_lib_transparent_operators             201510L
+  // freestanding, also in <memory>, <functional>
+#define __cpp_lib_trivially_relocatable             202502L
+  // freestanding, also in <memory>, <type_traits>
+#define __cpp_lib_tuple_element_t                   201402L // freestanding, also in <tuple>
+#define __cpp_lib_tuple_like                        202311L
   // also in <utility>, <tuple>, <map>, <unordered_map>
+#define __cpp_lib_tuples_by_type                    201304L // freestanding, also in <utility>, <tuple>
+#define __cpp_lib_type_identity                     201806L // freestanding, also in <type_traits>
+#define __cpp_lib_type_order                        202506L // also in <compare>
+#define __cpp_lib_type_trait_variable_templates     201510L // freestanding, also in <type_traits>
+#define __cpp_lib_uncaught_exceptions               201411L // freestanding, also in <exception>
 #define __cpp_lib_unordered_map_try_emplace         201411L // also in <unordered_map>
+#define __cpp_lib_unreachable                       202202L // freestanding, also in <utility>
+#define __cpp_lib_unwrap_ref                        201811L // freestanding, also in <type_traits>
+#define __cpp_lib_variant                           202306L // also in <variant>
+#define __cpp_lib_void_t                            201411L // freestanding, also in <type_traits>
 ```
+Additionally, each of the following macros is defined in a hardened
+implementation:
+``` cpp
+#define __cpp_lib_hardened_array                    202502L // also in <array>
+#define __cpp_lib_hardened_basic_stacktrace         202506L // also in <stacktrace>
+#define __cpp_lib_hardened_basic_string             202502L // also in <string>
+#define __cpp_lib_hardened_basic_string_view        202502L // also in <string_view>
+#define __cpp_lib_hardened_bitset                   202502L // also in <bitset>
+#define __cpp_lib_hardened_common_iterator          202506L // also in <iterator>
+#define __cpp_lib_hardened_counted_iterator         202506L // also in <iterator>
+#define __cpp_lib_hardened_deque                    202502L // also in <deque>
+#define __cpp_lib_hardened_expected                 202502L // also in <expected>
+#define __cpp_lib_hardened_forward_list             202502L // also in <forward_list>
+#define __cpp_lib_hardened_inplace_vector           202502L // also in <inplace_vector>
+#define __cpp_lib_hardened_list                     202502L // also in <list>
+#define __cpp_lib_hardened_mdspan                   202502L // also in <mdspan>
+#define __cpp_lib_hardened_optional                 202502L // also in <optional>
+#define __cpp_lib_hardened_shared_ptr_array         202506L // also in <memory>
+#define __cpp_lib_hardened_span                     202502L // also in <span>
+#define __cpp_lib_hardened_valarray                 202502L // also in <valarray>
+#define __cpp_lib_hardened_vector                   202502L // also in <vector>
+#define __cpp_lib_hardened_view_interface           202506L // also in <ranges>
+```
+The macro `__cpp_lib_freestanding_operator_new` is defined to the
+integer literal `202306L` if all the default versions of the replaceable
+global allocation functions meet the requirements of a hosted
+implementation, and to the integer literal `0` otherwise [[new.delete]].
+*Recommended practice:* Freestanding implementations should only define
+a macro from `<version>` if the implementation provides the
+corresponding facility in its entirety.
+*Recommended practice:* A non-hardened implementation should not define
+macros from `<version>` required for hardened implementations.
 ### Header `<limits>` synopsis <a id="limits.syn">[[limits.syn]]</a>
 ``` cpp
 // all freestanding
 namespace std {
 #### `numeric_limits` members <a id="numeric.limits.members">[[numeric.limits.members]]</a>
 Each member function defined in this subclause is signal-safe
 [[support.signal]].
+[*Note 1*:  The arithmetic specification described in ISO/IEC
+10967-1:2012 is commonly termed LIA-1. — *end note*]
 ``` cpp
 static constexpr T min() noexcept;
 ```
 Minimum finite value.[^3]
 Number of `radix` digits that can be represented without change.
 For integer types, the number of non-sign bits in the representation.
 For floating-point types, the number of `radix` digits in the
+significand.[^6]
 ``` cpp
 static constexpr int digits10;
 ```
 ``` cpp
 static constexpr bool is_iec559;
 ```
+`true` if and only if the type adheres to ISO/IEC 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*]
 ### Header `<climits>` synopsis <a id="climits.syn">[[climits.syn]]</a>
 ``` cpp
 // all freestanding
+#define BOOL_WIDTH see below
 #define CHAR_BIT see below
+#define CHAR_WIDTH see below
+#define SCHAR_WIDTH see below
+#define UCHAR_WIDTH see below
+#define USHRT_WIDTH see below
+#define SHRT_WIDTH see below
+#define UINT_WIDTH see below
+#define INT_WIDTH see below
+#define ULONG_WIDTH see below
+#define LONG_WIDTH see below
+#define ULLONG_WIDTH see below
+#define LLONG_WIDTH see below
 #define SCHAR_MIN see below
 #define SCHAR_MAX see below
 #define UCHAR_MAX see below
 #define CHAR_MIN see below
 #define CHAR_MAX see below
 #define LLONG_MAX see below
 #define ULLONG_MAX see below
 ```
 The header `<climits>` defines all macros the same as the C standard
+library header `<limits.h>`, except that it does not define the macro
+`BITINT_MAXWIDTH`.
+[*Note 1*: Except for the `WIDTH` macros, `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.3.5.3.2
 ### Header `<cfloat>` synopsis <a id="cfloat.syn">[[cfloat.syn]]</a>
 ``` cpp
 // all freestanding
+#define __STDC_VERSION_FLOAT_H__ 202311L
 #define FLT_ROUNDS see below
 #define FLT_EVAL_METHOD see below
 #define FLT_RADIX see below
+#define INFINITY see below
+#define NAN see below
+#define FLT_SNAN see below
+#define DBL_SNAN see below
+#define LDBL_SNAN see below
 #define FLT_MANT_DIG see below
 #define DBL_MANT_DIG see below
 #define LDBL_MANT_DIG see below
 #define FLT_DECIMAL_DIG see below
 #define DBL_DECIMAL_DIG see below
 #define LDBL_DECIMAL_DIG see below
 #define FLT_DIG see below
 #define DBL_DIG see below
 #define LDBL_DIG see below
 #define FLT_MIN_EXP see below
 #define DBL_MIN_EXP see below
 ```
 The header `<cfloat>` defines all macros the same as the C standard
 library header `<float.h>`.
+See also: ISO C 5.3.5.3.3
 ## 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
+#define __STDC_VERSION_STDINT_H__ 202311L
 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
 }
 #define INTN_MIN          see below
 #define INTN_MAX          see below
 #define UINTN_MAX         see below
+#define INTN_WIDTH        see below
+#define UINTN_WIDTH       see below
 #define INT_FASTN_MIN     see below
 #define INT_FASTN_MAX     see below
 #define UINT_FASTN_MAX    see below
+#define INT_FASTN_WIDTH   see below
+#define UINT_FASTN_WIDTH  see below
 #define INT_LEASTN_MIN    see below
 #define INT_LEASTN_MAX    see below
 #define UINT_LEASTN_MAX   see below
+#define INT_LEASTN_WIDTH  see below
+#define UINT_LEASTN_WIDTH see below
 #define INTMAX_MIN        see below
 #define INTMAX_MAX        see below
 #define UINTMAX_MAX       see below
+#define INTMAX_WIDTH      see below
+#define UINTMAX_WIDTH     see below
 #define INTPTR_MIN        see below              // optional
 #define INTPTR_MAX        see below              // optional
 #define UINTPTR_MAX       see below              // optional
+#define INTPTR_WIDTH      see below              // optional
+#define UINTPTR_WIDTH     see below              // optional
 #define PTRDIFF_MIN       see below
 #define PTRDIFF_MAX       see below
+#define PTRDIFF_WIDTH     see below
 #define SIZE_MAX          see below
+#define SIZE_WIDTH        see below
 #define SIG_ATOMIC_MIN    see below
 #define SIG_ATOMIC_MAX    see below
+#define SIG_ATOMIC_WIDTH  see below
 #define WCHAR_MIN         see below
 #define WCHAR_MAX         see below
+#define WCHAR_WIDTH       see below
 #define WINT_MIN          see below
 #define WINT_MAX          see below
+#define WINT_WIDTH        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>`. The types denoted by `intmax_t` and
+`uintmax_t` are not required to be able to represent all values of
+extended integer types wider than `long long` and `unsigned long long`,
+respectively.
+See also: ISO C 7.22
 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
 *Effects:* This function has the semantics specified in the C standard
 library.
 *Remarks:* The program is terminated without executing destructors for
+objects with automatic, thread, or static storage duration and without
 calling functions passed to `atexit()` [[basic.start.term]]. The
 function `_Exit` is signal-safe [[support.signal]].
 ``` cpp
 [[noreturn]] void abort() noexcept;
 `_Exit(status)`.
 *Remarks:* The function `quick_exit` is signal-safe [[support.signal]]
 when the functions registered with `at_quick_exit` are.
+See also: ISO C 7.24.5
 ## Dynamic memory management <a id="support.dynamic">[[support.dynamic]]</a>
 ### General <a id="support.dynamic.general">[[support.dynamic.general]]</a>
   using new_handler = void (*)();
   new_handler get_new_handler() noexcept;
   new_handler set_new_handler(new_handler new_p) noexcept;
   // [ptr.launder], pointer optimization barrier
+  template<class T> constexpr T* launder(T* p) noexcept;
   // [hardware.interference], hardware interference size
   inline constexpr size_t hardware_destructive_interference_size = implementation-defined{};
   inline constexpr size_t hardware_constructive_interference_size = implementation-defined{};
 }
 // [new.delete], storage allocation and deallocation
+void* operator new(std::size_t size);
+void* operator new(std::size_t size, std::align_val_t alignment);
+void* operator new(std::size_t size, const std::nothrow_t&) noexcept;
+void* operator new(std::size_t size, std::align_val_t alignment, const std::nothrow_t&) noexcept;
 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;
 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;
+void* operator new[](std::size_t size);
+void* operator new[](std::size_t size, std::align_val_t alignment);
+void* operator new[](std::size_t size, const std::nothrow_t&) noexcept;
+void* operator new[](std::size_t size, std::align_val_t alignment,
                      const std::nothrow_t&) noexcept;
 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;
 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;
+constexpr void* operator new  (std::size_t size, void* ptr) noexcept;
+constexpr void* operator new[](std::size_t size, void* ptr) noexcept;
 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>
 [[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.
+On freestanding implementations, it is *implementation-defined* whether
+the default versions of the replaceable global allocation functions
+satisfy the required behaviors described in [[new.delete.single]] and
+[[new.delete.array]].
+[*Note 1*: A freestanding implementation’s default versions of the
+replaceable global allocation functions can cause undefined behavior
+when invoked. During constant evaluation, the behaviors of those default
+versions are irrelevant, as those calls are omitted
+[[expr.new]]. — *end note*]
+*Recommended practice:* If any of the default versions of the
+replaceable global allocation functions meet the requirements of a
+hosted implementation, they all should.
 #### Single-object forms <a id="new.delete.single">[[new.delete.single]]</a>
 ``` cpp
+void* operator new(std::size_t size);
+void* operator new(std::size_t size, std::align_val_t alignment);
 ```
 *Effects:* The allocation functions [[basic.stc.dynamic.allocation]]
 called by 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.
 *Required behavior:* Return a non-null pointer to suitably aligned
 storage [[basic.stc.dynamic]], or else throw a `bad_alloc` exception.
 This requirement is binding on any replacement versions of these
 functions.
   function [[new.handler]]. If the called function returns, the loop
   repeats.
 - The loop terminates when an attempt to allocate the requested storage
   is successful or when a called `new_handler` function does not return.
+*Remarks:* This function is replaceable [[term.replaceable.function]].
 ``` cpp
+void* operator new(std::size_t size, const std::nothrow_t&) noexcept;
+void* operator new(std::size_t size, std::align_val_t alignment, const std::nothrow_t&) noexcept;
 ```
 *Effects:* Same as above, except that these are called by a placement
 version of a *new-expression* when a C++ program prefers a null pointer
 result as an error indication, instead of a `bad_alloc` exception.
 *Required behavior:* Return a non-null pointer to suitably aligned
 storage [[basic.stc.dynamic]], or else return a null pointer. Each of
 these nothrow versions of `operator new` returns a pointer obtained as
 if acquired from the (possibly replaced) corresponding non-placement
 function. This requirement is binding on any replacement versions of
 T* p2 = new(nothrow) T;         // returns nullptr if it fails
 ```
 — *end example*]
+*Remarks:* This function is replaceable [[term.replaceable.function]].
 ``` cpp
 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.
 *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.
+[*Note 1*: A conforming implementation is for
 `operator delete(void* ptr, std::size_t size)` to simply call
 `operator delete(ptr)`. — *end note*]
 *Default behavior:* The functions that have a `size` parameter forward
 their other parameters to the corresponding function without a `size`
 parameter.
+[*Note 2*: See the note in the below *Remarks:*
 paragraph. — *end note*]
 *Default behavior:* If `ptr` is null, does nothing. Otherwise, reclaims
 the storage allocated by the earlier call to `operator new`.
 *Remarks:* It is unspecified under what conditions part or all of such
 reclaimed storage will be allocated by subsequent calls to
 `operator new` or any of `aligned_alloc`, `calloc`, `malloc`, or
+`realloc`, declared in `<cstdlib>`. This function is
+replaceable [[term.replaceable.function]]. If a replacement function
+without a `size` parameter is defined by the program, the program should
+also define the corresponding function with a `size` parameter. If a
+replacement function with a `size` parameter is defined by the program,
+the program shall also define the corresponding version without the
+`size` parameter.
+[*Note 3*: The default behavior above might change in the future, which
+will require replacing both deallocation functions when replacing the
+allocation function. — *end note*]
 ``` 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.
 *Default behavior:* Calls `operator delete(ptr)`, or
 `operator delete(ptr, alignment)`, respectively.
+*Remarks:* This function is replaceable [[term.replaceable.function]].
 #### Array forms <a id="new.delete.array">[[new.delete.array]]</a>
 ``` cpp
+void* operator new[](std::size_t size);
+void* operator new[](std::size_t size, std::align_val_t alignment);
 ```
 *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]
 *Required behavior:* Same as for the corresponding single-object forms.
 This requirement is binding on any replacement versions of these
 functions.
 *Default behavior:* Returns `operator new(size)`, or
 `operator new(size, alignment)`, respectively.
+*Remarks:* This function is replaceable [[term.replaceable.function]].
 ``` cpp
+void* operator new[](std::size_t size, const std::nothrow_t&) noexcept;
+void* operator new[](std::size_t size, std::align_val_t alignment, const std::nothrow_t&) noexcept;
 ```
 *Effects:* Same as above, except that these are called by a placement
 version of a *new-expression* when a C++ program prefers a null pointer
 result as an error indication, instead of a `bad_alloc` exception.
 *Required behavior:* Return a non-null pointer to suitably aligned
 storage [[basic.stc.dynamic]], or else return a null pointer. Each of
 these nothrow versions of `operator new[]` returns a pointer obtained as
 if acquired from the (possibly replaced) corresponding non-placement
 function. This requirement is binding on any replacement versions of
 *Default behavior:* Calls `operator new[](size)`, or
 `operator new[](size, alignment)`, respectively. If the call returns
 normally, returns the result of that call. Otherwise, returns a null
 pointer.
+*Remarks:* This function is replaceable [[term.replaceable.function]].
 ``` cpp
 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.
 *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.
+[*Note 1*: A conforming implementation is for
 `operator delete[](void* ptr, std::size_t size)` to simply call
 `operator delete[](ptr)`. — *end note*]
 *Default behavior:* The functions that have a `size` parameter forward
 their other parameters to the corresponding function without a `size`
 parameter. The functions that do not have a `size` parameter forward
 their parameters to the corresponding `operator delete` (single-object)
 function.
+*Remarks:* This function is replaceable [[term.replaceable.function]].
+If a replacement function without a `size` parameter is defined by the
+program, the program should also define the corresponding function with
+a `size` parameter. If a replacement function with a `size` parameter is
+defined by the program, the program shall also define the corresponding
+version without the `size` parameter.
+[*Note 2*: The default behavior above might change in the future, which
+will require replacing both deallocation functions when replacing the
+allocation function. — *end note*]
 ``` 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.
 *Default behavior:* Calls `operator delete[](ptr)`, or
 `operator delete[](ptr, alignment)`, respectively.
+*Remarks:* This function is replaceable [[term.replaceable.function]].
 #### Non-allocating forms <a id="new.delete.placement">[[new.delete.placement]]</a>
 These functions are reserved; a C++ program may not define functions
 that displace the versions in the C++ standard library [[constraints]].
 The provisions of  [[basic.stc.dynamic]] do not apply to these reserved
 placement forms of `operator new` and `operator delete`.
 ``` cpp
+constexpr void* operator new(std::size_t size, void* ptr) noexcept;
 ```
 *Returns:* `ptr`.
 *Remarks:* Intentionally performs no other action.
 ```
 — *end example*]
 ``` cpp
+constexpr void* operator new[](std::size_t size, void* ptr) noexcept;
 ```
 *Returns:* `ptr`.
 *Remarks:* Intentionally performs no other action.
 ``` cpp
 namespace std {
   class bad_alloc : public exception {
   public:
     // see [exception] for the specification of the special member functions
+ constexpr const char* what() const noexcept override;
   };
 }
 ```
 The class `bad_alloc` defines the type of objects thrown as exceptions
 by the implementation to report a failure to allocate storage.
 ``` cpp
+constexpr const char* what() const noexcept override;
 ```
 *Returns:* An *implementation-defined* NTBS.
 #### Class `bad_array_new_length` <a id="new.badlength">[[new.badlength]]</a>
 ``` cpp
 namespace std {
   class bad_array_new_length : public bad_alloc {
   public:
     // see [exception] for the specification of the special member functions
+ constexpr const char* what() const noexcept override;
   };
 }
 ```
 The class `bad_array_new_length` defines the type of objects thrown as
 exceptions by the implementation to report an attempt to allocate an
 array of size less than zero or greater than an *implementation-defined*
 limit [[expr.new]].
 ``` cpp
+constexpr const char* what() const noexcept override;
 ```
 *Returns:* An *implementation-defined* NTBS.
 #### Type `new_handler` <a id="new.handler">[[new.handler]]</a>
 [*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> 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
 ### 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. The header `<typeindex>` defines a
+wrapper type for use as an index type in associative containers
+[[associative]] and in unordered associative containers [[unord]].
 ### Header `<typeinfo>` synopsis <a id="typeinfo.syn">[[typeinfo.syn]]</a>
 ``` cpp
 // all freestanding
     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;
+    type_info& operator=(const type_info&) = delete;
   };
 }
 ```
 The class `type_info` describes type information generated by the
 ``` cpp
 namespace std {
   class bad_cast : public exception {
   public:
     // see [exception] for the specification of the special member functions
+ constexpr const char* what() const noexcept override;
   };
 }
 ```
 The class `bad_cast` defines the type of objects thrown as exceptions by
 the implementation to report the execution of an invalid `dynamic_cast`
 expression [[expr.dynamic.cast]].
 ``` cpp
+constexpr const char* what() const noexcept override;
 ```
 *Returns:* An *implementation-defined* NTBS.
 ### Class `bad_typeid` <a id="bad.typeid">[[bad.typeid]]</a>
 ``` cpp
 namespace std {
   class bad_typeid : public exception {
   public:
     // see [exception] for the specification of the special member functions
+ constexpr const char* what() const noexcept override;
   };
 }
 ```
 The class `bad_typeid` defines the type of objects thrown as exceptions
 by the implementation to report a null pointer in a `typeid` expression
 [[expr.typeid]].
 ``` cpp
+constexpr const char* what() const noexcept override;
 ```
 *Returns:* An *implementation-defined* NTBS.
+### Header `<typeindex>` synopsis <a id="type.index.synopsis">[[type.index.synopsis]]</a>
+``` cpp
+#include <compare>              // see [compare.syn]
+namespace std {
+  class type_index;
+  template<class T> struct hash;
+  template<> struct hash<type_index>;
+}
+```
+### Class `type_index` <a id="type.index">[[type.index]]</a>
+``` cpp
+namespace std {
+  class type_index {
+  public:
+    type_index(const type_info& rhs) noexcept;
+    bool operator==(const type_index& rhs) const noexcept;
+    bool operator< (const type_index& rhs) const noexcept;
+    bool operator> (const type_index& rhs) const noexcept;
+    bool operator<=(const type_index& rhs) const noexcept;
+    bool operator>=(const type_index& rhs) const noexcept;
+    strong_ordering operator<=>(const type_index& rhs) const noexcept;
+    size_t hash_code() const noexcept;
+    const char* name() const noexcept;
+  private:
+    const type_info* target;    // exposition only
+    // Note that the use of a pointer here, rather than a reference,
+    // means that the default copy/move constructor and assignment
+    // operators will be provided and work as expected.
+  };
+}
+```
+The class `type_index` provides a simple wrapper for `type_info` which
+can be used as an index type in associative containers [[associative]]
+and in unordered associative containers [[unord]].
+``` cpp
+type_index(const type_info& rhs) noexcept;
+```
+*Effects:* Constructs a `type_index` object, the equivalent of
+`target = &rhs`.
+``` cpp
+bool operator==(const type_index& rhs) const noexcept;
+```
+*Returns:* `*target == *rhs.target`.
+``` cpp
+bool operator<(const type_index& rhs) const noexcept;
+```
+*Returns:* `target->before(*rhs.target)`.
+``` cpp
+bool operator>(const type_index& rhs) const noexcept;
+```
+*Returns:* `rhs.target->before(*target)`.
+``` cpp
+bool operator<=(const type_index& rhs) const noexcept;
+```
+*Returns:* `!rhs.target->before(*target)`.
+``` cpp
+bool operator>=(const type_index& rhs) const noexcept;
+```
+*Returns:* `!target->before(*rhs.target)`.
+``` cpp
+strong_ordering operator<=>(const type_index& rhs) const noexcept;
+```
+*Effects:* Equivalent to:
+``` cpp
+if (*target == *rhs.target) return strong_ordering::equal;
+if (target->before(*rhs.target)) return strong_ordering::less;
+return strong_ordering::greater;
+```
+``` cpp
+size_t hash_code() const noexcept;
+```
+*Returns:* `target->hash_code()`.
+``` cpp
+const char* name() const noexcept;
+```
+*Returns:* `target->name()`.
+``` cpp
+template<> struct hash<type_index>;
+```
+For an object `index` of type `type_index`, `hash<type_index>()(index)`
+shall evaluate to the same result as `index.hash_code()`.
 ## Source location <a id="support.srcloc">[[support.srcloc]]</a>
 ### Header `<source_location>` synopsis <a id="source.location.syn">[[source.location.syn]]</a>
 The header `<source_location>` defines the class `source_location` that
   [[support.srcloc.current]].
 - Otherwise, when invoked in some other way, returns a `source_location`
   whose data members are initialized with valid but unspecified values.
 *Remarks:* Any call to `current` that appears as a default member
+initializer [[class.mem.general]], or as a subexpression thereof, should
 correspond to the location of the constructor definition or aggregate
 initialization that uses the default member initializer. Any call to
 `current` that appears as a default argument [[dcl.fct.default]], or as
 a subexpression thereof, should correspond to the location of the
 invocation of the function that uses the default argument [[expr.call]].
   using terminate_handler = void (*)();
   terminate_handler get_terminate() noexcept;
   terminate_handler set_terminate(terminate_handler f) noexcept;
   [[noreturn]] void terminate() noexcept;
+ constexpr int uncaught_exceptions() noexcept;
   using exception_ptr = unspecified;
+ constexpr exception_ptr current_exception() noexcept;
+  [[noreturn]] constexpr void rethrow_exception(exception_ptr p);
+  template<class E> constexpr exception_ptr make_exception_ptr(E e) noexcept;
+  template<class E> constexpr const E* exception_ptr_cast(const exception_ptr& p) noexcept;
+  template<class E> void exception_ptr_cast(const exception_ptr&&) = delete;
+  template<class T> [[noreturn]] constexpr void throw_with_nested(T&& t);
+  template<class E> constexpr void rethrow_if_nested(const E& e);
 }
 ```
 ### Class `exception` <a id="exception">[[exception]]</a>
 ``` cpp
 namespace std {
   class exception {
   public:
+ constexpr exception() noexcept;
+ constexpr exception(const exception&) noexcept;
+ constexpr exception& operator=(const exception&) noexcept;
+ constexpr virtual ~exception();
+ constexpr virtual const char* what() const noexcept;
   };
 }
 ```
 The class `exception` defines the base class for the types of objects
 thrown as exceptions by C++ standard library components, and certain
 expressions, to report errors detected during program execution.
+Except where explicitly specified otherwise, each standard library class
+`T` that derives from class `exception` has the following publicly
+accessible member functions, each of them having a non-throwing
+exception specification [[except.spec]]:
 - default constructor (unless the class synopsis shows other
   constructors)
 - copy constructor
 - copy assignment operator
 and `lhs` is a copy of `rhs`, then `strcmp(lhs.what(), rhs.what())` is
 equal to `0`. The `what()` member function of each such `T` satisfies
 the constraints specified for `exception::what()` (see below).
 ``` cpp
+constexpr exception(const exception& rhs) noexcept;
+constexpr exception& operator=(const exception& rhs) noexcept;
 ```
 *Ensures:* If `*this` and `rhs` both have dynamic type `exception` then
 the value of the expression `strcmp(what(), rhs.what())` shall equal 0.
 ``` cpp
+constexpr virtual ~exception();
 ```
 *Effects:* Destroys an object of class `exception`.
 ``` cpp
+constexpr virtual const char* what() const noexcept;
 ```
+*Returns:* An *implementation-defined* NTBS, which during constant
+evaluation is encoded with the ordinary literal encoding [[lex.ccon]].
 *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
 ``` cpp
 namespace std {
   class bad_exception : public exception {
   public:
     // see [exception] for the specification of the special member functions
+ constexpr const char* what() const noexcept override;
   };
 }
 ```
 The class `bad_exception` defines the type of the object referenced by
 the `exception_ptr` returned from a call to `current_exception`
 [[propagation]] when the currently active exception object fails to
 copy.
 ``` cpp
+constexpr const char* what() const noexcept override;
 ```
 *Returns:* An *implementation-defined* NTBS.
 ### Abnormal termination <a id="exception.terminate">[[exception.terminate]]</a>
 called directly by the program.
 ### `uncaught_exceptions` <a id="uncaught.exceptions">[[uncaught.exceptions]]</a>
 ``` cpp
+constexpr int uncaught_exceptions() noexcept;
 ```
+*Returns:* The number of uncaught exceptions [[except.throw]] in the
+current thread.
 *Remarks:* When `uncaught_exceptions() > 0`, throwing an exception can
 result in a call of the function `std::terminate` [[except.terminate]].
 ### Exception propagation <a id="propagation">[[propagation]]</a>
 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` or `exception_ptr_cast` 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*]
+All member functions are marked `constexpr`.
 ``` cpp
+constexpr exception_ptr current_exception() noexcept;
 ```
 *Returns:* An `exception_ptr` object that refers to the currently
 handled exception [[except.handle]] or a copy of the currently handled
 exception, or a null `exception_ptr` object if no exception is being
 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 can substitute a `bad_exception` object to avoid
+infinite recursion. — *end note*]
 ``` cpp
+[[noreturn]] constexpr 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
 - 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> constexpr exception_ptr make_exception_ptr(E e) noexcept;
 ```
 *Effects:* Creates an `exception_ptr` object that refers to a copy of
 `e`, as if:
 ```
 [*Note 5*: This function is provided for convenience and efficiency
 reasons. — *end note*]
+``` cpp
+template<class E> constexpr const E* exception_ptr_cast(const exception_ptr& p) noexcept;
+```
+*Mandates:* `E` is a cv-unqualified complete object type. `E` is not an
+array type. `E` is not a pointer or pointer-to-member type.
+[*Note 6*: When `E` is a pointer or pointer-to-member type, a handler
+of type `const E&` can match without binding to the exception object
+itself. — *end note*]
+*Returns:* A pointer to the exception object referred to by `p`, if `p`
+is not null and a handler of type `const E&` would be a
+match [[except.handle]] for that exception object. Otherwise, `nullptr`.
 ### `nested_exception` <a id="except.nested">[[except.nested]]</a>
 ``` cpp
 namespace std {
   class nested_exception {
   public:
+ constexpr nested_exception() noexcept;
+ constexpr nested_exception(const nested_exception&) noexcept = default;
+ constexpr nested_exception& operator=(const nested_exception&) noexcept = default;
+ constexpr virtual ~nested_exception() = default;
     // access functions
+    [[noreturn]] constexpr void rethrow_nested() const;
+ constexpr exception_ptr nested_ptr() const noexcept;
   };
+  template<class T> [[noreturn]] constexpr void throw_with_nested(T&& t);
+  template<class E> constexpr void rethrow_if_nested(const E& e);
 }
 ```
 The class `nested_exception` is designed for use as a mixin through
 multiple inheritance. It captures the currently handled exception and
 [*Note 1*: `nested_exception` has a virtual destructor to make it a
 polymorphic class. Its presence can be tested for with
 `dynamic_cast`. — *end note*]
 ``` cpp
+constexpr nested_exception() noexcept;
 ```
 *Effects:* The constructor calls `current_exception()` and stores the
 returned value.
 ``` cpp
+[[noreturn]] constexpr void rethrow_nested() const;
 ```
 *Effects:* If `nested_ptr()` returns a null pointer, the function calls
 the function `std::terminate`. Otherwise, it throws the stored exception
 captured by `*this`.
 ``` cpp
+constexpr exception_ptr nested_ptr() const noexcept;
 ```
 *Returns:* The stored exception captured by this `nested_exception`
 object.
 ``` cpp
+template<class T> [[noreturn]] constexpr void throw_with_nested(T&& t);
 ```
 Let `U` be `decay_t<T>`.
 *Preconditions:* `U` meets the *Cpp17CopyConstructible* requirements.
 is `true`, an exception of unspecified type that is publicly derived
 from both `U` and `nested_exception` and constructed from
 `std::forward<T>(t)`, otherwise `std::forward<T>(t)`.
 ``` cpp
+template<class E> constexpr void rethrow_if_nested(const E& e);
 ```
 *Effects:* If `E` is not a polymorphic class type, or if
 `nested_exception` is an inaccessible or ambiguous base class of `E`,
 there is no effect. Otherwise, performs:
 ``` cpp
 if (auto p = dynamic_cast<const nested_exception*>(addressof(e)))
   p->rethrow_nested();
 ```
+## Contract-violation handling <a id="support.contract">[[support.contract]]</a>
+### Header `<contracts>` synopsis <a id="contracts.syn">[[contracts.syn]]</a>
+The header `<contracts>` defines types for reporting information about
+contract violations [[basic.contract.eval]].
+``` cpp
+// all freestanding
+namespace std::contracts {
+  enum class assertion_kind : unspecified {
+    pre = 1,
+    post = 2,
+    assert = 3
+  };
+  enum class evaluation_semantic : unspecified {
+    ignore = 1,
+    observe = 2,
+    enforce = 3,
+    quick_enforce = 4
+  };
+  enum class detection_mode : unspecified {
+    predicate_false = 1,
+    evaluation_exception = 2
+  };
+  class contract_violation {
+    // no user-accessible constructor
+  public:
+    contract_violation(const contract_violation&) = delete;
+    contract_violation& operator=(const contract_violation&) = delete;
+    see below ~contract_violation();
+    const char* comment() const noexcept;
+    contracts::detection_mode detection_mode() const noexcept;
+    exception_ptr evaluation_exception() const noexcept;
+    bool is_terminating() const noexcept;
+    assertion_kind kind() const noexcept;
+    source_location location() const noexcept;
+    evaluation_semantic semantic() const noexcept;
+  };
+  void invoke_default_contract_violation_handler(const contract_violation&);
+}
+```
+### Enumerations <a id="support.contract.enum">[[support.contract.enum]]</a>
+*Recommended practice:* For all enumerations in
+[[support.contract.enum]], if implementation-defined enumerators are
+provided, they should have a minimum value of 1000.
+The enumerators of `assertion_kind` correspond to the syntactic forms of
+a contract assertion [[basic.contract.general]], with meanings listed in
+Table  [[tab:support.contract.enum.kind]].
+**Table: Enum `assertion_kind`** <a id="support.contract.enum.kind">[support.contract.enum.kind]</a>
+| Name     | Meaning                   |
+| -------- | ------------------------- |
+| `pre`    | A precondition assertion  |
+| `post`   | A postcondition assertion |
+| `assert` | An *assertion-statement*  |
+The enumerators of `evaluation_semantic` correspond to the evaluation
+semantics with which a contract assertion may be evaluated
+[[basic.contract.eval]], with meanings listed in Table
+[[tab:support.contract.enum.semantic]].
+**Table: Enum `evaluation_semantic`** <a id="support.contract.enum.semantic">[support.contract.enum.semantic]</a>
+| Name            | Meaning                           |
+| --------------- | --------------------------------- |
+| `ignore`        | Ignore evaluation semantic        |
+| `observe`       | Observe evaluation semantic       |
+| `enforce`       | Enforce evaluation semantic       |
+| `quick_enforce` | Quick-enforce evaluation semantic |
+The enumerators of `detection_mode` correspond to the manners in which a
+contract violation can be identified [[basic.contract.eval]], with
+meanings listed in Table~ [[tab:support.contract.enum.detection]].
+**Table: Enum `detection_mode`** <a id="support.contract.enum.detection">[support.contract.enum.detection]</a>
+| Name                   | Meaning                                                                                          |
+| ---------------------- | ------------------------------------------------------------------------------------------------ |
+| `predicate_false`      | The predicate of the contract assertion evaluated to `false` or would have evaluated to `false`. |
+| `evaluation_exception` | An uncaught exception occurred during evaluation of the contract assertion.                      |
+### Class `contract_violation` <a id="support.contract.violation">[[support.contract.violation]]</a>
+The class `contract_violation` defines the type of objects used to
+represent a contract violation that has been detected during the
+evaluation of a contract assertion with a particular evaluation semantic
+[[basic.contract.eval]]. Objects of this type can be created only by the
+implementation. It is *implementation-defined* whether the destructor is
+virtual.
+``` cpp
+const char* comment() const noexcept;
+```
+*Returns:* An *implementation-defined* NTMBS in the ordinary literal
+encoding [[lex.charset]].
+*Recommended practice:* The string returned should contain a textual
+representation of the predicate of the violated contract assertion or an
+empty string if storing a textual representation is undesired.
+[*Note 1*: The string can represent a truncated, reformatted, or
+summarized rendering of the predicate, before or after
+preprocessing. — *end note*]
+``` cpp
+contracts::detection_mode detection_mode() const noexcept;
+```
+*Returns:* The enumerator value corresponding to the manner in which the
+contract violation was identified.
+``` cpp
+exception_ptr evaluation_exception() const noexcept;
+```
+*Returns:* If the contract violation occurred because the evaluation of
+the predicate exited via an exception, an `exception_ptr` object that
+refers to that exception or a copy of that exception; otherwise, a null
+`exception_ptr` object.
+``` cpp
+bool is_terminating() const noexcept;
+```
+*Returns:* `true` if the evaluation semantic is a terminating
+semantic [[basic.contract.eval]]; otherwise, `false`.
+``` cpp
+assertion_kind kind() const noexcept;
+```
+*Returns:* The enumerator value corresponding to the syntactic form of
+the violated contract assertion.
+``` cpp
+source_location location() const noexcept;
+```
+*Returns:* A `source_location` object with *implementation-defined*
+value.
+*Recommended practice:* The value returned should be a default
+constructed `source_location` object or a value identifying the violated
+contract assertion:
+- When possible, if the violated contract assertion was a precondition,
+  the source location of the function invocation should be returned.
+- Otherwise, the source location of the contract assertion should be
+  returned.
+``` cpp
+evaluation_semantic semantic() const noexcept;
+```
+*Returns:* The enumerator value corresponding to the evaluation semantic
+with which the violated contract assertion was evaluated.
+### Invoke default handler <a id="support.contract.invoke">[[support.contract.invoke]]</a>
+``` cpp
+void invoke_default_contract_violation_handler(const contract_violation& v);
+```
+*Effects:* Invokes the default contract-violation
+handler [[basic.contract.handler]] with the argument `v`.
 ## 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
 objects of type `const E`.
 [*Note 1*: A pair of pointers or a pointer plus a length would be
 obvious representations for `initializer_list`. `initializer_list` is
 used to implement initializer lists as specified in  [[dcl.init.list]].
+Copying an `initializer_list` does not copy the underlying
 elements. — *end note*]
 If an explicit specialization or partial specialization of
 `initializer_list` is declared, the program is ill-formed.
   template<class... Ts>
   struct common_comparison_category {
     using type = see below;
   };
   template<class... Ts>
+    using common_comparison_category_t = common_comparison_category<Ts...>::type;
   // [cmp.concept], concept three_way_comparable
   template<class T, class Cat = partial_ordering>
     concept three_way_comparable = see below;
   template<class T, class U, class Cat = partial_ordering>
   // [cmp.result], result of three-way comparison
   template<class T, class U = T> struct compare_three_way_result;
   template<class T, class U = T>
+    using compare_three_way_result_t = compare_three_way_result<T, U>::type;
   // [comparisons.three.way], class compare_three_way
   struct compare_three_way;
   // [cmp.alg], comparison algorithms
     inline constexpr unspecified partial_order = unspecified;
     inline constexpr unspecified compare_strong_order_fallback = unspecified;
     inline constexpr unspecified compare_weak_order_fallback = unspecified;
     inline constexpr unspecified compare_partial_order_fallback = unspecified;
   }
+  // [compare.type], type ordering
+  template<class T, class U>
+    struct type_order;
+  template<class T, class U>
+    constexpr strong_ordering type_order_v = type_order<T, U>::value;
 }
 ```
 ### Comparison category types <a id="cmp.categories">[[cmp.categories]]</a>
 — *end example*]
 In this context, the behavior of a program that supplies an argument
 other than a literal `0` is undefined.
+For the purposes of [[cmp.categories]], *substitutability* is the
+property that `f(a) == f(b)` is `true` whenever `a == b` is `true`,
 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>
 ``` 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
   public:
     // valid values
     static const partial_ordering less;
     static const partial_ordering equivalent;
 constexpr bool operator> (partial_ordering v, unspecified) noexcept;
 constexpr bool operator<=(partial_ordering v, unspecified) noexcept;
 constexpr bool operator>=(partial_ordering v, unspecified) noexcept;
 ```
+*Returns:* For `operator`, `v.`*`is-ordered`*` && v.`*`value`*` 0`.
 ``` cpp
 constexpr bool operator< (unspecified, partial_ordering v) noexcept;
 constexpr bool operator> (unspecified, partial_ordering v) noexcept;
 constexpr bool operator<=(unspecified, partial_ordering v) noexcept;
 constexpr bool operator>=(unspecified, partial_ordering v) noexcept;
 ```
+*Returns:* For `operator`, `v.`*`is-ordered`*` && 0 v.`*`value`*.
 ``` cpp
 constexpr partial_ordering operator<=>(partial_ordering v, unspecified) noexcept;
 ```
 constexpr bool operator> (weak_ordering v, unspecified) noexcept;
 constexpr bool operator<=(weak_ordering v, unspecified) noexcept;
 constexpr bool operator>=(weak_ordering v, unspecified) noexcept;
 ```
+*Returns:* `v.`*`value`*` 0` for `operator`.
 ``` cpp
 constexpr bool operator< (unspecified, weak_ordering v) noexcept;
 constexpr bool operator> (unspecified, weak_ordering v) noexcept;
 constexpr bool operator<=(unspecified, weak_ordering v) noexcept;
 constexpr bool operator>=(unspecified, weak_ordering v) noexcept;
 ```
+*Returns:* `0 v.`*`value`* for `operator`.
 ``` cpp
 constexpr weak_ordering operator<=>(weak_ordering v, unspecified) noexcept;
 ```
 constexpr bool operator> (strong_ordering v, unspecified) noexcept;
 constexpr bool operator<=(strong_ordering v, unspecified) noexcept;
 constexpr bool operator>=(strong_ordering v, unspecified) noexcept;
 ```
+*Returns:* `v.`*`value`*` 0` for `operator`.
 ``` cpp
 constexpr bool operator< (unspecified, strong_ordering v) noexcept;
 constexpr bool operator> (unspecified, strong_ordering v) noexcept;
 constexpr bool operator<=(unspecified, strong_ordering v) noexcept;
 constexpr bool operator>=(unspecified, strong_ordering v) noexcept;
 ```
+*Returns:* `0 v.`*`value`* for `operator`.
 ``` cpp
 constexpr strong_ordering operator<=>(strong_ordering v, unspecified) noexcept;
 ```
     };
 ```
 Let `t` and `u` be lvalues of types `const remove_reference_t<T>` and
 `const remove_reference_t<U>`, respectively. `T` and `U` model
+`partially-ordered-with<T, U>` only if
 - `t < u`, `t <= u`, `t > u`, `t >= u`, `u < t`, `u <= t`, `u > t`, and
+  `u >= t` have the same domain,
 - `bool(t < u) == bool(u > t)` is `true`,
 - `bool(u < t) == bool(t > u)` is `true`,
 - `bool(t <= u) == bool(u >= t)` is `true`, and
 - `bool(u <= t) == bool(t >= u)` is `true`.
       { a <=> b } -> compares-as<Cat>;
     };
 ```
 Let `a` and `b` be lvalues of type `const remove_reference_t<T>`. `T`
+and `Cat` model `three_way_comparable<T, Cat>` only if
 - `(a <=> b == 0) == bool(a == b)` is `true`,
 - `(a <=> b != 0) == bool(a != b)` is `true`,
 - `((a <=> b) <=> 0)` and `(0 <=> (b <=> a))` are equal,
 - `(a <=> b < 0) == bool(a < b)` is `true`,
 `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`,
   [[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 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
 - 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)`, `decltype(E < F)`, and
+ `decltype(F < E)` models `boolean-testable`,
   ``` cpp
   E == F ? partial_ordering::equivalent :
   E < F  ? partial_ordering::less :
   F < E  ? partial_ordering::greater :
            partial_ordering::unordered
 [*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*]
+### Type Ordering <a id="compare.type">[[compare.type]]</a>
+There is an *implementation-defined* total ordering of all types. For
+any (possibly incomplete) types `X` and `Y`, the expression
+`TYPE-ORDER(X, Y)` is a constant expression [[expr.const]] of type
+`strong_ordering` [[cmp.strongord]]. Its value is
+`strong_ordering::less` if `X` precedes `Y` in this
+implementation-defined total order, `strong_ordering::greater` if `Y`
+precedes `X`, and `strong_ordering::equal` if they are the same type.
+[*Note 1*: `int`, `const int` and `int&` are different
+types. — *end note*]
+[*Note 2*: This ordering need not be consistent with the one induced by
+`type_info::before`. — *end note*]
+[*Note 3*: The ordering of TU-local types from different translation
+units is not observable, because the necessary specialization of
+`type_order` is impossible to name. — *end note*]
+``` cpp
+template<class T, class U>
+  struct type_order;
+```
+The name `type_order` denotes a *Cpp17BinaryTypeTrait*[[meta.rqmts]]
+with a base characteristic of
+`integral_constant<strong_ordering, `*`TYPE-ORDER`*`(T, U)>`.
+*Recommended practice:* The order should be lexicographical on
+parameter-type-lists and template argument lists.
 ## 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
 *qualified-id* `R::promise_type` is valid and denotes a type
 [[temp.deduct]], then `coroutine_traits<R, ArgTypes...>` has the
 following publicly accessible member:
 ``` cpp
+using promise_type = R::promise_type;
 ```
 Otherwise, `coroutine_traits<R, ArgTypes...>` has no members.
 Program-defined specializations of this template shall define a publicly
 The class `noop_coroutine_promise` defines the promise type for the
 coroutine referred to by `noop_coroutine_handle` [[coroutine.syn]].
 #### Class `coroutine_handle<noop_coroutine_promise>` <a id="coroutine.handle.noop">[[coroutine.handle.noop]]</a>
+##### General <a id="coroutine.handle.noop.general">[[coroutine.handle.noop.general]]</a>
 ``` cpp
 namespace std {
   template<>
   struct coroutine_handle<noop_coroutine_promise>
   {
 ### Header `<cstdarg>` synopsis <a id="cstdarg.syn">[[cstdarg.syn]]</a>
 ``` cpp
 // all freestanding
+#define __STDC_VERSION_STDARG_H__ 202311L
 namespace std {
   using va_list = see below;
 }
 #define va_arg(V, P) see below
 #define va_copy(VDST, VSRC) see below
 #define va_end(V) see below
+#define va_start(V, ...) 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/IEC
+ 9899:2018 (C) 6.5.3.3, the definition in  [[expr.call]] applies.
+- The preprocessing tokens comprising the second and subsequent
+ arguments to `va_start` (if any) are discarded. \[*Note 1*: `va_start`
+ accepts a second argument for compatibility with prior revisions of
+ C++. — *end note*]
+See also: ISO C 7.16
 ### Header `<csetjmp>` synopsis <a id="csetjmp.syn">[[csetjmp.syn]]</a>
 ``` cpp
+#define __STDC_VERSION_SETJMP_H__ 202311L
 namespace std {
   using jmp_buf = see below;
   [[noreturn]] void longjmp(jmp_buf env, int val);
 }
 - 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]][^33] ; 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.
 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
+C. Source files that are not intended to also be valid 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 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 <uchar.h> // for char8_t in C, not necessary in C++{}
 #include <stddef.h>     // for size_t
 #ifdef __cplusplus      // see [cpp.predefined]
 extern "C"              // see [dcl.link]
 #endif
+void f(char8_t s[], size_t n);
 ```
 — *end example*]
 ### Header `<complex.h>` synopsis <a id="complex.h.syn">[[complex.h.syn]]</a>
 [[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>`.
 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>`.
+See also: ISO C 7.19
 ### Header `<tgmath.h>` synopsis <a id="tgmath.h.syn">[[tgmath.h.syn]]</a>
 ``` cpp
 #include <cmath>
 `<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>`, `<stdbit.h>`, `<stdbool.h>`, `<stdckdint.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 \IsoCUndated. 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
+[associative]: containers.md#associative
 [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.contract.eval]: basic.md#basic.contract.eval
+[basic.contract.general]: basic.md#basic.contract.general
+[basic.contract.handler]: basic.md#basic.contract.handler
 [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.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]: text.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]: text.md#c.mb.wcs
 [cfloat.syn]: #cfloat.syn
+[class.mem.general]: class.md#class.mem.general
 [class.prop]: class.md#class.prop
 [class.spaceship]: class.md#class.spaceship
 [climits.syn]: #climits.syn
 [cmp]: #cmp
 [cmp.alg]: #cmp.alg
 [cmp.partialord]: #cmp.partialord
 [cmp.result]: #cmp.result
 [cmp.strongord]: #cmp.strongord
 [cmp.weakord]: #cmp.weakord
 [compare.syn]: #compare.syn
+[compare.type]: #compare.type
 [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
+[contracts.syn]: #contracts.syn
 [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.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.general]: #coroutine.handle.noop.general
 [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
 [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.throw]: except.md#except.throw
 [exception]: #exception
 [exception.syn]: #exception.syn
 [exception.terminate]: #exception.terminate
 [expr.add]: expr.md#expr.add
 [expr.await]: expr.md#expr.await
 [expr.call]: expr.md#expr.call
+[expr.const]: expr.md#expr.const
 [expr.context]: expr.md#expr.context
 [expr.delete]: expr.md#expr.delete
 [expr.dynamic.cast]: expr.md#expr.dynamic.cast
 [expr.eq]: expr.md#expr.eq
 [expr.new]: expr.md#expr.new
 [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.ccon]: lex.md#lex.ccon
+[lex.charset]: lex.md#lex.charset
 [lex.key]: lex.md#lex.key
 [library.c]: library.md#library.c
 [limits.syn]: #limits.syn
+[locale.codecvt]: text.md#locale.codecvt
+[meta.rqmts]: meta.md#meta.rqmts
 [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
 [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.contract]: #support.contract
+[support.contract.enum]: #support.contract.enum
+[support.contract.invoke]: #support.contract.invoke
+[support.contract.violation]: #support.contract.violation
 [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.types]: #support.types
 [support.types.byteops]: #support.types.byteops
 [support.types.layout]: #support.types.layout
 [support.types.nullptr]: #support.types.nullptr
 [swappable.requirements]: library.md#swappable.requirements
+[tab:support.contract.enum.detection]: #tab:support.contract.enum.detection
+[tab:support.contract.enum.kind]: #tab:support.contract.enum.kind
+[tab:support.contract.enum.semantic]: #tab:support.contract.enum.semantic
 [temp.deduct]: temp.md#temp.deduct
 [temp.dep.constexpr]: temp.md#temp.dep.constexpr
 [temp.dep.expr]: temp.md#temp.dep.expr
 [term.odr.use]: basic.md#term.odr.use
+[term.replaceable.function]: dcl.md#term.replaceable.function
 [terminate]: #terminate
 [terminate.handler]: #terminate.handler
 [tgmath.h.syn]: #tgmath.h.syn
+[type.index]: #type.index
+[type.index.synopsis]: #type.index.synopsis
 [type.info]: #type.info
 [typeinfo.syn]: #typeinfo.syn
 [uncaught.exceptions]: #uncaught.exceptions
+[unord]: containers.md#unord
 [unord.hash]: utilities.md#unord.hash
 [utility.arg.requirements]: library.md#utility.arg.requirements
 [version.syn]: #version.syn
 [^1]: Possible definitions include `0` and `0L`, but not `(void*)0`.
 [^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 ISO/IEC 10967-1:2012 Section 5.2.4
+ and Annex C Rationale Section C.5.2.4 — Rounding and rounding
+    constants.
 [^12]: Equivalent to `FLT_MIN_EXP`, `DBL_MIN_EXP`, `LDBL_MIN_EXP`.
 [^13]: Equivalent to `FLT_MIN_10_EXP`, `DBL_MIN_10_EXP`,
     `LDBL_MIN_10_EXP`.
 [^14]: Equivalent to `FLT_MAX_EXP`, `DBL_MAX_EXP`, `LDBL_MAX_EXP`.
 [^15]: Equivalent to `FLT_MAX_10_EXP`, `DBL_MAX_10_EXP`,
     `LDBL_MAX_10_EXP`.
+[^16]: Required by ISO/IEC 10967-1:2012.
+[^17]: Required by ISO/IEC 10967-1:2012.
+[^18]: Required by ISO/IEC 10967-1:2012.
+[^19]: Required by ISO/IEC 10967-1:2012.
+[^20]: Required by ISO/IEC 10967-1:2012.
+[^21]: Required by ISO/IEC 10967-1:2012.
+[^22]: ISO/IEC 60559:2020 is the same as IEEE 754-2019.
+[^23]: Required by ISO/IEC 10967-1:2012.
+[^24]: Required by ISO/IEC 10967-1:2012.
+[^25]: Required by ISO/IEC 10967-1:2012.
+[^26]: Refer to ISO/IEC 60559. Required by ISO/IEC 10967-1:2012.
+[^27]: Equivalent to `FLT_ROUNDS`. Required by ISO/IEC 10967-1:2012.
 [^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
     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]: Such initialization can occur because it is the first odr-use
     [[term.odr.use]] of that variable.

Diff to HTML by rtfpessoa