<!DOCTYPE html>
<html>
<style type="text/css">
  ins, ins * { text-decoration:none; font-weight:bold; background-color:#A0FFA0 }
  del, del * { text-decoration:line-through; background-color:#FFA0A0 }
  #hidedel:checked ~ * del, #hidedel:checked ~ * del * { display:none; visibility:hidden }

blockquote {
  padding: .5em;
  border: .5em;
  border-color: silver;
  border-left-style: solid;
}

blockquote.std { color: #000000; background-color: #F1F1F1;
  border: 1px solid #D1D1D1;
  padding-left: 0.5em; padding-right: 0.5em; }
blockquote.stdins { text-decoration: underline;
  color: #000000; background-color: #C8FFC8;
  border: 1px solid #B3EBB3; padding: 0.5em; }
blockquote.stddel { text-decoration: line-through;
  color: #000000; background-color: #FFEBFF;
  border: 1px solid #ECD7EC;
  padding-left: 0.5em; padding-right: 0.5em; }

p.grammarlhs { margin-bottom: 0 }
p.grammarrhs { margin-left:8em; margin-top:0; margin-bottom:0; text-indent:-4em }

div.wrapper {
    max-width: 60em;
    margin: auto;
}

a { text-decoration: none; }

a.hidden_link {
    text-decoration: none;
    color: inherit;
}

li {
    margin-top: 0.0em;
    margin-bottom: 0.0em;
}

h1 { line-height: 1; }
h2 { line-height: 1; }
h3 { line-height: 1; }
h4 { line-height: 1; }

:target { background-color: #C9FBC9; }
:target .codeblock { background-color: #C9FBC9; }
:target ul { background-color: #C9FBC9; }

.abbr_ref { float: right; }

.folded_abbr_ref { float: right; }
:target .folded_abbr_ref { display: none; }

:target .unfolded_abbr_ref { float: right; display: inherit; }
.unfolded_abbr_ref { display: none; }

.secnum { display: inline-block; min-width: 35pt; }
.annexnum { display: block; }

div.sourceLinkParent {
    float: right;
}

a.sourceLink {
    position: absolute;
    opacity: 0;
    margin-left: 10pt;
}

a.sourceLink:hover {
    opacity: 1;
}

div.marginalizedparent {
    position: relative;
    left: -5em;
}

div.footnoteNumberParent {
    position: relative;
    left: -4.7em;
}

a.marginalized {
    position: absolute;
    font-size: 75%;
    text-align: right;
    width: 5em;
}

a.enumerated_item_num {
    position: relative;
    left: -3.5em;
    display: inline-block;
    margin-right: -3em;
    text-align: right;
    width: 3em;
}

div.para { margin-bottom: 0.6em; margin-top: 0.6em; text-align: justify; }
div.section { text-align: justify; }
div.sentence { display: inline; }

span.indexparent {
    display: inline;
    position: relative;
    float: right;
    right: -1em;
}

a.index {
    position: absolute;
    display: none;
}

a.index:before { content: "âŸµ"; }
    /* this way the content is not selectable */

a.index:target {
    display: inline;
}

.indexitems {
    margin-left: 2em;
    text-indent: -2em;
}

div.itemdescr {
    margin-left: 3em;
}

.bnf {
    font-family: serif;
    margin-left: 40pt;
    margin-top: 0.5em;
    margin-bottom: 0.5em;
}

.ncbnf {
    font-family: serif;
    margin-top: 0.5em;
    margin-bottom: 0.5em;
    margin-left: 40pt;
}

.bnftab {
    font-family: serif;
    font-style: italic;
    margin-left: 40pt;
    margin-top: 0.5em;
    margin-bottom: 0.5em;
}

.ncsimplebnf {
    font-family: serif;
    font-style: italic;
    margin-top: 0.5em;
    margin-bottom: 0.5em;
    margin-left: 40pt;
}

.ncbnftab {
    font-family: serif;
    font-style: italic;
    margin-top: 0.5em;
    margin-bottom: 0.5em;
    margin-left: 40pt;
}

.bnfkeywordtab {
    margin-top: 0.5em;
    margin-bottom: 0.5em;
    margin-left: 40pt;
}

span.textnormal {
    font-style: normal;
    font-family: serif;
    white-space: normal;
    display: inline-block;
}

span.descr { font-style: normal; font-family: serif; }
span.grammarterm { font-style: italic; }
span.term { font-style: italic; }
span.terminal { font-family: monospace; font-style: normal; }
span.nonterminal { font-style: italic; }
span.tcode { font-family: monospace; font-style: normal; }
span.textbf { font-weight: bold; }
span.textsc { font-variant: small-caps; }
a.nontermdef { font-style: italic; font-family: serif; }
span.emph { font-style: italic; }
span.techterm { font-style: italic; }
span.mathit { font-style: italic; }
span.mathsf { font-family: sans-serif; }
span.mathrm { font-family: serif; font-style: normal; }
span.textrm { font-family: serif; }
span.textsl { font-style: italic; }
span.mathtt { font-family: monospace; font-style: normal; }
span.mbox { font-family: serif; font-style: normal; }
span.ungap { display: inline-block; width: 2pt; }
span.textit { font-style: italic; }
span.texttt { font-family: monospace; }
span.tcode_in_codeblock { font-family: monospace; font-style: normal; }

span.phantom { color: white; }
span.math { }

span.mathblock {
    display: block;
    margin-left: auto;
    margin-right: auto;
    margin-top: 1.2em;
    margin-bottom: 1.2em;
    text-align: center;
}

span.mathalpha {
    font-style: italic;
}

span.synopsis {
    font-weight: bold;
    margin-top: 0.5em;
    display: block;
}

span.definition {
    font-weight: bold;
    display: block;
}

.codeblock {
    margin-left: 1.2em;
    line-height: 127%;
}

code {
    font-family: monospace;
    font-style: normal;
}

code.itemdecl {
    margin-top: 2ex;
    white-space: pre;
    display: block;
}

.comment {
    font-style: italic;
    font-family: serif;
}

span.textsuperscript {
    vertical-align: super;
    font-size: smaller;
    line-height: 0;
}

.footnotenum { vertical-align: super; font-size: smaller; line-height: 0; }

.footnote {
    font-size: small;
    margin-left: 2em;
    margin-right: 2em;
    margin-top: 0.6em;
    margin-bottom: 0.6em;
}

div.minipage {
    display: inline-block;
    margin-right: 3em;
}

div.numberedTable {
    text-align: center;
    margin: 2em;
}

div.figure {
    text-align: center;
    margin: 2em;
}

table {
    border: 1px solid black;
    border-collapse: collapse;
    margin-left: auto;
    margin-right: auto;
    margin-top: 0.8em;
    text-align: left;
    hyphens: none; /* otherwise some columns get very narrow, e.g. [tab:hash] */
}

td, th {
    padding-left: 1em;
    padding-right: 1em;
    vertical-align: top;
}

td.left {
    text-align: left;
}

td.right {
    text-align: right;
}

td.center {
    text-align: center;
}

td.justify {
    text-align: justify;
}

td.border {
    border-left: 1px solid black;
}

tr.rowsep, td.cline {
    border-top: 1px solid black;
}

tr.capsep {
    border-top: 3px solid black;
    border-top-style: double;
}

th {
    border-bottom: 1px solid black;
}

span.centry {
    font-weight: bold;
}

div.table {
    display: block;
    margin-left: auto;
    margin-right: auto;
    text-align: center;
    width: 90%;
}

span.indented {
    display: block;
    margin-left: 2em;
    margin-bottom: 1em;
    margin-top: 1em;
}
</style>

<body>
<h1>Freestanding Proposal</h1>
Document number: P0829R4<br/>
Date: 2019-01-12<br/>
Reply-to: Ben Craig &lt;ben dot craig at gmail dot com&gt;<br/>
Audience: SG14, Library Evolution Working Group
<h1>Change history</h1>
<h2> R3 -&gt; R4 </h2>
Updated to N4791.<br/>
Added most of the ranges proposal.<br/>
Added <code>default_delete</code> and removed <code>unique_ptr</code> template argument changes.<br/>
Removed <code>_Exit</code>.<br/>
Removed <code>shuffle_order_engine</code> and <code>knuth_b</code>, as they are usually implemented with floating point.<br/>
<h2> R2 -&gt; R3 </h2>
Changed feature test macro to better align with P1105.<br/>
Split feature test macros into freestanding and hosted macros.<br/>
Updating to July 26, 2018 snapshot of the standard.<br/>
Added <code>identity</code>.<br/>
Added <code>&lt;contract&gt;</code> and <code>&lt;concepts&gt;</code>.<br/>
Added new <code>shift_left</code> and <code>shift_right</code> algorithms.<br/>
Added insert iterators.<br/>
Added <code>mbstate_t</code> and <code>wint_t</code> for <code>char_traits</code>.<br/>
<h2> R1 -&gt; R2 </h2>
Removed <code>atoi</code> because of reliance on <code>isspace</code>.<br/>
Added <code>visit</code> and <code>bad_variant_access</code>.<br/>
Added <code>bitset</code>, minus the string members and throwing members.<br/>
Added <code>&lt;version&gt;</code> and moved the feature macro there.<br/>
Added <code>unique_ptr</code>.  Leaving <code>make_unique</code> and <code>default_delete</code> out.<br/>
Added <code>&lt;span&gt;</code>.<br/>
Added <code>days</code>, <code>weeks</code>, <code>months</code>, and <code>years</code> time durations.<br/>
Added <code>&lt;csetjmp&gt;</code>.<br/>
Updated to N4741.<br/>
<h2> R0 -&gt; R1 </h2>
R1 adds an abstract.<br/>
R1 no longer removes any existing freestanding libraries.<br/>
R1 no longer gives implementations freedom to add <code>static_assert</code>s to allocation functions in freestanding mode.<br/>
<code>unique_ptr</code> is no longer included in freestanding, with the hopes that <code>unique_resource</code> and <code>scope_exit</code> will fill the void<br/>
R1 adds naming alternatives for freestanding.<br/>
R1 includes substantially less of <code>&lt;random&gt;</code>, and white-lists inclusions rather than black-lists omissions.<br/>
R1 adds some allocator machinery, though it does not add the default allocator.<br/>
R1 adds <code>&lt;compare&gt;</code>, as it seems to have been accidentally omitted from the freestanding headers list.<br/>
R1 adds large portions of <code>&lt;chrono&gt;</code>, <code>&lt;optional&gt;</code>, and <code>&lt;variant&gt;</code>.<br/>
R1 adds a feature test macro.
<h1>Abstract</h1>
Add everything to the freestanding implementation that can be implemented without OS calls and space overhead.
<h1>Introduction</h1>
<p>
The current definition of the freestanding implementation is not very useful.  Here is the current high level definition from [intro.compliance]:
<blockquote class="std"><div class='para' id='7'>
<div class='marginalizedparent'><a class='marginalized'>7</a></div>
<div id='7.sentence-1' class='sentence'>Two kinds of implementations are defined: a <i >hosted implementation</i> and a
<i >freestanding implementation</i>.</div> <div id='7.sentence-2' class='sentence'>For a hosted implementation, this
document defines the set of available libraries.</div> <div id='7.sentence-3' class='sentence'>A freestanding
implementation is one in which execution may take place without the benefit of
an operating system, and has an <span class='indexparent'><a class='index' id=':required_libraries_for_freestanding_implementation'></a></span>implementation-defined set of libraries that includes certain language-support
libraries ([compliance]).</div></div></blockquote>
<p>
The main people served by the current freestanding definition are people writing their own hosted C++ standard library to sit atop the compiler author's freestanding implementation (i.e. the STLport use case).  The freestanding portions contain all the functions and types known to the compiler that can't easily be authored in a cross-compiler manner.
</p><p>
The current set of freestanding libraries provides too little to kernel, micro-controller, and GPU programmers.  Why should a systems programmer need to rewrite <code>std::sort()</code> or <code>std::memcpy()</code>?
</p><p>
I propose we provide the (nearly) maximal subset of the library that does not require an OS or space overhead.  In order to continue supporting the "layered" C++ standard library users, we will continue to provide the (nearly) minimal subset of the library needed to support all the language features, even if these features have space overhead.  Language features requiring space overhead or OS support will remain intact.
</p>
<h1>Motivation</h1>
<p>
Systems programmers want to sort things.  They want to use move semantics.  They may even want to bundle the arguments of a variadic template function into a <code>std::tuple</code>.  These are all reasonable things to do on a system with no operating system and kilobytes of storage.  The C++ standard even has reasonable specifications for these operations in the context of a tiny, OS-less system.  However, systems programmers must currently rely on either hand-rolled code or implementer extensions in order to get these facilities.
</p><p>
Systems programmers don't have a guide as to what C++ library facilities will work without trying them.  The standard says <code>atomic_load</code> will work; <code>memcpy</code> will probably work; but will <code>stable_sort</code>?  Standardizing the subset of implementable C++ that is usable in a freestanding environment would provide clarity here, and help to educate systems programmers.
</p>
<h1>Current State</h1>
<p>
There were some presentations at recent CppCons where others made a more full featured C++ work in the Linux and Windows kernels [Quinn2016] [Baker2017].  In both of these cases, C++ was being used in a sandboxed / pseudo-virtualized way.  C++ code (with exceptions and RTTI) was being run in the kernel context, but very few calls were made between the C++ code and the operating system kernel.  The C++ code was in a guest operating system.  This proposal should make it reasonable to have C++ code interact closely with the internals of a host operating system, perhaps in the context of a driver.
</p><p>
The Microsoft Windows kernel and Apple Mac OSX kernel both currently support limited, non-compliant subsets of C++ for driver writers.  The Linux kernel does not support C++ officially, though with a fair amount of work on the part of the driver developer, C++ can be made to work.  Drivers written in C++ are highly unlikely to be accepted in the upstream Linux source repositories.
</p><p>
IncludeOS [Bratterud2017] is an OS primarily intended for running in VMs, though some bare metal support has been tested.  One might expect such a project to use a freestanding implementation as a base, but instead, it starts with a hosted implmentation of C++ and drops support for the impractical parts (threads and filestreams in particular).
</p><p>
Out of libstdc++, libc++, and Microsoft's Visual Studio STL, only libstdc++ has any relevant mention of "freestanding" or "hosted".  In practice, users take a hosted implementation of C++ and use it as-is in situations where it was never intended.  This means that all the headers tend to be available, but only a few of the headers actually work.  Many of the headers that work aren't marked freestanding.  Some headers have parts that could work, except they are mixed with other parts that won't work.  For example, <code>iterator_traits</code> in <code>&lt;iterator&gt;</code> is fine, but the implementation details of the stream iterators cause build errors with the <code>/kernel</code> flag in Microsoft Visual Studio 2017 15.7.
</p>
<h1>Scope</h1>
<p>
The current scope of this proposal is limited to the freestanding standard library available to micro-controller, kernel, and GPU development.
</p><p>
This paper is currently concerned with the divisions of headers and library functions as they were in C++17.  <a href="http://wg21.link/p0581">"Standard Library Modules" (P0581)</a> discusses how the library will be split up in a post-modules world.  This paper may influence the direction of P0581, but this paper won't make any modules recommendations.
</p><p>
I could see the scope increasing to the availability of the standard library on GPUs.
</p><p>
<h1>Impact on the standard</h1>
<p>
The standard will no longer list all of the facilities available to the freestanding implementation, as is currently done in [compliance].  Instead, [compliance] will list all the headers that are required to be present, and the header and class synopses will tag which parts of the headers and classes will be available.  This is a large number of small, easy to understand edits, along with the addition of a sub-clause that discusses how the tagging works.
</p><p>
There is precedent for this kind of tagging in other specification documents.  The ECMAScript Language Specification has optional support for ECMA-402 (internationalization).  The impact of ECMA-402 is called out explicitly in several places.  POSIX tags functions as supported in base, XSI, or in one of many option groups.
</p><p>
There were some conversations in the 2017 Albuquerque meeting around adding another class of conforming implementation.  I believe that such an action would be a mistake.  Maintaining two classifications is difficult enough as is, and freestanding is often neglected.  Adding another classification would magnify these problems.  I also feel that the freestanding classification should be removed if no action is taken to make it more useful.
</p>
<h2>Naming alternatives</h2>
<p>
There was some desire to come up with a new name for "freestanding" in the 2017 Albuquerque meeting.  This new name could better express the intended audience of such an implementation.  My current recommendation will be to keep the name "freestanding", but I will suggest some alternatives just the same.
</p>
<ul>
<li>backless</li>
<li>barebones</li>
<li>basic</li>
<li>embedded</li>
<li>foundational</li>
<li>freestanding</li>
<li>fundamental</li>
<li>independent</li>
<li>kernel</li>
<li>minimal</li>
<li>OS-free</li>
<li>OS-less</li>
<li>portable</li>
<li>reduced</li>
<li>resource-constrained</li>
<li>skeleton</li>
<li>standalone</li>
<li>stripped</li>
<li>system-free</li>
<li>unsupported</li>
</ul>

<h1>Impact on implementations</h1>
<p>
C++ standard library headers will likely need to add preprocessor feature toggles to portions of headers that would emit warnings or errors in freestanding mode.  The precision and timeliness (compile time vs. link time) of errors remains a quality-of-implementation detail.
</p><p>
A minimal freestanding C11 standard library will not be sufficient to provide the C portions of the C++ standard library.  <code>std::char_traits</code> and many of the function specializations in <code>&lt;algorithm&gt;</code> are implemented in terms of non-freestanding C functions.  In practice, most C libraries are not minimal freestanding C11 libraries.  The optimized versions of the <code>&lt;cstring&gt;</code> and <code>&lt;cwchar&gt;</code> functions will typically be the same for both hosted and freestanding environments.
</p><p>
My expectation is that no new freestanding library will be authored as a result of this paper.  Instead hosted libraries will be stripped down through some feature toggle mechanism to become freestanding.
</p><p>
The Microsoft Visual Studio standard library implementation has taken recent steps in version 15.8 (released Aug 14, 2018) to try to better enable uses of the standard library in the kernel.  From the <a href="https://blogs.msdn.microsoft.com/vcblog/2018/09/18/stl-features-and-fixes-in-vs-2017-15-8/">Features and Fixes blog post</a>
<blockquote>
The header structure of the STL was changed to allow use of a subset of the library in conditions where the user can’t link with msvcp140.dll, such as driver development. [...] The following headers are now considered “core” and don’t inject our runtime dependencies (though we do still assume some form of CRT headers are present):
<ul>
<li><code>&lt;cstddef&gt;</code></li>
<li><code>&lt;cstdlib&gt;</code></li>
<li><code>&lt;initializer_list&gt;</code></li>
<li><code>&lt;ratio&gt;</code></li>
<li><code>&lt;type_traits&gt;</code></li>
</ul>
</blockquote>
</p><p>
I was able to test the Microsoft Visual Studio 15.8 implementation.  The C++14 parts of my additions were able to run in the Windows kernel successfully.  I don't have tests for the C++17 and C++20 parts.
</p><p>
I had the following email discussion with Jonathan Wakely, the maintainer of libstdc++, the gcc implementation of the C++ standard library.
<blockquote>
<b>From: Ben Craig</b><br/>
<p>
If *someone* (possibly me) added the maze of #ifdefs to a branch of libstdc++ to support p0829, would the libstdc++ maintainers be willing to accept and maintain such a thing (assuming it is in the working draft, has tests, high quality, etc)?
</p>
<b>From: Jonathan Wakely</b><br/>
<p>
Yes, definitely. If it's in the WP (and even better, useful to constrained environments) we will support it.
</p><p>
GCC is heavily used on bare-metal systems (especially ARM) and if those users can leverage the C++ standard library then we provide more value to them.
</p>
</blockquote>
I had similar email discussion with Marshall Clow, the maintainer of libc++, the clang implementation of the C++ standard library.
<blockquote>
<b>From: Ben Craig</b><br/>
<p>
[...]<p/>
If *someone* (possibly me) added the maze of #ifdefs to a branch of libc++ to support p0829, would the libc++ maintainers be willing to accept and maintain such a thing (assuming it is in the working draft, has tests, high quality, etc)?  In the next draft of p0829, may I publicly state that libc++ would be willing to add that support?<p/>
[...]
</p>
<b>From: Marshall Clow</b><br/>
<p>
I haven’t been ignoring you, but rather talking to a bunch of people who use libc++
</p><p>
In general, they are in favor of supporting a freestanding mode for libc++.
Some of them, however, have serious concerns about p0829.
</p><p>
So, yes, you can put my name on the list, but I suspect you’ll get comments about the specifics.
</p>
</blockquote></p>


<h1>Design decisions</h1>
<p>
Even more so than for a hosted implementation; kernel, micro-controller, and GPU programmers do not want to pay for what they don't use.  As a consequence, I am not adding features that require global storage, even if that storage is immutable.
</p><p>
Note that the following concerns are not revolving around execution time performance.  These are generally concerns about space overhead and correctness.
</p><p>
This proposal doesn't remove problematic features from the language, but it does make it so that the bulk of the freestanding standard library doesn't require those features.  Users that disable the problematic features (as is existing practice) will still have portable portions of the standard library at their disposal.
</p><p>
Note that we cannot just take the list of <code>constexpr</code> functions and make those functions the freestanding subset.  We also can't do the reverse, and make everything freestanding <code>constexpr</code> or conditionally <code>noexcept</code>.  <code>memcpy</code> cannot currently be made <code>constexpr</code> because it must convert from <code>cv void*</code> to <code>unsigned char[]</code>.  Several floating point functions could be made <code>constexpr</code>, but would not be permitted in freestanding.  <code>constexpr</code> also allows allocations, which freestanding avoids.
</p><p>
We also cannot just take the list of everything that is conditionally <code>noexcept</code> and make those functions freestanding.  The "Lakos Rule"[Meredith11] prohibits most standard library functions from being conditionally <code>noexcept</code>, unless they have a wide contract.
</p><p>
Regardless, if a function or class is <code>constexpr</code> or <code>noexcept</code>, and it doesn't involve floating point, then that function or class is a strong candidate to be put into freestanding mode.
</p><p>
In the future, it may make sense to allow all <code>constexpr</code> functions into freestanding, so long as they are used in a <code>constexpr</code> context and not invoked at runtime.
</p>
<h2>Exceptions</h2>
<p>
Exceptions either require external jump tables or extra bookkeeping instructions.  This consumes program storage space.
</p><p>
In the Itanium ABI, throwing an exception requires a heap allocation.  In the Microsoft ABI, re-throwing an exception will consume surprisingly large amounts of stack space (2,100 bytes for a re-throw in 32-bit environments, 9,700 bytes in a 64-bit environment).  Program storage space, heap space, and stack space are typically scarce resources in micro-controller development.
</p><p>
In environments with threads, exception handling requires the use of thread-local storage.
</p>
<h2>RTTI</h2>
RTTI requires extra data in vtables and extra classes that are difficult to optimize away, consuming program storage space.
<h2>Thread-local storage</h2>
Thread-local storage requires extra code in the operating system for support.  In addition, if one thread uses thread-local storage, that cost is imposed on other threads.
<h2>The heap</h2>
The heap is a big set of global state.  In addition, heap exhaustion is typically expressed via exception.  Some micro-controller systems don't have a heap.  In kernel environments, there is typically a heap, but there isn't a reasonable choice of <i>which</i> heap to use as the default.  In the Windows kernel, the two best candidates for a default heap are the paged pool (plentiful available memory, but unsafe to use in many contexts), and the non-paged pool (safe to use, but limited capacity).  The C++ implementation in the Windows kernel forces users to implement their own global <code>operator new</code> to make this decision.
<h2>Floating point</h2>
<p>
Many micro-controller systems don't have floating point hardware.  Software emulated floating point can drag in large runtimes that are difficult to optimize away.
</p><p>
Most operating systems speed up system calls by not saving and restoring floating point state.  That means that kernel uses of floating point operations require extra care to avoid corrupting user state.
</p>
<h2>Functions requiring global or thread-local storage</h2>
These functions have been omitted or removed from the freestanding library.  Examples are the locale aware functions and the C random number functions.</li>
<h2>Parallel algorithms</h2>
For the <code>&lt;algorithms&gt;</code>, <code>&lt;numeric&gt;</code>, and <code>&lt;memory&gt;</code> headers, we would only be able to support sequential execution of parallel algorithms.  Since this adds little value, the execution policy overloads will be omitted.
<h2>Partial class inclusion</h2>
<p>
Some classes are only partially freestanding.  In the Albuquerque 2017 meeting, there was no consensus on allowing or prohibiting this (SF F N A SA 0 9 3 5 1).
</p><p>
In this proposal, I partially include three classes: <code>std::array</code>, <code>std::string_view</code>, and <code>std::optional</code>.  If we were designing these classes from scratch with a freestanding environment in mind, they would have the exact same layout and the exact same interface, with the exception of the excluded methods.  I think it is highly unlikely that the committee would standardize a <code>std::freestanding_array</code> that was the exact same as <code>std::array</code>, just without the <code>at()</code> method.
</p><p>
I would like to call out <code>std::variant</code> as well.  While I do include the entire class, I do exclude the <code>get()</code> function.  <code>get()</code> is logically part of the interface.  The same general argument I used for <code>std::array</code>, <code>std::string_view</code>, and <code>std::optional</code> holds for <code>std::variant</code>.
</p>
<h1>Technical Specifications</h1>
<h2>Complete headers newly required for freestanding implementations</h2>
<code><ul>
<li>&lt;csetjmp&gt;</li>
<li>&lt;utility&gt;</li>
<li>&lt;tuple&gt;</li>
<li>&lt;ratio&gt;</li>
<li>&lt;compare&gt;</li>
<li>&lt;span&gt;</li>
<li>&lt;contract&gt;</li>
<li>&lt;ranges&gt;</li>
</ul></code>
<h2>Partial headers newly required for freestanding implementations</h2>
Portions of <code>&lt;cstdlib&gt;</code>
<ul>
<code><li>size_t</li>
<li>div_t</li>
<li>ldiv_t</li>
<li>lldiv_t</li>
<li>NULL</li>
<li>bsearch</li>
<li>qsort</li>
<li>abs(int)</li>
<li>abs(long int)</li>
<li>abs(long long int)</li>
<li>labs</li>
<li>llabs</li>
<li>div</li>
<li>ldiv</li>
<li>lldiv</li></code>
</ul>
<p>
All the error <code>#defines</code> in <code>&lt;cerrno&gt;</code>, but not <code>errno</code>.
</p><p>
The <code>errc</code> enum from <code>&lt;system_error&gt;</code>.
</p><p>
All of <code>&lt;optional&gt;</code>, except for <code>bad_optional_access</code> and <code>optional::value</code>.  The <code>optional</code> value can be accessed through the unchecked observers, <code>operator*</code> and <code>operator-&gt;</code>.
</p><p>
All of <code>&lt;variant&gt;</code>, except for <code>get</code>.  The <code>variant</code> value can be accessed through <code>get_if</code>.
</p><p>
All of <code>&lt;bitset&gt;</code> except for operator&lt;&lt;; operator&gt;&gt;; bitset::to_string; the bitset string constructors; and the indexed versions of bitset::set, bitset::reset, and bitset::flip.
</p><p>
Portions of <code>&lt;memory&gt;</code>.
</p>
<ul>
<li><code>pointer_traits</code></li>
<li><code>to_address</code></li>
<li><code>align</code></li>
<li><code>allocator_arg_t</code></li>
<li><code>allocator_arg</code></li>
<li><code>uses_allocator</code></li>
<li><code>allocator_traits</code></li>
<li><a href="https://wg21.link/specialized.algorithms">[specialized.algorithms]</a>, except for the ExecutionPolicy overloads</li>
<li><code>unique_ptr</code></li>
<li><code>default_delete</code></li>
<li><code>uses_allocator_v</code></li>
</ul>
<p>
Most of <code>&lt;functional&gt;</code>.  <b>Omit</b> the following.
<ul>
<li><a href="https://wg21.link/func.wrap">[func.wrap]</a>, polymorphic function wrappers (i.e. <code>std::function</code> and friends).</li>
<li><a href="https://wg21.link/func.search.bm">[func.search.bm]</a>, <code>boyer_moore_searcher</code></li>
<li><a href="https://wg21.link/func.search.bmh">[func.search.bmh]</a>, <code>boyer_moore_horspool_searcher</code></li>
</ul>
</p><p>
<code>&lt;chrono&gt;</code> durations and duration math.  <b>Omit</b> clocks, civil time, and streaming functions.
</p><p>
Portions of <code>&lt;charconv&gt;</code>.
</p>
<ul>
<li><code>to_chars_result</code></li>
<li><code>from_chars_result</code></li>
<li><code>to_chars</code>(integral)</li>
<li><code>from_chars</code>(integral)</li>
</ul>
<p>
The <code>char_traits</code> class from <code>&lt;string&gt;</code>.
</p><p>
Most of <code>&lt;string_view&gt;</code>.  These functions will be <b>omitted</b>:
</p>
<ul>
<code><li>operator&lt;&lt;</li>
<li>basic_string_view::at</li>
<li>basic_string_view::copy</li>
<li>basic_string_view::substr</li>
<li>basic_string_view::compare(size_type pos1, size_type n1, basic_string_view s);
<li>basic_string_view::compare(size_type pos1, size_type n1, basic_string_view s,
size_type pos2, size_type n2);
<li>basic_string_view::compare(size_type pos1, size_type n1, const charT* s);
<li>basic_string_view::compare(size_type pos1, size_type n1, const charT* s,
size_type n2);
</code></ul><p>
Portions of <code>&lt;cstring&gt;</code>.
<ul>
<code><li>memcpy</li>
<li>memmove</li>
<li>strcpy</li>
<li>strncpy</li>
<li>strcat</li>
<li>strncat</li>
<li>memcmp</li>
<li>strcmp</li>
<li>strncmp</li>
<li>memchr</li>
<li>strchr</li>
<li>strcspn</li>
<li>strpbrk</li>
<li>strrchr</li>
<li>strspn</li>
<li>strstr</li>
<li>memset</li>
<li>strlen</li>
</code></ul>
Portions of <code>&lt;cwchar&gt;</code>.
<ul>
<code><li>wcscpy</li>
<li>wcsncpy</li>
<li>wmemcpy</li>
<li>wmemmove</li>
<li>wcscat</li>
<li>wcsncat</li>
<li>wcscmp</li>
<li>wcsncmp</li>
<li>wmemcmp</li>
<li>wcschr</li>
<li>wcscspn</li>
<li>wcspbrk</li>
<li>wcsrchr</li>
<li>wcsspn</li>
<li>wcsstr</li>
<li>wcstok</li>
<li>wmemchr</li>
<li>wcslen</li>
<li>wmemset</li>
</code></ul>
<p>
All of <code>&lt;array&gt;</code> except for <code>array::at</code>.
</p><p>
All of <code>&lt;iterator&gt;</code> except for the stream iterators.
</p><p>
Most of <code>&lt;algorithm&gt;</code> and <code>&lt;numeric&gt;</code>.  The ExecutionPolicy overloads will not be included.  The following functions will be <b>omitted</b> due to the usage of temporary buffers:
</p>
<ul>
<code><li>stable_sort</li>
<li>stable_partition</li>
<li>inplace_merge</li>
</code></ul>
<p>
Portions of <code>&lt;random&gt;</code>.  The following portions will be included:
</p>
<ul>
<code>
<li>linear_congruential_engine</li>
<li>mersenne_twister_engine</li>
<li>subtract_with_carry_engine</li>
<li>discard_block_engine</li>
<li>independent_bits_engine</li>
</code>
<li>[rand.predef], except for <code>knuth_b</code></li>
<li><code>uniform_int_distribution</code></li>
</ul>
A small portion of <code>&lt;cmath&gt;</code> will be present.
<ul>
<code><li>abs(int)</li>
<li>abs(long int)</li>
<li>abs(long long int)</li>
</code></ul>
A portion of <code>&lt;cinttypes&gt;</code> will be present.
<ul>
<code><li>imaxabs</li>
<li>imaxdiv</li>
<li>abs(intmax_t)</li>
<li>div(intmax_t, intmax_t)</li>
</code></ul>
<h2>Notable omissions</h2>
<p>
<code>errno</code> is not included as it is global state.  In addition, errno is best implemented as a thread-local variable.
</p><p>
<code>error_code</code>, <code>error_condition</code>, and <code>error_category</code> all have <code>string</code> in the interface.
</p><p>
Many string functions (<code>strtol</code> and family) rely on <code>errno</code>.
</p><p>
<code>strtok</code> and <code>rand</code> aren't required to use thread-local storage, but good implementations do.  I don't want to encourage bad implementations.
</p><p>
<code>assert</code> is not included as it requires a stderror stream.
</p><p>
<code>_Exit</code> is not included as I do not wish to add more termination functions.  I hope to remove most of them in the future.  Program termination requires involvement from the operating system / environment.
</p><p>
<code>&lt;cctype&gt;</code> and <code>&lt;cwctype&gt;</code> rely heavily on global locale data.
</p><p>
<code>make_unique</code> is not included, although <code>unique_ptr</code> is included.  <code>make_unique</code> has a dependency on heap management functionality, and can throw on heap exhaustion.
</p><p>
<code>seed_seq</code> uses the heap.  Users can create their own classes satisfying the seed sequence requirements if they wish to use the Sseq constructors on the engine templates.
</p><p>
<code>shuffle_order_engine</code> doesn't have floating point in its interface, but the algorithm in the standard uses math on the real numbers, which is typically translated into code as floating point.  <code>knuth_b</code> is just a convenience typedef on <code>shuffle_order_engine</code>.  <code>shuffle_order_engine</code> can be added if an efficient non-floating point implementation of the algorithm is discovered.
</p>
<h2>Potential removals</h2>
Here are some things that I am currently requiring, but could be convinced to remove.
<ul><li><code>&lt;cwchar&gt;</code></li></ul>
The <code>&lt;cwchar&gt;</code> functions are implementable for freestanding environments, but infrequently used for systems programming.  They do not exist in freestanding C11 implementations.
<ul><li>Insert iterators</li></ul>
<code>back_insert_iterator</code>, <code>front_insert_iterator</code>, and <code>insert_iterator</code> don't directly allocate memory, but their typical usage with standard containers does allocate memory.  This paper doesn't add any standard containers that can be used with the insert iterators.  It is also unclear how a user would signal an insertion failure.  Regardless, the iterators could be used with a user's (or future standard) <code>fixed_capacity_vector</code>.
<ul><li><code>visit</code></li></ul>
<code>visit</code> only throws when the <code>variant</code> is valueless.  If exceptions are disabled, the <code>variant</code> will always have a value.  Since the standard doesn't acknowledge exceptions being disabled, we include the (hopefully) dead <code>bad_variant_access</code> class.
<ul><li><code>unique_ptr</code></li></ul>
<code>unique_ptr</code> is generally used for heap management, but is occasionally used as a makeshift RAII object for other resources.  In the Jacksonville 2018 wg21 meeting, there was a strong interest in providing <code>unique_ptr</code>.
<ul><li><code>default_delete</code></li></ul>
<code>default_delete</code> looks like it has a dependency on the heap, due to its use of the <code>delete</code> operator.  <code>default_delete</code> only ends up depending on the heap if the templated type would depend on the heap for <code>new</code> and <code>delete</code> though.  A class with a custom, non-throwing <code>operator new</code> and <code>operator delete</code> will work just fine without pulling in the heap machinery.<br/>
Pulling in <code>default_delete</code> also keeps us from forking the definition of <code>unique_ptr</code>.
<ul><li>Partial classes</li></ul>
<code>array</code>, <code>bitset</code>, <code>optional</code>, <code>string_view</code>, and <code>variant</code> all have functions that throw.  These functions aren't critical to the use of the class.  The exceptions that <code>array</code>, <code>bitset</code>, and <code>string_view</code> throw are doubly bad, as those exceptions require <code>std::string</code>.  These headers and classes can be omitted if the committee strongly objects to marking a class partially freestanding.

<h2>Potential additions</h2>
Here are some things that I am not currently requiring, but could be convinced to add.
<ul><li><code>complex&lt;integer&gt;</code></li></ul>
I currently omit the <code>complex</code> class entirely, but in theory, the integer version of <code>complex</code> are fine.  I am unsure how many of the associated functions are implementable without floating point access though.  I do not believe that <code>complex</code> for integer types is a widely used class.
<ul><li>Floating point support</li></ul>
Perhaps we don't worry about library portability in all cases.  Just because kernel modes can't easily use floating point doesn't mean that we should deny floating point to the micro-controller space.  Do note that most of <code>&lt;cmath&gt;</code> has a dependency on <code>errno</code>.
<ul><li><code>errno</code> and string functions like <code>strtol</code></li></ul>
While <code>errno</code> is global data, it isn't much global data.  Thread safety is a concern for those platforms that have threading, but don't have thread-local storage.
<h1>Feature Test Macros</h1>
<p>
A freestanding implementation that provides support for this paper shall define the following feature test macro.
</p>
<table border="1">
    <thead><tr>
        <th>Name</th>
        <th>Value</th>
        <th>Header</th>
    </tr></thead>
    <tbody><tr>
        <td><code>__cpp_freestanding_library</code></td>
        <td><var>201803</var></td>
        <td><code>&lt;version&gt;<code></td>
    </tr></tbody>
</table>
<p>
The <code>__cpp_freestanding_library</code> macro is useful for detecting the absence of throwing facilities.  A user could conditionally use a hand-rolled implementation in freestanding mode or the standard implementation in hosted mode.
</p><p>
The library feature macros have been partitioned into those that must be present in both freestanding and hosted mode, and those that only need to be present in hosted mode.  If the implementation provides more than the minimal freestanding subset, then the implementation shall also provide the corresponding feature test macros.
</p><p>
The pre-existing feature macros were not provided on freestanding / hosted boundaries.  As a result, a choice has to be made about feature test macros that contain both freestanding and non-freestanding code (e.g. <code>__cpp_lib_chrono</code>, <code>__cpp_lib_boyer_moore_searcher</code>, and others).  This revision includes feature test macros in freestanding if any of the feature is included in freestanding.  Users that need to detect the non-freestanding parts will also need to test against <code>__cpp_freestanding_library</code>.
</p>
<h1>Wording</h1>
<p>
Wording is based off of an intermediate version of Working Draft, Standard for Programming Language C++, from July 26, 2018.
</p>
Add a new subclause [freestanding.membership], under [conventions] and after [objects.within.classes]:
<blockquote class="stdins">
<h4 ><a class='secnum' style='min-width:118pt'>?.?.?.?</a> Freestanding membership <a class='abbr_ref'>[freestanding.membership]</a></h4>
<div class='para'>
    <div class='marginalizedparent'><a class='marginalized'>1</a></div>
    <div class='sentence'>The freestanding implementation has several declarations and macro definitions that shall meet the same requirements as for a hosted implementation unless otherwise specified.</div>
    <div class='sentence'>In the associated header synopsis for such declarations and macro definitions, the items shall be followed with a comment that ends with <span class='textit'>freestanding</span>, as in:</div>
<pre class='codeblock'>
#define E2BIG <span class='textit'><span class='texttt'>see below</span></span> <span class='comment'>// <span class='textit'>freestanding</span></span>
</pre>
</div>
<div class='para'>
    <div class='marginalizedparent'><a class='marginalized'>2</a></div>
    <div class='sentence'>The freestanding implementation has several headers that shall meet the same requirements as for a hosted implementation unless otherwise specified.</div>
    <div class='sentence'>The synopsis for these headers shall start with a comment that ends with <span class='textit'>freestanding</span>, as in:</div>
<pre class='codeblock'>
<span class='comment'>// <span class='textit'>freestanding</span></span>
namespace std {
</pre>
    <div class='sentence'>Individual declarations and macro definitions in such a header shall not be followed with a comment that ends with <span class='textit'>freestanding</span>.</div>
</div>
<div class='para'>
    <div class='marginalizedparent'><a class='marginalized'>3</a></div>
    <div class='sentence'>Some classes and class templates are required to be partially implemented in a freestanding implementation.</div>
    <div class='sentence'>Such entities are permitted to be fully implemented in a freestanding implementation.</div>
    <div class='sentence'>In the associated header synopsis for such declarations, the declarations shall be followed with a comment that ends with <span class='textit'>freestanding, partial</span>, as in:</div>
<pre class='codeblock'>
  template&lt;class T&gt;
    class optional; <span class='comment'>// <span class='textit'>freestanding, partial</span></span>
</pre>
    <div class='sentence'>Some member functions in partially implemented entities are not required to be present in a freestanding implementation.</div>
    <div class='sentence'>In the associated class or class template synopsis for such member functions, the declarations shall be followed by a comment that ends with <span class='textit'>freestanding, omit</span>, as in:</div>
<pre class='codeblock'>
    constexpr const T&amp; value() const&amp;; <span class='comment'>// <span class='textit'>freestanding, omit</span></span>
</pre>
    <div class='sentence'>All declarations in the partially implemented class or class template that are not followed by a <span class='textit'>freestanding, omit</span> comment shall meet the same requirements as for a hosted implementation unless otherwise specified.</div>
</div>
<div class='para'>
    <div class='marginalizedparent'><a class='marginalized'>4</a></div>
    <div class='sentence'>Deduction guides for class templates that are implemented (partially or fully) in a freestanding implementation shall be implemented in a freestanding implementation.</div>
    <div class='sentence'>The containing namespace for each non-namespace declaration that is implemented (partially or fully) in a freestanding implementation shall be implemented in a freestanding implementation.</div>
</div>
</blockquote>

Rework Table 22 referenced from [compliance]:
<del>
<div class='numberedTable'>Table 22 - C++ headers for freestanding implementations<br><table >
<tr class='rowsep'>
  <td colspan='2' class='center'><div id='2.sentence-3' class='sentence'><b>Subclause</b></div></td>
  <td class='left'><div id='2.sentence-4' class='sentence'><b>Header(s)</b></div></td>
</tr>
<tr class='capsep'>
  <td class='left'><div id='2.sentence-5' class='sentence'>[support.types]</div></td>
  <td class='left'><div id='2.sentence-6' class='sentence'>Types</div></td>
  <td class='left'><div id='2.sentence-7' class='sentence'><span class='texttt'>&lt;cstddef&gt;</span></div></td>
</tr>
<tr class='rowsep'>
  <td class='left'><div id='2.sentence-8' class='sentence'>[support.limits]</div></td>
  <td class='left'><div id='2.sentence-9' class='sentence'>Implementation properties</div></td>
  <td class='left'><div id='2.sentence-10' class='sentence'><span class='texttt'>&lt;cfloat&gt;</span> <span class='texttt'>&lt;limits&gt;</span> <span class='texttt'>&lt;climits&gt;</span> <span class='texttt'>&lt;version&gt;</span></div></td>
</tr>
<tr class='rowsep'>
  <td class='left'><div id='2.sentence-11' class='sentence'>[cstdint]</div></td>
  <td class='left'><div id='2.sentence-12' class='sentence'>Integer types</div></td>
  <td class='left'><div id='2.sentence-13' class='sentence'><span class='texttt'>&lt;cstdint&gt;</span></div></td>
</tr>
<tr class='rowsep'>
  <td class='left'><div id='2.sentence-14' class='sentence'>[support.start.term]</div></td>
  <td class='left'><div id='2.sentence-15' class='sentence'>Start and termination</div></td>
  <td class='left'><div id='2.sentence-16' class='sentence'><span class='texttt'>&lt;cstdlib&gt;</span></div></td>
</tr>
<tr class='rowsep'>
  <td class='left'><div id='2.sentence-17' class='sentence'>[support.dynamic]</div></td>
  <td class='left'><div id='2.sentence-18' class='sentence'>Dynamic memory management</div></td>
  <td class='left'><div id='2.sentence-19' class='sentence'><span class='texttt'>&lt;new&gt;</span></div></td>
</tr>
<tr class='rowsep'>
  <td class='left'><div id='2.sentence-20' class='sentence'>[support.rtti]</div></td>
  <td class='left'><div id='2.sentence-21' class='sentence'>Type identification</div></td>
  <td class='left'><div id='2.sentence-22' class='sentence'><span class='texttt'>&lt;typeinfo&gt;</span></div></td>
</tr>
<tr class='rowsep'>
  <td class='left'><div id='2.sentence-23' class='sentence'>[support.exception]</div></td>
  <td class='left'><div id='2.sentence-24' class='sentence'>Exception handling</div></td>
  <td class='left'><div id='2.sentence-25' class='sentence'><span class='texttt'>&lt;exception&gt;</span></div></td>
</tr>
<tr class='rowsep'>
  <td class='left'><div id='2.sentence-26' class='sentence'>[support.initlist]</div></td>
  <td class='left'><div id='2.sentence-27' class='sentence'>Initializer lists</div></td>
  <td class='left'><div id='2.sentence-28' class='sentence'><span class='texttt'>&lt;initializer_&shy;list&gt;</span></div></td>
</tr>
<tr class='rowsep'>
  <td class='left'><div id='2.sentence-29' class='sentence'>[support.runtime]</div></td>
  <td class='left'><div id='2.sentence-30' class='sentence'>Other runtime support</div></td>
  <td class='left'><div id='2.sentence-31' class='sentence'><span class='texttt'>&lt;cstdarg&gt;</span></div></td>
</tr>
<tr class='rowsep'>
  <td class='left'><div id='2.sentence-29' class='sentence'>[concepts]</div></td>
  <td class='left'><div id='2.sentence-30' class='sentence'>Concepts library</div></td>
  <td class='left'><div id='2.sentence-31' class='sentence'><span class='texttt'>&lt;concepts&gt;</span></div></td>
</tr>
<tr class='rowsep'>
  <td class='left'><div id='2.sentence-32' class='sentence'>[meta]</div></td>
  <td class='left'><div id='2.sentence-33' class='sentence'>Type traits</div></td>
  <td class='left'><div id='2.sentence-34' class='sentence'><span class='texttt'>&lt;type_&shy;traits&gt;</span></div></td>
</tr>
<tr class='rowsep'>
  <td class='left'><div id='2.sentence-35' class='sentence'>[bit]</div></td>
  <td class='left'><div id='2.sentence-36' class='sentence'>Bit manipulation</div></td>
  <td class='left'><div id='2.sentence-37' class='sentence'><span class='texttt'>&lt;bit&gt;</span></div></td>
</tr>
<tr class='rowsep'>
  <td class='left'><div id='2.sentence-38' class='sentence'>[atomics]</div></td>
  <td class='left'><div id='2.sentence-39' class='sentence'>Atomics</div></td>
  <td class='left'><div id='2.sentence-40' class='sentence'><span class='texttt'>&lt;atomic&gt;</span></div></td>
</tr>
</table></div></div>
</del>
<ins>
<div class='numberedTable'>Table 21 - C++ headers for freestanding implementations<br><table >
<tr class='rowsep'>
    <td class='left'><div class='sentence'><span class='texttt'>&lt;algorithm&gt;</span></div></td>
    <td class='left'><div class='sentence'><span class='texttt'>&lt;cmath&gt;</span></div></td>
    <td class='left'><div class='sentence'><span class='texttt'>&lt;exception&gt;</span></div></td>
    <td class='left'><div class='sentence'><span class='texttt'>&lt;ratio&gt;</span></div></td>
</tr>
<tr>
    <td class='left'><div class='sentence'><span class='texttt'>&lt;array&gt;</span></div></td>
    <td class='left'><div class='sentence'><span class='texttt'>&lt;compare&gt;</span></div></td>
    <td class='left'><div class='sentence'><span class='texttt'>&lt;functional&gt;</span></div></td>
    <td class='left'><div class='sentence'><span class='texttt'>&lt;span&gt;</span></div></td>
</tr>
<tr>
    <td class='left'><div class='sentence'><span class='texttt'>&lt;atomic&gt;</span></div></td>
    <td class='left'><div class='sentence'><span class='texttt'>&lt;concepts&gt;</span></div></td>
    <td class='left'><div class='sentence'><span class='texttt'>&lt;initializer_list&gt;</span></div></td>
    <td class='left'><div class='sentence'><span class='texttt'>&lt;string&gt;</span></div></td>
</tr>
<tr>
    <td class='left'><div class='sentence'><span class='texttt'>&lt;bit&gt;</span></div></td>
    <td class='left'><div class='sentence'><span class='texttt'>&lt;contract&gt;</span></div></td>
    <td class='left'><div class='sentence'><span class='texttt'>&lt;iterator&gt;</span></div></td>
    <td class='left'><div class='sentence'><span class='texttt'>&lt;string_view&gt;</span></div></td>
</tr>
<tr>
    <td class='left'><div class='sentence'><span class='texttt'>&lt;bitset&gt;</span></div></td>
    <td class='left'><div class='sentence'><span class='texttt'>&lt;csetjmp&gt;</span></div></td>
    <td class='left'><div class='sentence'><span class='texttt'>&lt;limits&gt;</span></div></td>
    <td class='left'><div class='sentence'><span class='texttt'>&lt;system_error&gt;</span></div></td>
</tr>
<tr>
    <td class='left'><div class='sentence'><span class='texttt'>&lt;cerrno&gt;</span></div></td>
    <td class='left'><div class='sentence'><span class='texttt'>&lt;cstdarg&gt;</span></div></td>
    <td class='left'><div class='sentence'><span class='texttt'>&lt;memory&gt;</span></div></td>
    <td class='left'><div class='sentence'><span class='texttt'>&lt;tuple&gt;</span></div></td>
</tr>
<tr>
    <td class='left'><div class='sentence'><span class='texttt'>&lt;cfloat&gt;</span></div></td>
    <td class='left'><div class='sentence'><span class='texttt'>&lt;cstddef&gt;</span></div></td>
    <td class='left'><div class='sentence'><span class='texttt'>&lt;new&gt;</span></div></td>
    <td class='left'><div class='sentence'><span class='texttt'>&lt;type_traits&gt;</span></div></td>
</tr>
<tr>
    <td class='left'><div class='sentence'><span class='texttt'>&lt;charconv&gt;</span></div></td>
    <td class='left'><div class='sentence'><span class='texttt'>&lt;cstdint&gt;</span></div></td>
    <td class='left'><div class='sentence'><span class='texttt'>&lt;numeric&gt;</span></div></td>
    <td class='left'><div class='sentence'><span class='texttt'>&lt;typeinfo&gt;</span></div></td>
</tr>
<tr>
    <td class='left'><div class='sentence'><span class='texttt'>&lt;chrono&gt;</span></div></td>
    <td class='left'><div class='sentence'><span class='texttt'>&lt;cstdlib&gt;</span></div></td>
    <td class='left'><div class='sentence'><span class='texttt'>&lt;optional&gt;</span></div></td>
    <td class='left'><div class='sentence'><span class='texttt'>&lt;utility&gt;</span></div></td>
</tr>
<tr>
    <td class='left'><div class='sentence'><span class='texttt'>&lt;cinttypes&gt;</span></div></td>
    <td class='left'><div class='sentence'><span class='texttt'>&lt;cstring&gt;</span></div></td>
    <td class='left'><div class='sentence'><span class='texttt'>&lt;random&gt;</span></div></td>
    <td class='left'><div class='sentence'><span class='texttt'>&lt;variant&gt;</span></div></td>
</tr>
<tr>
    <td class='left'><div class='sentence'><span class='texttt'>&lt;climits&gt;</span></div></td>
    <td class='left'><div class='sentence'><span class='texttt'>&lt;cwchar&gt;</span></div></td>
    <td class='left'><div class='sentence'><span class='texttt'>&lt;ranges&gt;</span></div></td>
    <td class='left'><div class='sentence'><span class='texttt'>&lt;version&gt;</span></div></td>
</tr>
</table></div></ins>
Change in [compliance] paragraph 3:
<blockquote class="std">
<div class='para'>
<del>
    <div class='sentence'>The supplied version of the header
    <span class='texttt'>&lt;cstdlib&gt;</span>
    shall declare at least the functions
    <span class='texttt'>abort</span>,
    <span class='texttt'>atexit</span>,
    <span class='texttt'>at_&shy;quick_&shy;exit</span>,
    <span class='texttt'>exit</span>,
    and
    <span class='texttt'>quick_&shy;exit</span> [support.start.term].</div>
    <div class='sentence'>The other headers listed in this table shall meet the same requirements as for a hosted implementation.</div>
</del>

<ins>
    <div class='sentence'>The supplied versions of the header
    <span class='texttt'>&lt;version&gt;</span>
    shall meet the requirements specified in [support.limits.general].</div>
    <div class='sentence'>The other headers listed in this table shall meet the requirements for a freestanding implementation, as specified in the respective header synopsis.</div>
</ins>
</div>
</blockquote>

Instructions to the editor:<br/>
Please add a <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins> comment to the beginning of the following synopses.  These headers are entirely freestanding.
<ul>
<li><ins>[cstddef.syn]</ins></li>
<li><ins>[limits.syn]</ins></li>
<li><ins>[climits.syn]</ins></li>
<li><ins>[cfloat.syn]</ins></li>
<li><ins>[cstdint.syn]</ins></li>
<li><ins>[climits.syn]</ins></li>
<li><ins>[cstdint.syn]</ins></li>
<li><ins>[new.syn]</ins></li>
<li><ins>[typeinfo.syn]</ins></li>
<li><ins>[exception.syn]</ins></li>
<li><ins>[initializer_list.syn]</ins></li>
<li><ins>[compare.syn]</ins></li>
<li><ins>[cstdarg.syn]</ins></li>
<li><ins>[csetjmp.syn]</ins></li>
<li><ins>[concepts.syn]</ins></li>
<li><ins>[utility.syn]</ins></li>
<li><ins>[tuple.syn]</ins></li>
<li><ins>[meta.type.synop]</ins></li>
<li><ins>[ratio.syn]</ins></li>
<li><ins>[span.syn]</ins></li>
<li><ins>[ranges.syn]</ins></li>
<li><ins>[bit.syn]</ins></li>
<li><ins>[atomics.syn]</ins></li>
</ul>

Change in [cstdlib.syn]:
<blockquote class="std">
<h3 ><a class='secnum' style='min-width:103pt'>???</a> Header <span class='texttt'>&lt;cstdlib&gt;</span> synopsis <a class='abbr_ref'>[cstdlib.syn]</a></h3>
<pre class='codeblock'>
namespace std {
  using size_t = <span class='textit'><span class='texttt'>see below</span></span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  using div_t = <span class='textit'><span class='texttt'>see below</span></span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  using ldiv_t = <span class='textit'><span class='texttt'>see below</span></span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  using lldiv_t = <span class='textit'><span class='texttt'>see below</span></span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
}

#define NULL <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define EXIT_FAILURE <span class='textit'><span class='texttt'>see below</span></span>
#define EXIT_SUCCESS <span class='textit'><span class='texttt'>see below</span></span>
#define RAND_MAX <span class='textit'><span class='texttt'>see below</span></span>
#define MB_CUR_MAX <span class='textit'><span class='texttt'>see below</span></span>

namespace std {
  <span class='comment'>// Exposition-only function type aliases
</span>  extern "C" using <span class='textit'>c-atexit-handler</span> = void();                        <span class='comment'>// <span class='textit'>exposition only</span>
</span>  extern "C++" using <span class='textit'>atexit-handler</span> = void();                        <span class='comment'>// <span class='textit'>exposition only</span>
</span>  extern "C" using <span class='textit'>c-compare-pred</span> = int(const void*, const void*);   <span class='comment'>// <span class='textit'>exposition only</span>
</span>  extern "C++" using <span class='textit'>compare-pred</span> = int(const void*, const void*);   <span class='comment'>// <span class='textit'>exposition only</span>
</span>
  <span class='comment'>// [support.start.term], start and termination
</span>  [[noreturn]] void abort() noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  int atexit(<span class='textit'>c-atexit-handler</span>* func) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  int atexit(<span class='textit'>atexit-handler</span>* func) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  int at_quick_exit(<span class='textit'>c-atexit-handler</span>* func) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  int at_quick_exit(<span class='textit'>atexit-handler</span>* func) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  [[noreturn]] void exit(int status); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  [[noreturn]] void _Exit(int status) noexcept;
  [[noreturn]] void quick_exit(int status) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  char* <span id='lib:getenv'><span class='tcode_in_codeblock'>getenv</span></span>(const char* name);
  int system(const char* string);

  <span class='comment'>// [c.malloc], C library memory allocation
</span>  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);
  unsigned long long int strtoull(const char* nptr, char** endptr, int base);

  <span class='comment'>// [c.mb.wcs], multibyte / wide string and character conversion functions
</span>  int mblen(const char* s, size_t n);
  int mbtowc(wchar_t* pwc, const char* s, size_t n);
  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);

  <span class='comment'>// [alg.c.library], C standard library algorithms
</span>  void* bsearch(const void* key, const void* base, size_t nmemb, size_t size,
                <span class='textit'>c-compare-pred</span>* compar); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  void* bsearch(const void* key, const void* base, size_t nmemb, size_t size,
                <span class='textit'>compare-pred</span>* compar); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  void qsort(void* base, size_t nmemb, size_t size, <span class='textit'>c-compare-pred</span>* compar); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  void qsort(void* base, size_t nmemb, size_t size, <span class='textit'>compare-pred</span>* compar); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  <span class='comment'>// [c.math.rand], low-quality random number generation
</span>  int rand();
  void srand(unsigned int seed);

  <span class='comment'>// [c.math.abs], absolute values
</span>  int abs(int j); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  long int abs(long int j); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  long long int abs(long long int j); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  float abs(float j);
  double abs(double j);
  long double abs(long double j);

  long int labs(long int j); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  long long int llabs(long long int j); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  div_t div(int numer, int denom); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  ldiv_t div(long int numer, long int denom);             <span class='comment'>// see [library.c]<ins>, <span class='textit'>freestanding</span></ins>
</span>  lldiv_t div(long long int numer, long long int denom);  <span class='comment'>// see [library.c]<ins>, <span class='textit'>freestanding</span></ins>
</span>  ldiv_t ldiv(long int numer, long int denom); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  lldiv_t lldiv(long long int numer, long long int denom); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
}</pre>
</blockquote>

Replace paragraph 3 in [support.limits.general]:
<blockquote class="std">
<del>
<div class='para'><div class='marginalizedparent'><a class='marginalized'>3</a></div><div class='sourceLinkParent'></div>
  <div class='sentence'>The macros in Table 36 are defined after inclusion of the header <span class='texttt'>&lt;version&gt;</span> or
one of the corresponding headers specified in the table.</div>
  <div class='note'>[<a class='note_link'><span class='textit'>Note</span></a><span class='textit'>:</span> Future versions of this International Standard might replace the values of these macros with greater values. -<i>end note</i>]</div>
</div>
</del>
<ins>
<div class='para'><div class='marginalizedparent'><a class='marginalized'>3</a></div><div class='sourceLinkParent'></div>
  <div class='sentence'>On freestanding and hosted implementations, the macros in Table ??35?? are defined after inclusion of the header <span class='texttt'>&lt;version&gt;</span> or one of the corresponding headers specified in the table.</div>
  <div class='sentence'>On hosted implementations, the macros in Table ??36?? are defined after inclusion of the header <span class='texttt'>&lt;version&gt;</span> or one of the corresponding headers specified in the table.</div>
  <div class='sentence'>The presence of the macros in Table ??36?? is implementation defined on freestanding implementations.</div>
  <div class='note'>[<a class='note_link'><span class='textit'>Note</span></a><span class='textit'>:</span> Future versions of this International Standard might replace the values of these macros with greater values. -<i>end note</i>]</div>
</div>
</ins>
</blockquote>

Add a new paragraph to the end of [support.limits.general]:
<blockquote class="stdins">
<div class='para'><div class='marginalizedparent'><a class='marginalized'>???</a></div><div class='sourceLinkParent'></div>
  <div class='sentence'>A freestanding implementation shall define the <span class='texttt'>__cpp_freestanding_library</span> macro with the value <span class='texttt'>201803L</span> in the <span class='texttt'>&lt;version&gt;</span> header.</div>
</div>
</blockquote>

Split Table 36.<br/>
The new Table ??36?? will be named <ins>Table ??36?? - Freestanding and hosted standard library feature-test macros</ins>.  Leave the following macros in Table ??36??.
<ul>
  <li><code>__cpp_lib_addressof_constexpr</code></li>
  <li><code>__cpp_lib_allocator_traits_is_always_equal</code></li>
  <li><code>__cpp_lib_apply</code></li>
  <li><code>__cpp_lib_array_constexpr</code></li>
  <li><code>__cpp_lib_as_const</code></li>
  <li><code>__cpp_lib_atomic_is_always_lock_free</code></li>
  <li><code>__cpp_lib_atomic_ref</code></li>
  <li><code>__cpp_lib_bind_front</code></li>
  <li><code>__cpp_lib_bit_cast</code></li>
  <li><code>__cpp_lib_bool_constant</code></li>
  <li><code>__cpp_lib_boyer_moore_searcher</code></li>
  <li><code>__cpp_lib_byte</code></li>
  <li><code>__cpp_lib_char8_t</code></li>
  <li><code>__cpp_lib_chrono</code></li>
  <li><code>__cpp_lib_chrono_udls</code></li>
  <li><code>__cpp_lib_clamp</code></li>
  <li><code>__cpp_lib_concepts</code></li>
  <li><code>__cpp_lib_constexpr_misc</code></li>
  <li><code>__cpp_lib_constexpr_swap_algorithms</code></li>
  <li><code>__cpp_lib_exchange_function</code></li>
  <li><code>__cpp_lib_gcd_lcm</code></li>
  <li><code>__cpp_lib_hardware_interference_size</code></li>
  <li><code>__cpp_lib_has_unique_object_representations</code></li>
  <li><code>__cpp_lib_integer_sequence</code></li>
  <li><code>__cpp_lib_integral_constant_callable</code></li>
  <li><code>__cpp_lib_invoke</code></li>
  <li><code>__cpp_lib_is_aggregate</code></li>
  <li><code>__cpp_lib_is_constant_evaluated</code></li>
  <li><code>__cpp_lib_is_final</code></li>
  <li><code>__cpp_lib_is_invocable</code></li>
  <li><code>__cpp_lib_is_null_pointer</code></li>
  <li><code>__cpp_lib_is_swappable</code></li>
  <li><code>__cpp_lib_launder</code></li>
  <li><code>__cpp_lib_logical_traits</code></li>
  <li><code>__cpp_lib_make_from_tuple</code></li>
  <li><code>__cpp_lib_make_reverse_iterator</code></li>
  <li><code>__cpp_lib_nonmember_container_access</code></li>
  <li><code>__cpp_lib_not_fn</code></li>
  <li><code>__cpp_lib_null_iterators</code></li>
  <li><code>__cpp_lib_optional</code></li>
  <li><code>__cpp_lib_ranges</code></li>
  <li><code>__cpp_lib_raw_memory_algorithms</code></li>
  <li><code>__cpp_lib_result_of_sfinae</code></li>
  <li><code>__cpp_lib_robust_nonmodifying_seq_ops</code></li>
  <li><code>__cpp_lib_sample</code></li>
  <li><code>__cpp_lib_string_view</code></li>
  <li><code>__cpp_lib_three_way_comparison</code></li>
  <li><code>__cpp_lib_to_chars</code></li>
  <li><code>__cpp_lib_transformation_trait_aliases</code></li>
  <li><code>__cpp_lib_transparent_operators</code></li>
  <li><code>__cpp_lib_tuple_element_t</code></li>
  <li><code>__cpp_lib_tuples_by_type</code></li>
  <li><code>__cpp_lib_type_trait_variable_templates</code></li>
  <li><code>__cpp_lib_uncaught_exceptions</code></li>
  <li><code>__cpp_lib_variant</code></li>
  <li><code>__cpp_lib_void_t</code></li>
</ul>

The new Table ??37?? will be named <ins>Table ??37?? - Hosted standard library feature-test macros</ins>.  Move the following macros into Table ??37??.
<ul>
  <li><code>__cpp_lib_any</code></li>
  <li><code>__cpp_lib_complex_udls</code></li>
  <li><code>__cpp_lib_destroying_delete</code></li>
  <li><code>__cpp_lib_enable_shared_from_this</code></li>
  <li><code>__cpp_lib_erase_if</code></li>
  <li><code>__cpp_lib_execution</code></li>
  <li><code>__cpp_lib_filesystem</code></li>
  <li><code>__cpp_lib_generic_associative_lookup</code></li>
  <li><code>__cpp_lib_generic_unordered_lookup</code></li>
  <li><code>__cpp_lib_hypot</code></li>
  <li><code>__cpp_lib_incomplete_container_elements</code></li>
  <li><code>__cpp_lib_list_remove_return_type</code></li>
  <li><code>__cpp_lib_make_unique</code></li>
  <li><code>__cpp_lib_map_try_emplace</code></li>
  <li><code>__cpp_lib_math_special_functions</code></li>
  <li><code>__cpp_lib_memory_resource</code></li>
  <li><code>__cpp_lib_node_extract</code></li>
  <li><code>__cpp_lib_parallel_algorithm</code></li>
  <li><code>__cpp_lib_quoted_string_io</code></li>
  <li><code>__cpp_lib_scoped_lock</code></li>
  <li><code>__cpp_lib_shared_mutex</code></li>
  <li><code>__cpp_lib_shared_ptr_arrays</code></li>
  <li><code>__cpp_lib_shared_ptr_weak_type</code></li>
  <li><code>__cpp_lib_shared_timed_mutex</code></li>
  <li><code>__cpp_lib_string_udls</code></li>
  <li><code>__cpp_lib_unordered_map_try_emplace</code></li>
</ul>

Change in [cerrno.syn]:
<blockquote class="std">
<h3 ><a class='secnum' style='min-width:103pt'>?.?.?</a> Header <span class='texttt'>&lt;cerrno&gt;</span> synopsis <a class='abbr_ref'>[cerrno.syn]</a></h3>
<pre class='codeblock'>
#define errno <span class='textit'><span class='texttt'>see below</span></span>

#define E2BIG <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define EACCES <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define EADDRINUSE <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define EADDRNOTAVAIL <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define EAFNOSUPPORT <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define EAGAIN <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define EALREADY <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define EBADF <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define EBADMSG <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define EBUSY <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define ECANCELED <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define ECHILD <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define ECONNABORTED <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define ECONNREFUSED <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define ECONNRESET <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define EDEADLK <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define EDESTADDRREQ <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define EDOM <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define EEXIST <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define EFAULT <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define EFBIG <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define EHOSTUNREACH <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define EIDRM <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define EILSEQ <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define EINPROGRESS <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define EINTR <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define EINVAL <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define EIO <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define EISCONN <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define EISDIR <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define ELOOP <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define EMFILE <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define EMLINK <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define EMSGSIZE <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define ENAMETOOLONG <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define ENETDOWN <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define ENETRESET <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define ENETUNREACH <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define ENFILE <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define ENOBUFS <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define ENODATA <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define ENODEV <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define ENOENT <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define ENOEXEC <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define ENOLCK <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define ENOLINK <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define ENOMEM <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define ENOMSG <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define ENOPROTOOPT <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define ENOSPC <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define ENOSR <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define ENOSTR <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define ENOSYS <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define ENOTCONN <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define ENOTDIR <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define ENOTEMPTY <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define ENOTRECOVERABLE <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define ENOTSOCK <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define ENOTSUP <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define ENOTTY <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define ENXIO <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define EOPNOTSUPP <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define EOVERFLOW <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define EOWNERDEAD <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define EPERM <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define EPIPE <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define EPROTO <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define EPROTONOSUPPORT <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define EPROTOTYPE <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define ERANGE <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define EROFS <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define ESPIPE <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define ESRCH <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define ETIME <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define ETIMEDOUT <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define ETXTBSY <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define EWOULDBLOCK <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define EXDEV <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
</pre>
</blockquote>

Change in [system_error.syn]:
<blockquote class="std">
<h3 ><a class='secnum' style='min-width:103pt'>?.?.?</a> Header <span class='texttt'>&lt;system_&shy;error&gt;</span> synopsis <a class='abbr_ref'>[system_error.syn]</a></h3>
<div  class='sentence'>
<pre class='codeblock'>
namespace std {
  class error_category;
  const error_category&amp; generic_category() noexcept;
  const error_category&amp; system_category() noexcept;

  class error_code;
  class error_condition;
  class system_error;

  template&lt;class T&gt;
    struct is_error_code_enum : public false_type {};

  template&lt;class T&gt;
    struct is_error_condition_enum : public false_type {};

  enum class errc { <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    address_family_not_supported,       <span class='comment'>// <span class='tcode_in_codeblock'>EAFNOSUPPORT</span>
</span>    address_in_use,                     <span class='comment'>// <span class='tcode_in_codeblock'>EADDRINUSE</span>
</span>    address_not_available,              <span class='comment'>// <span class='tcode_in_codeblock'>EADDRNOTAVAIL</span>
</span></pre>
</div>
</blockquote>

Change in [optional.syn]:
<blockquote class="std">
<h3 ><a class='secnum' style='min-width:103pt'>?.?.?</a> Header <span class='texttt'>&lt;optional&gt;</span> synopsis <a class='abbr_ref'>[optional.syn]</a></h3>
<pre class='codeblock'>
namespace std {
  <span class='comment'>// [optional.optional], class template <span class='tcode_in_codeblock'>optional</span>
</span>  template&lt;class T&gt;
    class optional; <ins><span class='comment'>// <span class='textit'>freestanding, partial</span></span></ins>

  <span class='comment'>// [optional.nullopt], no-value state indicator
</span>  struct nullopt_t{<span class='textit'><span class='texttt'>see below</span></span>}; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  inline constexpr nullopt_t nullopt(<span class='textit'><span class='texttt'>unspecified</span></span>); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  <span class='comment'>// [optional.bad.access], class <span class='tcode_in_codeblock'>bad_&shy;optional_&shy;access</span>
</span>  class bad_optional_access;

  <span class='comment'>// [optional.relops], relational operators
</span>  template&lt;class T, class U&gt;
  constexpr bool operator==(const optional&lt;T&gt;&amp;, const optional&lt;U&gt;&amp;); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T, class U&gt;
  constexpr bool operator!=(const optional&lt;T&gt;&amp;, const optional&lt;U&gt;&amp;); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T, class U&gt;
  constexpr bool operator&lt;(const optional&lt;T&gt;&amp;, const optional&lt;U&gt;&amp;); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T, class U&gt;
  constexpr bool operator&gt;(const optional&lt;T&gt;&amp;, const optional&lt;U&gt;&amp;); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T, class U&gt;
  constexpr bool operator&lt;=(const optional&lt;T&gt;&amp;, const optional&lt;U&gt;&amp;); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T, class U&gt;
  constexpr bool operator&gt;=(const optional&lt;T&gt;&amp;, const optional&lt;U&gt;&amp;); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  <span class='comment'>// [optional.nullops], comparison with <span class='tcode_in_codeblock'>nullopt</span>
</span>  template&lt;class T&gt; constexpr bool operator==(const optional&lt;T&gt;&amp;, nullopt_t) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T&gt; constexpr bool operator==(nullopt_t, const optional&lt;T&gt;&amp;) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T&gt; constexpr bool operator!=(const optional&lt;T&gt;&amp;, nullopt_t) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T&gt; constexpr bool operator!=(nullopt_t, const optional&lt;T&gt;&amp;) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T&gt; constexpr bool operator&lt;(const optional&lt;T&gt;&amp;, nullopt_t) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T&gt; constexpr bool operator&lt;(nullopt_t, const optional&lt;T&gt;&amp;) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T&gt; constexpr bool operator&gt;(const optional&lt;T&gt;&amp;, nullopt_t) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T&gt; constexpr bool operator&gt;(nullopt_t, const optional&lt;T&gt;&amp;) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T&gt; constexpr bool operator&lt;=(const optional&lt;T&gt;&amp;, nullopt_t) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T&gt; constexpr bool operator&lt;=(nullopt_t, const optional&lt;T&gt;&amp;) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T&gt; constexpr bool operator&gt;=(const optional&lt;T&gt;&amp;, nullopt_t) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T&gt; constexpr bool operator&gt;=(nullopt_t, const optional&lt;T&gt;&amp;) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  <span class='comment'>// [optional.comp_with_t], comparison with <span class='tcode_in_codeblock'>T</span>
</span>  template&lt;class T, class U&gt; constexpr bool operator==(const optional&lt;T&gt;&amp;, const U&amp;); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T, class U&gt; constexpr bool operator==(const T&amp;, const optional&lt;U&gt;&amp;); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T, class U&gt; constexpr bool operator!=(const optional&lt;T&gt;&amp;, const U&amp;); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T, class U&gt; constexpr bool operator!=(const T&amp;, const optional&lt;U&gt;&amp;); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T, class U&gt; constexpr bool operator&lt;(const optional&lt;T&gt;&amp;, const U&amp;); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T, class U&gt; constexpr bool operator&lt;(const T&amp;, const optional&lt;U&gt;&amp;); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T, class U&gt; constexpr bool operator&gt;(const optional&lt;T&gt;&amp;, const U&amp;); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T, class U&gt; constexpr bool operator&gt;(const T&amp;, const optional&lt;U&gt;&amp;); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T, class U&gt; constexpr bool operator&lt;=(const optional&lt;T&gt;&amp;, const U&amp;); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T, class U&gt; constexpr bool operator&lt;=(const T&amp;, const optional&lt;U&gt;&amp;); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T, class U&gt; constexpr bool operator&gt;=(const optional&lt;T&gt;&amp;, const U&amp;); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T, class U&gt; constexpr bool operator&gt;=(const T&amp;, const optional&lt;U&gt;&amp;); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  <span class='comment'>// [optional.specalg], specialized algorithms
</span>  template&lt;class T&gt;
    void swap(optional&lt;T&gt;&amp;, optional&lt;T&gt;&amp;) noexcept(<span class='textit'><span class='texttt'>see below</span></span>); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  template&lt;class T&gt;
    constexpr optional&lt;<span class='textit'><span class='texttt'>see below</span></span>&gt; make_optional(T&amp;&amp;); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T, class... Args&gt;
    constexpr optional&lt;T&gt; make_optional(Args&amp;&amp;... args); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T, class U, class... Args&gt;
    constexpr optional&lt;T&gt; make_optional(initializer_list&lt;U&gt; il, Args&amp;&amp;... args); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  <span class='comment'>// [optional.hash], hash support
</span>  template&lt;class T&gt; struct hash; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T&gt; struct hash&lt;optional&lt;T&gt;&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
}</pre>
</blockquote>

Change in [optional.optional]
<blockquote class="std">
<pre class='codeblock'>
    <span class='comment'>// [optional.observe], observers
</span>    constexpr const T* operator-&gt;() const;
    constexpr T* operator-&gt;();
    constexpr const T&amp; operator*() const&amp;;
    constexpr T&amp; operator*() &amp;;
    constexpr T&amp;&amp; operator*() &amp;&amp;;
    constexpr const T&amp;&amp; operator*() const&amp;&amp;;
    constexpr explicit operator bool() const noexcept;
    constexpr bool has_value() const noexcept;
    constexpr const T&amp; value() const&amp;; <ins><span class='comment'>// <span class='textit'>freestanding, omit</span></span></ins>
    constexpr T&amp; value() &amp;; <ins><span class='comment'>// <span class='textit'>freestanding, omit</span></span></ins>
    constexpr T&amp;&amp; value() &amp;&amp;; <ins><span class='comment'>// <span class='textit'>freestanding, omit</span></span></ins>
    constexpr const T&amp;&amp; value() const&amp;&amp;; <ins><span class='comment'>// <span class='textit'>freestanding, omit</span></span></ins>
    template&lt;class U&gt; constexpr T value_or(U&amp;&amp;) const&amp;;
    template&lt;class U&gt; constexpr T value_or(U&amp;&amp;) &amp;&amp;;
</pre>
</blockquote>

Change in [variant.syn]:
<blockquote class="std">
<h3 ><a class='secnum' style='min-width:103pt'>?.?.?</a> Header <span class='texttt'>&lt;variant&gt;</span> synopsis <a class='abbr_ref'>[variant.syn]</a></h3>
<pre class='codeblock'>
namespace std {
  <span class='comment'>// [variant.variant], class template <span class='tcode_in_codeblock'>variant</span>
</span>  template&lt;class... Types&gt;
    class variant; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  <span class='comment'>// [variant.helper], variant helper classes
</span>  template&lt;class T&gt; struct variant_size;                   <span class='comment'>// not defined<ins>, <span class='textit'>freestanding</span></ins>
</span>  template&lt;class T&gt; struct variant_size&lt;const T&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T&gt; struct variant_size&lt;volatile T&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T&gt; struct variant_size&lt;const volatile T&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T&gt;
    inline constexpr size_t variant_size_v = variant_size&lt;T&gt;::value; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  template&lt;class... Types&gt;
    struct variant_size&lt;variant&lt;Types...&gt;&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  template&lt;size_t I, class T&gt; struct variant_alternative;  <span class='comment'>// not defined<ins>, <span class='textit'>freestanding</span></ins>
</span>  template&lt;size_t I, class T&gt; struct variant_alternative&lt;I, const T&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;size_t I, class T&gt; struct variant_alternative&lt;I, volatile T&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;size_t I, class T&gt; struct variant_alternative&lt;I, const volatile T&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;size_t I, class T&gt;
    using variant_alternative_t = typename variant_alternative&lt;I, T&gt;::type; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  template&lt;size_t I, class... Types&gt;
    struct variant_alternative&lt;I, variant&lt;Types...&gt;&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  inline constexpr size_t variant_npos = -1; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  <span class='comment'>// [value.get], value access
</span>  template&lt;class T, class... Types&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    constexpr bool holds_alternative(const variant&lt;Types...&gt;&amp;) noexcept; 

  template&lt;size_t I, class... Types&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    constexpr variant_alternative_t&lt;I, variant&lt;Types...&gt;&gt;&amp; get(variant&lt;Types...&gt;&amp;);
  template&lt;size_t I, class... Types&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    constexpr variant_alternative_t&lt;I, variant&lt;Types...&gt;&gt;&amp;&amp; get(variant&lt;Types...&gt;&amp;&amp;);
  template&lt;size_t I, class... Types&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    constexpr const variant_alternative_t&lt;I, variant&lt;Types...&gt;&gt;&amp; get(const variant&lt;Types...&gt;&amp;);
  template&lt;size_t I, class... Types&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    constexpr const variant_alternative_t&lt;I, variant&lt;Types...&gt;&gt;&amp;&amp; get(const variant&lt;Types...&gt;&amp;&amp;);

  template&lt;class T, class... Types&gt;
    constexpr T&amp; get(variant&lt;Types...&gt;&amp;);
  template&lt;class T, class... Types&gt;
    constexpr T&amp;&amp; get(variant&lt;Types...&gt;&amp;&amp;);
  template&lt;class T, class... Types&gt;
    constexpr const T&amp; get(const variant&lt;Types...&gt;&amp;);
  template&lt;class T, class... Types&gt;
    constexpr const T&amp;&amp; get(const variant&lt;Types...&gt;&amp;&amp;);

  template&lt;size_t I, class... Types&gt;
    constexpr add_pointer_t&lt;variant_alternative_t&lt;I, variant&lt;Types...&gt;&gt;&gt;
      get_if(variant&lt;Types...&gt;*) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;size_t I, class... Types&gt;
    constexpr add_pointer_t&lt;const variant_alternative_t&lt;I, variant&lt;Types...&gt;&gt;&gt;
      get_if(const variant&lt;Types...&gt;*) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  template&lt;class T, class... Types&gt;
    constexpr add_pointer_t&lt;T&gt;
      get_if(variant&lt;Types...&gt;*) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T, class... Types&gt;
    constexpr add_pointer_t&lt;const T&gt;
      get_if(const variant&lt;Types...&gt;*) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  <span class='comment'>// [variant.relops], relational operators
</span>  template&lt;class... Types&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    constexpr bool operator==(const variant&lt;Types...&gt;&amp;, const variant&lt;Types...&gt;&amp;);
  template&lt;class... Types&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    constexpr bool operator!=(const variant&lt;Types...&gt;&amp;, const variant&lt;Types...&gt;&amp;);
  template&lt;class... Types&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    constexpr bool operator&lt;(const variant&lt;Types...&gt;&amp;, const variant&lt;Types...&gt;&amp;);
  template&lt;class... Types&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    constexpr bool operator&gt;(const variant&lt;Types...&gt;&amp;, const variant&lt;Types...&gt;&amp;);
  template&lt;class... Types&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    constexpr bool operator&lt;=(const variant&lt;Types...&gt;&amp;, const variant&lt;Types...&gt;&amp;);
  template&lt;class... Types&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    constexpr bool operator&gt;=(const variant&lt;Types...&gt;&amp;, const variant&lt;Types...&gt;&amp;);

  <span class='comment'>// [variant.visit], visitation
</span>  template&lt;class Visitor, class... Variants&gt;
    constexpr <span class='textit'><span class='texttt'>see below</span></span> visit(Visitor&amp;&amp;, Variants&amp;&amp;...); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
</span>  template&lt;class R, class Visitor, class... Variants&gt;
    constexpr R visit(Visitor&amp;&amp;, Variants&amp;&amp;...); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  <span class='comment'>// [variant.monostate], class <span class='tcode_in_codeblock'>monostate</span>
</span>  struct monostate; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  <span class='comment'>// [variant.monostate.relops], <span class='tcode_in_codeblock'>monostate</span> relational operators
</span>  constexpr bool operator==(monostate, monostate) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  constexpr bool operator!=(monostate, monostate) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  constexpr bool operator&lt;(monostate, monostate) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  constexpr bool operator&gt;(monostate, monostate) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  constexpr bool operator&lt;=(monostate, monostate) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  constexpr bool operator&gt;=(monostate, monostate) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  <span class='comment'>// [variant.specalg], specialized algorithms
</span>  template&lt;class... Types&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    void swap(variant&lt;Types...&gt;&amp;, variant&lt;Types...&gt;&amp;) noexcept(<span class='textit'><span class='texttt'>see below</span></span>);

  <span class='comment'>// [variant.bad.access], class <span class='tcode_in_codeblock'>bad_&shy;variant_&shy;access</span>
</span>  class bad_variant_access; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  <span class='comment'>// [variant.hash], hash support
</span>  template&lt;class T&gt; struct hash; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class... Types&gt; struct hash&lt;variant&lt;Types...&gt;&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;&gt; struct hash&lt;monostate&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
}
</pre></blockquote>

Change in [bitset.syn]:
<blockquote class="std">
<h3 ><a class='secnum' style='min-width:103pt'>?.?.?</a> Header <span class='texttt'>&lt;bitset&gt;</span> synopsis <a class='abbr_ref'>[bitset.syn]</a></h3>
<pre class='codeblock'>
#include &lt;string&gt;
#include &lt;iosfwd&gt;   <span class='comment'>// for <span class='tcode_in_codeblock'>istream</span>, <span class='tcode_in_codeblock'>ostream</span>, see [iosfwd.syn]
</span>
namespace std {
  template&lt;size_t N&gt; class bitset; <ins><span class='comment'>// <span class='textit'>freestanding, partial</span></span></ins>

  <span class='comment'>// [bitset.operators], bitset operators
</span>  template&lt;size_t N&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    bitset&lt;N&gt; operator&amp;(const bitset&lt;N&gt;&amp;, const bitset&lt;N&gt;&amp;) noexcept;
  template&lt;size_t N&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    bitset&lt;N&gt; operator|(const bitset&lt;N&gt;&amp;, const bitset&lt;N&gt;&amp;) noexcept;
  template&lt;size_t N&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    bitset&lt;N&gt; operator^(const bitset&lt;N&gt;&amp;, const bitset&lt;N&gt;&amp;) noexcept;
  template&lt;class charT, class traits, size_t N&gt;
    basic_istream&lt;charT, traits&gt;&amp;
      operator&gt;&gt;(basic_istream&lt;charT, traits&gt;&amp; is, bitset&lt;N&gt;&amp; x);
  template&lt;class charT, class traits, size_t N&gt;
    basic_ostream&lt;charT, traits&gt;&amp;
      operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp; os, const bitset&lt;N&gt;&amp; x);
}</pre></blockquote>

Change in [template.bitset]:
<blockquote class="std">
<h3 ><a class='secnum' style='min-width:103pt'>?.?.?</a> Class template <span class='texttt'>bitset</span> <a class='abbr_ref'>[template.bitset]</a></h3><pre class='codeblock'>
namespace std {
  template&lt;size_t N&gt; class bitset {
  public:
    <span class='comment'>// bit reference
</span>    class reference {
      friend class bitset;
      reference() noexcept;

    public:
      reference(const reference&amp;) = default;
      ~reference();
      reference&amp; operator=(bool x) noexcept;            <span class='comment'>// for <span class='tcode_in_codeblock'>b[i] = x;</span>
</span>      reference&amp; operator=(const reference&amp;) noexcept;  <span class='comment'>// for <span class='tcode_in_codeblock'>b[i] = b[j];</span>
</span>      bool operator~() const noexcept;                  <span class='comment'>// flips the bit
</span>      operator bool() const noexcept;                   <span class='comment'>// for <span class='tcode_in_codeblock'>x = b[i];</span>
</span>      reference&amp; flip() noexcept;                       <span class='comment'>// for <span class='tcode_in_codeblock'>b[i].flip();</span>
</span>    };

    <span class='comment'>// [bitset.cons], constructors
</span>    constexpr bitset() noexcept;
    constexpr bitset(unsigned long long val) noexcept;
    template&lt;class charT, class traits, class Allocator&gt;
      explicit bitset(
        const basic_string&lt;charT, traits, Allocator&gt;&amp; str,
        typename basic_string&lt;charT, traits, Allocator&gt;::size_type pos = 0,
        typename basic_string&lt;charT, traits, Allocator&gt;::size_type n
          = basic_string&lt;charT, traits, Allocator&gt;::npos,
        charT zero = charT('0'),
        charT one = charT('1')); <ins><span class='comment'>// <span class='textit'>freestanding, omit</span></span></ins>
    template&lt;class charT&gt;
      explicit bitset(
        const charT* str,
        typename basic_string&lt;charT&gt;::size_type n = basic_string&lt;charT&gt;::npos,
        charT zero = charT('0'),
        charT one = charT('1')); <ins><span class='comment'>// <span class='textit'>freestanding, omit</span></span></ins>

    <span class='comment'>// [bitset.members], bitset operations
</span>    bitset&lt;N&gt;&amp; operator&amp;=(const bitset&lt;N&gt;&amp; rhs) noexcept;
    bitset&lt;N&gt;&amp; operator|=(const bitset&lt;N&gt;&amp; rhs) noexcept;
    bitset&lt;N&gt;&amp; operator^=(const bitset&lt;N&gt;&amp; rhs) noexcept;
    bitset&lt;N&gt;&amp; operator&lt;&lt;=(size_t pos) noexcept;
    bitset&lt;N&gt;&amp; operator&gt;&gt;=(size_t pos) noexcept;
    bitset&lt;N&gt;&amp; set() noexcept;
    bitset&lt;N&gt;&amp; set(size_t pos, bool val = true); <ins><span class='comment'>// <span class='textit'>freestanding, omit</span></span></ins>
    bitset&lt;N&gt;&amp; reset() noexcept;
    bitset&lt;N&gt;&amp; reset(size_t pos); <ins><span class='comment'>// <span class='textit'>freestanding, omit</span></span></ins>
    bitset&lt;N&gt;  operator~() const noexcept;
    bitset&lt;N&gt;&amp; flip() noexcept;
    bitset&lt;N&gt;&amp; flip(size_t pos); <ins><span class='comment'>// <span class='textit'>freestanding, omit</span></span></ins>

    <span class='comment'>// element access
</span>    constexpr bool operator[](size_t pos) const;        <span class='comment'>// for <span class='tcode_in_codeblock'>b[i];</span>
</span>    reference operator[](size_t pos);                   <span class='comment'>// for <span class='tcode_in_codeblock'>b[i];</span>
</span>
    unsigned long to_ulong() const;
    unsigned long long to_ullong() const;
    template&lt;class charT = char,
              class traits = char_traits&lt;charT&gt;,
              class Allocator = allocator&lt;charT&gt;&gt;
      basic_string&lt;charT, traits, Allocator&gt;
        to_string(charT zero = charT('0'), charT one = charT('1')) const; <ins><span class='comment'>// <span class='textit'>freestanding, omit</span></span></ins>

    size_t count() const noexcept;
    constexpr size_t size() const noexcept;
    bool operator==(const bitset&lt;N&gt;&amp; rhs) const noexcept;
    bool operator!=(const bitset&lt;N&gt;&amp; rhs) const noexcept;
    bool test(size_t pos) const;
    bool all() const noexcept;
    bool any() const noexcept;
    bool none() const noexcept;
    bitset&lt;N&gt; operator&lt;&lt;(size_t pos) const noexcept;
    bitset&lt;N&gt; operator&gt;&gt;(size_t pos) const noexcept;
  };

  <span class='comment'>// [bitset.hash], hash support
</span>  template&lt;class T&gt; struct hash;
  template&lt;size_t N&gt; struct hash&lt;bitset&lt;N&gt;&gt;;
}</pre></blockquote>

Change in [memory.syn]:
<blockquote class="std">
<h3 ><a class='secnum' style='min-width:103pt'>?.?.?</a> Header <span class='texttt'>&lt;memory&gt;</span> synopsis <a class='abbr_ref'>[memory.syn]</a></h3>
<div class='para' >
    <div class='marginalizedparent'><a class='marginalized'>1</a></div>
    <div  class='sentence'>The header <span class='texttt'>&lt;memory&gt;</span> defines several types and function templates that
describe properties of pointers and pointer-like types, manage memory
for containers and other template types, destroy objects, and
construct multiple objects in
uninitialized memory
buffers ([pointer.traits]-[specialized.algorithms]).</div>
<div  class='sentence'>The header also defines the templates
<span class='texttt'>unique_&shy;ptr</span>, <span class='texttt'>shared_&shy;ptr</span>, <span class='texttt'>weak_&shy;ptr</span>, and various function
templates that operate on objects of these types ([smartptr]).</div>
<pre class='codeblock'>
namespace std {
  <span class='comment'>// [pointer.traits], pointer traits
</span>  template&lt;class Ptr&gt; struct pointer_traits; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T&gt; struct pointer_traits&lt;T*&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  <span class='comment'>// [pointer.conversion], pointer conversion
</span>  template&lt;class Ptr&gt;
    auto to_address(const Ptr&amp; p) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T&gt;
    constexpr T* to_address(T* p) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  <span class='comment'>// [util.dynamic.safety], pointer safety
</span>  enum class pointer_safety { relaxed, preferred, strict };
  void declare_reachable(void* p);
  template&lt;class T&gt;
    T* undeclare_reachable(T* p);
  void declare_no_pointers(char* p, size_t n);
  void undeclare_no_pointers(char* p, size_t n);
  pointer_safety get_pointer_safety() noexcept;

  <span class='comment'>// [ptr.align], pointer alignment
</span>  void* align(size_t alignment, size_t size, void*&amp; ptr, size_t&amp; space); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
</span>  template&lt;size_t N, class T&gt;
    [[nodiscard]] constexpr T* assume_aligned(T* ptr);<ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  <span class='comment'>// [allocator.tag], allocator argument tag
</span>  struct allocator_arg_t { explicit allocator_arg_t() = default; }; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  inline constexpr allocator_arg_t allocator_arg{}; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  <span class='comment'>// [allocator.uses], <span class='tcode_in_codeblock'>uses_&shy;allocator</span>
</span>  template&lt;class T, class Alloc&gt; struct uses_allocator; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  <span class='comment' style='font-style:italic;font-family:serif;'>// [allocator.uses.trait], <span class='tcode_in_codeblock'>uses_&shy;allocator</span></span>
  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> T, <span class='keyword'>class</span> Alloc<span class='anglebracket'>&gt;</span>
    <span class='keyword'>inline</span> <span class='keyword'>constexpr</span> <span class='keyword'>bool</span> uses_allocator_v <span class='operator'>=</span> uses_allocator<span class='anglebracket'>&lt;</span>T, Alloc<span class='anglebracket'>&gt;</span><span class='operator'>:</span><span class='operator'>:</span>value; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  <span class='comment' style='font-style:italic;font-family:serif;'>// [allocator.uses.construction], uses-allocator construction</span>
  <span class='keyword'>template</span> <span class='anglebracket'>&lt;</span><span class='keyword'>class</span> T, <span class='keyword'>class</span> Alloc, <span class='keyword'>class</span><span class='operator'>.</span><span class='operator'>.</span><span class='operator'>.</span> Args<span class='anglebracket'>&gt;</span>
    <span class='keyword'>auto</span> uses_allocator_construction_args<span class='parenthesis'>(</span><span class='keyword'>const</span> Alloc<span class='operator'>&amp;</span> alloc, Args<span class='operator'>&amp;</span><span class='operator'>&amp;</span><span class='operator'>.</span><span class='operator'>.</span><span class='operator'>.</span> args<span class='parenthesis'>)</span> <span class='operator'>-</span><span class='anglebracket'>&gt;</span> <span class='textit'><span class='texttt'>see below</span></span>;
  <span class='keyword'>template</span> <span class='anglebracket'>&lt;</span><span class='keyword'>class</span> T, <span class='keyword'>class</span> Alloc, <span class='keyword'>class</span> Tuple1, <span class='keyword'>class</span> Tuple2<span class='anglebracket'>&gt;</span>
    <span class='keyword'>auto</span> uses_allocator_construction_args<span class='parenthesis'>(</span><span class='keyword'>const</span> Alloc<span class='operator'>&amp;</span> alloc, piecewise_construct_t,
                                          Tuple1<span class='operator'>&amp;</span><span class='operator'>&amp;</span> x, Tuple2<span class='operator'>&amp;</span><span class='operator'>&amp;</span> y<span class='parenthesis'>)</span> <span class='operator'>-</span><span class='anglebracket'>&gt;</span>  <span class='textit'><span class='texttt'>see below</span></span>;
  <span class='keyword'>template</span> <span class='anglebracket'>&lt;</span><span class='keyword'>class</span> T, <span class='keyword'>class</span> Alloc<span class='anglebracket'>&gt;</span>
    <span class='keyword'>auto</span> uses_allocator_construction_args<span class='parenthesis'>(</span><span class='keyword'>const</span> Alloc<span class='operator'>&amp;</span> alloc<span class='parenthesis'>)</span> <span class='operator'>-</span><span class='anglebracket'>&gt;</span> <span class='textit'><span class='texttt'>see below</span></span>;
  <span class='keyword'>template</span> <span class='anglebracket'>&lt;</span><span class='keyword'>class</span> T, <span class='keyword'>class</span> Alloc, <span class='keyword'>class</span> U, <span class='keyword'>class</span> V<span class='anglebracket'>&gt;</span>
    <span class='keyword'>auto</span> uses_allocator_construction_args<span class='parenthesis'>(</span><span class='keyword'>const</span> Alloc<span class='operator'>&amp;</span> alloc, U<span class='operator'>&amp;</span><span class='operator'>&amp;</span> u, V<span class='operator'>&amp;</span><span class='operator'>&amp;</span> v<span class='parenthesis'>)</span> <span class='operator'>-</span><span class='anglebracket'>&gt;</span> <span class='textit'><span class='texttt'>see below</span></span>;
  <span class='keyword'>template</span> <span class='anglebracket'>&lt;</span><span class='keyword'>class</span> T, <span class='keyword'>class</span> Alloc, <span class='keyword'>class</span> U, <span class='keyword'>class</span> V<span class='anglebracket'>&gt;</span>
    <span class='keyword'>auto</span> uses_allocator_construction_args<span class='parenthesis'>(</span><span class='keyword'>const</span> Alloc<span class='operator'>&amp;</span> alloc, <span class='keyword'>const</span> pair<span class='anglebracket'>&lt;</span>U,V<span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span> pr<span class='parenthesis'>)</span> <span class='operator'>-</span><span class='anglebracket'>&gt;</span> <span class='textit'><span class='texttt'>see below</span></span>;
  <span class='keyword'>template</span> <span class='anglebracket'>&lt;</span><span class='keyword'>class</span> T, <span class='keyword'>class</span> Alloc, <span class='keyword'>class</span> U, <span class='keyword'>class</span> V<span class='anglebracket'>&gt;</span>
    <span class='keyword'>auto</span> uses_allocator_construction_args<span class='parenthesis'>(</span><span class='keyword'>const</span> Alloc<span class='operator'>&amp;</span> alloc, pair<span class='anglebracket'>&lt;</span>U,V<span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span><span class='operator'>&amp;</span> pr<span class='parenthesis'>)</span> <span class='operator'>-</span><span class='anglebracket'>&gt;</span> <span class='textit'><span class='texttt'>see below</span></span>;
  <span class='keyword'>template</span> <span class='anglebracket'>&lt;</span><span class='keyword'>class</span> T, <span class='keyword'>class</span> Alloc, <span class='keyword'>class</span><span class='operator'>.</span><span class='operator'>.</span><span class='operator'>.</span> Args<span class='anglebracket'>&gt;</span>
    T make_obj_using_allocator<span class='parenthesis'>(</span><span class='keyword'>const</span> Alloc<span class='operator'>&amp;</span> alloc, Args<span class='operator'>&amp;</span><span class='operator'>&amp;</span><span class='operator'>.</span><span class='operator'>.</span><span class='operator'>.</span> args<span class='parenthesis'>)</span>;
  <span class='keyword'>template</span> <span class='anglebracket'>&lt;</span><span class='keyword'>class</span> T, <span class='keyword'>class</span> Alloc, <span class='keyword'>class</span><span class='operator'>.</span><span class='operator'>.</span><span class='operator'>.</span> Args<span class='anglebracket'>&gt;</span>
    T<span class='operator'>*</span> uninitialized_construct_using_allocator<span class='parenthesis'>(</span>T<span class='operator'>*</span> p, <span class='keyword'>const</span> Alloc<span class='operator'>&amp;</span> alloc, Args<span class='operator'>&amp;</span><span class='operator'>&amp;</span><span class='operator'>.</span><span class='operator'>.</span><span class='operator'>.</span> args<span class='parenthesis'>)</span>;

  <span class='comment'>// [allocator.traits], allocator traits
</span>  template&lt;class Alloc&gt; struct allocator_traits; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  <span class='comment'>// [default.allocator], the default allocator
</span>  template&lt;class T&gt; class allocator;
  template&lt;class T, class U&gt;
    bool operator==(const allocator&lt;T&gt;&amp;, const allocator&lt;U&gt;&amp;) noexcept;
  template&lt;class T, class U&gt;
    bool operator!=(const allocator&lt;T&gt;&amp;, const allocator&lt;U&gt;&amp;) noexcept;

  <span class='comment'>// [specialized.algorithms], specialized algorithms</span>
  <span class='comment' style='font-style:italic;font-family:serif;'>// [special.mem.concepts], special memory concepts</span>
  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> I<span class='anglebracket'>&gt;</span>
    <span class='keyword'>concept</span> <span class='textit'>no-throw-input-iterator</span> <span class='operator'>=</span> <span class='textit'><span class='texttt'>see below</span></span>;    <span class='comment' style='font-style:italic;font-family:serif;'>// <span class='textit'>exposition only</span></span>
  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> I<span class='anglebracket'>&gt;</span>
    <span class='keyword'>concept</span> <span class='textit'>no-throw-forward-iterator</span> <span class='operator'>=</span> <span class='textit'><span class='texttt'>see below</span></span>;  <span class='comment' style='font-style:italic;font-family:serif;'>// <span class='textit'>exposition only</span></span>
  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> S, <span class='keyword'>class</span> I<span class='anglebracket'>&gt;</span>
    <span class='keyword'>concept</span> <span class='textit'>no-throw-sentinel</span> <span class='operator'>=</span> <span class='textit'><span class='texttt'>see below</span></span>;          <span class='comment' style='font-style:italic;font-family:serif;'>// <span class='textit'>exposition only</span></span>
  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> R<span class='anglebracket'>&gt;</span>
    <span class='keyword'>concept</span> <span class='textit'>no-throw-input-range</span> <span class='operator'>=</span> <span class='textit'><span class='texttt'>see below</span></span>;       <span class='comment' style='font-style:italic;font-family:serif;'>// <span class='textit'>exposition only</span></span>
  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> R<span class='anglebracket'>&gt;</span>
    <span class='keyword'>concept</span> <span class='textit'>no-throw-forward-range</span> <span class='operator'>=</span> <span class='textit'><span class='texttt'>see below</span></span>;     <span class='comment' style='font-style:italic;font-family:serif;'>// <span class='textit'>exposition only</span></span>

  template&lt;class T&gt;
    constexpr T* addressof(T&amp; r) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T&gt;
    const T* addressof(const T&amp;&amp;) = delete; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class ForwardIterator&gt;
    void uninitialized_default_construct(ForwardIterator first, ForwardIterator last); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class ExecutionPolicy, class ForwardIterator&gt;
    void uninitialized_default_construct(ExecutionPolicy&amp;&amp; exec, <span class='comment'>// see [algorithms.parallel.overloads]
</span>                                         ForwardIterator first, ForwardIterator last);
  template&lt;class ForwardIterator, class Size&gt;
    ForwardIterator uninitialized_default_construct_n(ForwardIterator first, Size n); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class ExecutionPolicy, class ForwardIterator, class Size&gt;
    ForwardIterator uninitialized_default_construct_n(ExecutionPolicy&amp;&amp; exec, <span class='comment'>// see [algorithms.parallel.overloads]
</span>                                                      ForwardIterator first, Size n);

  <span class='keyword'>namespace</span> ranges <span class='curlybracket'>{</span>
    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='textit'>no-throw-forward-iterator</span> I, <span class='textit'>no-throw-sentinel</span><span class='anglebracket'>&lt;</span>I<span class='anglebracket'>&gt;</span> S<span class='anglebracket'>&gt;</span>
      <span class='keyword'>requires</span> DefaultConstructible<span class='anglebracket'>&lt;</span>iter_value_t<span class='anglebracket'>&lt;</span>I<span class='anglebracket'>&gt;</span><span class='anglebracket'>&gt;</span>
        I uninitialized_default_construct<span class='parenthesis'>(</span>I first, S last<span class='parenthesis'>)</span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='textit'>no-throw-forward-range</span> R<span class='anglebracket'>&gt;</span>
      <span class='keyword'>requires</span> DefaultConstructible<span class='anglebracket'>&lt;</span>iter_value_t<span class='anglebracket'>&lt;</span>iterator_t<span class='anglebracket'>&lt;</span>R<span class='anglebracket'>&gt;</span><span class='anglebracket'>&gt;</span><span class='anglebracket'>&gt;</span>
        safe_iterator_t<span class='anglebracket'>&lt;</span>R<span class='anglebracket'>&gt;</span> uninitialized_default_construct<span class='parenthesis'>(</span>R<span class='operator'>&amp;</span><span class='operator'>&amp;</span> r<span class='parenthesis'>)</span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='textit'>no-throw-forward-iterator</span> I<span class='anglebracket'>&gt;</span>
      <span class='keyword'>requires</span> DefaultConstructible<span class='anglebracket'>&lt;</span>iter_value_t<span class='anglebracket'>&lt;</span>I<span class='anglebracket'>&gt;</span><span class='anglebracket'>&gt;</span>
        I uninitialized_default_construct_n<span class='parenthesis'>(</span>I first, iter_difference_t<span class='anglebracket'>&lt;</span>I<span class='anglebracket'>&gt;</span> n<span class='parenthesis'>)</span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  <span class='curlybracket'>}</span>

  template&lt;class ForwardIterator&gt;
    void uninitialized_value_construct(ForwardIterator first, ForwardIterator last);  <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class ExecutionPolicy, class ForwardIterator&gt;
    void uninitialized_value_construct(ExecutionPolicy&amp;&amp; exec, <span class='comment'>// see [algorithms.parallel.overloads]
</span>                                       ForwardIterator first, ForwardIterator last);
  template&lt;class ForwardIterator, class Size&gt;
    ForwardIterator uninitialized_value_construct_n(ForwardIterator first, Size n); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class ExecutionPolicy, class ForwardIterator, class Size&gt;
    ForwardIterator uninitialized_value_construct_n(ExecutionPolicy&amp;&amp; exec, <span class='comment'>// see [algorithms.parallel.overloads]
</span>                                                    ForwardIterator first, Size n);

  <span class='keyword'>namespace</span> ranges <span class='curlybracket'>{</span>
    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='textit'>no-throw-forward-iterator</span> I, <span class='textit'>no-throw-sentinel</span><span class='anglebracket'>&lt;</span>I<span class='anglebracket'>&gt;</span> S<span class='anglebracket'>&gt;</span>
      <span class='keyword'>requires</span> DefaultConstructible<span class='anglebracket'>&lt;</span>iter_value_t<span class='anglebracket'>&lt;</span>I<span class='anglebracket'>&gt;</span><span class='anglebracket'>&gt;</span>
        I uninitialized_value_construct<span class='parenthesis'>(</span>I first, S last<span class='parenthesis'>)</span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='textit'>no-throw-forward-range</span> R<span class='anglebracket'>&gt;</span>
      <span class='keyword'>requires</span> DefaultConstructible<span class='anglebracket'>&lt;</span>iter_value_t<span class='anglebracket'>&lt;</span>iterator_t<span class='anglebracket'>&lt;</span>R<span class='anglebracket'>&gt;</span><span class='anglebracket'>&gt;</span><span class='anglebracket'>&gt;</span>
        safe_iterator_t<span class='anglebracket'>&lt;</span>R<span class='anglebracket'>&gt;</span> uninitialized_value_construct<span class='parenthesis'>(</span>R<span class='operator'>&amp;</span><span class='operator'>&amp;</span> r<span class='parenthesis'>)</span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='textit'>no-throw-forward-iterator</span> I<span class='anglebracket'>&gt;</span>
      <span class='keyword'>requires</span> DefaultConstructible<span class='anglebracket'>&lt;</span>iter_value_t<span class='anglebracket'>&lt;</span>I<span class='anglebracket'>&gt;</span><span class='anglebracket'>&gt;</span>
        I uninitialized_value_construct_n<span class='parenthesis'>(</span>I first, iter_difference_t<span class='anglebracket'>&lt;</span>I<span class='anglebracket'>&gt;</span> n<span class='parenthesis'>)</span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  <span class='curlybracket'>}</span>

  template&lt;class InputIterator, class ForwardIterator&gt;
    ForwardIterator uninitialized_copy(InputIterator first, InputIterator last,
                                       ForwardIterator result); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class ExecutionPolicy, class InputIterator, class ForwardIterator&gt;
    ForwardIterator uninitialized_copy(ExecutionPolicy&amp;&amp; exec, <span class='comment'>// see [algorithms.parallel.overloads]
</span>                                       InputIterator first, InputIterator last,
                                       ForwardIterator result);
  template&lt;class InputIterator, class Size, class ForwardIterator&gt;
    ForwardIterator uninitialized_copy_n(InputIterator first, Size n,
                                         ForwardIterator result); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class ExecutionPolicy, class InputIterator, class Size, class ForwardIterator&gt;
    ForwardIterator uninitialized_copy_n(ExecutionPolicy&amp;&amp; exec, <span class='comment'>// see [algorithms.parallel.overloads]
</span>                                         InputIterator first, Size n,
                                         ForwardIterator result);

  <span class='keyword'>namespace</span> ranges <span class='curlybracket'>{</span>
    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> I, <span class='keyword'>class</span> O<span class='anglebracket'>&gt;</span>
    <span class='keyword'>using</span> uninitialized_copy_result <span class='operator'>=</span> copy_result<span class='anglebracket'>&lt;</span>I, O<span class='anglebracket'>&gt;</span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span>InputIterator I, Sentinel<span class='anglebracket'>&lt;</span>I<span class='anglebracket'>&gt;</span> S1,
             <span class='textit'>no-throw-forward-iterator</span> O, <span class='textit'>no-throw-sentinel</span><span class='anglebracket'>&lt;</span>O<span class='anglebracket'>&gt;</span> S2<span class='anglebracket'>&gt;</span>
      <span class='keyword'>requires</span> Constructible<span class='anglebracket'>&lt;</span>iter_value_t<span class='anglebracket'>&lt;</span>O<span class='anglebracket'>&gt;</span>, iter_reference_t<span class='anglebracket'>&lt;</span>I<span class='anglebracket'>&gt;</span><span class='anglebracket'>&gt;</span>
        uninitialized_copy_result<span class='anglebracket'>&lt;</span>I, O<span class='anglebracket'>&gt;</span>
          uninitialized_copy<span class='parenthesis'>(</span>I ifirst, S1 ilast, O ofirst, S2 olast<span class='parenthesis'>)</span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span>InputRange IR, <span class='textit'>no-throw-forward-range</span> OR<span class='anglebracket'>&gt;</span>
      <span class='keyword'>requires</span> Constructible<span class='anglebracket'>&lt;</span>iter_value_t<span class='anglebracket'>&lt;</span>iterator_t<span class='anglebracket'>&lt;</span>OR<span class='anglebracket'>&gt;</span><span class='anglebracket'>&gt;</span>, iter_reference_t<span class='anglebracket'>&lt;</span>iterator_t<span class='anglebracket'>&lt;</span>IR<span class='anglebracket'>&gt;</span><span class='anglebracket'>&gt;</span><span class='anglebracket'>&gt;</span>
        uninitialized_copy_result<span class='anglebracket'>&lt;</span>safe_iterator_t<span class='anglebracket'>&lt;</span>IR<span class='anglebracket'>&gt;</span>, safe_iterator_t<span class='anglebracket'>&lt;</span>OR<span class='anglebracket'>&gt;</span><span class='anglebracket'>&gt;</span>
          uninitialized_copy<span class='parenthesis'>(</span>IR<span class='operator'>&amp;</span><span class='operator'>&amp;</span> input_range, OR<span class='operator'>&amp;</span><span class='operator'>&amp;</span> output_range<span class='parenthesis'>)</span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> I, <span class='keyword'>class</span> O<span class='anglebracket'>&gt;</span>
      <span class='keyword'>using</span> uninitialized_copy_n_result <span class='operator'>=</span> uninitialized_copy_result<span class='anglebracket'>&lt;</span>I, O<span class='anglebracket'>&gt;</span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span>InputIterator I, <span class='textit'>no-throw-forward-iterator</span> O, <span class='textit'>no-throw-sentinel</span><span class='anglebracket'>&lt;</span>O<span class='anglebracket'>&gt;</span> S<span class='anglebracket'>&gt;</span>
      <span class='keyword'>requires</span> Constructible<span class='anglebracket'>&lt;</span>iter_value_t<span class='anglebracket'>&lt;</span>O<span class='anglebracket'>&gt;</span>, iter_reference_t<span class='anglebracket'>&lt;</span>I<span class='anglebracket'>&gt;</span><span class='anglebracket'>&gt;</span>
        uninitialized_copy_n_result<span class='anglebracket'>&lt;</span>I, O<span class='anglebracket'>&gt;</span>
          uninitialized_copy_n<span class='parenthesis'>(</span>I ifirst, iter_difference_t<span class='anglebracket'>&lt;</span>I<span class='anglebracket'>&gt;</span> n, O ofirst, S olast<span class='parenthesis'>)</span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  <span class='curlybracket'>}</span>

  template&lt;class InputIterator, class ForwardIterator&gt;
    ForwardIterator uninitialized_move(InputIterator first, InputIterator last,
                                       ForwardIterator result); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class ExecutionPolicy, class InputIterator, class ForwardIterator&gt;
    ForwardIterator uninitialized_move(ExecutionPolicy&amp;&amp; exec, <span class='comment'>// see [algorithms.parallel.overloads]
</span>                                       InputIterator first, InputIterator last,
                                       ForwardIterator result);
  template&lt;class InputIterator, class Size, class ForwardIterator&gt;
    pair&lt;InputIterator, ForwardIterator&gt; uninitialized_move_n(InputIterator first, Size n,
                                                              ForwardIterator result); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class ExecutionPolicy, class InputIterator, class Size, class ForwardIterator&gt;
    pair&lt;InputIterator, ForwardIterator&gt; uninitialized_move_n(ExecutionPolicy&amp;&amp; exec, <span class='comment'>// see [algorithms.parallel.overloads]
</span>                                                              InputIterator first, Size n,
                                                              ForwardIterator result);

  <span class='keyword'>namespace</span> ranges <span class='curlybracket'>{</span>
    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> I, <span class='keyword'>class</span> O<span class='anglebracket'>&gt;</span>
      <span class='keyword'>using</span> uninitialized_move_result <span class='operator'>=</span> uninitialized_copy_result<span class='anglebracket'>&lt;</span>I, O<span class='anglebracket'>&gt;</span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span>InputIterator I, Sentinel<span class='anglebracket'>&lt;</span>I<span class='anglebracket'>&gt;</span> S1,
             <span class='textit'>no-throw-forward-iterator</span> O, <span class='textit'>no-throw-sentinel</span><span class='anglebracket'>&lt;</span>O<span class='anglebracket'>&gt;</span> S2<span class='anglebracket'>&gt;</span>
      <span class='keyword'>requires</span> Constructible<span class='anglebracket'>&lt;</span>iter_value_t<span class='anglebracket'>&lt;</span>O<span class='anglebracket'>&gt;</span>, iter_rvalue_reference_t<span class='anglebracket'>&lt;</span>I<span class='anglebracket'>&gt;</span><span class='anglebracket'>&gt;</span>
        uninitialized_move_result<span class='anglebracket'>&lt;</span>I, O<span class='anglebracket'>&gt;</span>
          uninitialized_move<span class='parenthesis'>(</span>I ifirst, S1 ilast, O ofirst, S2 olast<span class='parenthesis'>)</span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span>InputRange IR, <span class='textit'>no-throw-forward-range</span> OR<span class='anglebracket'>&gt;</span>
      <span class='keyword'>requires</span> Constructible<span class='anglebracket'>&lt;</span>iter_value_t<span class='anglebracket'>&lt;</span>iterator_t<span class='anglebracket'>&lt;</span>OR<span class='anglebracket'>&gt;</span><span class='anglebracket'>&gt;</span>,
                             iter_rvalue_reference_t<span class='anglebracket'>&lt;</span>iterator_t<span class='anglebracket'>&lt;</span>IR<span class='anglebracket'>&gt;</span><span class='anglebracket'>&gt;</span><span class='anglebracket'>&gt;</span>
        uninitialized_move_result<span class='anglebracket'>&lt;</span>safe_iterator_t<span class='anglebracket'>&lt;</span>IR<span class='anglebracket'>&gt;</span>, safe_iterator_t<span class='anglebracket'>&lt;</span>OR<span class='anglebracket'>&gt;</span><span class='anglebracket'>&gt;</span>
          uninitialized_move<span class='parenthesis'>(</span>IR<span class='operator'>&amp;</span><span class='operator'>&amp;</span> input_range, OR<span class='operator'>&amp;</span><span class='operator'>&amp;</span> output_range<span class='parenthesis'>)</span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> I, <span class='keyword'>class</span> O<span class='anglebracket'>&gt;</span>
      <span class='keyword'>using</span> uninitialized_move_n_result <span class='operator'>=</span> uninitialized_copy_result<span class='anglebracket'>&lt;</span>I, O<span class='anglebracket'>&gt;</span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span>InputIterator I,
             <span class='textit'>no-throw-forward-iterator</span> O, <span class='textit'>no-throw-sentinel</span><span class='anglebracket'>&lt;</span>O<span class='anglebracket'>&gt;</span> S<span class='anglebracket'>&gt;</span>
      <span class='keyword'>requires</span> Constructible<span class='anglebracket'>&lt;</span>iter_value_t<span class='anglebracket'>&lt;</span>O<span class='anglebracket'>&gt;</span>, iter_rvalue_reference_t<span class='anglebracket'>&lt;</span>I<span class='anglebracket'>&gt;</span><span class='anglebracket'>&gt;</span>
        uninitialized_move_n_result<span class='anglebracket'>&lt;</span>I, O<span class='anglebracket'>&gt;</span>
          uninitialized_move_n<span class='parenthesis'>(</span>I ifirst, iter_difference_t<span class='anglebracket'>&lt;</span>I<span class='anglebracket'>&gt;</span> n, O ofirst, S olast<span class='parenthesis'>)</span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  <span class='curlybracket'>}</span>

  template&lt;class ForwardIterator, class T&gt;
    void uninitialized_fill(ForwardIterator first, ForwardIterator last, const T&amp; x); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class ExecutionPolicy, class ForwardIterator, class T&gt;
    void uninitialized_fill(ExecutionPolicy&amp;&amp; exec, <span class='comment'>// see [algorithms.parallel.overloads]
</span>                            ForwardIterator first, ForwardIterator last, const T&amp; x);
  template&lt;class ForwardIterator, class Size, class T&gt;
    ForwardIterator uninitialized_fill_n(ForwardIterator first, Size n, const T&amp; x); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class ExecutionPolicy, class ForwardIterator, class Size, class T&gt;
    ForwardIterator uninitialized_fill_n(ExecutionPolicy&amp;&amp; exec, <span class='comment'>// see [algorithms.parallel.overloads]
</span>                                         ForwardIterator first, Size n, const T&amp; x);

  <span class='keyword'>namespace</span> ranges <span class='curlybracket'>{</span>
    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='textit'>no-throw-forward-iterator</span> I, <span class='textit'>no-throw-sentinel</span><span class='anglebracket'>&lt;</span>I<span class='anglebracket'>&gt;</span> S, <span class='keyword'>class</span> T<span class='anglebracket'>&gt;</span>
      <span class='keyword'>requires</span> Constructible<span class='anglebracket'>&lt;</span>iter_value_t<span class='anglebracket'>&lt;</span>I<span class='anglebracket'>&gt;</span>, <span class='keyword'>const</span> T<span class='operator'>&amp;</span><span class='anglebracket'>&gt;</span>
        I uninitialized_fill<span class='parenthesis'>(</span>I first, S last, <span class='keyword'>const</span> T<span class='operator'>&amp;</span> x<span class='parenthesis'>)</span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='textit'>no-throw-forward-range</span> R, <span class='keyword'>class</span> T<span class='anglebracket'>&gt;</span>
      <span class='keyword'>requires</span> Constructible<span class='anglebracket'>&lt;</span>iter_value_t<span class='anglebracket'>&lt;</span>iterator_t<span class='anglebracket'>&lt;</span>R<span class='anglebracket'>&gt;</span><span class='anglebracket'>&gt;</span>, <span class='keyword'>const</span> T<span class='operator'>&amp;</span><span class='anglebracket'>&gt;</span>
        safe_iterator_t<span class='anglebracket'>&lt;</span>R<span class='anglebracket'>&gt;</span> uninitialized_fill<span class='parenthesis'>(</span>R<span class='operator'>&amp;</span><span class='operator'>&amp;</span> r, <span class='keyword'>const</span> T<span class='operator'>&amp;</span> x<span class='parenthesis'>)</span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='textit'>no-throw-forward-iterator</span> I, <span class='keyword'>class</span> T<span class='anglebracket'>&gt;</span>
      <span class='keyword'>requires</span> Constructible<span class='anglebracket'>&lt;</span>iter_value_t<span class='anglebracket'>&lt;</span>I<span class='anglebracket'>&gt;</span>, <span class='keyword'>const</span> T<span class='operator'>&amp;</span><span class='anglebracket'>&gt;</span>
        I uninitialized_fill_n<span class='parenthesis'>(</span>I first, iter_difference_t<span class='anglebracket'>&lt;</span>I<span class='anglebracket'>&gt;</span> n, <span class='keyword'>const</span> T<span class='operator'>&amp;</span> x<span class='parenthesis'>)</span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  <span class='curlybracket'>}</span>

  template&lt;class T&gt;
    void destroy_at(T* location); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class ForwardIterator&gt;
    void destroy(ForwardIterator first, ForwardIterator last); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class ExecutionPolicy, class ForwardIterator&gt;
    void destroy(ExecutionPolicy&amp;&amp; exec, <span class='comment'>// see [algorithms.parallel.overloads]
</span>                 ForwardIterator first, ForwardIterator last);
  template&lt;class ForwardIterator, class Size&gt;
    ForwardIterator destroy_n(ForwardIterator first, Size n); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class ExecutionPolicy, class ForwardIterator, class Size&gt;
    ForwardIterator destroy_n(ExecutionPolicy&amp;&amp; exec, <span class='comment'>// see [algorithms.parallel.overloads]
</span>                              ForwardIterator first, Size n);

  <span class='keyword'>namespace</span> ranges <span class='curlybracket'>{</span>
    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span>Destructible T<span class='anglebracket'>&gt;</span>
      <span class='keyword'>void</span> destroy_at<span class='parenthesis'>(</span>T<span class='operator'>*</span> location<span class='parenthesis'>)</span> <span class='keyword'>noexcept</span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='textit'>no-throw-input-iterator</span> I, <span class='textit'>no-throw-sentinel</span><span class='anglebracket'>&lt;</span>I<span class='anglebracket'>&gt;</span> S<span class='anglebracket'>&gt;</span>
      <span class='keyword'>requires</span> Destructible<span class='anglebracket'>&lt;</span>iter_value_t<span class='anglebracket'>&lt;</span>I<span class='anglebracket'>&gt;</span><span class='anglebracket'>&gt;</span>
        I destroy<span class='parenthesis'>(</span>I first, S last<span class='parenthesis'>)</span> <span class='keyword'>noexcept</span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='textit'>no-throw-input-range</span> R<span class='anglebracket'>&gt;</span>
      <span class='keyword'>requires</span> Destructible<span class='anglebracket'>&lt;</span>iter_value_t<span class='anglebracket'>&lt;</span>iterator_t<span class='anglebracket'>&lt;</span>R<span class='anglebracket'>&gt;</span><span class='anglebracket'>&gt;</span>
        safe_iterator_t<span class='anglebracket'>&lt;</span>R<span class='anglebracket'>&gt;</span> destroy<span class='parenthesis'>(</span>R<span class='operator'>&amp;</span><span class='operator'>&amp;</span> r<span class='parenthesis'>)</span> <span class='keyword'>noexcept</span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='textit'>no-throw-input-iterator</span> I<span class='anglebracket'>&gt;</span>
      <span class='keyword'>requires</span> Destructible<span class='anglebracket'>&lt;</span>iter_value_t<span class='anglebracket'>&lt;</span>I<span class='anglebracket'>&gt;</span><span class='anglebracket'>&gt;</span>
        I destroy_n<span class='parenthesis'>(</span>I first, iter_difference_t<span class='anglebracket'>&lt;</span>I<span class='anglebracket'>&gt;</span> n<span class='parenthesis'>)</span> <span class='keyword'>noexcept</span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  <span class='curlybracket'>}</span>

  <span class='comment'>// [unique.ptr], class template <span class='tcode_in_codeblock'>unique_&shy;ptr</span>
</span>  template&lt;class T&gt; struct default_delete; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T&gt; struct default_delete&lt;T[]&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T, class D = default_delete&lt;T&gt;&gt; class unique_ptr; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T, class D&gt; class unique_ptr&lt;T[], D&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> T, <span class='keyword'>class</span><span class='operator'>.</span><span class='operator'>.</span><span class='operator'>.</span> Args<span class='anglebracket'>&gt;</span>
    unique_ptr<span class='anglebracket'>&lt;</span>T<span class='anglebracket'>&gt;</span> make_unique<span class='parenthesis'>(</span>Args<span class='operator'>&amp;</span><span class='operator'>&amp;</span><span class='operator'>.</span><span class='operator'>.</span><span class='operator'>.</span> args<span class='parenthesis'>)</span>;                                  <span class='comment' style='font-style:italic;font-family:serif;'>// <span class='tcode_in_codeblock'>T</span> is not array</span>
  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> T<span class='anglebracket'>&gt;</span>
    unique_ptr<span class='anglebracket'>&lt;</span>T<span class='anglebracket'>&gt;</span> make_unique<span class='parenthesis'>(</span>size_t n<span class='parenthesis'>)</span>;                                        <span class='comment' style='font-style:italic;font-family:serif;'>// <span class='tcode_in_codeblock'>T</span> is <span class='tcode_in_codeblock'>U[]</span></span>
  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> T, <span class='keyword'>class</span><span class='operator'>.</span><span class='operator'>.</span><span class='operator'>.</span> Args<span class='anglebracket'>&gt;</span>
    <span class='textit'><span class='texttt'>unspecified</span></span> make_unique<span class='parenthesis'>(</span>Args<span class='operator'>&amp;</span><span class='operator'>&amp;</span><span class='operator'>.</span><span class='operator'>.</span><span class='operator'>.</span><span class='parenthesis'>)</span> <span class='operator'>=</span> <span class='keyword'>delete</span>;                                <span class='comment' style='font-style:italic;font-family:serif;'>// <span class='tcode_in_codeblock'>T</span> is <span class='tcode_in_codeblock'>U[N]</span></span>

  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> T<span class='anglebracket'>&gt;</span>
    unique_ptr<span class='anglebracket'>&lt;</span>T<span class='anglebracket'>&gt;</span> make_unique_default_init<span class='parenthesis'>(</span><span class='parenthesis'>)</span>;                                   <span class='comment' style='font-style:italic;font-family:serif;'>// <span class='tcode_in_codeblock'>T</span> is not array</span>
  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> T<span class='anglebracket'>&gt;</span>
    unique_ptr<span class='anglebracket'>&lt;</span>T<span class='anglebracket'>&gt;</span> make_unique_default_init<span class='parenthesis'>(</span>size_t n<span class='parenthesis'>)</span>;                           <span class='comment' style='font-style:italic;font-family:serif;'>// <span class='tcode_in_codeblock'>T</span> is <span class='tcode_in_codeblock'>U[]</span></span>
  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> T, <span class='keyword'>class</span><span class='operator'>.</span><span class='operator'>.</span><span class='operator'>.</span> Args<span class='anglebracket'>&gt;</span>
    <span class='textit'><span class='texttt'>unspecified</span></span> make_unique_default_init<span class='parenthesis'>(</span>Args<span class='operator'>&amp;</span><span class='operator'>&amp;</span><span class='operator'>.</span><span class='operator'>.</span><span class='operator'>.</span><span class='parenthesis'>)</span> <span class='operator'>=</span> <span class='keyword'>delete</span>;                   <span class='comment' style='font-style:italic;font-family:serif;'>// <span class='tcode_in_codeblock'>T</span> is <span class='tcode_in_codeblock'>U[N]</span></span>

  template&lt;class T, class D&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    void swap(unique_ptr&lt;T, D&gt;&amp; x, unique_ptr&lt;T, D&gt;&amp; y) noexcept;

  template&lt;class T1, class D1, class T2, class D2&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    bool operator==(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
  template&lt;class T1, class D1, class T2, class D2&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    bool operator!=(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
  template&lt;class T1, class D1, class T2, class D2&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    bool operator&lt;(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
  template&lt;class T1, class D1, class T2, class D2&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    bool operator&gt;(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
  template&lt;class T1, class D1, class T2, class D2&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    bool operator&lt;=(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
  template&lt;class T1, class D1, class T2, class D2&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    bool operator&gt;=(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);

  template&lt;class T, class D&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    bool operator==(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t) noexcept;
  template&lt;class T, class D&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    bool operator==(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; y) noexcept;
  template&lt;class T, class D&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    bool operator!=(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t) noexcept;
  template&lt;class T, class D&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    bool operator!=(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; y) noexcept;
  template&lt;class T, class D&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    bool operator&lt;(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t);
  template&lt;class T, class D&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    bool operator&lt;(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; y);
  template&lt;class T, class D&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    bool operator&gt;(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t);
  template&lt;class T, class D&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    bool operator&gt;(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; y);
  template&lt;class T, class D&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    bool operator&lt;=(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t);
  template&lt;class T, class D&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    bool operator&lt;=(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; y);
  template&lt;class T, class D&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    bool operator&gt;=(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t);
  template&lt;class T, class D&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    bool operator&gt;=(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; y);

  template&lt;class E, class T, class Y, class D&gt;
    basic_ostream&lt;E, T&gt;&amp; operator&lt;&lt;(basic_ostream&lt;E, T&gt;&amp; os, const unique_ptr&lt;Y, D&gt;&amp; p);

  <span class='comment'>// [util.smartptr.weak.bad], class <span class='tcode_in_codeblock'>bad_&shy;weak_&shy;ptr</span>
</span>  class bad_weak_ptr;

  <span class='comment'>// [util.smartptr.shared], class template <span class='tcode_in_codeblock'>shared_&shy;ptr</span>
</span>  template&lt;class T&gt; class shared_ptr;

  <span class='comment'>// [util.smartptr.shared.create], <span class='tcode_in_codeblock'>shared_&shy;ptr</span> creation</span>
  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> T, <span class='keyword'>class</span><span class='operator'>.</span><span class='operator'>.</span><span class='operator'>.</span> Args<span class='anglebracket'>&gt;</span>
    shared_ptr<span class='anglebracket'>&lt;</span>T<span class='anglebracket'>&gt;</span> make_shared<span class='parenthesis'>(</span>Args<span class='operator'>&amp;</span><span class='operator'>&amp;</span><span class='operator'>.</span><span class='operator'>.</span><span class='operator'>.</span> args<span class='parenthesis'>)</span>;                                  <span class='comment' style='font-style:italic;font-family:serif;'>// <span class='tcode_in_codeblock'>T</span> is not array</span>
  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> T, <span class='keyword'>class</span> A, <span class='keyword'>class</span><span class='operator'>.</span><span class='operator'>.</span><span class='operator'>.</span> Args<span class='anglebracket'>&gt;</span>
    shared_ptr<span class='anglebracket'>&lt;</span>T<span class='anglebracket'>&gt;</span> allocate_shared<span class='parenthesis'>(</span><span class='keyword'>const</span> A<span class='operator'>&amp;</span> a, Args<span class='operator'>&amp;</span><span class='operator'>&amp;</span><span class='operator'>.</span><span class='operator'>.</span><span class='operator'>.</span> args<span class='parenthesis'>)</span>;                  <span class='comment' style='font-style:italic;font-family:serif;'>// <span class='tcode_in_codeblock'>T</span> is not array</span>

  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> T<span class='anglebracket'>&gt;</span>
    shared_ptr<span class='anglebracket'>&lt;</span>T<span class='anglebracket'>&gt;</span> make_shared<span class='parenthesis'>(</span>size_t N<span class='parenthesis'>)</span>;                                        <span class='comment' style='font-style:italic;font-family:serif;'>// <span class='tcode_in_codeblock'>T</span> is <span class='tcode_in_codeblock'>U[]</span></span>
  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> T, <span class='keyword'>class</span> A<span class='anglebracket'>&gt;</span>
    shared_ptr<span class='anglebracket'>&lt;</span>T<span class='anglebracket'>&gt;</span> allocate_shared<span class='parenthesis'>(</span><span class='keyword'>const</span> A<span class='operator'>&amp;</span> a, size_t N<span class='parenthesis'>)</span>;                        <span class='comment' style='font-style:italic;font-family:serif;'>// <span class='tcode_in_codeblock'>T</span> is <span class='tcode_in_codeblock'>U[]</span></span>

  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> T<span class='anglebracket'>&gt;</span>
    shared_ptr<span class='anglebracket'>&lt;</span>T<span class='anglebracket'>&gt;</span> make_shared<span class='parenthesis'>(</span><span class='parenthesis'>)</span>;                                                <span class='comment' style='font-style:italic;font-family:serif;'>// <span class='tcode_in_codeblock'>T</span> is <span class='tcode_in_codeblock'>U[N]</span></span>
  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> T, <span class='keyword'>class</span> A<span class='anglebracket'>&gt;</span>
    shared_ptr<span class='anglebracket'>&lt;</span>T<span class='anglebracket'>&gt;</span> allocate_shared<span class='parenthesis'>(</span><span class='keyword'>const</span> A<span class='operator'>&amp;</span> a<span class='parenthesis'>)</span>;                                  <span class='comment' style='font-style:italic;font-family:serif;'>// <span class='tcode_in_codeblock'>T</span> is <span class='tcode_in_codeblock'>U[N]</span></span>

  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> T<span class='anglebracket'>&gt;</span>
    shared_ptr<span class='anglebracket'>&lt;</span>T<span class='anglebracket'>&gt;</span> make_shared<span class='parenthesis'>(</span>size_t N, <span class='keyword'>const</span> remove_extent_t<span class='anglebracket'>&lt;</span>T<span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span> u<span class='parenthesis'>)</span>;           <span class='comment' style='font-style:italic;font-family:serif;'>// <span class='tcode_in_codeblock'>T</span> is <span class='tcode_in_codeblock'>U[]</span></span>
  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> T, <span class='keyword'>class</span> A<span class='anglebracket'>&gt;</span>
    shared_ptr<span class='anglebracket'>&lt;</span>T<span class='anglebracket'>&gt;</span> allocate_shared<span class='parenthesis'>(</span><span class='keyword'>const</span> A<span class='operator'>&amp;</span> a, size_t N,
                                  <span class='keyword'>const</span> remove_extent_t<span class='anglebracket'>&lt;</span>T<span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span> u<span class='parenthesis'>)</span>;                 <span class='comment' style='font-style:italic;font-family:serif;'>// <span class='tcode_in_codeblock'>T</span> is <span class='tcode_in_codeblock'>U[]</span></span>

  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> T<span class='anglebracket'>&gt;</span>
    shared_ptr<span class='anglebracket'>&lt;</span>T<span class='anglebracket'>&gt;</span> make_shared<span class='parenthesis'>(</span><span class='keyword'>const</span> remove_extent_t<span class='anglebracket'>&lt;</span>T<span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span> u<span class='parenthesis'>)</span>;                     <span class='comment' style='font-style:italic;font-family:serif;'>// <span class='tcode_in_codeblock'>T</span> is <span class='tcode_in_codeblock'>U[N]</span></span>
  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> T, <span class='keyword'>class</span> A<span class='anglebracket'>&gt;</span>
    shared_ptr<span class='anglebracket'>&lt;</span>T<span class='anglebracket'>&gt;</span> allocate_shared<span class='parenthesis'>(</span><span class='keyword'>const</span> A<span class='operator'>&amp;</span> a, <span class='keyword'>const</span> remove_extent_t<span class='anglebracket'>&lt;</span>T<span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span> u<span class='parenthesis'>)</span>;     <span class='comment' style='font-style:italic;font-family:serif;'>// <span class='tcode_in_codeblock'>T</span> is <span class='tcode_in_codeblock'>U[N]</span></span>

  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> T<span class='anglebracket'>&gt;</span>
    shared_ptr<span class='anglebracket'>&lt;</span>T<span class='anglebracket'>&gt;</span> make_shared_default_init<span class='parenthesis'>(</span><span class='parenthesis'>)</span>;                                   <span class='comment' style='font-style:italic;font-family:serif;'>// <span class='tcode_in_codeblock'>T</span> is not <span class='tcode_in_codeblock'>U[]</span></span>
  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> T, <span class='keyword'>class</span> A<span class='anglebracket'>&gt;</span>
    shared_ptr<span class='anglebracket'>&lt;</span>T<span class='anglebracket'>&gt;</span> allocate_shared_default_init<span class='parenthesis'>(</span><span class='keyword'>const</span> A<span class='operator'>&amp;</span> a<span class='parenthesis'>)</span>;                     <span class='comment' style='font-style:italic;font-family:serif;'>// <span class='tcode_in_codeblock'>T</span> is not <span class='tcode_in_codeblock'>U[]</span></span>

  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> T<span class='anglebracket'>&gt;</span>
    shared_ptr<span class='anglebracket'>&lt;</span>T<span class='anglebracket'>&gt;</span> make_shared_default_init<span class='parenthesis'>(</span>size_t N<span class='parenthesis'>)</span>;                           <span class='comment' style='font-style:italic;font-family:serif;'>// <span class='tcode_in_codeblock'>T</span> is <span class='tcode_in_codeblock'>U[]</span></span>
  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> T, <span class='keyword'>class</span> A<span class='anglebracket'>&gt;</span>
    shared_ptr<span class='anglebracket'>&lt;</span>T<span class='anglebracket'>&gt;</span> allocate_shared_default_init<span class='parenthesis'>(</span><span class='keyword'>const</span> A<span class='operator'>&amp;</span> a, size_t N<span class='parenthesis'>)</span>;           <span class='comment' style='font-style:italic;font-family:serif;'>// <span class='tcode_in_codeblock'>T</span> is <span class='tcode_in_codeblock'>U[]</span></span>

  <span class='comment'>// [util.smartptr.shared.cmp], <span class='tcode_in_codeblock'>shared_&shy;ptr</span> comparisons
</span>  template&lt;class T, class U&gt;
    bool operator==(const shared_ptr&lt;T&gt;&amp; a, const shared_ptr&lt;U&gt;&amp; b) noexcept;
  template&lt;class T, class U&gt;
    bool operator!=(const shared_ptr&lt;T&gt;&amp; a, const shared_ptr&lt;U&gt;&amp; b) noexcept;
  template&lt;class T, class U&gt;
    bool operator&lt;(const shared_ptr&lt;T&gt;&amp; a, const shared_ptr&lt;U&gt;&amp; b) noexcept;
  template&lt;class T, class U&gt;
    bool operator&gt;(const shared_ptr&lt;T&gt;&amp; a, const shared_ptr&lt;U&gt;&amp; b) noexcept;
  template&lt;class T, class U&gt;
    bool operator&lt;=(const shared_ptr&lt;T&gt;&amp; a, const shared_ptr&lt;U&gt;&amp; b) noexcept;
  template&lt;class T, class U&gt;
    bool operator&gt;=(const shared_ptr&lt;T&gt;&amp; a, const shared_ptr&lt;U&gt;&amp; b) noexcept;

  template&lt;class T&gt;
    bool operator==(const shared_ptr&lt;T&gt;&amp; x, nullptr_t) noexcept;
  template&lt;class T&gt;
    bool operator==(nullptr_t, const shared_ptr&lt;T&gt;&amp; y) noexcept;
  template&lt;class T&gt;
    bool operator!=(const shared_ptr&lt;T&gt;&amp; x, nullptr_t) noexcept;
  template&lt;class T&gt;
    bool operator!=(nullptr_t, const shared_ptr&lt;T&gt;&amp; y) noexcept;
  template&lt;class T&gt;
    bool operator&lt;(const shared_ptr&lt;T&gt;&amp; x, nullptr_t) noexcept;
  template&lt;class T&gt;
    bool operator&lt;(nullptr_t, const shared_ptr&lt;T&gt;&amp; y) noexcept;
  template&lt;class T&gt;
    bool operator&lt;=(const shared_ptr&lt;T&gt;&amp; x, nullptr_t) noexcept;
  template&lt;class T&gt;
    bool operator&lt;=(nullptr_t, const shared_ptr&lt;T&gt;&amp; y) noexcept;
  template&lt;class T&gt;
    bool operator&gt;(const shared_ptr&lt;T&gt;&amp; x, nullptr_t) noexcept;
  template&lt;class T&gt;
    bool operator&gt;(nullptr_t, const shared_ptr&lt;T&gt;&amp; y) noexcept;
  template&lt;class T&gt;
    bool operator&gt;=(const shared_ptr&lt;T&gt;&amp; x, nullptr_t) noexcept;
  template&lt;class T&gt;
    bool operator&gt;=(nullptr_t, const shared_ptr&lt;T&gt;&amp; y) noexcept;

  <span class='comment'>// [util.smartptr.shared.spec], <span class='tcode_in_codeblock'>shared_&shy;ptr</span> specialized algorithms
</span>  template&lt;class T&gt;
    void swap(shared_ptr&lt;T&gt;&amp; a, shared_ptr&lt;T&gt;&amp; b) noexcept;

  <span class='comment'>// [util.smartptr.shared.cast], <span class='tcode_in_codeblock'>shared_&shy;ptr</span> casts</span>
  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> T, <span class='keyword'>class</span> U<span class='anglebracket'>&gt;</span>
    shared_ptr<span class='anglebracket'>&lt;</span>T<span class='anglebracket'>&gt;</span> static_pointer_cast<span class='parenthesis'>(</span><span class='keyword'>const</span> shared_ptr<span class='anglebracket'>&lt;</span>U<span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span> r<span class='parenthesis'>)</span> <span class='keyword'>noexcept</span>;
  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> T, <span class='keyword'>class</span> U<span class='anglebracket'>&gt;</span>
    shared_ptr<span class='anglebracket'>&lt;</span>T<span class='anglebracket'>&gt;</span> static_pointer_cast<span class='parenthesis'>(</span>shared_ptr<span class='anglebracket'>&lt;</span>U<span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span><span class='operator'>&amp;</span> r<span class='parenthesis'>)</span> <span class='keyword'>noexcept</span>;
  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> T, <span class='keyword'>class</span> U<span class='anglebracket'>&gt;</span>
    shared_ptr<span class='anglebracket'>&lt;</span>T<span class='anglebracket'>&gt;</span> dynamic_pointer_cast<span class='parenthesis'>(</span><span class='keyword'>const</span> shared_ptr<span class='anglebracket'>&lt;</span>U<span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span> r<span class='parenthesis'>)</span> <span class='keyword'>noexcept</span>;
  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> T, <span class='keyword'>class</span> U<span class='anglebracket'>&gt;</span>
    shared_ptr<span class='anglebracket'>&lt;</span>T<span class='anglebracket'>&gt;</span> dynamic_pointer_cast<span class='parenthesis'>(</span>shared_ptr<span class='anglebracket'>&lt;</span>U<span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span><span class='operator'>&amp;</span> r<span class='parenthesis'>)</span> <span class='keyword'>noexcept</span>;
  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> T, <span class='keyword'>class</span> U<span class='anglebracket'>&gt;</span>
    shared_ptr<span class='anglebracket'>&lt;</span>T<span class='anglebracket'>&gt;</span> const_pointer_cast<span class='parenthesis'>(</span><span class='keyword'>const</span> shared_ptr<span class='anglebracket'>&lt;</span>U<span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span> r<span class='parenthesis'>)</span> <span class='keyword'>noexcept</span>;
  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> T, <span class='keyword'>class</span> U<span class='anglebracket'>&gt;</span>
    shared_ptr<span class='anglebracket'>&lt;</span>T<span class='anglebracket'>&gt;</span> const_pointer_cast<span class='parenthesis'>(</span>shared_ptr<span class='anglebracket'>&lt;</span>U<span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span><span class='operator'>&amp;</span> r<span class='parenthesis'>)</span> <span class='keyword'>noexcept</span>;
  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> T, <span class='keyword'>class</span> U<span class='anglebracket'>&gt;</span>
    shared_ptr<span class='anglebracket'>&lt;</span>T<span class='anglebracket'>&gt;</span> reinterpret_pointer_cast<span class='parenthesis'>(</span><span class='keyword'>const</span> shared_ptr<span class='anglebracket'>&lt;</span>U<span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span> r<span class='parenthesis'>)</span> <span class='keyword'>noexcept</span>;
  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> T, <span class='keyword'>class</span> U<span class='anglebracket'>&gt;</span>
    shared_ptr<span class='anglebracket'>&lt;</span>T<span class='anglebracket'>&gt;</span> reinterpret_pointer_cast<span class='parenthesis'>(</span>shared_ptr<span class='anglebracket'>&lt;</span>U<span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span><span class='operator'>&amp;</span> r<span class='parenthesis'>)</span> <span class='keyword'>noexcept</span>;

  <span class='comment'>// [util.smartptr.getdeleter], <span class='tcode_in_codeblock'>shared_&shy;ptr</span> <span class='tcode_in_codeblock'>get_&shy;deleter</span>
</span>  template&lt;class D, class T&gt;
    D* get_deleter(const shared_ptr&lt;T&gt;&amp; p) noexcept;

  <span class='comment'>// [util.smartptr.shared.io], <span class='tcode_in_codeblock'>shared_&shy;ptr</span> I/O
</span>  template&lt;class E, class T, class Y&gt;
    basic_ostream&lt;E, T&gt;&amp; operator&lt;&lt;(basic_ostream&lt;E, T&gt;&amp; os, const shared_ptr&lt;Y&gt;&amp; p);

  <span class='comment'>// [util.smartptr.weak], class template <span class='tcode_in_codeblock'>weak_&shy;ptr</span>
</span>  template&lt;class T&gt; class weak_ptr;

  <span class='comment'>// [util.smartptr.weak.spec], <span class='tcode_in_codeblock'>weak_&shy;ptr</span> specialized algorithms
</span>  template&lt;class T&gt; void swap(weak_ptr&lt;T&gt;&amp; a, weak_ptr&lt;T&gt;&amp; b) noexcept;

  <span class='comment'>// [util.smartptr.ownerless], class template <span class='tcode_in_codeblock'>owner_&shy;less</span>
</span>  template&lt;class T = void&gt; struct owner_less;

  <span class='comment'>// [util.smartptr.enab], class template <span class='tcode_in_codeblock'>enable_&shy;shared_&shy;from_&shy;this</span>
</span>  template&lt;class T&gt; class enable_shared_from_this;

  <span class='comment'>// [util.smartptr.hash], hash support
</span>  template&lt;class T&gt; struct hash; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T, class D&gt; struct hash&lt;unique_ptr&lt;T, D&gt;&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T&gt; struct hash&lt;shared_ptr&lt;T&gt;&gt;;

  <span class='comment'>// [util.smartptr.atomic], atomic smart pointers
</span>  template&lt;class T&gt; struct atomic&lt;shared_ptr&lt;T&gt;&gt;;
  template&lt;class T&gt; struct atomic&lt;weak_ptr&lt;T&gt;&gt;;
}</pre></div>
</blockquote>

Change in [functional.syn]:
<blockquote class="std">
<h3 ><a class='secnum' style='min-width:103pt'>?.?.?</a> Header <span class='texttt'>&lt;functional&gt;</span> synopsis <a class='abbr_ref'>[functional.syn]</a></h3>
<pre class='codeblock'>
namespace std {
  <span class='comment'>// [func.invoke], invoke
</span>  template&lt;class F, class... Args&gt;
    invoke_result_t&lt;F, Args...&gt; invoke(F&amp;&amp; f, Args&amp;&amp;... args)
      noexcept(is_nothrow_invocable_v&lt;F, Args...&gt;); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  <span class='comment'>// [refwrap], <span class='tcode_in_codeblock'>reference_&shy;wrapper</span>
</span>  template&lt;class T&gt; class reference_wrapper; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  template&lt;class T&gt; reference_wrapper&lt;T&gt; ref(T&amp;) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T&gt; reference_wrapper&lt;const T&gt; cref(const T&amp;) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T&gt; void ref(const T&amp;&amp;) = delete; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T&gt; void cref(const T&amp;&amp;) = delete; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  template&lt;class T&gt; reference_wrapper&lt;T&gt; ref(reference_wrapper&lt;T&gt;) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T&gt; reference_wrapper&lt;const T&gt; cref(reference_wrapper&lt;T&gt;) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> T<span class='anglebracket'>&gt;</span> <span class='keyword'>struct</span> unwrap_reference; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> T<span class='anglebracket'>&gt;</span> <span class='keyword'>struct</span> unwrap_ref_decay <span class='operator'>:</span> unwrap_reference<span class='anglebracket'>&lt;</span>decay_t<span class='anglebracket'>&lt;</span>T<span class='anglebracket'>&gt;</span><span class='anglebracket'>&gt;</span> <span class='curlybracket'>{</span><span class='curlybracket'>}</span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> T<span class='anglebracket'>&gt;</span> <span class='keyword'>using</span> unwrap_ref_decay_t <span class='operator'>=</span> <span class='keyword'>typename</span> unwrap_ref_decay<span class='anglebracket'>&lt;</span>T<span class='anglebracket'>&gt;</span><span class='operator'>:</span><span class='operator'>:</span>type; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  <span class='comment'>// [arithmetic.operations], arithmetic operations
</span>  template&lt;class T = void&gt; struct plus; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T = void&gt; struct minus; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T = void&gt; struct multiplies; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T = void&gt; struct divides; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T = void&gt; struct modulus; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T = void&gt; struct negate; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;&gt; struct plus&lt;void&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;&gt; struct minus&lt;void&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;&gt; struct multiplies&lt;void&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;&gt; struct divides&lt;void&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;&gt; struct modulus&lt;void&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;&gt; struct negate&lt;void&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  <span class='comment'>// [comparisons], comparisons
</span>  template&lt;class T = void&gt; struct equal_to; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T = void&gt; struct not_equal_to; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T = void&gt; struct greater; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T = void&gt; struct less; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T = void&gt; struct greater_equal; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T = void&gt; struct less_equal; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;&gt; struct equal_to&lt;void&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;&gt; struct not_equal_to&lt;void&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;&gt; struct greater&lt;void&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;&gt; struct less&lt;void&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;&gt; struct greater_equal&lt;void&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;&gt; struct less_equal&lt;void&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  <span class='comment'>// [logical.operations], logical operations
</span>  template&lt;class T = void&gt; struct logical_and; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T = void&gt; struct logical_or; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T = void&gt; struct logical_not; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;&gt; struct logical_and&lt;void&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;&gt; struct logical_or&lt;void&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;&gt; struct logical_not&lt;void&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  <span class='comment'>// [bitwise.operations], bitwise operations
</span>  template&lt;class T = void&gt; struct bit_and; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T = void&gt; struct bit_or; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T = void&gt; struct bit_xor; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T = void&gt; struct bit_not; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;&gt; struct bit_and&lt;void&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;&gt; struct bit_or&lt;void&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;&gt; struct bit_xor&lt;void&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;&gt; struct bit_not&lt;void&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  <span class='comment'>// [func.identity], identity
</span>  struct identity; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  <span class='comment'>// [func.not_fn], function template <span class='tcode_in_codeblock'>not_&shy;fn</span>
</span>  template&lt;class F&gt; <span class='textit'><span class='texttt'>unspecified</span></span> not_fn(F&amp;&amp; f); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  <span class='comment' style='font-style:italic;font-family:serif;'>// [func.bind_front], function template <span class='tcode_in_codeblock'>bind_&shy;front</span></span>
  <span class='keyword'>template</span> <span class='anglebracket'>&lt;</span><span class='keyword'>class</span> F, <span class='keyword'>class</span><span class='operator'>.</span><span class='operator'>.</span><span class='operator'>.</span> Args<span class='anglebracket'>&gt;</span> <span class='textit'><span class='texttt'>unspecified</span></span> bind_front<span class='parenthesis'>(</span>F<span class='operator'>&amp;</span><span class='operator'>&amp;</span>, Args<span class='operator'>&amp;</span><span class='operator'>&amp;</span><span class='operator'>.</span><span class='operator'>.</span><span class='operator'>.</span><span class='parenthesis'>)</span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  <span class='comment'>// [func.bind], bind
</span>  template&lt;class T&gt; struct is_bind_expression; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T&gt; struct is_placeholder; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  template&lt;class F, class... BoundArgs&gt;
    <span class='textit'><span class='texttt'>unspecified</span></span> bind(F&amp;&amp;, BoundArgs&amp;&amp;...); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class R, class F, class... BoundArgs&gt;
    <span class='textit'><span class='texttt'>unspecified</span></span> bind(F&amp;&amp;, BoundArgs&amp;&amp;...); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  namespace placeholders {
    <span class='comment'>// <span class='tcode_in_codeblock'><span class='textit'>M</span></span> is the <span class='indexparent'><a class='index'></a></span>implementation-defined number of placeholders
</span>    <span class='textit'><span class='texttt'>see below</span></span> _1; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    <span class='textit'><span class='texttt'>see below</span></span> _2; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
               .
               .
               .
    <span class='textit'><span class='texttt'>see below</span></span> _<span class='textit'>M</span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  }

  <span class='comment'>// [func.memfn], member function adaptors
</span>  template&lt;class R, class T&gt;
    <span class='textit'><span class='texttt'>unspecified</span></span> mem_fn(R T::*) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  <span class='comment'>// [func.wrap], polymorphic function wrappers
</span>  class bad_function_call;

  template&lt;class&gt; class function; <span class='comment'>// not defined
</span>  template&lt;class R, class... ArgTypes&gt; class function&lt;R(ArgTypes...)&gt;;

  template&lt;class R, class... ArgTypes&gt;
    void swap(function&lt;R(ArgTypes...)&gt;&amp;, function&lt;R(ArgTypes...)&gt;&amp;) noexcept;

  template&lt;class R, class... ArgTypes&gt;
    bool operator==(const function&lt;R(ArgTypes...)&gt;&amp;, nullptr_t) noexcept;
  template&lt;class R, class... ArgTypes&gt;
    bool operator==(nullptr_t, const function&lt;R(ArgTypes...)&gt;&amp;) noexcept;
  template&lt;class R, class... ArgTypes&gt;
    bool operator!=(const function&lt;R(ArgTypes...)&gt;&amp;, nullptr_t) noexcept;
  template&lt;class R, class... ArgTypes&gt;
    bool operator!=(nullptr_t, const function&lt;R(ArgTypes...)&gt;&amp;) noexcept;

  <span class='comment'>// [func.search], searchers
</span>  template&lt;class ForwardIterator, class BinaryPredicate = equal_to&lt;&gt;&gt;
    class default_searcher; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  template&lt;class RandomAccessIterator,
           class Hash = hash&lt;typename iterator_traits&lt;RandomAccessIterator&gt;::value_type&gt;,
           class BinaryPredicate = equal_to&lt;&gt;&gt;
    class boyer_moore_searcher;

  template&lt;class RandomAccessIterator,
           class Hash = hash&lt;typename iterator_traits&lt;RandomAccessIterator&gt;::value_type&gt;,
           class BinaryPredicate = equal_to&lt;&gt;&gt;
    class boyer_moore_horspool_searcher;

  <span class='comment'>// [unord.hash], hash function primary template
</span>  template&lt;class T&gt;
    struct hash; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  <span class='comment'>// [func.bind], function object binders
</span>  template&lt;class T&gt;
    inline constexpr bool is_bind_expression_v = is_bind_expression&lt;T&gt;::value; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T&gt;
    inline constexpr int is_placeholder_v = is_placeholder&lt;T&gt;::value; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  <span class='keyword'>namespace</span> ranges <span class='curlybracket'>{</span>
    <span class='comment' style='font-style:italic;font-family:serif;'>// [range.cmp], range comparisons</span>
    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> T <span class='operator'>=</span> <span class='keyword'>void</span><span class='anglebracket'>&gt;</span>
      <span class='keyword'>requires</span> <span class='textit'><span class='texttt'>see below</span></span>
    <span class='keyword'>struct</span> equal_to; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> T <span class='operator'>=</span> <span class='keyword'>void</span><span class='anglebracket'>&gt;</span>
      <span class='keyword'>requires</span> <span class='textit'><span class='texttt'>see below</span></span>
    <span class='keyword'>struct</span> not_equal_to; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> T <span class='operator'>=</span> <span class='keyword'>void</span><span class='anglebracket'>&gt;</span>
      <span class='keyword'>requires</span> <span class='textit'><span class='texttt'>see below</span></span>
    <span class='keyword'>struct</span> greater; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> T <span class='operator'>=</span> <span class='keyword'>void</span><span class='anglebracket'>&gt;</span>
      <span class='keyword'>requires</span> <span class='textit'><span class='texttt'>see below</span></span>
    <span class='keyword'>struct</span> less; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> T <span class='operator'>=</span> <span class='keyword'>void</span><span class='anglebracket'>&gt;</span>
      <span class='keyword'>requires</span> <span class='textit'><span class='texttt'>see below</span></span>
    <span class='keyword'>struct</span> greater_equal; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> T <span class='operator'>=</span> <span class='keyword'>void</span><span class='anglebracket'>&gt;</span>
      <span class='keyword'>requires</span> <span class='textit'><span class='texttt'>see below</span></span>
    <span class='keyword'>struct</span> less_equal; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='anglebracket'>&gt;</span> <span class='keyword'>struct</span> equal_to<span class='anglebracket'>&lt;</span><span class='keyword'>void</span><span class='anglebracket'>&gt;</span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='anglebracket'>&gt;</span> <span class='keyword'>struct</span> not_equal_to<span class='anglebracket'>&lt;</span><span class='keyword'>void</span><span class='anglebracket'>&gt;</span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='anglebracket'>&gt;</span> <span class='keyword'>struct</span> greater<span class='anglebracket'>&lt;</span><span class='keyword'>void</span><span class='anglebracket'>&gt;</span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='anglebracket'>&gt;</span> <span class='keyword'>struct</span> less<span class='anglebracket'>&lt;</span><span class='keyword'>void</span><span class='anglebracket'>&gt;</span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='anglebracket'>&gt;</span> <span class='keyword'>struct</span> greater_equal<span class='anglebracket'>&lt;</span><span class='keyword'>void</span><span class='anglebracket'>&gt;</span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='anglebracket'>&gt;</span> <span class='keyword'>struct</span> less_equal<span class='anglebracket'>&lt;</span><span class='keyword'>void</span><span class='anglebracket'>&gt;</span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  <span class='curlybracket'>}</span>
}</pre>
</blockquote>

Change in [charconv.syn]:
<blockquote class="std">
<h3 ><a class='secnum' style='min-width:103pt'>?.?.?</a> Header <span class='texttt'>&lt;charconv&gt;</span> synopsis <a class='abbr_ref'>[charconv.syn]</a></h3>
<pre class='codeblock'>
namespace std {
  <span class='comment'>// floating-point format for primitive numerical conversion
</span>  enum class <span><span class='tcode_in_codeblock'>chars_&shy;format</span></span> {
    <span><span><span class='tcode_in_codeblock'>scientific</span></span></span> = <span class='textit'><span class='texttt'>unspecified</span></span>,
    <span><span><span class='tcode_in_codeblock'>fixed</span></span></span> = <span class='textit'><span class='texttt'>unspecified</span></span>,
    <span><span><span class='tcode_in_codeblock'>hex</span></span></span> = <span class='textit'><span class='texttt'>unspecified</span></span>,
    <span><span><span class='tcode_in_codeblock'>general</span></span></span> = fixed | scientific
  };

  <span class='comment'>// [charconv.to.chars], primitive numerical output conversion
</span>  struct <span><span class='tcode_in_codeblock'>to_&shy;chars_&shy;result</span></span> {
    char* <span><span><span class='tcode_in_codeblock'>ptr</span></span></span>;
    errc <span><span><span class='tcode_in_codeblock'>ec</span></span></span>;
  }; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  to_chars_result to_chars(char* first, char* last, <span class='textit'><span class='texttt'>see below</span></span> value, int base = 10); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  to_chars_result to_chars(char* first, char* last, float value);
  to_chars_result to_chars(char* first, char* last, double value);
  to_chars_result to_chars(char* first, char* last, long double value);

  to_chars_result to_chars(char* first, char* last, float value, chars_format fmt);
  to_chars_result to_chars(char* first, char* last, double value, chars_format fmt);
  to_chars_result to_chars(char* first, char* last, long double value, chars_format fmt);

  to_chars_result to_chars(char* first, char* last, float value,
                           chars_format fmt, int precision);
  to_chars_result to_chars(char* first, char* last, double value,
                           chars_format fmt, int precision);
  to_chars_result to_chars(char* first, char* last, long double value,
                           chars_format fmt, int precision);

  <span class='comment'>// [charconv.from.chars], primitive numerical input conversion
</span>  struct <span><span class='tcode_in_codeblock'>from_&shy;chars_&shy;result</span></span> {
    const char* <span><span><span class='tcode_in_codeblock'>ptr</span></span></span>;
    errc <span><span><span class='tcode_in_codeblock'>ec</span></span></span>;
  }; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  from_chars_result from_chars(const char* first, const char* last,
                               <span class='textit'><span class='texttt'>see below</span></span>&amp; value, int base = 10); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  from_chars_result from_chars(const char* first, const char* last, float&amp; value,
                               chars_format fmt = chars_format::general);
  from_chars_result from_chars(const char* first, const char* last, double&amp; value,
                               chars_format fmt = chars_format::general);
  from_chars_result from_chars(const char* first, const char* last, long double&amp; value,
                               chars_format fmt = chars_format::general);
}</pre>
</blockquote>

Change in [string.syn]:
<blockquote class="std">
<h3 ><a class='secnum' style='min-width:103pt'>?.?.?</a> Header <span class='texttt'>&lt;string&gt;</span> synopsis <a class='abbr_ref'>[string.syn]</a></h3>
<pre class='codeblock'>
#include &lt;initializer_list&gt;

namespace std {
  <span class='comment'>// [char.traits], character traits
</span>  template&lt;class charT&gt; struct char_traits; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;&gt; struct char_traits&lt;char&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;&gt; struct char_traits&lt;char8_t&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;&gt; struct char_traits&lt;char16_t&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;&gt; struct char_traits&lt;char32_t&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;&gt; struct char_traits&lt;wchar_t&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
</pre>
</blockquote>

Change in [string.view.synop]:
<blockquote class="std">
<h3 ><a class='secnum' style='min-width:103pt'>?.?.?</a> Header <span class='texttt'>&lt;string_&shy;view&gt;</span> synopsis <a class='abbr_ref'>[string.view.synop]</a></h3>
<pre class='codeblock'>
namespace std {
  <span class='comment'>// [string.view.template], class template <span class='tcode_in_codeblock'>basic_&shy;string_&shy;view</span>
</span>  template&lt;class charT, class traits = char_traits&lt;charT&gt;&gt;
  class basic_string_view; <ins><span class='comment'>// <span class='textit'>freestanding, partial</span></span></ins>

  <span class='comment'>// [string.view.comparison], non-member comparison functions
</span>  template&lt;class charT, class traits&gt;
    constexpr bool operator==(basic_string_view&lt;charT, traits&gt; x,
                              basic_string_view&lt;charT, traits&gt; y) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class charT, class traits&gt;
    constexpr bool operator!=(basic_string_view&lt;charT, traits&gt; x,
                              basic_string_view&lt;charT, traits&gt; y) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class charT, class traits&gt;
    constexpr bool operator&lt; (basic_string_view&lt;charT, traits&gt; x,
                              basic_string_view&lt;charT, traits&gt; y) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class charT, class traits&gt;
    constexpr bool operator&gt; (basic_string_view&lt;charT, traits&gt; x,
                              basic_string_view&lt;charT, traits&gt; y) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class charT, class traits&gt;
    constexpr bool operator&lt;=(basic_string_view&lt;charT, traits&gt; x,
                              basic_string_view&lt;charT, traits&gt; y) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class charT, class traits&gt;
    constexpr bool operator&gt;=(basic_string_view&lt;charT, traits&gt; x,
                              basic_string_view&lt;charT, traits&gt; y) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  <span class='comment'>// see [string.view.comparison], sufficient additional overloads of comparison functions<ins>, <span class='textit'>freestanding</span></ins>
</span>
  <span class='comment'>// [string.view.io], inserters and extractors
</span>  template&lt;class charT, class traits&gt;
    basic_ostream&lt;charT, traits&gt;&amp;
      operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp; os,
                 basic_string_view&lt;charT, traits&gt; str);

  <span class='comment'>// <span class='tcode_in_codeblock'>basic_&shy;string_&shy;view</span> typedef names
</span>  using string_view    = basic_string_view&lt;char&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  using u8string_view = basic_string_view&lt;char8_t&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  using u16string_view = basic_string_view&lt;char16_t&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  using u32string_view = basic_string_view&lt;char32_t&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  using wstring_view   = basic_string_view&lt;wchar_t&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  <span class='comment'>// [string.view.hash], hash support
</span>  template&lt;class T&gt; struct hash; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;&gt; struct hash&lt;string_view&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;&gt; struct hash&lt;u8string_view&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;&gt; struct hash&lt;u16string_view&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;&gt; struct hash&lt;u32string_view&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;&gt; struct hash&lt;wstring_view&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  inline namespace literals {
  inline namespace string_view_literals {
    <span class='comment'>// [string.view.literals], suffix for <span class='tcode_in_codeblock'>basic_&shy;string_&shy;view</span> literals
</span>    constexpr string_view    operator""sv(const char* str, size_t len) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    constexpr u8string_view operator""sv(const char8_t* str, size_t len) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    constexpr u16string_view operator""sv(const char16_t* str, size_t len) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    constexpr u32string_view operator""sv(const char32_t* str, size_t len) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    constexpr wstring_view   operator""sv(const wchar_t* str, size_t len) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  }
  }
}
</pre>
</blockquote>

Change in [string.view.template]:
<blockquote class="std">
<pre class='codeblock'>
  <span class='comment'>// [string.view.access], element access
</span>  constexpr const_reference operator[](size_type pos) const;
  constexpr const_reference at(size_type pos) const; <ins><span class='comment'>// <span class='textit'>freestanding, omit</span></span></ins>
  constexpr const_reference front() const;
  constexpr const_reference back() const;
  constexpr const_pointer data() const noexcept;

  <span class='comment'>// [string.view.modifiers], modifiers
</span>  constexpr void remove_prefix(size_type n);
  constexpr void remove_suffix(size_type n);
  constexpr void swap(basic_string_view&amp; s) noexcept;

  <span class='comment'>// [string.view.ops], string operations
</span>  constexpr size_type copy(charT* s, size_type n, size_type pos = 0) const; <ins><span class='comment'>// <span class='textit'>freestanding, omit</span></span></ins>

  constexpr basic_string_view substr(size_type pos = 0, size_type n = npos) const; <ins><span class='comment'>// <span class='textit'>freestanding, omit</span></span></ins>

  constexpr int compare(basic_string_view s) const noexcept;
  constexpr int compare(size_type pos1, size_type n1, basic_string_view s) const; <ins><span class='comment'>// <span class='textit'>freestanding, omit</span></span></ins>
  constexpr int compare(size_type pos1, size_type n1, basic_string_view s,
                        size_type pos2, size_type n2) const; <ins><span class='comment'>// <span class='textit'>freestanding, omit</span></span></ins>
  constexpr int compare(const charT* s) const;
  constexpr int compare(size_type pos1, size_type n1, const charT* s) const; <ins><span class='comment'>// <span class='textit'>freestanding, omit</span></span></ins>
  constexpr int compare(size_type pos1, size_type n1, const charT* s, size_type n2) const; <ins><span class='comment'>// <span class='textit'>freestanding, omit</span></span></ins>
</pre>
</blockquote>

Change in [cstring.syn]:
<blockquote class="std">
<h3 ><a class='secnum' style='min-width:103pt'>?.?.?</a> Header <span class='texttt'>&lt;cstring&gt;</span> synopsis <a class='abbr_ref'>[cstring.syn]</a></h3>
<pre class='codeblock'>
namespace std {
  using size_t = <span class='textit'>see [support.types.layout]</span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  void* memcpy(void* s1, const void* s2, size_t n); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  void* memmove(void* s1, const void* s2, size_t n); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  char* strcpy(char* s1, const char* s2); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  char* strncpy(char* s1, const char* s2, size_t n); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  char* strcat(char* s1, const char* s2); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  char* strncat(char* s1, const char* s2, size_t n); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  int memcmp(const void* s1, const void* s2, size_t n); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  int strcmp(const char* s1, const char* s2); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  int strcoll(const char* s1, const char* s2);
  int strncmp(const char* s1, const char* s2, size_t n); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  size_t strxfrm(char* s1, const char* s2, size_t n);
  const void* memchr(const void* s, int c, size_t n);  <span class='comment'>// see [library.c]<ins><span class='textit'>, freestanding</span></ins>
</span>  void* memchr(void* s, int c, size_t n);  <span class='comment'>// see [library.c]<ins><span class='textit'>, freestanding</span></ins>
</span>  const char* strchr(const char* s, int c);  <span class='comment'>// see [library.c]<ins><span class='textit'>, freestanding</span></ins>
</span>  char* strchr(char* s, int c);  <span class='comment'>// see [library.c]<ins><span class='textit'>, freestanding</span></ins>
</span>  size_t strcspn(const char* s1, const char* s2); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  const char* strpbrk(const char* s1, const char* s2);  <span class='comment'>// see [library.c]<ins><span class='textit'>, freestanding</span></ins>
</span>  char* strpbrk(char* s1, const char* s2);  <span class='comment'>// see [library.c]<ins><span class='textit'>, freestanding</span></ins>
</span>  const char* strrchr(const char* s, int c);  <span class='comment'>// see [library.c]<ins><span class='textit'>, freestanding</span></ins>
</span>  char* strrchr(char* s, int c);  <span class='comment'>// see [library.c]<ins><span class='textit'>, freestanding</span></ins>
</span>  size_t strspn(const char* s1, const char* s2); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  const char* strstr(const char* s1, const char* s2);  <span class='comment'>// see [library.c]<ins><span class='textit'>, freestanding</span></ins>
</span>  char* strstr(char* s1, const char* s2);  <span class='comment'>// see [library.c]<ins><span class='textit'>, freestanding</span></ins>
</span>  char* strtok(char* s1, const char* s2);
  void* memset(void* s, int c, size_t n); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  char* strerror(int errnum);
  size_t strlen(const char* s); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
}

#define NULL <span class='textit'>see [support.types.nullptr]</span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins></pre>
</blockquote>

Change in [cwchar.syn]:
<blockquote class="std">
<h3 ><a class='secnum' style='min-width:103pt'>?.?.?</a> Header <span class='texttt'>&lt;cwchar&gt;</span> synopsis <a class='abbr_ref'>[cwchar.syn]</a></h3>
<pre class='codeblock'>
namespace std {
  using size_t = <span class='textit'>see [support.types.layout]</span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  using mbstate_t = <span class='textit'><span class='texttt'>see below</span></span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  using wint_t = <span class='textit'><span class='texttt'>see below</span></span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  struct tm;

  int fwprintf(FILE* stream, const wchar_t* format, ...);
  int fwscanf(FILE* stream, const wchar_t* format, ...);
  int swprintf(wchar_t* s, size_t n, const wchar_t* format, ...);
  int swscanf(const wchar_t* s, const wchar_t* format, ...);
  int vfwprintf(FILE* stream, const wchar_t* format, va_list arg);
  int vfwscanf(FILE* stream, const wchar_t* format, va_list arg);
  int vswprintf(wchar_t* s, size_t n, const wchar_t* format, va_list arg);
  int vswscanf(const wchar_t* s, const wchar_t* format, va_list arg);
  int vwprintf(const wchar_t* format, va_list arg);
  int vwscanf(const wchar_t* format, va_list arg);
  int wprintf(const wchar_t* format, ...);
  int wscanf(const wchar_t* format, ...);
  wint_t fgetwc(FILE* stream);
  wchar_t* fgetws(wchar_t* s, int n, FILE* stream);
  wint_t fputwc(wchar_t c, FILE* stream);
  int fputws(const wchar_t* s, FILE* stream);
  int fwide(FILE* stream, int mode);
  wint_t getwc(FILE* stream);
  wint_t getwchar();
  wint_t putwc(wchar_t c, FILE* stream);
  wint_t putwchar(wchar_t c);
  wint_t ungetwc(wint_t c, FILE* stream);
  double wcstod(const wchar_t* nptr, wchar_t** endptr);
  float wcstof(const wchar_t* nptr, wchar_t** endptr);
  long double wcstold(const wchar_t* nptr, wchar_t** endptr);
  long int wcstol(const wchar_t* nptr, wchar_t** endptr, int base);
  long long int wcstoll(const wchar_t* nptr, wchar_t** endptr, int base);
  unsigned long int wcstoul(const wchar_t* nptr, wchar_t** endptr, int base);
  unsigned long long int wcstoull(const wchar_t* nptr, wchar_t** endptr, int base);
  wchar_t* wcscpy(wchar_t* s1, const wchar_t* s2); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  wchar_t* wcsncpy(wchar_t* s1, const wchar_t* s2, size_t n); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  wchar_t* wmemcpy(wchar_t* s1, const wchar_t* s2, size_t n); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  wchar_t* wmemmove(wchar_t* s1, const wchar_t* s2, size_t n); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  wchar_t* wcscat(wchar_t* s1, const wchar_t* s2); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  wchar_t* wcsncat(wchar_t* s1, const wchar_t* s2, size_t n); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  int wcscmp(const wchar_t* s1, const wchar_t* s2); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  int wcscoll(const wchar_t* s1, const wchar_t* s2);
  int wcsncmp(const wchar_t* s1, const wchar_t* s2, size_t n); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  size_t wcsxfrm(wchar_t* s1, const wchar_t* s2, size_t n);
  int wmemcmp(const wchar_t* s1, const wchar_t* s2, size_t n); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  const wchar_t* wcschr(const wchar_t* s, wchar_t c);  <span class='comment'>// see [library.c]<ins><span class='textit'>, freestanding</span></ins>
</span>  wchar_t* wcschr(wchar_t* s, wchar_t c);  <span class='comment'>// see [library.c]<ins><span class='textit'>, freestanding</span></ins>
</span>  size_t wcscspn(const wchar_t* s1, const wchar_t* s2); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  const wchar_t* wcspbrk(const wchar_t* s1, const wchar_t* s2);  <span class='comment'>// see [library.c]<ins><span class='textit'>, freestanding</span></ins>
</span>  wchar_t* wcspbrk(wchar_t* s1, const wchar_t* s2);  <span class='comment'>// see [library.c]<ins><span class='textit'>, freestanding</span></ins>
</span>  const wchar_t* wcsrchr(const wchar_t* s, wchar_t c);  <span class='comment'>// see [library.c]<ins><span class='textit'>, freestanding</span></ins>
</span>  wchar_t* wcsrchr(wchar_t* s, wchar_t c);  <span class='comment'>// see [library.c]<ins><span class='textit'>, freestanding</span></ins>
</span>  size_t wcsspn(const wchar_t* s1, const wchar_t* s2); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  const wchar_t* wcsstr(const wchar_t* s1, const wchar_t* s2);  <span class='comment'>// see [library.c]<ins><span class='textit'>, freestanding</span></ins>
</span>  wchar_t* wcsstr(wchar_t* s1, const wchar_t* s2);  <span class='comment'>// see [library.c]<ins><span class='textit'>, freestanding</span></ins>
</span>  wchar_t* wcstok(wchar_t* s1, const wchar_t* s2, wchar_t** ptr); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  const wchar_t* wmemchr(const wchar_t* s, wchar_t c, size_t n);  <span class='comment'>// see [library.c]<ins><span class='textit'>, freestanding</span></ins>
</span>  wchar_t* wmemchr(wchar_t* s, wchar_t c, size_t n);  <span class='comment'>// see [library.c]<ins><span class='textit'>, freestanding</span></ins>
</span>  size_t wcslen(const wchar_t* s); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  wchar_t* wmemset(wchar_t* s, wchar_t c, size_t n); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  size_t wcsftime(wchar_t* s, size_t maxsize, const wchar_t* format, const struct tm* timeptr);
  wint_t btowc(int c);
  int wctob(wint_t c);

  <span class='comment'>// [c.mb.wcs], multibyte / wide string and character conversion functions
</span>  int mbsinit(const mbstate_t* ps);
  size_t mbrlen(const char* s, size_t n, mbstate_t* ps);
  size_t mbrtowc(wchar_t* pwc, const char* s, size_t n, mbstate_t* ps);
  size_t wcrtomb(char* s, wchar_t wc, mbstate_t* ps);
  size_t mbsrtowcs(wchar_t* dst, const char** src, size_t len, mbstate_t* ps);
  size_t wcsrtombs(char* dst, const wchar_t** src, size_t len, mbstate_t* ps);
}

#define NULL <span class='textit'>see [support.types.nullptr]</span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define WCHAR_MAX <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define WCHAR_MIN <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
#define WEOF <span class='textit'><span class='texttt'>see below</span></span> <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins></pre>
</blockquote>

Change in [array.syn]:
<blockquote class="std">
<h3 ><a class='secnum' style='min-width:103pt'>?.?.?</a> Header <span class='texttt'>&lt;array&gt;</span> synopsis <a class='abbr_ref'>[array.syn]</a></h3>
<pre class='codeblock'>
#include &lt;initializer_list&gt;

namespace std {
  <span class='comment'>// [array], class template <span class='tcode_in_codeblock'>array</span>
</span>  template&lt;class T, size_t N&gt; struct array; <ins><span class='comment'>// <span class='textit'>freestanding, partial</span></span></ins>

  template&lt;class T, size_t N&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    constexpr bool operator==(const array&lt;T, N&gt;&amp; x, const array&lt;T, N&gt;&amp; y);
  template&lt;class T, size_t N&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    constexpr bool operator!=(const array&lt;T, N&gt;&amp; x, const array&lt;T, N&gt;&amp; y);
  template&lt;class T, size_t N&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    constexpr bool operator&lt; (const array&lt;T, N&gt;&amp; x, const array&lt;T, N&gt;&amp; y);
  template&lt;class T, size_t N&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    constexpr bool operator&gt; (const array&lt;T, N&gt;&amp; x, const array&lt;T, N&gt;&amp; y);
  template&lt;class T, size_t N&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    constexpr bool operator&lt;=(const array&lt;T, N&gt;&amp; x, const array&lt;T, N&gt;&amp; y);
  template&lt;class T, size_t N&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    constexpr bool operator&gt;=(const array&lt;T, N&gt;&amp; x, const array&lt;T, N&gt;&amp; y);
  template&lt;class T, size_t N&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    constexpr void swap(array&lt;T, N&gt;&amp; x, array&lt;T, N&gt;&amp; y) noexcept(noexcept(x.swap(y)));

  template&lt;class T&gt; class tuple_size; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;size_t I, class T&gt; class tuple_element; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;class T, size_t N&gt;
    struct tuple_size&lt;array&lt;T, N&gt;&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;size_t I, class T, size_t N&gt;
    struct tuple_element&lt;I, array&lt;T, N&gt;&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;size_t I, class T, size_t N&gt;
    constexpr T&amp; get(array&lt;T, N&gt;&amp;) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;size_t I, class T, size_t N&gt;
    constexpr T&amp;&amp; get(array&lt;T, N&gt;&amp;&amp;) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;size_t I, class T, size_t N&gt;
    constexpr const T&amp; get(const array&lt;T, N&gt;&amp;) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  template&lt;size_t I, class T, size_t N&gt;
    constexpr const T&amp;&amp; get(const array&lt;T, N&gt;&amp;&amp;) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
}
</pre>
</blockquote>

Change in [array.overview]:
<blockquote class="std">
<pre class='codeblock'>
    <span class='comment'>// element access
</span>    constexpr reference       operator[](size_type n);
    constexpr const_reference operator[](size_type n) const;
    constexpr reference       at(size_type n); <ins><span class='comment'>// <span class='textit'>freestanding, omit</span></span></ins>
    constexpr const_reference at(size_type n) const; <ins><span class='comment'>// <span class='textit'>freestanding, omit</span></span></ins>
    constexpr reference       front();
    constexpr const_reference front() const;
    constexpr reference       back();
    constexpr const_reference back() const;
</pre>
</blockquote>

Change in [iterator.synopsis]: <br/>
Instructions to the editor: <br/>
Please add a <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins> comment to everything in [iterator.synopsis] except for the entities described under the [stream.iterators] section (i.e. <code>istream_iterator</code>, <code>ostream_iterator</code>, <code>istreambuf_iterator</code>, <code>ostreambuf_iterator</code>, and their associated comparison functions).<br/>
<br/>
Change in [algorithm.syn]: <br/>
Instructions to the editor: <br/>
Please add a <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins> comment to all of the following declarations:
<ul>
<li><ins><code>for_each_result</code></ins></li>
<li><ins><code>mismatch_result</code></ins></li>
<li><ins><code>copy_result</code></ins></li>
<li><ins><code>copy_n_result</code></ins></li>
<li><ins><code>copy_if_result</code></ins></li>
<li><ins><code>copy_backward_result</code></ins></li>
<li><ins><code>move_result</code></ins></li>
<li><ins><code>move_backward_result</code></ins></li>
<li><ins><code>swap_ranges_result</code></ins></li>
<li><ins><code>unary_transform_result</code></ins></li>
<li><ins><code>binary_transform_result</code></ins></li>
<li><ins><code>replace_copy_result</code></ins></li>
<li><ins><code>replace_copy_if_result</code></ins></li>
<li><ins><code>remove_copy_result</code></ins></li>
<li><ins><code>remove_copy_if_result</code></ins></li>
<li><ins><code>unique_copy_result</code></ins></li>
<li><ins><code>reverse_copy_result</code></ins></li>
<li><ins><code>rotate_copy_result</code></ins></li>
<li><ins><code>partition_copy_result</code></ins></li>
<li><ins><code>merge_result</code></ins></li>
<li><ins><code>set_union_result</code></ins></li>
<li><ins><code>set_intersection_result</code></ins></li>
<li><ins><code>set_difference_result</code></ins></li>
<li><ins><code>set_symmetric_difference_result</code></ins></li>
<li><ins><code>minmax_result</code></ins></li>
</ul>
Please add a <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins> comment to all of the non-ExecutionPolicy overloads of the following functions (including the ones in the <code>ranges</code> namespace):
<ul>
<li><ins><code>all_of</code></ins></li>
<li><ins><code>any_of</code></ins></li>
<li><ins><code>none_of</code></ins></li>
<li><ins><code>for_each</code></ins></li>
<li><ins><code>for_each_n</code></ins></li>
<li><ins><code>find</code></ins></li>
<li><ins><code>find_if</code></ins></li>
<li><ins><code>find_if_not</code></ins></li>
<li><ins><code>find_end</code></ins></li>
<li><ins><code>find_first_of</code></ins></li>
<li><ins><code>adjacent_find</code></ins></li>
<li><ins><code>count</code></ins></li>
<li><ins><code>count_if</code></ins></li>
<li><ins><code>mismatch</code></ins></li>
<li><ins><code>equal</code></ins></li>
<li><ins><code>is_permutation</code></ins></li>
<li><ins><code>search</code></ins></li>
<li><ins><code>search_n</code></ins></li>
<li><ins><code>copy</code></ins></li>
<li><ins><code>copy_n</code></ins></li>
<li><ins><code>copy_if</code></ins></li>
<li><ins><code>copy_backward</code></ins></li>
<li><ins><code>move</code></ins></li>
<li><ins><code>move_backward</code></ins></li>
<li><ins><code>swap_ranges</code></ins></li>
<li><ins><code>iter_swap</code></ins></li>
<li><ins><code>transform</code></ins></li>
<li><ins><code>replace</code></ins></li>
<li><ins><code>replace_if</code></ins></li>
<li><ins><code>replace_copy</code></ins></li>
<li><ins><code>replace_copy_if</code></ins></li>
<li><ins><code>fill</code></ins></li>
<li><ins><code>fill_n</code></ins></li>
<li><ins><code>generate</code></ins></li>
<li><ins><code>generate_n</code></ins></li>
<li><ins><code>remove</code></ins></li>
<li><ins><code>remove_if</code></ins></li>
<li><ins><code>remove_copy</code></ins></li>
<li><ins><code>remove_copy_if</code></ins></li>
<li><ins><code>unique</code></ins></li>
<li><ins><code>unique_copy</code></ins></li>
<li><ins><code>reverse</code></ins></li>
<li><ins><code>reverse_copy</code></ins></li>
<li><ins><code>rotate</code></ins></li>
<li><ins><code>rotate_copy</code></ins></li>
<li><ins><code>sample</code></ins></li>
<li><ins><code>shuffle</code></ins></li>
<li><ins><code>shift_left</code></ins></li>
<li><ins><code>shift_right</code></ins></li>
<li><ins><code>sort</code></ins></li>
<li><ins><code>partial_sort</code></ins></li>
<li><ins><code>partial_sort_copy</code></ins></li>
<li><ins><code>is_sorted</code></ins></li>
<li><ins><code>is_sorted_until</code></ins></li>
<li><ins><code>nth_element</code></ins></li>
<li><ins><code>lower_bound</code></ins></li>
<li><ins><code>upper_bound</code></ins></li>
<li><ins><code>equal_range</code></ins></li>
<li><ins><code>binary_search</code></ins></li>
<li><ins><code>is_partitioned</code></ins></li>
<li><ins><code>partition</code></ins></li>
<li><ins><code>partition_copy</code></ins></li>
<li><ins><code>partition_point</code></ins></li>
<li><ins><code>merge</code></ins></li>
<li><ins><code>includes</code></ins></li>
<li><ins><code>set_union</code></ins></li>
<li><ins><code>set_intersection</code></ins></li>
<li><ins><code>set_difference</code></ins></li>
<li><ins><code>set_symmetric_difference</code></ins></li>
<li><ins><code>push_heap</code></ins></li>
<li><ins><code>pop_heap</code></ins></li>
<li><ins><code>make_heap</code></ins></li>
<li><ins><code>sort_heap</code></ins></li>
<li><ins><code>is_heap</code></ins></li>
<li><ins><code>is_heap_until</code></ins></li>
<li><ins><code>min</code></ins></li>
<li><ins><code>max</code></ins></li>
<li><ins><code>minmax</code></ins></li>
<li><ins><code>min_element</code></ins></li>
<li><ins><code>max_element</code></ins></li>
<li><ins><code>minmax_element</code></ins></li>
<li><ins><code>clamp</code></ins></li>
<li><ins><code>lexicographical_compare</code></ins></li>
<li><ins><code>compare_3way</code></ins></li>
<li><ins><code>lexicographical_compare_3way</code></ins></li>
<li><ins><code>next_permutation</code></ins></li>
<li><ins><code>prev_permutation</code></ins></li>
</ul>

Note that <code>stable_sort</code>, <code>stable_partition</code>, and <code>inplace_merge</code> are purposefully omitted.<br/>
<br/>
Change in [numeric.ops.overview]:<br/>
Instructions to the editor: <br/>
Please add a <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins> comment to all of the non-ExecutionPolicy overloads of the following functions:
<ul>
<li><ins><code>accumulate</code></ins></li>
<li><ins><code>reduce</code></ins></li>
<li><ins><code>inner_product</code></ins></li>
<li><ins><code>transform_reduce</code></ins></li>
<li><ins><code>partial_sum</code></ins></li>
<li><ins><code>exclusive_scan</code></ins></li>
<li><ins><code>inclusive_scan</code></ins></li>
<li><ins><code>transform_exclusive_scan</code></ins></li>
<li><ins><code>transform_inclusive_scan</code></ins></li>
<li><ins><code>adjacent_difference</code></ins></li>
<li><ins><code>iota</code></ins></li>
<li><ins><code>gcd</code></ins></li>
<li><ins><code>lcm</code></ins></li>
</ul>

Change in [rand.synopsis]:
<blockquote class="std">
<h3 ><a class='secnum' style='min-width:103pt'>?.?.?</a> Header <span class='texttt'>&lt;random&gt;</span> synopsis <a class='abbr_ref'>[rand.synopsis]</a></h3>
<pre class='codeblock'>
#include &lt;initializer_list&gt;

namespace std {
  <span class='comment'>// [rand.req.urng], uniform random bit generator requirements
</span>  template&lt;class G&gt;
    concept UniformRandomBitGenerator = <span class='textit'><span class='texttt'>see below</span></span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  <span class='comment'>// [rand.eng.lcong], class template <span class='tcode_in_codeblock'>linear_&shy;congruential_&shy;engine</span>
</span>  template&lt;class UIntType, UIntType a, UIntType c, UIntType m&gt;
    class linear_congruential_engine; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  <span class='comment'>// [rand.eng.mers], class template <span class='tcode_in_codeblock'>mersenne_&shy;twister_&shy;engine</span>
</span>  template&lt;class UIntType, size_t w, size_t n, size_t m, size_t r,
           UIntType a, size_t u, UIntType d, size_t s,
           UIntType b, size_t t,
           UIntType c, size_t l, UIntType f&gt;
    class mersenne_twister_engine; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  <span class='comment'>// [rand.eng.sub], class template <span class='tcode_in_codeblock'>subtract_&shy;with_&shy;carry_&shy;engine</span>
</span>  template&lt;class UIntType, size_t w, size_t s, size_t r&gt;
    class subtract_with_carry_engine; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  <span class='comment'>// [rand.adapt.disc], class template <span class='tcode_in_codeblock'>discard_&shy;block_&shy;engine</span>
</span>  template&lt;class Engine, size_t p, size_t r&gt;
    class discard_block_engine; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  <span class='comment'>// [rand.adapt.ibits], class template <span class='tcode_in_codeblock'>independent_&shy;bits_&shy;engine</span>
</span>  template&lt;class Engine, size_t w, class UIntType&gt;
    class independent_bits_engine; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  <span class='comment'>// [rand.adapt.shuf], class template <span class='tcode_in_codeblock'>shuffle_&shy;order_&shy;engine</span>
</span>  template&lt;class Engine, size_t k&gt;
    class shuffle_order_engine;

  <span class='comment'>// [rand.predef], engines and engine adaptors with predefined parameters
</span>  using minstd_rand0  = <span class='textit'><span class='texttt'>see below</span></span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  using minstd_rand   = <span class='textit'><span class='texttt'>see below</span></span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  using mt19937       = <span class='textit'><span class='texttt'>see below</span></span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  using mt19937_64    = <span class='textit'><span class='texttt'>see below</span></span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  using ranlux24_base = <span class='textit'><span class='texttt'>see below</span></span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  using ranlux48_base = <span class='textit'><span class='texttt'>see below</span></span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  using ranlux24      = <span class='textit'><span class='texttt'>see below</span></span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  using ranlux48      = <span class='textit'><span class='texttt'>see below</span></span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  using knuth_b       = <span class='textit'><span class='texttt'>see below</span></span>;

  using default_random_engine = <span class='textit'><span class='texttt'>see below</span></span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  <span class='comment'>// [rand.device], class <span class='tcode_in_codeblock'>random_&shy;device</span>
</span>  class random_device;

  <span class='comment'>// [rand.util.seedseq], class <span class='tcode_in_codeblock'>seed_&shy;seq</span>
</span>  class seed_seq;

  <span class='comment'>// [rand.util.canonical], function template <span class='tcode_in_codeblock'>generate_&shy;canonical</span>
</span>  template&lt;class RealType, size_t bits, class URBG&gt;
    RealType generate_canonical(URBG&amp; g);

  <span class='comment'>// [rand.dist.uni.int], class template <span class='tcode_in_codeblock'>uniform_&shy;int_&shy;distribution</span>
</span>  template&lt;class IntType = int&gt;
    class uniform_int_distribution; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  <span class='comment'>// [rand.dist.uni.real], class template <span class='tcode_in_codeblock'>uniform_&shy;real_&shy;distribution</span>
</span>  template&lt;class RealType = double&gt;
    class uniform_real_distribution;
</pre></blockquote>

Change in [cmath.syn]:
<blockquote class="std">
<pre class='codeblock'>
  <span class='comment'>// [c.math.abs], absolute values
</span>  int abs(int j); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  long int abs(long int j);<ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  long long int abs(long long int j); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  float abs(float j);
  double abs(double j);
  long double abs(long double j);
</pre>
</blockquote>

Change 1 of 2 in [time.syn]:
<blockquote class="std">
<h3 ><a class='secnum' style='min-width:103pt'>?.?</a> Header <span class='texttt'>&lt;chrono&gt;</span> synopsis <a class='abbr_ref'>[time.syn]</a></h3>
<pre class='codeblock'>
namespace std {
  namespace chrono {
    <span class='comment'>// [time.duration], class template <span class='tcode_in_codeblock'>duration</span>
</span>    template&lt;class Rep, class Period = ratio&lt;1&gt;&gt; class duration; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

    <span class='comment'>// [time.point], class template <span class='tcode_in_codeblock'>time_&shy;point</span>
</span>    template&lt;class Clock, class Duration = typename Clock::duration&gt; class time_point; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  }

  <span class='comment'>// [time.traits.specializations], <span class='tcode_in_codeblock'>common_&shy;type</span> specializations
</span>  template&lt;class Rep1, class Period1, class Rep2, class Period2&gt;
    struct common_type&lt;chrono::duration&lt;Rep1, Period1&gt;,
                       chrono::duration&lt;Rep2, Period2&gt;&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  template&lt;class Clock, class Duration1, class Duration2&gt;
    struct common_type&lt;chrono::time_point&lt;Clock, Duration1&gt;,
                       chrono::time_point&lt;Clock, Duration2&gt;&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  namespace chrono {
    <span class='comment'>// [time.traits], customization traits
</span>    template&lt;class Rep&gt; struct treat_as_floating_point; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    template&lt;class Rep&gt; struct duration_values; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    template&lt;class Rep&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
      inline constexpr bool treat_as_floating_point_v = treat_as_floating_point&lt;Rep&gt;::value;

    template&lt;class T&gt; struct is_clock;
    template&lt;class T&gt; inline constexpr bool is_clock_v = is_clock&lt;T&gt;::value;

    <span class='comment'>// [time.duration.nonmember], <span class='tcode_in_codeblock'>duration</span> arithmetic
</span>    template&lt;class Rep1, class Period1, class Rep2, class Period2&gt;
      constexpr common_type_t&lt;duration&lt;Rep1, Period1&gt;, duration&lt;Rep2, Period2&gt;&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
        operator+(const duration&lt;Rep1, Period1&gt;&amp; lhs, const duration&lt;Rep2, Period2&gt;&amp; rhs);
    template&lt;class Rep1, class Period1, class Rep2, class Period2&gt;
      constexpr common_type_t&lt;duration&lt;Rep1, Period1&gt;, duration&lt;Rep2, Period2&gt;&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
        operator-(const duration&lt;Rep1, Period1&gt;&amp; lhs, const duration&lt;Rep2, Period2&gt;&amp; rhs);
    template&lt;class Rep1, class Period, class Rep2&gt;
      constexpr duration&lt;common_type_t&lt;Rep1, Rep2&gt;, Period&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
        operator*(const duration&lt;Rep1, Period&gt;&amp; d, const Rep2&amp; s);
    template&lt;class Rep1, class Rep2, class Period&gt;
      constexpr duration&lt;common_type_t&lt;Rep1, Rep2&gt;, Period&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
        operator*(const Rep1&amp; s, const duration&lt;Rep2, Period&gt;&amp; d);
    template&lt;class Rep1, class Period, class Rep2&gt;
      constexpr duration&lt;common_type_t&lt;Rep1, Rep2&gt;, Period&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
        operator/(const duration&lt;Rep1, Period&gt;&amp; d, const Rep2&amp; s);
    template&lt;class Rep1, class Period1, class Rep2, class Period2&gt;
      constexpr common_type_t&lt;Rep1, Rep2&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
        operator/(const duration&lt;Rep1, Period1&gt;&amp; lhs, const duration&lt;Rep2, Period2&gt;&amp; rhs);
    template&lt;class Rep1, class Period, class Rep2&gt;
      constexpr duration&lt;common_type_t&lt;Rep1, Rep2&gt;, Period&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
        operator%(const duration&lt;Rep1, Period&gt;&amp; d, const Rep2&amp; s);
    template&lt;class Rep1, class Period1, class Rep2, class Period2&gt;
      constexpr common_type_t&lt;duration&lt;Rep1, Period1&gt;, duration&lt;Rep2, Period2&gt;&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
        operator%(const duration&lt;Rep1, Period1&gt;&amp; lhs, const duration&lt;Rep2, Period2&gt;&amp; rhs);

    <span class='comment'>// [time.duration.comparisons], <span class='tcode_in_codeblock'>duration</span> comparisons
</span>    template&lt;class Rep1, class Period1, class Rep2, class Period2&gt;
      constexpr bool operator==(const duration&lt;Rep1, Period1&gt;&amp; lhs,
                                const duration&lt;Rep2, Period2&gt;&amp; rhs); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    template&lt;class Rep1, class Period1, class Rep2, class Period2&gt;
      constexpr bool operator!=(const duration&lt;Rep1, Period1&gt;&amp; lhs,
                                const duration&lt;Rep2, Period2&gt;&amp; rhs); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    template&lt;class Rep1, class Period1, class Rep2, class Period2&gt;
      constexpr bool operator&lt; (const duration&lt;Rep1, Period1&gt;&amp; lhs,
                                const duration&lt;Rep2, Period2&gt;&amp; rhs); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    template&lt;class Rep1, class Period1, class Rep2, class Period2&gt;
      constexpr bool operator&gt; (const duration&lt;Rep1, Period1&gt;&amp; lhs,
                                const duration&lt;Rep2, Period2&gt;&amp; rhs); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    template&lt;class Rep1, class Period1, class Rep2, class Period2&gt;
      constexpr bool operator&lt;=(const duration&lt;Rep1, Period1&gt;&amp; lhs,
                                const duration&lt;Rep2, Period2&gt;&amp; rhs); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    template&lt;class Rep1, class Period1, class Rep2, class Period2&gt;
      constexpr bool operator&gt;=(const duration&lt;Rep1, Period1&gt;&amp; lhs,
                                const duration&lt;Rep2, Period2&gt;&amp; rhs); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

    <span class='comment'>// [time.duration.cast], <span class='tcode_in_codeblock'>duration_&shy;cast</span>
</span>    template&lt;class ToDuration, class Rep, class Period&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
      constexpr ToDuration duration_cast(const duration&lt;Rep, Period&gt;&amp; d);
    template&lt;class ToDuration, class Rep, class Period&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
      constexpr ToDuration floor(const duration&lt;Rep, Period&gt;&amp; d);
    template&lt;class ToDuration, class Rep, class Period&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
      constexpr ToDuration ceil(const duration&lt;Rep, Period&gt;&amp; d);
    template&lt;class ToDuration, class Rep, class Period&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
      constexpr ToDuration round(const duration&lt;Rep, Period&gt;&amp; d);

    <span class='comment'>// [time.duration.io], <span class='tcode_in_codeblock'>duration</span> I/O
</span>    template&lt;class charT, class traits, class Rep, class Period&gt;
      basic_ostream&lt;charT, traits&gt;&amp;
        operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp; os,
                   const duration&lt;Rep, Period&gt;&amp; d);
    template&lt;class charT, class traits, class Rep, class Period&gt;
      basic_ostream&lt;charT, traits&gt;&amp;
        to_stream(basic_ostream&lt;charT, traits&gt;&amp; os, const charT* fmt,
                  const duration&lt;Rep, Period&gt;&amp; d);
    template&lt;class charT, class traits, class Rep, class Period, class Alloc = allocator&lt;charT&gt;&gt;
      basic_istream&lt;charT, traits&gt;&amp;
        from_stream(basic_istream&lt;charT, traits&gt;&amp; is, const charT* fmt,
                    duration&lt;Rep, Period&gt;&amp; d,
                    basic_string&lt;charT, traits, Alloc&gt;* abbrev = nullptr,
                    minutes* offset = nullptr);

    <span class='comment'>// convenience typedefs
</span>    using nanoseconds  = duration&lt;<i>signed integer type of at least 64 bits</i>, nano&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    using microseconds = duration&lt;<i>signed integer type of at least 55 bits</i>, micro&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    using milliseconds = duration&lt;<i>signed integer type of at least 45 bits</i>, milli&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    using seconds      = duration&lt;<i>signed integer type of at least 35 bits</i>&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    using minutes      = duration&lt;<i>signed integer type of at least 29 bits</i>, ratio&lt;  60&gt;&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    using hours        = duration&lt;<i>signed integer type of at least 23 bits</i>, ratio&lt;3600&gt;&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    using days         = duration&lt;<i>signed integer type of at least 25 bits</i>,
                                  ratio_multiply&lt;ratio&lt;24&gt;, hours::period&gt;&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    using weeks        = duration&lt;<i>signed integer type of at least 22 bits</i>,
                                  ratio_multiply&lt;ratio&lt;7&gt;, days::period&gt;&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    using years        = duration&lt;<i>signed integer type of at least 17 bits</i>,
                                  ratio_multiply&lt;ratio&lt;146097, 400&gt;, days::period&gt;&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    using months       = duration&lt;<i>signed integer type of at least 20 bits</i>,
                                  ratio_divide&lt;years::period, ratio&lt;12&gt;&gt;&gt;; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

    <span class='comment'>// [time.point.nonmember], <span class='tcode_in_codeblock'>time_&shy;point</span> arithmetic
</span>    template&lt;class Clock, class Duration1, class Rep2, class Period2&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
      constexpr time_point&lt;Clock, common_type_t&lt;Duration1, duration&lt;Rep2, Period2&gt;&gt;&gt;
        operator+(const time_point&lt;Clock, Duration1&gt;&amp; lhs, const duration&lt;Rep2, Period2&gt;&amp; rhs);
    template&lt;class Rep1, class Period1, class Clock, class Duration2&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
      constexpr time_point&lt;Clock, common_type_t&lt;duration&lt;Rep1, Period1&gt;, Duration2&gt;&gt;
        operator+(const duration&lt;Rep1, Period1&gt;&amp; lhs, const time_point&lt;Clock, Duration2&gt;&amp; rhs);
    template&lt;class Clock, class Duration1, class Rep2, class Period2&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
      constexpr time_point&lt;Clock, common_type_t&lt;Duration1, duration&lt;Rep2, Period2&gt;&gt;&gt;
        operator-(const time_point&lt;Clock, Duration1&gt;&amp; lhs, const duration&lt;Rep2, Period2&gt;&amp; rhs);
    template&lt;class Clock, class Duration1, class Duration2&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
      constexpr common_type_t&lt;Duration1, Duration2&gt;
        operator-(const time_point&lt;Clock, Duration1&gt;&amp; lhs,
                  const time_point&lt;Clock, Duration2&gt;&amp; rhs);

    <span class='comment'>// [time.point.comparisons], <span class='tcode_in_codeblock'>time_&shy;point</span> comparisons
</span>    template&lt;class Clock, class Duration1, class Duration2&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
       constexpr bool operator==(const time_point&lt;Clock, Duration1&gt;&amp; lhs,
                                 const time_point&lt;Clock, Duration2&gt;&amp; rhs);
    template&lt;class Clock, class Duration1, class Duration2&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
       constexpr bool operator!=(const time_point&lt;Clock, Duration1&gt;&amp; lhs,
                                 const time_point&lt;Clock, Duration2&gt;&amp; rhs);
    template&lt;class Clock, class Duration1, class Duration2&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
       constexpr bool operator&lt; (const time_point&lt;Clock, Duration1&gt;&amp; lhs,
                                 const time_point&lt;Clock, Duration2&gt;&amp; rhs);
    template&lt;class Clock, class Duration1, class Duration2&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
       constexpr bool operator&gt; (const time_point&lt;Clock, Duration1&gt;&amp; lhs,
                                 const time_point&lt;Clock, Duration2&gt;&amp; rhs);
    template&lt;class Clock, class Duration1, class Duration2&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
       constexpr bool operator&lt;=(const time_point&lt;Clock, Duration1&gt;&amp; lhs,
                                 const time_point&lt;Clock, Duration2&gt;&amp; rhs);
    template&lt;class Clock, class Duration1, class Duration2&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
       constexpr bool operator&gt;=(const time_point&lt;Clock, Duration1&gt;&amp; lhs,
                                 const time_point&lt;Clock, Duration2&gt;&amp; rhs);

    <span class='comment'>// [time.point.cast], <span class='tcode_in_codeblock'>time_&shy;point_&shy;cast</span>
</span>    template&lt;class ToDuration, class Clock, class Duration&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
      constexpr time_point&lt;Clock, ToDuration&gt;
        time_point_cast(const time_point&lt;Clock, Duration&gt;&amp; t);
    template&lt;class ToDuration, class Clock, class Duration&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
      constexpr time_point&lt;Clock, ToDuration&gt; floor(const time_point&lt;Clock, Duration&gt;&amp; tp);
    template&lt;class ToDuration, class Clock, class Duration&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
      constexpr time_point&lt;Clock, ToDuration&gt; ceil(const time_point&lt;Clock, Duration&gt;&amp; tp);
    template&lt;class ToDuration, class Clock, class Duration&gt; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
      constexpr time_point&lt;Clock, ToDuration&gt; round(const time_point&lt;Clock, Duration&gt;&amp; tp);

    <span class='comment'>// [time.duration.alg], specialized algorithms
</span>    template&lt;class Rep, class Period&gt;
      constexpr duration&lt;Rep, Period&gt; abs(duration&lt;Rep, Period&gt; d); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
</pre>
</blockquote>

Change 2 of 2 in [time.syn]:
<blockquote class="std">
<pre class='codeblock'>
  inline namespace literals {
  inline namespace chrono_literals {
    <span class='comment'>// [time.duration.literals], suffixes for duration literals
</span>    constexpr chrono::hours                                 operator""h(unsigned long long); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    constexpr chrono::duration&lt;<span class='textit'><span class='texttt'>unspecified</span></span>, ratio&lt;3600, 1&gt;&gt; operator""h(long double); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

    constexpr chrono::minutes                             operator""min(unsigned long long); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    constexpr chrono::duration&lt;<span class='textit'><span class='texttt'>unspecified</span></span>, ratio&lt;60, 1&gt;&gt; operator""min(long double); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

    constexpr chrono::seconds               operator""s(unsigned long long); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    constexpr chrono::duration&lt;<span class='textit'><span class='texttt'>unspecified</span></span>&gt; operator""s(long double); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

    constexpr chrono::milliseconds                 operator""ms(unsigned long long); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    constexpr chrono::duration&lt;<span class='textit'><span class='texttt'>unspecified</span></span>, milli&gt; operator""ms(long double); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

    constexpr chrono::microseconds                 operator""us(unsigned long long); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    constexpr chrono::duration&lt;<span class='textit'><span class='texttt'>unspecified</span></span>, micro&gt; operator""us(long double); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

    constexpr chrono::nanoseconds                 operator""ns(unsigned long long); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
    constexpr chrono::duration&lt;<span class='textit'><span class='texttt'>unspecified</span></span>, nano&gt; operator""ns(long double); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

    <span class='comment'>// [time.cal.day.nonmembers], non-member functions
</span>    constexpr chrono::day  operator""d(unsigned long long d) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

    <span class='comment'>// [time.cal.year.nonmembers], non-member functions
</span>    constexpr chrono::year operator""y(unsigned long long y) noexcept; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  }
  }

  namespace chrono {
    using namespace literals::chrono_literals; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  }
}</pre></blockquote>

Change in [cinttypes.syn]:
<blockquote class="std">
<h3 ><a class='secnum' style='min-width:103pt'>?.?.?</a> Header <span class='texttt'>&lt;cinttypes&gt;</span> synopsis <a class='abbr_ref'>[cinttypes.syn]</a></h3>
<pre class='codeblock'>
#include &lt;cstdint&gt;  <span class='comment'>// see <a
>[cstdint.syn]</a>
</span>
namespace std {
  using imaxdiv_t = <span class='textit'><span class='texttt'>see below</span></span>; <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>

  intmax_t imaxabs(intmax_t j); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  imaxdiv_t imaxdiv(intmax_t numer, intmax_t denom); <ins><span class='comment'>// <span class='textit'>freestanding</span></span></ins>
  intmax_t strtoimax(const char* nptr, char** endptr, int base);
  uintmax_t strtoumax(const char* nptr, char** endptr, int base);
  intmax_t wcstoimax(const wchar_t* nptr, wchar_t** endptr, int base);
  uintmax_t wcstoumax(const wchar_t* nptr, wchar_t** endptr, int base);

  intmax_t abs(intmax_t);  <span class='comment'>// optional, see below<ins><span class='textit'>, freestanding</span></ins>
</span>  imaxdiv_t div(intmax_t, intmax_t);  <span class='comment'>// optional, see below<ins><span class='textit'>, freestanding</span></ins>
</span>}
</pre>
</blockquote>

<h1>Acknowledgements</h1>
<p>
Thanks to Brandon Streiff, Joshua Cannon, Phil Hindman, and Irwan Djajadi for reviewing this proposal.
</p><p>
Thanks to Odin Holmes for helping publicize this paper, presenting it in Rapperswil, and providing feedback.
</p><p>
Similar work was done in the C++11 timeframe by Lawrence Crowl and Alberto Ganesh Barbati in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3256.html">N3256</a>.
</p><p>
CppCon talks on getting C++ support in various unusual environments:
</p><p>
[Baker2017] CppCon 2017: Billy Baker "Almost Unlimited Modern C++ in Kernel-Mode Applications"
</p><p>
[Quinn2016] CppCon 2016: Rian Quinn "Making C++ and the STL Work in the Linux / Windows Kernels"
</p><p>
[Bratterud2017] CppCon 2017: Alfred Bratterud "Deconstructing the OS: The devil's In the side effects"
</p><p>
[Meredith11] Conservative use of noexcept in the Library. A. Meredith; J. Lakos.  <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3279.pdf">N3279</a>.
</p>
</body>
</html>

