[input.output] - C++20 → C++23

Files changed (1) hide show

tmp/tmp0skc848x/{from.md → to.md} +2056 -871

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

@@ -12,35 +12,25 @@ formatting and manipulators, string streams, and file streams, as
 summarized in [[iostreams.summary]].
 **Table: Input/output library summary** <a id="iostreams.summary">[iostreams.summary]</a>
 | Subclause                  |                             | Header                                           |
-| -------------------------- | --------------------------- | ------------------------------------- |
 | [[iostreams.requirements]] | Requirements                |                                                  |
 | [[iostream.forward]]       | Forward declarations        | `<iosfwd>`                                       |
 | [[iostream.objects]]       | Standard iostream objects   | `<iostream>`                                     |
 | [[iostreams.base]]         | Iostreams base classes      | `<ios>`                                          |
 | [[stream.buffers]]         | Stream buffers              | `<streambuf>`                                    |
-| [[iostream.format]]        | Formatting and manipulators | `<iomanip>`, `<istream>`, `<ostream>` |
 | [[string.streams]]         | String streams              | `<sstream>`                                      |
 | [[file.streams]]           | File streams                | `<fstream>`                                      |
 | [[syncstream]]             | Synchronized output streams | `<syncstream>`                                   |
 | [[filesystems]]            | File systems                | `<filesystem>`                                   |
 | [[c.files]]                | C library files             | `<cstdio>`, `<cinttypes>`                        |
-[*Note 1*: Figure [[fig:iostreams.streampos]] illustrates
-relationships among various types described in this clause. A line from
-**A** to **B** indicates that **A** is an alias (e.g., a typedef) for
-**B** or that **A** is defined in terms of **B**.
-<a id="fig:iostreams.streampos"></a>
-![Stream position, offset, and size types \[fig:iostreams.streampos\]](images/figstreampos.svg)
- — *end note*]
 ## Iostreams requirements <a id="iostreams.requirements">[[iostreams.requirements]]</a>
 ### Imbue limitations <a id="iostream.limits.imbue">[[iostream.limits.imbue]]</a>
 No function described in [[input.output]] except for `ios_base::imbue`
@@ -48,30 +38,54 @@ and `basic_filebuf::pubimbue` causes any instance of `basic_ios::imbue`
 or `basic_streambuf::imbue` to be called. If any user function called
 from a function declared in [[input.output]] or as an overriding virtual
 function of any class declared in [[input.output]] calls `imbue`, the
 behavior is undefined.
 ### Positioning type limitations <a id="iostreams.limits.pos">[[iostreams.limits.pos]]</a>
 The classes of [[input.output]] with template arguments `charT` and
 `traits` behave as described if `traits::pos_type` and
 `traits::off_type` are `streampos` and `streamoff` respectively. Except
 as noted explicitly below, their behavior when `traits::pos_type` and
 `traits::off_type` are other types is *implementation-defined*.
 In the classes of [[input.output]], a template parameter with name
 `charT` represents a member of the set of types containing `char`,
 `wchar_t`, and any other *implementation-defined* character types that
 meet the requirements for a character on which any of the iostream
 components can be instantiated.
 ### Thread safety <a id="iostreams.threadsafety">[[iostreams.threadsafety]]</a>
-Concurrent access to a stream object ([[string.streams]],
-[[file.streams]]), stream buffer object [[stream.buffers]], or C Library
-stream [[c.files]] by multiple threads may result in a data race
-[[intro.multithread]] unless otherwise specified [[iostream.objects]].
 [*Note 1*: Data races result in undefined behavior
 [[intro.multithread]]. — *end note*]
 If one thread makes a library call *a* that writes a value to a stream
@@ -116,10 +130,19 @@ namespace std {
     class basic_ostringstream;
   template<class charT, class traits = char_traits<charT>,
            class Allocator = allocator<charT>>
     class basic_stringstream;
   template<class charT, class traits = char_traits<charT>>
     class basic_filebuf;
   template<class charT, class traits = char_traits<charT>>
     class basic_ifstream;
   template<class charT, class traits = char_traits<charT>>
@@ -150,10 +173,15 @@ namespace std {
   using stringbuf     = basic_stringbuf<char>;
   using istringstream = basic_istringstream<char>;
   using ostringstream = basic_ostringstream<char>;
   using stringstream  = basic_stringstream<char>;
   using filebuf  = basic_filebuf<char>;
   using ifstream = basic_ifstream<char>;
   using ofstream = basic_ofstream<char>;
   using fstream  = basic_fstream<char>;
@@ -168,10 +196,15 @@ namespace std {
   using wstringbuf     = basic_stringbuf<wchar_t>;
   using wistringstream = basic_istringstream<wchar_t>;
   using wostringstream = basic_ostringstream<wchar_t>;
   using wstringstream  = basic_stringstream<wchar_t>;
   using wfilebuf  = basic_filebuf<wchar_t>;
   using wifstream = basic_ifstream<wchar_t>;
   using wofstream = basic_ofstream<wchar_t>;
   using wfstream  = basic_fstream<wchar_t>;
@@ -187,11 +220,11 @@ namespace std {
 }
 ```
 Default template arguments are described as appearing both in `<iosfwd>`
 and in the synopsis of other headers but it is well-formed to include
-both `<iosfwd>` and one or more of the other headers.[^1]
 ### Overview <a id="iostream.forward.overview">[[iostream.forward.overview]]</a>
 The class template specialization `basic_ios<charT, traits>` serves as a
 virtual base class for the class templates `basic_istream`,
@@ -266,27 +299,40 @@ standard C streams provided for by the functions declared in `<cstdio>`,
 and includes all the headers necessary to use these objects.
 The objects are constructed and the associations are established at some
 time prior to or during the first time an object of class
 `ios_base::Init` is constructed, and in any case before the body of
-`main` [[basic.start.main]] begins execution.[^2] The objects are not
-destroyed during program execution.[^3] The results of including
-`<iostream>` in a translation unit shall be as if `<iostream>` defined
-an instance of `ios_base::Init` with static storage duration.
 Mixing operations on corresponding wide- and narrow-character streams
 follows the same semantics as mixing such operations on `FILE`s, as
 specified in the C standard library.
 Concurrent access to a synchronized [[ios.members.static]] standard
 iostream object’s formatted and unformatted input [[istream]] and output
 [[ostream]] functions or a standard C stream by multiple threads does
 not result in a data race [[intro.multithread]].
-[*Note 1*: Users must still synchronize concurrent use of these objects
-and streams by multiple threads if they wish to avoid interleaved
-characters. — *end note*]
 See also: ISO C 7.21.2
 ### Narrow stream objects <a id="narrow.stream.objects">[[narrow.stream.objects]]</a>
@@ -428,30 +474,14 @@ namespace std {
   error_condition make_error_condition(io_errc e) noexcept;
   const error_category& iostream_category() noexcept;
 }
 ```
-### Types <a id="stream.types">[[stream.types]]</a>
-``` cpp
-using streamoff = implementation-defined;
-```
-The type `streamoff` is a synonym for one of the signed basic integral
-types of sufficient size to represent the maximum possible file size for
-the operating system.[^4]
-``` cpp
-using streamsize = implementation-defined;
-```
-The type `streamsize` is a synonym for one of the signed basic integral
-types. It is used to represent the number of characters transferred in
-an I/O operation, or the size of I/O buffers.[^5]
 ### Class `ios_base` <a id="ios.base">[[ios.base]]</a>
 ``` cpp
 namespace std {
   class ios_base {
   public:
     class failure;              // see below
@@ -488,10 +518,11 @@ namespace std {
     using openmode = T3;
     static constexpr openmode app = unspecified;
     static constexpr openmode ate = unspecified;
     static constexpr openmode binary = unspecified;
     static constexpr openmode in = unspecified;
     static constexpr openmode out = unspecified;
     static constexpr openmode trunc = unspecified;
     // [ios.seekdir], seekdir
     using seekdir = T4;
@@ -701,15 +732,16 @@ The type `openmode` is a bitmask type [[bitmask.types]]. It contains the
 elements indicated in [[ios.openmode]].
 **Table: `openmode` effects** <a id="ios.openmode">[ios.openmode]</a>
 | Element     | Effect(s) if set                                                  |
-| -------- | ----------------------------------------------------------------- |
 | `app`       | seek to end before each write                                     |
 | `ate`       | open and seek to end immediately after opening                    |
 | `binary`    | perform input and output in binary mode (as opposed to text mode) |
 | `in`        | open for input                                                    |
 | `out`       | open for output                                                   |
 | `trunc`     | truncate an existing stream when opening                          |
 ##### Type `ios_base::seekdir` <a id="ios.seekdir">[[ios.seekdir]]</a>
@@ -738,10 +770,11 @@ namespace std {
   public:
     Init();
     Init(const Init&) = default;
     ~Init();
     Init& operator=(const Init&) = default;
   private:
     static int init_cnt;        // exposition only
   };
 }
 ```
@@ -867,22 +900,22 @@ and output operations.
 ``` cpp
 static bool sync_with_stdio(bool sync = true);
 ```
-*Returns:* `true` if the previous state of the standard iostream
-objects [[iostream.objects]] was synchronized and otherwise returns
-`false`. The first time it is called, the function returns `true`.
 *Effects:* If any input or output operation has occurred using the
 standard streams prior to the call, the effect is
 *implementation-defined*. Otherwise, called with a `false` argument, it
 allows the standard streams to operate independently of the standard C
 streams.
-When a standard iostream object `str` is *synchronized* with a standard
-stdio stream `f`, the effect of inserting a character `c` by
 ``` cpp
 fputc(f, c);
 ```
@@ -916,11 +949,11 @@ is the same as the effect of
 ``` cpp
 str.rdbuf()->sputbackc(c);
 ```
-for any sequence of characters.[^6]
 #### Storage functions <a id="ios.base.storage">[[ios.base.storage]]</a>
 ``` cpp
 static int xalloc();
@@ -940,17 +973,20 @@ long& iword(int idx);
 *Effects:* If `iarray` is a null pointer, allocates an array of `long`
 of unspecified size and stores a pointer to its first element in
 `iarray`. The function then extends the array pointed at by `iarray` as
 necessary to include the element `iarray[idx]`. Each newly allocated
 element of the array is initialized to zero. The reference returned is
-invalid after any other operations on the object.[^7] However, the value
-of the storage referred to is retained, so that until the next call to
-`copyfmt`, calling `iword` with the same index yields another reference
-to the same value. If the function fails[^8] and `*this` is a base class
-subobject of a `basic_ios<>` object or subobject, the effect is
-equivalent to calling `basic_ios<>::setstate(badbit)` on the derived
-object (which may throw `failure`).
 *Returns:* On success `iarray[idx]`. On failure, a valid `long&`
 initialized to 0.
 ``` cpp
@@ -962,17 +998,19 @@ void*& pword(int idx);
 *Effects:* If `parray` is a null pointer, allocates an array of pointers
 to `void` of unspecified size and stores a pointer to its first element
 in `parray`. The function then extends the array pointed at by `parray`
 as necessary to include the element `parray[idx]`. Each newly allocated
 element of the array is initialized to a null pointer. The reference
-returned is invalid after any other operations on the object. However,
 the value of the storage referred to is retained, so that until the next
 call to `copyfmt`, calling `pword` with the same index yields another
-reference to the same value. If the function fails[^9] and `*this` is a
-base class subobject of a `basic_ios<>` object or subobject, the effect
-is equivalent to calling `basic_ios<>::setstate(badbit)` on the derived
-object (which may throw `failure`).
 *Returns:* On success `parray[idx]`. On failure a valid `void*&`
 initialized to 0.
 *Remarks:* After a subsequent call to `pword(int)` for the same object,
@@ -1012,22 +1050,23 @@ destroyed, whichever comes first; otherwise the behavior is undefined.
 ```
 *Effects:* Calls each registered callback pair `(fn, idx)`
 [[ios.base.callback]] as `(*fn)(erase_event, *this, idx)` at such time
 that any `ios_base` member function called from within `fn` has
-well-defined results.
 ### Class template `fpos` <a id="fpos">[[fpos]]</a>
 ``` cpp
 namespace std {
   template<class stateT> class fpos {
   public:
     // [fpos.members], members
     stateT state() const;
     void state(stateT);
-  private;
     stateT st;                  // exposition only
   };
 }
 ```
@@ -1054,25 +1093,25 @@ object whose type is equal to the template parameter `stateT`. Type
 [[cpp17.copyconstructible]]), *Cpp17CopyAssignable* (
 [[cpp17.copyassignable]]), and *Cpp17Destructible* (
 [[cpp17.destructible]]) requirements. If
 `is_trivially_copy_constructible_v<stateT>` is `true`, then
 `fpos<stateT>` has a trivial copy constructor. If
-`is_trivially_copy_assignable<stateT>` is `true`, then `fpos<stateT>`
 has a trivial copy assignment operator. If
 `is_trivially_destructible_v<stateT>` is `true`, then `fpos<stateT>` has
 a trivial destructor. All specializations of `fpos` meet the
 *Cpp17DefaultConstructible*, *Cpp17CopyConstructible*,
 *Cpp17CopyAssignable*, *Cpp17Destructible*, and
 *Cpp17EqualityComparable* ([[cpp17.equalitycomparable]]) requirements.
 In addition, the expressions shown in [[fpos.operations]] are valid and
 have the indicated semantics. In that table,
-- `P` refers to an instance of `fpos`,
 - `p` and `q` refer to values of type `P` or `const P`,
 - `pl` and `ql` refer to modifiable lvalues of type `P`,
 - `O` refers to type `streamoff`, and
-- `o` refers to a value of type `streamoff` or `const streamoff`.
 Stream operations that return a value of type `traits::pos_type` return
 `P(O(-1))` as an invalid value to signal an error. If this value is used
 as an argument to any `istream`, `ostream`, or `streambuf` member that
 accepts a value of type `traits::pos_type` then the behavior of that
@@ -1136,11 +1175,10 @@ namespace std {
     void init(basic_streambuf<charT, traits>* sb);
     void move(basic_ios& rhs);
     void move(basic_ios&& rhs);
     void swap(basic_ios& rhs) noexcept;
     void set_rdbuf(basic_streambuf<charT, traits>* sb);
   };
 }
 ```
 #### Constructors <a id="basic.ios.cons">[[basic.ios.cons]]</a>
@@ -1276,11 +1314,11 @@ member objects of `rhs` as follows:
   `(*fn)(erase_event, *this, idx)`;
 - then, assigns to the member objects of `*this` the corresponding
   member objects of `rhs`, except that
   - `rdstate()`, `rdbuf()`, and `exceptions()` are left unchanged;
   - the contents of arrays pointed at by `pword` and `iword` are copied,
-    not the pointers themselves;[^10] and
   - if any newly stored pointer values in `*this` point at objects
     stored outside the object `rhs` and those objects are destroyed when
     `rhs` is destroyed, the newly stored pointer values are altered to
     point at newly constructed copies of the objects;
 - then, calls each callback pair that was copied from `rhs` as
@@ -1365,19 +1403,19 @@ iostate rdstate() const;
 ``` cpp
 void clear(iostate state = goodbit);
 ```
-*Ensures:* If `rdbuf() != 0` then `state == rdstate()`; otherwise
-`rdstate() == (state | ios_base::badbit)`.
 *Effects:* If
 `((state | (rdbuf() ? goodbit : badbit)) & exceptions()) == 0`, returns.
 Otherwise, the function throws an object of class `ios_base::failure`
 [[ios.failure]], constructed with *implementation-defined* argument
 values.
 ``` cpp
 void setstate(iostate state);
 ```
 *Effects:* Calls `clear(rdstate() | state)` (which may throw
@@ -1397,11 +1435,11 @@ bool eof() const;
 ``` cpp
 bool fail() const;
 ```
-*Returns:* `true` if `failbit` or `badbit` is set in `rdstate()`.[^11]
 ``` cpp
 bool bad() const;
 ```
@@ -1416,14 +1454,14 @@ exceptions to be thrown.
 ``` cpp
 void exceptions(iostate except);
 ```
-*Ensures:* `except == exceptions()`.
 *Effects:* Calls `clear(rdstate())`.
 ### `ios_base` manipulators <a id="std.ios.manip">[[std.ios.manip]]</a>
 #### `fmtflags` manipulators <a id="fmtflags.manip">[[fmtflags.manip]]</a>
 Each function specified in this subclause is a designated addressable
@@ -1579,11 +1617,11 @@ function [[namespace.std]].
 ios_base& dec(ios_base& str);
 ```
 *Effects:* Calls `str.setf(ios_base::dec, ios_base::basefield)`.
-*Returns:* `str`[^12].
 ``` cpp
 ios_base& hex(ios_base& str);
 ```
@@ -1627,14 +1665,13 @@ ios_base& hexfloat(ios_base& str);
 *Effects:* Calls
 `str.setf(ios_base::fixed | ios_base::scientific, ios_base::floatfield)`.
 *Returns:* `str`.
-[*Note 1*: The more obvious use of `ios_base::hex` to specify
-hexadecimal floating-point format would change the meaning of existing
-well-defined programs. C++03 gives no meaning to the combination of
-`fixed` and `scientific`. — *end note*]
 ``` cpp
 ios_base& defaultfloat(ios_base& str);
 ```
@@ -1735,10 +1772,12 @@ above:
   shall have a defined value and is the next element to read (to get, or
   to obtain a character value, from the sequence).
 ### Class template `basic_streambuf` <a id="streambuf">[[streambuf]]</a>
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_streambuf {
   public:
@@ -1842,15 +1881,15 @@ for deriving various *stream buffers* whose objects each control two
 ``` cpp
 basic_streambuf();
 ```
-*Effects:* Initializes:[^13]
 - all pointer member objects to null pointers,
-- the `getloc()` member to a copy the global locale, `locale()`, at the
-  time of construction.
 *Remarks:* Once the `getloc()` member is initialized, results of calling
 locale member functions, and of members of facets so obtained, can
 safely be cached until the next time the member `imbue` is called.
@@ -2119,11 +2158,11 @@ functions and to members of facets so obtained.
 basic_streambuf* setbuf(char_type* s, streamsize n);
 ```
 *Effects:* Influences stream buffering in a way that is defined
 separately for each class derived from `basic_streambuf` in this
-Clause ([[stringbuf.virtuals]], [[filebuf.virtuals]]).
 *Default behavior:* Does nothing. Returns `this`.
 ``` cpp
 pos_type seekoff(off_type off, ios_base::seekdir way,
@@ -2131,12 +2170,12 @@ pos_type seekoff(off_type off, ios_base::seekdir way,
                   = ios_base::in | ios_base::out);
 ```
 *Effects:* Alters the stream positions within one or more of the
 controlled sequences in a way that is defined separately for each class
-derived from `basic_streambuf` in this Clause ([[stringbuf.virtuals]],
-[[filebuf.virtuals]]).
 *Default behavior:* Returns `pos_type(off_type(-1))`.
 ``` cpp
 pos_type seekpos(pos_type sp,
@@ -2144,12 +2183,12 @@ pos_type seekpos(pos_type sp,
                   = ios_base::in | ios_base::out);
 ```
 *Effects:* Alters the stream positions within one or more of the
 controlled sequences in a way that is defined separately for each class
-derived from `basic_streambuf` in this Clause ([[stringbuf]],
-[[filebuf]]).
 *Default behavior:* Returns `pos_type(off_type(-1))`.
 ``` cpp
 int sync();
@@ -2166,14 +2205,15 @@ each derived class [[filebuf.virtuals]].
 *Default behavior:* Returns zero.
 ##### Get area <a id="streambuf.virt.get">[[streambuf.virt.get]]</a>
 ``` cpp
-streamsize showmanyc();\footnote{The morphemes of showmanyc\
-are ``es-how-many-see'', not ``show-manic''.}
 ```
 *Returns:* An estimate of the number of characters available in the
 sequence, or -1. If it returns a positive value, then successive calls
 to `underflow()` will not return `traits::eof()` until at least that
 number of characters have been extracted from the stream. If
 `showmanyc()` returns -1, then calls to `underflow()` or `uflow()` will
@@ -2199,18 +2239,10 @@ to `sbumpc()` would return `traits::eof()`.
 ``` cpp
 int_type underflow();
 ```
-*Remarks:* The public members of `basic_streambuf` call this virtual
-function only if `gptr()` is null or `gptr() >= egptr()`.
-*Returns:* `traits::to_int_type(c)`, where `c` is the first *character*
-of the *pending sequence*, without moving the input sequence position
-past it. If the pending sequence is null then the function returns
-`traits::eof()` to indicate failure.
 The *pending sequence* of characters is defined as the concatenation of
 - the empty sequence if `gptr()` is null, otherwise the characters in
   \[`gptr()`, `egptr()`), followed by
 - some (possibly empty) sequence of characters read from the input
@@ -2236,12 +2268,20 @@ that either
   in which case the characters in \[`eback()`, `gptr()`) agree with the
   last `gptr() - eback()` characters of the backup sequence, or
 - the characters in \[`gptr() - n`, `gptr()`) agree with the backup
   sequence (where `n` is the length of the backup sequence).
 *Default behavior:* Returns `traits::eof()`.
 ``` cpp
 int_type uflow();
 ```
 *Preconditions:* The constraints are the same as for `underflow()`,
@@ -2249,26 +2289,21 @@ except that the result character is transferred from the pending
 sequence to the backup sequence, and the pending sequence is not empty
 before the transfer.
 *Default behavior:* Calls `underflow()`. If `underflow()` returns
 `traits::eof()`, returns `traits::eof()`. Otherwise, returns the value
-of `traits::to_int_type(*gptr())` and increment the value of the next
 pointer for the input sequence.
 *Returns:* `traits::eof()` to indicate failure.
 ##### Putback <a id="streambuf.virt.pback">[[streambuf.virt.pback]]</a>
 ``` cpp
 int_type pbackfail(int_type c = traits::eof());
 ```
-*Remarks:* The public functions of `basic_streambuf` call this virtual
-function only when `gptr()` is null, `gptr() == eback()`, or
-`traits::eq(traits::to_char_type(c), gptr()[-1])` returns `false`. Other
-calls shall also satisfy that constraint.
 The *pending sequence* is defined as for `underflow()`, with the
 modifications that
 - If `traits::eq_int_type(c, traits::eof())` returns `true`, then the
   input sequence is backed up one character before the pending sequence
@@ -2280,17 +2315,22 @@ modifications that
 *Ensures:* On return, the constraints of `gptr()`, `eback()`, and
 `pptr()` are the same as for `underflow()`.
 *Returns:* `traits::eof()` to indicate failure. Failure may occur
 because the input sequence could not be backed up, or if for some other
-reason the pointers could not be set consistent with the constraints.
 `pbackfail()` is called only when put back has really failed.
 Returns some value other than `traits::eof()` to indicate success.
 *Default behavior:* Returns `traits::eof()`.
 ##### Put area <a id="streambuf.virt.put">[[streambuf.virt.put]]</a>
 ``` cpp
 streamsize xsputn(const char_type* s, streamsize n);
 ```
@@ -2316,14 +2356,10 @@ of
 - the empty sequence if `pbase()` is null, otherwise the
   `pptr() - pbase()` characters beginning at `pbase()`, followed by
 - the empty sequence if `traits::eq_int_type(c, traits::eof())` returns
   `true`, otherwise the sequence consisting of `c`.
-*Remarks:* The member functions `sputc()` and `sputn()` call this
-function in case that no room can be found in the put buffer enough to
-accommodate the argument character sequence.
 *Preconditions:* Every overriding definition of this virtual function
 obeys the following constraints:
 - The effect of consuming a character on the associated output sequence
   is specified.[^16]
@@ -2343,10 +2379,14 @@ obeys the following constraints:
 Otherwise, returns some value other than `traits::eof()` to indicate
 success.[^17]
 *Default behavior:* Returns `traits::eof()`.
 ## Formatting and manipulators <a id="iostream.format">[[iostream.format]]</a>
 ### Header `<istream>` synopsis <a id="istream.syn">[[istream.syn]]</a>
 ``` cpp
@@ -2364,12 +2404,12 @@ namespace std {
   using wiostream = basic_iostream<wchar_t>;
   template<class charT, class traits>
     basic_istream<charT, traits>& ws(basic_istream<charT, traits>& is);
-  template<class charT, class traits, class T>
- basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>&& is, T&& x);
 }
 ```
 ### Header `<ostream>` synopsis <a id="ostream.syn">[[ostream.syn]]</a>
@@ -2393,56 +2433,96 @@ namespace std {
   template<class charT, class traits>
     basic_ostream<charT, traits>& noemit_on_flush(basic_ostream<charT, traits>& os);
   template<class charT, class traits>
     basic_ostream<charT, traits>& flush_emit(basic_ostream<charT, traits>& os);
-  template<class charT, class traits, class T>
- basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>&& os, const T& x);
 }
 ```
 ### Header `<iomanip>` synopsis <a id="iomanip.syn">[[iomanip.syn]]</a>
 ``` cpp
 namespace std {
- // types T1, T2, ... are unspecified implementation types
- T1 resetiosflags(ios_base::fmtflags mask);
- T2 setiosflags  (ios_base::fmtflags mask);
- T3 setbase(int base);
- template<class charT> T4 setfill(charT c);
- T5 setprecision(int n);
- T6 setw(int n);
-  template<class moneyT> T7 get_money(moneyT& mon, bool intl = false);
-  template<class moneyT> T8 put_money(const moneyT& mon, bool intl = false);
-  template<class charT> T9 get_time(struct tm* tmb, const charT* fmt);
-  template<class charT> T10 put_time(const struct tm* tmb, const charT* fmt);
   template<class charT>
- T11 quoted(const charT* s, charT delim = charT('"'), charT escape = charT('\\'));
   template<class charT, class traits, class Allocator>
- T12 quoted(const basic_string<charT, traits, Allocator>& s,
     \itcorr                   charT delim = charT('"'), charT escape = charT('\\'));
   template<class charT, class traits, class Allocator>
- T13 quoted(basic_string<charT, traits, Allocator>& s,
     \itcorr                   charT delim = charT('"'), charT escape = charT('\\'));
   template<class charT, class traits>
- T14 quoted(basic_string_view<charT, traits> s,
     \itcorr                   charT delim = charT('"'), charT escape = charT('\\'));
 }
 ```
 ### Input streams <a id="input.streams">[[input.streams]]</a>
-The header `<istream>` defines two types and a function signature that
-control input from a stream buffer along with a function template that
-extracts from stream rvalues.
 #### Class template `basic_istream` <a id="istream">[[istream]]</a>
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_istream : virtual public basic_ios<charT, traits> {
   public:
@@ -2459,64 +2539,62 @@ namespace std {
     // [istream.sentry], prefix/suffix
     class sentry;
     // [istream.formatted], formatted input
-    basic_istream<charT, traits>&
- operator>>(basic_istream<charT, traits>& (*pf)(basic_istream<charT, traits>&));
-    basic_istream<charT, traits>&
-      operator>>(basic_ios<charT, traits>& (*pf)(basic_ios<charT, traits>&));
-    basic_istream<charT, traits>&
-      operator>>(ios_base& (*pf)(ios_base&));
-    basic_istream<charT, traits>& operator>>(bool& n);
-    basic_istream<charT, traits>& operator>>(short& n);
-    basic_istream<charT, traits>& operator>>(unsigned short& n);
-    basic_istream<charT, traits>& operator>>(int& n);
-    basic_istream<charT, traits>& operator>>(unsigned int& n);
-    basic_istream<charT, traits>& operator>>(long& n);
-    basic_istream<charT, traits>& operator>>(unsigned long& n);
-    basic_istream<charT, traits>& operator>>(long long& n);
-    basic_istream<charT, traits>& operator>>(unsigned long long& n);
-    basic_istream<charT, traits>& operator>>(float& f);
-    basic_istream<charT, traits>& operator>>(double& f);
-    basic_istream<charT, traits>& operator>>(long double& f);
-    basic_istream<charT, traits>& operator>>(void*& p);
-    basic_istream<charT, traits>& operator>>(basic_streambuf<char_type, traits>* sb);
     // [istream.unformatted], unformatted input
     streamsize gcount() const;
     int_type get();
-    basic_istream<charT, traits>& get(char_type& c);
-    basic_istream<charT, traits>& get(char_type* s, streamsize n);
-    basic_istream<charT, traits>& get(char_type* s, streamsize n, char_type delim);
-    basic_istream<charT, traits>& get(basic_streambuf<char_type, traits>& sb);
-    basic_istream<charT, traits>& get(basic_streambuf<char_type, traits>& sb, char_type delim);
-    basic_istream<charT, traits>& getline(char_type* s, streamsize n);
-    basic_istream<charT, traits>& getline(char_type* s, streamsize n, char_type delim);
-    basic_istream<charT, traits>& ignore(streamsize n = 1, int_type delim = traits::eof());
     int_type       peek();
-    basic_istream<charT, traits>& read    (char_type* s, streamsize n);
     streamsize     readsome(char_type* s, streamsize n);
-    basic_istream<charT, traits>& putback(char_type c);
-    basic_istream<charT, traits>& unget();
     int sync();
     pos_type tellg();
-    basic_istream<charT, traits>& seekg(pos_type);
-    basic_istream<charT, traits>& seekg(off_type, ios_base::seekdir);
   protected:
     // [istream.cons], copy/move constructor
     basic_istream(const basic_istream&) = delete;
     basic_istream(basic_istream&& rhs);
-    // [istream.assign], assign and swap
     basic_istream& operator=(const basic_istream&) = delete;
     basic_istream& operator=(basic_istream&& rhs);
     void swap(basic_istream& rhs);
   };
@@ -2545,22 +2623,10 @@ Two groups of member function signatures share common properties: the
 *formatted input functions* (or *extractors*) and the *unformatted input
 functions.* Both groups of input functions are described as if they
 obtain (or *extract*) input *characters* by calling `rdbuf()->sbumpc()`
 or `rdbuf()->sgetc()`. They may use other public members of `istream`.
-If `rdbuf()->sbumpc()` or `rdbuf()->sgetc()` returns `traits::eof()`,
-then the input function, except as explicitly noted otherwise, completes
-its actions and does `setstate(eofbit)`, which may throw
-`ios_base::failure` [[iostate.flags]], before returning.
-If one of these called functions throws an exception, then unless
-explicitly noted otherwise, the input function sets `badbit` in the
-error state. If `badbit` is set in `exceptions()`, the input function
-rethrows the exception without completing its actions, otherwise it does
-not throw anything and proceeds as if the called function had returned a
-failure indication.
 ##### Constructors <a id="istream.cons">[[istream.cons]]</a>
 ``` cpp
 explicit basic_istream(basic_streambuf<charT, traits>* sb);
 ```
@@ -2603,15 +2669,16 @@ values returned by `gcount()` and `rhs.gcount()`.
 ##### Class `basic_istream::sentry` <a id="istream.sentry">[[istream.sentry]]</a>
 ``` cpp
 namespace std {
-  template<class charT, class traits = char_traits<charT>>
   class basic_istream<charT, traits>::sentry {
     bool ok_;                   // exposition only
   public:
-    explicit sentry(basic_istream<charT, traits>& is, bool noskipws = false);
     ~sentry();
     explicit operator bool() const { return ok_; }
     sentry(const sentry&) = delete;
     sentry& operator=(const sentry&) = delete;
   };
@@ -2620,32 +2687,34 @@ namespace std {
 The class `sentry` defines a class that is responsible for doing
 exception safe prefix and suffix operations.
 ``` cpp
-explicit sentry(basic_istream<charT, traits>& is, bool noskipws = false);
 ```
 *Effects:* If `is.good()` is `false`, calls `is.setstate(failbit)`.
 Otherwise, prepares for formatted or unformatted input. First, if
 `is.tie()` is not a null pointer, the function calls `is.tie()->flush()`
 to synchronize the output sequence with any associated external C
 stream. Except that this call can be suppressed if the put area of
 `is.tie()` is empty. Further an implementation is allowed to defer the
 call to `flush` until a call of `is.rdbuf()->underflow()` occurs. If no
 such call occurs before the `sentry` object is destroyed, the call to
-`flush` may be eliminated entirely.[^18] If `noskipws` is zero and
-`is.flags() & ios_base::skipws` is nonzero, the function extracts and
-discards each character as long as the next available input character
-`c` is a whitespace character. If `is.rdbuf()->sbumpc()` or
-`is.rdbuf()->sgetc()` returns `traits::eof()`, the function calls
-`setstate(failbit | eofbit)` (which may throw `ios_base::failure`).
 *Remarks:* The constructor
 ``` cpp
-explicit sentry(basic_istream<charT, traits>& is, bool noskipws = false)
 ```
 uses the currently imbued locale in `is`, to determine whether the next
 input character is whitespace or not.
@@ -2678,47 +2747,56 @@ explicit operator bool() const;
 #### Formatted input functions <a id="istream.formatted">[[istream.formatted]]</a>
 ##### Common requirements <a id="istream.formatted.reqmts">[[istream.formatted.reqmts]]</a>
 Each formatted input function begins execution by constructing an object
-of class `sentry` with the `noskipws` (second) argument `false`. If the
 `sentry` object returns `true`, when converted to a value of type
-`bool`, the function endeavors to obtain the requested input. If an
-exception is thrown during input then `ios_base::badbit` is turned
-on[^20] in `*this`’s error state. If `(exceptions()&badbit) != 0` then
-the exception is rethrown. In any case, the formatted input function
-destroys the `sentry` object. If no exception has been thrown, it
-returns `*this`.
 ##### Arithmetic extractors <a id="istream.formatted.arithmetic">[[istream.formatted.arithmetic]]</a>
 ``` cpp
-operator>>(unsigned short& val);
-operator>>(unsigned int& val);
-operator>>(long& val);
-operator>>(unsigned long& val);
-operator>>(long long& val);
-operator>>(unsigned long long& val);
-operator>>(float& val);
-operator>>(double& val);
-operator>>(long double& val);
-operator>>(bool& val);
-operator>>(void*& val);
 ```
 As in the case of the inserters, these extractors depend on the locale’s
 `num_get<>` [[locale.num.get]] object to perform parsing the input
 stream data. These extractors behave as formatted input functions (as
-described in  [[istream.formatted.reqmts]]). After a sentry object is
 constructed, the conversion occurs as if performed by the following code
-fragment:
 ``` cpp
 using numget = num_get<charT, istreambuf_iterator<charT, traits>>;
-iostate err = iostate::goodbit;
-use_facet<numget>(loc).get(*this, 0, *this, err, val);
-setstate(err);
 ```
 In the above fragment, `loc` stands for the private member of the
 `basic_ios` class.
@@ -2729,85 +2807,123 @@ directly. — *end note*]
 Class `locale` relies on this type as its interface to `istream`, so
 that it does not need to depend directly on `istream`.
 ``` cpp
-operator>>(short& val);
 ```
 The conversion occurs as if performed by the following code fragment
 (using the same notation as for the preceding code fragment):
 ``` cpp
 using numget = num_get<charT, istreambuf_iterator<charT, traits>>;
-iostate err = ios_base::goodbit;
 long lval;
-use_facet<numget>(loc).get(*this, 0, *this, err, lval);
 if (lval < numeric_limits<short>::min()) {
- err |= ios_base::failbit;
   val = numeric_limits<short>::min();
 } else if (numeric_limits<short>::max() < lval) {
- err |= ios_base::failbit;
   val = numeric_limits<short>::max();
 }  else
   val = static_cast<short>(lval);
-setstate(err);
 ```
 ``` cpp
-operator>>(int& val);
 ```
 The conversion occurs as if performed by the following code fragment
 (using the same notation as for the preceding code fragment):
 ``` cpp
 using numget = num_get<charT, istreambuf_iterator<charT, traits>>;
-iostate err = ios_base::goodbit;
 long lval;
-use_facet<numget>(loc).get(*this, 0, *this, err, lval);
 if (lval < numeric_limits<int>::min()) {
- err |= ios_base::failbit;
   val = numeric_limits<int>::min();
 } else if (numeric_limits<int>::max() < lval) {
- err |= ios_base::failbit;
   val = numeric_limits<int>::max();
 }  else
   val = static_cast<int>(lval);
-setstate(err);
 ```
 ##### `basic_istream::operator>>` <a id="istream.extractors">[[istream.extractors]]</a>
 ``` cpp
-basic_istream<charT, traits>&
-  operator>>(basic_istream<charT, traits>& (*pf)(basic_istream<charT, traits>&));
 ```
 *Effects:* None. This extractor does not behave as a formatted input
 function (as described in  [[istream.formatted.reqmts]]).
-*Returns:* `pf(*this)`.[^21]
 ``` cpp
-basic_istream<charT, traits>&
-  operator>>(basic_ios<charT, traits>& (*pf)(basic_ios<charT, traits>&));
 ```
 *Effects:* Calls `pf(*this)`. This extractor does not behave as a
 formatted input function (as described
 in  [[istream.formatted.reqmts]]).
 *Returns:* `*this`.
 ``` cpp
-basic_istream<charT, traits>& operator>>(ios_base& (*pf)(ios_base&));
 ```
-*Effects:* Calls `pf(*this)`.[^22] This extractor does not behave as a
-formatted input function (as described
-in  [[istream.formatted.reqmts]]).
 *Returns:* `*this`.
 ``` cpp
 template<class charT, class traits, size_t N>
@@ -2833,12 +2949,12 @@ Characters are extracted and stored until any of the following occurs:
 `operator>>` then stores a null byte (`charT()`) in the next position,
 which may be the first position if no characters were extracted.
 `operator>>` then calls `width(0)`.
-If the function extracted no characters, it calls `setstate(failbit)`,
-which may throw `ios_base::failure` [[iostate.flags]].
 *Returns:* `in`.
 ``` cpp
 template<class charT, class traits>
@@ -2848,132 +2964,138 @@ template<class traits>
 template<class traits>
   basic_istream<char, traits>& operator>>(basic_istream<char, traits>& in, signed char& c);
 ```
 *Effects:* Behaves like a formatted input member (as described
-in  [[istream.formatted.reqmts]]) of `in`. After a `sentry` object is
-constructed a character is extracted from `in`, if one is available, and
-stored in `c`. Otherwise, the function calls `in.setstate(failbit)`.
 *Returns:* `in`.
 ``` cpp
-basic_istream<charT, traits>& operator>>(basic_streambuf<charT, traits>* sb);
 ```
 *Effects:* Behaves as an unformatted input
 function [[istream.unformatted]]. If `sb` is null, calls
 `setstate(failbit)`, which may throw `ios_base::failure`
-[[iostate.flags]]. After a sentry object is constructed, extracts
 characters from `*this` and inserts them in the output sequence
 controlled by `sb`. Characters are extracted and inserted until any of
 the following occurs:
 - end-of-file occurs on the input sequence;
 - inserting in the output sequence fails (in which case the character to
   be inserted is not extracted);
 - an exception occurs (in which case the exception is caught).
-If the function inserts no characters, it calls `setstate(failbit)`,
-which may throw `ios_base::failure` [[iostate.flags]]. If it inserted no
-characters because it caught an exception thrown while extracting
-characters from `*this` and `failbit` is set in `exceptions()`
-[[iostate.flags]], then the caught exception is rethrown.
 *Returns:* `*this`.
 #### Unformatted input functions <a id="istream.unformatted">[[istream.unformatted]]</a>
 Each unformatted input function begins execution by constructing an
-object of class `sentry` with the default argument `noskipws` (second)
-argument `true`. If the `sentry` object returns `true`, when converted
-to a value of type `bool`, the function endeavors to obtain the
-requested input. Otherwise, if the sentry constructor exits by throwing
-an exception or if the sentry object returns `false`, when converted to
-a value of type `bool`, the function returns without attempting to
-obtain any input. In either case the number of extracted characters is
-set to 0; unformatted input functions taking a character array of
-nonzero size as an argument shall also store a null character (using
-`charT()`) in the first location of the array. If an exception is thrown
-during input then `ios_base::badbit` is turned on[^23] in `*this`’s
-error state. (Exceptions thrown from `basic_ios<>::clear()` are not
-caught or rethrown.) If `(exceptions()&badbit) != 0` then the exception
-is rethrown. It also counts the number of characters extracted. If no
-exception has been thrown it ends by storing the count in a member
-object and returning the value specified. In any event the `sentry`
-object is destroyed before leaving the unformatted input function.
 ``` cpp
 streamsize gcount() const;
 ```
 *Effects:* None. This member function does not behave as an unformatted
 input function (as described above).
 *Returns:* The number of characters extracted by the last unformatted
-input member function called for the object.
 ``` cpp
 int_type get();
 ```
 *Effects:* Behaves as an unformatted input function (as described
-above). After constructing a sentry object, extracts a character `c`, if
-one is available. Otherwise, the function calls `setstate(failbit)`,
-which may throw `ios_base::failure` [[iostate.flags]].
 *Returns:* `c` if available, otherwise `traits::eof()`.
 ``` cpp
-basic_istream<charT, traits>& get(char_type& c);
 ```
 *Effects:* Behaves as an unformatted input function (as described
-above). After constructing a sentry object, extracts a character, if one
-is available, and assigns it to `c`.[^24] Otherwise, the function calls
-`setstate(failbit)` (which may throw `ios_base::failure`
-[[iostate.flags]]).
 *Returns:* `*this`.
 ``` cpp
-basic_istream<charT, traits>& get(char_type* s, streamsize n, char_type delim);
 ```
 *Effects:* Behaves as an unformatted input function (as described
-above). After constructing a sentry object, extracts characters and
 stores them into successive locations of an array whose first element is
-designated by `s`.[^25] Characters are extracted and stored until any of
-the following occurs:
 - `n` is less than one or `n - 1` characters are stored;
-- end-of-file occurs on the input sequence (in which case the function
-  calls `setstate(eofbit)`);
 - `traits::eq(c, delim)` for the next available input character `c` (in
   which case `c` is not extracted).
-If the function stores no characters, it calls `setstate(failbit)`
-(which may throw `ios_base::failure` [[iostate.flags]]). In any case, if
-`n` is greater than zero it then stores a null character into the next
-successive location of the array.
 *Returns:* `*this`.
 ``` cpp
-basic_istream<charT, traits>& get(char_type* s, streamsize n);
 ```
 *Effects:* Calls `get(s, n, widen(’\n’))`.
 *Returns:* Value returned by the call.
 ``` cpp
-basic_istream<charT, traits>& get(basic_streambuf<char_type, traits>& sb, char_type delim);
 ```
 *Effects:* Behaves as an unformatted input function (as described
-above). After constructing a sentry object, extracts characters and
 inserts them in the output sequence controlled by `sb`. Characters are
 extracted and inserted until any of the following occurs:
 - end-of-file occurs on the input sequence;
 - inserting in the output sequence fails (in which case the character to
@@ -2981,45 +3103,45 @@ extracted and inserted until any of the following occurs:
 - `traits::eq(c, delim)` for the next available input character `c` (in
   which case `c` is not extracted);
 - an exception occurs (in which case, the exception is caught but not
   rethrown).
-If the function inserts no characters, it calls `setstate(failbit)`,
-which may throw `ios_base::failure` [[iostate.flags]].
 *Returns:* `*this`.
 ``` cpp
-basic_istream<charT, traits>& get(basic_streambuf<char_type, traits>& sb);
 ```
 *Effects:* Calls `get(sb, widen(’\n’))`.
 *Returns:* Value returned by the call.
 ``` cpp
-basic_istream<charT, traits>& getline(char_type* s, streamsize n, char_type delim);
 ```
 *Effects:* Behaves as an unformatted input function (as described
-above). After constructing a sentry object, extracts characters and
 stores them into successive locations of an array whose first element is
-designated by `s`.[^26] Characters are extracted and stored until one of
-the following occurs:
-1.  end-of-file occurs on the input sequence (in which case the function
-    calls `setstate(eofbit)`);
 2.  `traits::eq(c, delim)` for the next available input character `c`
     (in which case the input character is extracted but not
-    stored);[^27]
 3.  `n` is less than one or `n - 1` characters are stored (in which case
     the function calls `setstate(failbit)`).
-These conditions are tested in the order shown.[^28]
-If the function extracts no characters, it calls `setstate(failbit)`
-(which may throw `ios_base::failure` [[iostate.flags]]).[^29]
 In any case, if `n` is greater than zero, it then stores a null
 character (using `charT()`) into the next successive location of the
 array.
@@ -3053,21 +3175,21 @@ int main() {
 ```
 — *end example*]
 ``` cpp
-basic_istream<charT, traits>& getline(char_type* s, streamsize n);
 ```
 *Returns:* `getline(s, n, widen(’\n’))`
 ``` cpp
-basic_istream<charT, traits>& ignore(streamsize n = 1, int_type delim = traits::eof());
 ```
 *Effects:* Behaves as an unformatted input function (as described
-above). After constructing a sentry object, extracts characters and
 discards them. Characters are extracted until any of the following
 occurs:
 - `n != numeric_limits<streamsize>::max()` [[numeric.limits]] and `n`
   characters have been extracted so far
@@ -3075,36 +3197,38 @@ occurs:
   calls `setstate(eofbit)`, which may throw `ios_base::failure`
   [[iostate.flags]]);
 - `traits::eq_int_type(traits::to_int_type(c), delim)` for the next
   available input character `c` (in which case `c` is extracted).
-*Remarks:* The last condition will never occur if
-`traits::eq_int_type(delim, traits::eof())`.
 *Returns:* `*this`.
 ``` cpp
 int_type peek();
 ```
 *Effects:* Behaves as an unformatted input function (as described
-above). After constructing a sentry object, reads but does not extract
 the current input character.
 *Returns:* `traits::eof()` if `good()` is `false`. Otherwise, returns
 `rdbuf()->sgetc()`.
 ``` cpp
-basic_istream<charT, traits>& read(char_type* s, streamsize n);
 ```
 *Effects:* Behaves as an unformatted input function (as described
-above). After constructing a sentry object, if `!good()` calls
 `setstate(failbit)` which may throw an exception, and return. Otherwise
 extracts characters and stores them into successive locations of an
-array whose first element is designated by `s`.[^30] Characters are
-extracted and stored until either of the following occurs:
 - `n` characters are stored;
 - end-of-file occurs on the input sequence (in which case the function
   calls `setstate(failbit | eofbit)`, which may throw
   `ios_base::failure` [[iostate.flags]]).
@@ -3114,11 +3238,11 @@ extracted and stored until either of the following occurs:
 ``` cpp
 streamsize readsome(char_type* s, streamsize n);
 ```
 *Effects:* Behaves as an unformatted input function (as described
-above). After constructing a sentry object, if `!good()` calls
 `setstate(failbit)` which may throw an exception, and return. Otherwise
 extracts characters and stores them into successive locations of an
 array whose first element is designated by `s`. If
 `rdbuf()->in_avail() == -1`, calls `setstate(eofbit)` (which may throw
 `ios_base::failure` [[iostate.flags]]), and extracts no characters;
@@ -3127,51 +3251,51 @@ array whose first element is designated by `s`. If
 - If `rdbuf()->in_avail() > 0`, extracts `min(rdbuf()->in_avail(), n))`.
 *Returns:* The number of characters extracted.
 ``` cpp
-basic_istream<charT, traits>& putback(char_type c);
 ```
 *Effects:* Behaves as an unformatted input function (as described
 above), except that the function first clears `eofbit`. After
-constructing a sentry object, if `!good()` calls `setstate(failbit)`
 which may throw an exception, and return. If `rdbuf()` is not null,
 calls `rdbuf()->sputbackc(c)`. If `rdbuf()` is null, or if `sputbackc`
 returns `traits::eof()`, calls `setstate(badbit)` (which may throw
 `ios_base::failure` [[iostate.flags]]).
-[*Note 1*: This function extracts no characters, so the value returned
-by the next call to `gcount()` is 0. — *end note*]
-*Returns:* `*this`.
-``` cpp
-basic_istream<charT, traits>& unget();
-```
-*Effects:* Behaves as an unformatted input function (as described
-above), except that the function first clears `eofbit`. After
-constructing a sentry object, if `!good()` calls `setstate(failbit)`
-which may throw an exception, and return. If `rdbuf()` is not null,
-calls `rdbuf()->sungetc()`. If `rdbuf()` is null, or if `sungetc`
-returns `traits::eof()`, calls `setstate(badbit)` (which may throw
-`ios_base::failure` [[iostate.flags]]).
 [*Note 2*: This function extracts no characters, so the value returned
 by the next call to `gcount()` is 0. — *end note*]
 *Returns:* `*this`.
 ``` cpp
 int sync();
 ```
 *Effects:* Behaves as an unformatted input function (as described
 above), except that it does not count the number of characters extracted
 and does not affect the value returned by subsequent calls to
-`gcount()`. After constructing a sentry object, if `rdbuf()` is a null
 pointer, returns `-1`. Otherwise, calls `rdbuf()->pubsync()` and, if
 that function returns `-1` calls `setstate(badbit)` (which may throw
 `ios_base::failure` [[iostate.flags]], and returns `-1`. Otherwise,
 returns zero.
@@ -3182,38 +3306,38 @@ pos_type tellg();
 *Effects:* Behaves as an unformatted input function (as described
 above), except that it does not count the number of characters extracted
 and does not affect the value returned by subsequent calls to
 `gcount()`.
-*Returns:* After constructing a sentry object, if `fail() != false`,
 returns `pos_type(-1)` to indicate failure. Otherwise, returns
 `rdbuf()->pubseekoff(0, cur, in)`.
 ``` cpp
-basic_istream<charT, traits>& seekg(pos_type pos);
 ```
 *Effects:* Behaves as an unformatted input function (as described
 above), except that the function first clears `eofbit`, it does not
 count the number of characters extracted, and it does not affect the
 value returned by subsequent calls to `gcount()`. After constructing a
-sentry object, if `fail() != true`, executes
 `rdbuf()->pubseekpos(pos, ios_base::in)`. In case of failure, the
 function calls `setstate(failbit)` (which may throw
 `ios_base::failure`).
 *Returns:* `*this`.
 ``` cpp
-basic_istream<charT, traits>& seekg(off_type off, ios_base::seekdir dir);
 ```
 *Effects:* Behaves as an unformatted input function (as described
 above), except that the function first clears `eofbit`, does not count
 the number of characters extracted, and does not affect the value
-returned by subsequent calls to `gcount()`. After constructing a sentry
-object, if `fail() != true`, executes
 `rdbuf()->pubseekoff(off, dir, ios_base::in)`. In case of failure, the
 function calls `setstate(failbit)` (which may throw
 `ios_base::failure`).
 *Returns:* `*this`.
@@ -3229,11 +3353,11 @@ template<class charT, class traits>
 ```
 *Effects:* Behaves as an unformatted input
 function [[istream.unformatted]], except that it does not count the
 number of characters extracted and does not affect the value returned by
-subsequent calls to `is.gcount()`. After constructing a sentry object
 extracts characters as long as the next available character `c` is
 whitespace or until there are no more characters in the sequence.
 Whitespace characters are distinguished with the same criterion as used
 by `sentry::sentry` [[istream.sentry]]. If `ws` stops extracting
 characters because there are no more available it sets `eofbit`, but not
@@ -3247,22 +3371,24 @@ characters because there are no more available it sets `eofbit`, but not
 template<class Istream, class T>
   Istream&& operator>>(Istream&& is, T&& x);
 ```
 *Constraints:* The expression `is >> std::forward<T>(x)` is well-formed
-when treated as an unevaluated operand and `Istream` is publicly and
-unambiguously derived from `ios_base`.
 *Effects:* Equivalent to:
 ``` cpp
 is >> std::forward<T>(x);
 return std::move(is);
 ```
 #### Class template `basic_iostream` <a id="iostreamclass">[[iostreamclass]]</a>
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_iostream
     : public basic_istream<charT, traits>,
@@ -3283,11 +3409,11 @@ namespace std {
   protected:
     // [iostream.cons], constructor
     basic_iostream(const basic_iostream&) = delete;
     basic_iostream(basic_iostream&& rhs);
-    // [iostream.assign], assign and swap
     basic_iostream& operator=(const basic_iostream&) = delete;
     basic_iostream& operator=(basic_iostream&& rhs);
     void swap(basic_iostream& rhs);
   };
 }
@@ -3312,11 +3438,11 @@ explicit basic_iostream(basic_streambuf<charT, traits>* sb);
 ``` cpp
 basic_iostream(basic_iostream&& rhs);
 ```
 *Effects:* Move constructs from the rvalue `rhs` by constructing the
-`basic_istream` base class with `move(rhs)`.
 ##### Destructor <a id="iostream.dest">[[iostream.dest]]</a>
 ``` cpp
 virtual ~basic_iostream();
@@ -3338,16 +3464,24 @@ void swap(basic_iostream& rhs);
 *Effects:* Calls `basic_istream<charT, traits>::swap(rhs)`.
 ### Output streams <a id="output.streams">[[output.streams]]</a>
-The header `<ostream>` defines a type and several function signatures
-that control output to a stream buffer along with a function template
-that inserts into stream rvalues.
 #### Class template `basic_ostream` <a id="ostream">[[ostream]]</a>
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_ostream : virtual public basic_ios<charT, traits> {
   public:
@@ -3364,51 +3498,50 @@ namespace std {
     // [ostream.sentry], prefix/suffix
     class sentry;
     // [ostream.formatted], formatted output
-    basic_ostream<charT, traits>&
- operator<<(basic_ostream<charT, traits>& (*pf)(basic_ostream<charT, traits>&));
-    basic_ostream<charT, traits>&
-      operator<<(basic_ios<charT, traits>& (*pf)(basic_ios<charT, traits>&));
-    basic_ostream<charT, traits>&
-      operator<<(ios_base& (*pf)(ios_base&));
-    basic_ostream<charT, traits>& operator<<(bool n);
-    basic_ostream<charT, traits>& operator<<(short n);
-    basic_ostream<charT, traits>& operator<<(unsigned short n);
-    basic_ostream<charT, traits>& operator<<(int n);
-    basic_ostream<charT, traits>& operator<<(unsigned int n);
-    basic_ostream<charT, traits>& operator<<(long n);
-    basic_ostream<charT, traits>& operator<<(unsigned long n);
-    basic_ostream<charT, traits>& operator<<(long long n);
-    basic_ostream<charT, traits>& operator<<(unsigned long long n);
-    basic_ostream<charT, traits>& operator<<(float f);
-    basic_ostream<charT, traits>& operator<<(double f);
-    basic_ostream<charT, traits>& operator<<(long double f);
-    basic_ostream<charT, traits>& operator<<(const void* p);
-    basic_ostream<charT, traits>& operator<<(nullptr_t);
-    basic_ostream<charT, traits>& operator<<(basic_streambuf<char_type, traits>* sb);
     // [ostream.unformatted], unformatted output
-    basic_ostream<charT, traits>& put(char_type c);
-    basic_ostream<charT, traits>& write(const char_type* s, streamsize n);
-    basic_ostream<charT, traits>& flush();
     // [ostream.seeks], seeks
     pos_type tellp();
-    basic_ostream<charT, traits>& seekp(pos_type);
-    basic_ostream<charT, traits>& seekp(off_type, ios_base::seekdir);
   protected:
     // [ostream.cons], copy/move constructor
     basic_ostream(const basic_ostream&) = delete;
     basic_ostream(basic_ostream&& rhs);
-    // [ostream.assign], assign and swap
     basic_ostream& operator=(const basic_ostream&) = delete;
     basic_ostream& operator=(basic_ostream&& rhs);
     void swap(basic_ostream& rhs);
   };
@@ -3544,15 +3677,16 @@ void swap(basic_ostream& rhs);
 ##### Class `basic_ostream::sentry` <a id="ostream.sentry">[[ostream.sentry]]</a>
 ``` cpp
 namespace std {
-  template<class charT, class traits = char_traits<charT>>
   class basic_ostream<charT, traits>::sentry {
     bool ok_;       // exposition only
   public:
-    explicit sentry(basic_ostream<charT, traits>& os);
     ~sentry();
     explicit operator bool() const { return ok_; }
     sentry(const sentry&) = delete;
     sentry& operator=(const sentry&) = delete;
@@ -3562,20 +3696,20 @@ namespace std {
 The class `sentry` defines a class that is responsible for doing
 exception safe prefix and suffix operations.
 ``` cpp
-explicit sentry(basic_ostream<charT, traits>& os);
 ```
 If `os.good()` is nonzero, prepares for formatted or unformatted output.
-If `os.tie()` is not a null pointer, calls `os.tie()->flush()`.[^31]
 If, after any preparation is completed, `os.good()` is `true`,
 `ok_ == true` otherwise, `ok_ == false`. During preparation, the
 constructor may call `setstate(failbit)` (which may throw
-`ios_base::failure` [[iostate.flags]]).[^32]
 ``` cpp
 ~sentry();
 ```
@@ -3601,22 +3735,22 @@ pos_type tellp();
 *Returns:* If `fail() != false`, returns `pos_type(-1)` to indicate
 failure. Otherwise, returns `rdbuf()->pubseekoff(0, cur, out)`.
 ``` cpp
-basic_ostream<charT, traits>& seekp(pos_type pos);
 ```
 *Effects:* If `fail() != true`, executes
 `rdbuf()->pubseekpos(pos, ios_base::out)`. In case of failure, the
 function calls `setstate(failbit)` (which may throw
 `ios_base::failure`).
 *Returns:* `*this`.
 ``` cpp
-basic_ostream<charT, traits>& seekp(off_type off, ios_base::seekdir dir);
 ```
 *Effects:* If `fail() != true`, executes
 `rdbuf()->pubseekoff(off, dir, ios_base::out)`. In case of failure, the
 function calls `setstate(failbit)` (which may throw
@@ -3627,20 +3761,22 @@ function calls `setstate(failbit)` (which may throw
 #### Formatted output functions <a id="ostream.formatted">[[ostream.formatted]]</a>
 ##### Common requirements <a id="ostream.formatted.reqmts">[[ostream.formatted.reqmts]]</a>
 Each formatted output function begins execution by constructing an
-object of class `sentry`. If this object returns `true` when converted
 to a value of type `bool`, the function endeavors to generate the
 requested output. If the generation fails, then the formatted output
-function does `setstate(ios_base::failbit)`, which might throw an
 exception. If an exception is thrown during output, then
-`ios_base::badbit` is turned on[^33] in `*this`’s error state. If
-`(exceptions()&badbit) != 0` then the exception is rethrown. Whether or
-not an exception is thrown, the `sentry` object is destroyed before
-leaving the formatted output function. If no exception is thrown, the
-result of the formatted output function is `*this`.
 The descriptions of the individual formatted output functions describe
 how they perform output and do not mention the `sentry` object.
 If a formatted output function of a stream `os` determines padding, it
@@ -3653,23 +3789,23 @@ the fill characters are placed after the character sequence; otherwise,
 they are placed before the character sequence.
 ##### Arithmetic inserters <a id="ostream.inserters.arithmetic">[[ostream.inserters.arithmetic]]</a>
 ``` cpp
-operator<<(bool val);
-operator<<(short val);
-operator<<(unsigned short val);
-operator<<(int val);
-operator<<(unsigned int val);
-operator<<(long val);
-operator<<(unsigned long val);
-operator<<(long long val);
-operator<<(unsigned long long val);
-operator<<(float val);
-operator<<(double val);
-operator<<(long double val);
-operator<<(const void* val);
 ```
 *Effects:* The classes `num_get<>` and `num_put<>` handle
 locale-dependent numeric formatting and parsing. These inserter
 functions use the imbued `locale` value to perform numeric formatting.
@@ -3740,49 +3876,90 @@ It provides formatting specifications such as field width, and a locale
 from which to obtain other facets. If `failed` is `true` then does
 `setstate(badbit)`, which may throw an exception, and returns.
 *Returns:* `*this`.
 ##### `basic_ostream::operator<<` <a id="ostream.inserters">[[ostream.inserters]]</a>
 ``` cpp
-basic_ostream<charT, traits>&
-  operator<<(basic_ostream<charT, traits>& (*pf)(basic_ostream<charT, traits>&));
 ```
 *Effects:* None. Does not behave as a formatted output function (as
 described in  [[ostream.formatted.reqmts]]).
-*Returns:* `pf(*this)`.[^34]
 ``` cpp
-basic_ostream<charT, traits>&
-  operator<<(basic_ios<charT, traits>& (*pf)(basic_ios<charT, traits>&));
 ```
 *Effects:* Calls `pf(*this)`. This inserter does not behave as a
 formatted output function (as described
 in  [[ostream.formatted.reqmts]]).
-*Returns:* `*this`.[^35]
 ``` cpp
-basic_ostream<charT, traits>& operator<<(ios_base& (*pf)(ios_base&));
 ```
 *Effects:* Calls `pf(*this)`. This inserter does not behave as a
 formatted output function (as described
 in  [[ostream.formatted.reqmts]]).
 *Returns:* `*this`.
 ``` cpp
-basic_ostream<charT, traits>& operator<<(basic_streambuf<charT, traits>* sb);
 ```
 *Effects:* Behaves as an unformatted output
-function [[ostream.unformatted]]. After the sentry object is
 constructed, if `sb` is null calls `setstate(badbit)` (which may throw
 `ios_base::failure`).
 Gets characters from `sb` and inserts them in `*this`. Characters are
 read from `sb` and inserted until any of the following occurs:
@@ -3799,11 +3976,11 @@ the error state, and if `failbit` is set in `exceptions()` the caught
 exception is rethrown.
 *Returns:* `*this`.
 ``` cpp
-basic_ostream<charT, traits>& operator<<(nullptr_t);
 ```
 *Effects:* Equivalent to:
 ``` cpp
@@ -3876,29 +4053,98 @@ Determines padding for `seq` as described
 in  [[ostream.formatted.reqmts]]. Inserts `seq` into `out`. Calls
 `width(0)`.
 *Returns:* `out`.
 #### Unformatted output functions <a id="ostream.unformatted">[[ostream.unformatted]]</a>
 Each unformatted output function begins execution by constructing an
-object of class `sentry`. If this object returns `true`, while
 converting to a value of type `bool`, the function endeavors to generate
 the requested output. If an exception is thrown during output, then
-`ios_base::badbit` is turned on[^36] in `*this`’s error state. If
-`(exceptions() & badbit) != 0` then the exception is rethrown. In any
-case, the unformatted output function ends by destroying the sentry
-object, then, if no exception was thrown, returning the value specified
-for the unformatted output function.
 ``` cpp
-basic_ostream<charT, traits>& put(char_type c);
 ```
 *Effects:* Behaves as an unformatted output function (as described
-above). After constructing a sentry object, inserts the character `c`,
-if possible.[^37]
 Otherwise, calls `setstate(badbit)` (which may throw `ios_base::failure`
 [[iostate.flags]]).
 *Returns:* `*this`.
@@ -3906,14 +4152,15 @@ Otherwise, calls `setstate(badbit)` (which may throw `ios_base::failure`
 ``` cpp
 basic_ostream& write(const char_type* s, streamsize n);
 ```
 *Effects:* Behaves as an unformatted output function (as described
-above). After constructing a sentry object, obtains characters to insert
-from successive locations of an array whose first element is designated
-by `s`.[^38] Characters are inserted until either of the following
-occurs:
 - `n` characters are inserted;
 - inserting in the output sequence fails (in which case the function
   calls `setstate(badbit)`, which may throw `ios_base::failure`
   [[iostate.flags]]).
@@ -3923,15 +4170,15 @@ occurs:
 ``` cpp
 basic_ostream& flush();
 ```
 *Effects:* Behaves as an unformatted output function (as described
-above). If `rdbuf()` is not a null pointer, constructs a sentry object.
-If this object returns `true` when converted to a value of type `bool`
-the function calls `rdbuf()->pubsync()`. If that function returns -1
-calls `setstate(badbit)` (which may throw `ios_base::failure`
-[[iostate.flags]]). Otherwise, if the sentry object returns `false`,
 does nothing.
 *Returns:* `*this`.
 #### Standard manipulators <a id="ostream.manip">[[ostream.manip]]</a>
@@ -4001,11 +4248,14 @@ template<class charT, class traits>
   basic_ostream<charT, traits>& flush_emit(basic_ostream<charT, traits>& os);
 ```
 *Effects:* Calls `os.flush()`. Then, if `os.rdbuf()` is a
 `basic_syncbuf<charT, traits, Allocator>*`, called `buf` for the purpose
-of exposition, calls `buf->emit()`.
 *Returns:* `os`.
 #### Rvalue stream insertion <a id="ostream.rvalue">[[ostream.rvalue]]</a>
@@ -4035,11 +4285,11 @@ unspecified resetiosflags(ios_base::fmtflags mask);
 *Returns:* An object of unspecified type such that if `out` is an object
 of type `basic_ostream<charT, traits>` then the expression
 `out << resetiosflags(mask)` behaves as if it called `f(out, mask)`, or
 if `in` is an object of type `basic_istream<charT, traits>` then the
 expression `in >> resetiosflags(mask)` behaves as if it called
-`f(in, mask)`, where the function `f` is defined as:[^39]
 ``` cpp
 void f(ios_base& str, ios_base::fmtflags mask) {
   // reset specified flags
   str.setf(ios_base::fmtflags(0), mask);
@@ -4234,25 +4484,25 @@ void f(basic_ios<charT, traits>& str, const moneyT& mon, bool intl) {
 The expression `out << put_money(mon, intl)` has type
 `basic_ostream<charT, traits>&` and value `out`.
 ``` cpp
-template<class charT> unspecified get_time(struct tm* tmb, const charT* fmt);
 ```
 *Preconditions:* The argument `tmb` is a valid pointer to an object of
-type `struct tm`, and \[`fmt`, `fmt + char_traits<charT>::length(fmt)`)
-is a valid range.
 *Returns:* An object of unspecified type such that if `in` is an object
 of type `basic_istream<charT, traits>` then the expression
 `in >> get_time(tmb, fmt)` behaves as if it called `f(in, tmb, fmt)`,
 where the function `f` is defined as:
 ``` cpp
 template<class charT, class traits>
-void f(basic_ios<charT, traits>& str, struct tm* tmb, const charT* fmt) {
   using Iter    = istreambuf_iterator<charT, traits>;
   using TimeGet = time_get<charT, Iter>;
   ios_base::iostate err = ios_base::goodbit;
   const TimeGet& tg = use_facet<TimeGet>(str.getloc());
@@ -4267,25 +4517,25 @@ void f(basic_ios<charT, traits>& str, struct tm* tmb, const charT* fmt) {
 The expression `in >> get_time(tmb, fmt)` has type
 `basic_istream<charT, traits>&` and value `in`.
 ``` cpp
-template<class charT> unspecified put_time(const struct tm* tmb, const charT* fmt);
 ```
 *Preconditions:* The argument `tmb` is a valid pointer to an object of
-type `struct tm`, and \[`fmt`, `fmt + char_traits<charT>::length(fmt)`)
-is a valid range.
 *Returns:* An object of unspecified type such that if `out` is an object
 of type `basic_ostream<charT, traits>` then the expression
 `out << put_time(tmb, fmt)` behaves as if it called `f(out, tmb, fmt)`,
 where the function `f` is defined as:
 ``` cpp
 template<class charT, class traits>
-void f(basic_ios<charT, traits>& str, const struct tm* tmb, const charT* fmt) {
   using Iter    = ostreambuf_iterator<charT, traits>;
   using TimePut = time_put<charT, Iter>;
   const TimePut& tp = use_facet<TimePut>(str.getloc());
   const Iter end = tp.put(Iter(str.rdbuf()), str, str.fill(), tmb,
@@ -4374,39 +4624,178 @@ template<class charT, class traits, class Allocator>
 - The expression `in >> quoted(s, delim, escape)` has type
   `basic_istream<charT, traits>&` and value `in`.
 - The expression `out << quoted(s, delim, escape)` has type
   `basic_ostream<charT, traits>&` and value `out`.
 ## String-based streams <a id="string.streams">[[string.streams]]</a>
 ### Header `<sstream>` synopsis <a id="sstream.syn">[[sstream.syn]]</a>
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>,
            class Allocator = allocator<charT>>
     class basic_stringbuf;
   using stringbuf  = basic_stringbuf<char>;
   using wstringbuf = basic_stringbuf<wchar_t>;
   template<class charT, class traits = char_traits<charT>,
            class Allocator = allocator<charT>>
     class basic_istringstream;
   using istringstream  = basic_istringstream<char>;
   using wistringstream = basic_istringstream<wchar_t>;
   template<class charT, class traits = char_traits<charT>,
            class Allocator = allocator<charT>>
     class basic_ostringstream;
   using ostringstream  = basic_ostringstream<char>;
   using wostringstream = basic_ostringstream<wchar_t>;
   template<class charT, class traits = char_traits<charT>,
            class Allocator = allocator<charT>>
     class basic_stringstream;
   using stringstream  = basic_stringstream<char>;
   using wstringstream = basic_stringstream<wchar_t>;
 }
 ```
@@ -4414,10 +4803,12 @@ The header `<sstream>` defines four class templates and eight types that
 associate stream buffers with objects of class `basic_string`, as
 described in  [[string.classes]].
 ### Class template `basic_stringbuf` <a id="stringbuf">[[stringbuf]]</a>
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>,
            class Allocator = allocator<charT>>
   class basic_stringbuf : public basic_streambuf<charT, traits> {
@@ -4455,11 +4846,11 @@ namespace std {
         ios_base::openmode which = ios_base::in | ios_base::out);
     basic_stringbuf(const basic_stringbuf&) = delete;
     basic_stringbuf(basic_stringbuf&& rhs);
     basic_stringbuf(basic_stringbuf&& rhs, const Allocator& a);
-    // [stringbuf.assign], assign and swap
     basic_stringbuf& operator=(const basic_stringbuf&) = delete;
     basic_stringbuf& operator=(basic_stringbuf&& rhs);
     void swap(basic_stringbuf& rhs) noexcept(see below);
     // [stringbuf.members], getters and setters
@@ -4493,14 +4884,10 @@ namespace std {
   private:
     ios_base::openmode mode;                        // exposition only
     basic_string<charT, traits, Allocator> buf;     // exposition only
     void init_buf_ptrs();                           // exposition only
   };
-  template<class charT, class traits, class Allocator>
-    void swap(basic_stringbuf<charT, traits, Allocator>& x,
-              basic_stringbuf<charT, traits, Allocator>& y) noexcept(noexcept(x.swap(y)));
 }
 ```
 The class `basic_stringbuf` is derived from `basic_streambuf` to
 associate possibly the input sequence and possibly the output sequence
@@ -4633,15 +5020,15 @@ would have had if it had been move constructed from `rhs`
 void swap(basic_stringbuf& rhs) noexcept(see below);
 ```
 *Preconditions:*
 `allocator_traits<Allocator>::propagate_on_container_swap::value` is
-`true` or `get_allocator() == s.get_allocator()` is `true`.
 *Effects:* Exchanges the state of `*this` and `rhs`.
-*Remarks:* The expression inside `noexcept` is equivalent to:
 `allocator_traits<Allocator>::propagate_on_container_swap::value ||`
 `allocator_traits<Allocator>::is_always_equal::value`.
 ``` cpp
 template<class charT, class traits, class Allocator>
@@ -4679,12 +5066,12 @@ according to `mode`.
   - otherwise `pptr() == pbase()` is `true`.
 - If `ios_base::in` is set in `mode`, `eback()` points to `buf.front()`,
   and `(gptr() == eback() && egptr() == eback() + buf.size())` is
   `true`.
-[*Note 1*: For efficiency reasons, stream buffer operations might
-violate invariants of `buf` while it is held encapsulated in the
 `basic_stringbuf`, e.g., by writing to characters in the range
 \[`buf.data() + buf.size()`, `buf.data() + buf.capacity()`). All
 operations retrieving a `basic_string` from `buf` ensure that the
 `basic_string` invariants hold on the returned value. — *end note*]
@@ -4720,19 +5107,19 @@ return basic_string<charT, traits, SAlloc>(view(), sa);
 ``` cpp
 basic_string<charT, traits, Allocator> str() &&;
 ```
 *Returns:* A `basic_string<charT, traits, Allocator>` object move
 constructed from the `basic_stringbuf`’s underlying character sequence
 in `buf`. This can be achieved by first adjusting `buf` to have the same
 content as `view()`.
-*Ensures:* The underlying character sequence `buf` is empty and
-`pbase()`, `pptr()`, `epptr()`, `eback()`, `gptr()`, and `egptr()` are
-initialized as if by calling `init_buf_ptrs()` with an empty `buf`.
 ``` cpp
 basic_string_view<charT, traits> view() const noexcept;
 ```
 Let `sv` be `basic_string_view<charT, traits>`.
@@ -4808,11 +5195,11 @@ sequence, if possible, in one of three ways:
   input sequence has a putback position available, and if
   `traits::eq(to_char_type(c), gptr()[-1])` returns `true`, assigns
   `gptr() - 1` to `gptr()`. Returns: `c`.
 - If `traits::eq_int_type(c, traits::eof())` returns `false` and if the
   input sequence has a putback position available, and if `mode` `&`
-  `ios_base::out` is nonzero, assigns `c` to `*``gptr()`. Returns: `c`.
 - If `traits::eq_int_type(c, traits::eof())` returns `true` and if the
   input sequence has a putback position available, assigns `gptr() - 1`
   to `gptr()`. Returns: `traits::not_eof(c)`.
 *Returns:* As specified above, or `traits::eof()` to indicate failure.
@@ -4833,15 +5220,15 @@ sequence, if possible, in one of two ways:
   function calls `sputc(c)`. Signals success by returning `c`.
 - If `traits::eq_int_type(c, traits::eof())` returns `true`, there is no
   character to append. Signals success by returning a value other than
   `traits::eof()`.
 *Remarks:* The function can alter the number of write positions
 available as a result of any call.
-*Returns:* As specified above, or `traits::eof()` to indicate failure.
 The function can make a write position available only if `ios_base::out`
 is set in `mode`. To make a write position available, the function
 reallocates (or initially allocates) an array object with a sufficient
 number of elements to hold the current array object (if any), plus at
 least one additional write position. If `ios_base::in` is set in `mode`,
@@ -4902,20 +5289,22 @@ pos_type seekpos(pos_type sp,
 *Returns:* `sp` to indicate success, or `pos_type(off_type(-1))` to
 indicate failure.
 ``` cpp
-basic_streambuf<charT, traits>* setbuf(charT* s, streamsize n);
 ```
 *Effects:* *implementation-defined*, except that `setbuf(0, 0)` has no
 effect.
 *Returns:* `this`.
 ### Class template `basic_istringstream` <a id="istringstream">[[istringstream]]</a>
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>,
            class Allocator = allocator<charT>>
   class basic_istringstream : public basic_istream<charT, traits> {
@@ -4950,13 +5339,14 @@ namespace std {
         const basic_string<charT, traits, SAlloc>& s,
         ios_base::openmode which = ios_base::in);
     basic_istringstream(const basic_istringstream&) = delete;
     basic_istringstream(basic_istringstream&& rhs);
-    // [istringstream.assign], assign and swap
     basic_istringstream& operator=(const basic_istringstream&) = delete;
     basic_istringstream& operator=(basic_istringstream&& rhs);
     void swap(basic_istringstream& rhs);
     // [istringstream.members], members
     basic_stringbuf<charT, traits, Allocator>* rdbuf() const;
     basic_string<charT, traits, Allocator> str() const &;
@@ -4971,14 +5361,10 @@ namespace std {
     void str(basic_string<charT, traits, Allocator>&& s);
   private:
     basic_stringbuf<charT, traits, Allocator> sb;   // exposition only
   };
-  template<class charT, class traits, class Allocator>
-    void swap(basic_istringstream<charT, traits, Allocator>& x,
-              basic_istringstream<charT, traits, Allocator>& y);
 }
 ```
 The class `basic_istringstream<charT, traits, Allocator>` supports
 reading objects of class `basic_string<{}charT, traits, Allocator>`. It
@@ -5005,11 +5391,12 @@ explicit basic_istringstream(
   ios_base::openmode which = ios_base::in);
 ```
 *Effects:* Initializes the base class with
 `basic_istream<charT, traits>(addressof(sb))` [[istream]] and `sb` with
-`basic_stringbuf<charT, traits, Allocator>(s, which | ios_base::in)`([[stringbuf.cons]]).
 ``` cpp
 basic_istringstream(ios_base::openmode which, const Allocator& a);
 ```
@@ -5036,11 +5423,12 @@ template<class SAlloc>
     ios_base::openmode which, const Allocator& a);
 ```
 *Effects:* Initializes the base class with
 `basic_istream<charT, traits>(addressof(sb))` [[istream]] and `sb` with
-`basic_stringbuf<charT, traits, Allocator>(s, which | ios_base::in, a)`([[stringbuf.cons]]).
 ``` cpp
 template<class SAlloc>
   explicit basic_istringstream(
     const basic_string<charT, traits, SAlloc>& s,
@@ -5060,11 +5448,11 @@ basic_istringstream(basic_istringstream&& rhs);
 by move constructing the base class, and the contained
 `basic_stringbuf`. Then calls
 `basic_istream<charT, traits>::set_rdbuf(addressof(sb))` to install the
 contained `basic_stringbuf`.
-#### Assignment and swap <a id="istringstream.assign">[[istringstream.assign]]</a>
 ``` cpp
 void swap(basic_istringstream& rhs);
 ```
@@ -5136,10 +5524,12 @@ void str(basic_string<charT, traits, Allocator>&& s);
 *Effects:* Equivalent to: `rdbuf()->str(std::move(s));`
 ### Class template `basic_ostringstream` <a id="ostringstream">[[ostringstream]]</a>
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>,
            class Allocator = allocator<charT>>
   class basic_ostringstream : public basic_ostream<charT, traits> {
@@ -5174,13 +5564,14 @@ namespace std {
         const basic_string<charT, traits, SAlloc>& s,
         ios_base::openmode which = ios_base::out);
     basic_ostringstream(const basic_ostringstream&) = delete;
     basic_ostringstream(basic_ostringstream&& rhs);
-    // [ostringstream.assign], assign and swap
     basic_ostringstream& operator=(const basic_ostringstream&) = delete;
     basic_ostringstream& operator=(basic_ostringstream&& rhs);
     void swap(basic_ostringstream& rhs);
     // [ostringstream.members], members
     basic_stringbuf<charT, traits, Allocator>* rdbuf() const;
@@ -5196,14 +5587,10 @@ namespace std {
     void str(basic_string<charT, traits, Allocator>&& s);
    private:
     basic_stringbuf<charT, traits, Allocator> sb;   // exposition only
   };
-  template<class charT, class traits, class Allocator>
-    void swap(basic_ostringstream<charT, traits, Allocator>& x,
-              basic_ostringstream<charT, traits, Allocator>& y);
 }
 ```
 The class `basic_ostringstream<charT, traits, Allocator>` supports
 writing objects of class `basic_string<{}charT, traits, Allocator>`. It
@@ -5229,19 +5616,21 @@ explicit basic_ostringstream(
   ios_base::openmode which = ios_base::out);
 ```
 *Effects:* Initializes the base class with
 `basic_ostream<charT, traits>(addressof(sb))` [[ostream]] and `sb` with
-`basic_stringbuf<charT, traits, Allocator>(s, which | ios_base::out)`([[stringbuf.cons]]).
 ``` cpp
 basic_ostringstream(ios_base::openmode which, const Allocator& a);
 ```
 *Effects:* Initializes the base class with
 `basic_ostream<charT, traits>(addressof(sb))` [[ostream]] and `sb` with
-`basic_stringbuf<charT, traits, Allocator>(which | ios_base::out, a)`([[stringbuf.cons]]).
 ``` cpp
 explicit basic_ostringstream(
   basic_string<charT, traits, Allocator>&& s,
   ios_base::openmode which = ios_base::out);
@@ -5259,11 +5648,12 @@ template<class SAlloc>
     ios_base::openmode which, const Allocator& a);
 ```
 *Effects:* Initializes the base class with
 `basic_ostream<charT, traits>(addressof(sb))` [[ostream]] and `sb` with
-`basic_stringbuf<charT, traits, Allocator>(s, which | ios_base::out, a)`([[stringbuf.cons]]).
 ``` cpp
 template<class SAlloc>
   explicit basic_ostringstream(
     const basic_string<charT, traits, SAlloc>& s,
@@ -5272,11 +5662,12 @@ template<class SAlloc>
 *Constraints:* `is_same_v<SAlloc,Allocator>` is `false`.
 *Effects:* Initializes the base class with
 `basic_ostream<charT, traits>(addressof(sb))` [[ostream]] and `sb` with
-`basic_stringbuf<charT, traits, Allocator>(s, which | ios_base::out)`([[stringbuf.cons]]).
 ``` cpp
 basic_ostringstream(basic_ostringstream&& rhs);
 ```
@@ -5284,11 +5675,11 @@ basic_ostringstream(basic_ostringstream&& rhs);
 by move constructing the base class, and the contained
 `basic_stringbuf`. Then calls
 `basic_ostream<charT, traits>::set_rdbuf(addressof(sb))` to install the
 contained `basic_stringbuf`.
-#### Assignment and swap <a id="ostringstream.assign">[[ostringstream.assign]]</a>
 ``` cpp
 void swap(basic_ostringstream& rhs);
 ```
@@ -5360,10 +5751,12 @@ void str(basic_string<charT, traits, Allocator>&& s);
 *Effects:* Equivalent to: `rdbuf()->str(std::move(s));`
 ### Class template `basic_stringstream` <a id="stringstream">[[stringstream]]</a>
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>,
            class Allocator = allocator<charT>>
   class basic_stringstream : public basic_iostream<charT, traits> {
@@ -5398,13 +5791,14 @@ namespace std {
         const basic_string<charT, traits, SAlloc>& s,
         ios_base::openmode which = ios_base::out | ios_base::in);
     basic_stringstream(const basic_stringstream&) = delete;
     basic_stringstream(basic_stringstream&& rhs);
-    // [stringstream.assign], assign and swap
     basic_stringstream& operator=(const basic_stringstream&) = delete;
     basic_stringstream& operator=(basic_stringstream&& rhs);
     void swap(basic_stringstream& rhs);
     // [stringstream.members], members
     basic_stringbuf<charT, traits, Allocator>* rdbuf() const;
@@ -5420,14 +5814,10 @@ namespace std {
     void str(basic_string<charT, traits, Allocator>&& s);
   private:
     basic_stringbuf<charT, traits> sb;  // exposition only
   };
-  template<class charT, class traits, class Allocator>
-    void swap(basic_stringstream<charT, traits, Allocator>& x,
-              basic_stringstream<charT, traits, Allocator>& y);
 }
 ```
 The class template `basic_stringstream<charT, traits>` supports reading
 and writing from objects of class
@@ -5513,11 +5903,11 @@ basic_stringstream(basic_stringstream&& rhs);
 by move constructing the base class, and the contained
 `basic_stringbuf`. Then calls
 `basic_istream<charT, traits>::set_rdbuf(addressof(sb))` to install the
 contained `basic_stringbuf`.
-#### Assignment and swap <a id="stringstream.assign">[[stringstream.assign]]</a>
 ``` cpp
 void swap(basic_stringstream& rhs);
 ```
@@ -5587,33 +5977,686 @@ template<class SAlloc>
 void str(basic_string<charT, traits, Allocator>&& s);
 ```
 *Effects:* Equivalent to: `rdbuf()->str(std::move(s));`
 ## File-based streams <a id="file.streams">[[file.streams]]</a>
 ### Header `<fstream>` synopsis <a id="fstream.syn">[[fstream.syn]]</a>
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>>
     class basic_filebuf;
   using filebuf  = basic_filebuf<char>;
   using wfilebuf = basic_filebuf<wchar_t>;
   template<class charT, class traits = char_traits<charT>>
     class basic_ifstream;
   using ifstream  = basic_ifstream<char>;
   using wifstream = basic_ifstream<wchar_t>;
   template<class charT, class traits = char_traits<charT>>
     class basic_ofstream;
   using ofstream  = basic_ofstream<char>;
   using wofstream = basic_ofstream<wchar_t>;
   template<class charT, class traits = char_traits<charT>>
     class basic_fstream;
   using fstream  = basic_fstream<char>;
   using wfstream = basic_fstream<wchar_t>;
 }
 ```
@@ -5626,18 +6669,20 @@ or sink of bytes. In an environment that uses a large character set, the
 file typically holds multibyte character sequences and the
 `basic_filebuf` object converts those multibyte sequences into wide
 character sequences. — *end note*]
 In subclause  [[file.streams]], member functions taking arguments of
-`const filesystem::path::value_type*` are only be provided on systems
-where `filesystem::path::value_type` [[fs.class.path]] is not `char`.
 [*Note 2*: These functions enable class `path` support for systems with
 a wide native path character type, such as `wchar_t`. — *end note*]
 ### Class template `basic_filebuf` <a id="filebuf">[[filebuf]]</a>
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_filebuf : public basic_streambuf<charT, traits> {
   public:
@@ -5651,11 +6696,11 @@ namespace std {
     basic_filebuf();
     basic_filebuf(const basic_filebuf&) = delete;
     basic_filebuf(basic_filebuf&& rhs);
     virtual ~basic_filebuf();
-    // [filebuf.assign], assign and swap
     basic_filebuf& operator=(const basic_filebuf&) = delete;
     basic_filebuf& operator=(basic_filebuf&& rhs);
     void swap(basic_filebuf& rhs);
     // [filebuf.members], members
@@ -5686,14 +6731,10 @@ namespace std {
                      ios_base::openmode which
                       = ios_base::in | ios_base::out) override;
     int      sync() override;
     void     imbue(const locale& loc) override;
   };
-  template<class charT, class traits>
-    void swap(basic_filebuf<charT, traits>& x,
-              basic_filebuf<charT, traits>& y);
 }
 ```
 The class `basic_filebuf<charT, traits>` associates both the input
 sequence and the output sequence with a file.
@@ -5791,12 +6832,11 @@ void swap(basic_filebuf& rhs);
 *Effects:* Exchanges the state of `*this` and `rhs`.
 ``` cpp
 template<class charT, class traits>
-  void swap(basic_filebuf<charT, traits>& x,
-            basic_filebuf<charT, traits>& y);
 ```
 *Effects:* Equivalent to: `x.swap(y)`.
 #### Member functions <a id="filebuf.members">[[filebuf.members]]</a>
@@ -5823,35 +6863,42 @@ argument determined from `mode & ~ios_base::ate` as indicated in
 [[filebuf.open.modes]]. If `mode` is not some combination of flags shown
 in the table then the open fails.
 **Table: File open modes** <a id="filebuf.open.modes">[filebuf.open.modes]</a>
-| `binary` | `in` | `out` | `trunc` | `app` | | `stdio` equivalent |
-| -------- | ---- | ----- | ------- | ----- | --- | ------------------ |
-|          |      | +     |         |       | `"w"` |
-|          |      | +     |         | + | `"a"` |
-|          |      |       |         | +     | `"a"` |
-|          |      | +     | +       |       | `"w"` |
-|          | + |       |         | | `"r"` |
-|          | +    | +     | |       | `"r+"` |
-|          | +    | +     | +       |       | `"w+"` |
-|          | +    | +     |         | +     | `"a+"` |
-|          | +    |       |         | +     | `"a+"` + | | +   |     |     | `"wb"` |
-| + |      | +     | | + | `"ab"` |
-| + | |       |         | +     | `"ab"` |
-| + | | +     | +       |       | `"wb"` |
-| +        | + |       |         |       | `"rb"` |
-| +        | +    | +     |         |       | `"r+b"` |
-| +        | +    | +     | +       |       | `"w+b"` |
-| +        | + | + | | + | `"a+b"` |
-| +        | + |       |         | +     | `"a+b"` |
 If the open operation succeeds and `ios_base::ate` is set in `mode`,
 positions the file to the end (as if by calling
 `fseek(file, 0, SEEK_END)`, where `file` is the pointer returned by
-calling `fopen`). [^40]
 If the repositioning operation fails, calls `close()` and returns a null
 pointer to indicate failure.
 *Returns:* `this` if successful, a null pointer otherwise.
@@ -5878,25 +6925,25 @@ or throws an exception, the function closes the file (as if by calling
 `fclose(file)`). If any of the calls made by the function, including
 `fclose`, fails, `close` fails by returning a null pointer. If one of
 these calls throws an exception, the exception is caught and rethrown
 after closing the file.
 *Returns:* `this` on success, a null pointer otherwise.
-*Ensures:* `is_open() == false`.
 #### Overridden virtual functions <a id="filebuf.virtuals">[[filebuf.virtuals]]</a>
 ``` cpp
 streamsize showmanyc() override;
 ```
 *Effects:* Behaves the same as `basic_streambuf::showmanyc()`
 [[streambuf.virtuals]].
-*Remarks:* An implementation might well provide an overriding definition
-for this function signature if it can determine that more characters can
 be read from the input sequence.
 ``` cpp
 int_type underflow() override;
 ```
@@ -6018,10 +7065,15 @@ operation fails. Otherwise, if `way != basic_ios::cur` or `off != 0`,
 and if the last operation was output, then update the output sequence
 and write any unshift sequence. Next, seek to the new position: if
 `width > 0`, call `fseek(file, width * off, whence)`, otherwise call
 `fseek(file, 0, whence)`.
 *Remarks:* “The last operation was output” means either the last virtual
 operation was overflow or the put buffer is non-empty. “Write any
 unshift sequence” means, if `width` if less than zero then call
 `a_codecvt.unshift(state, xbuf, xbuf+XSIZE, xbuf_end)` and output the
 resulting unshift sequence. The function determines one of three values
@@ -6034,16 +7086,10 @@ for the argument `whence`, of type `int`, as indicated in
 | ---------------- | ------------------ |
 | `basic_ios::beg` | `SEEK_SET`         |
 | `basic_ios::cur` | `SEEK_CUR`         |
 | `basic_ios::end` | `SEEK_END`         |
-*Returns:* A newly constructed `pos_type` object that stores the
-resultant stream position, if possible. If the positioning operation
-fails, or if the object cannot represent the resultant stream position,
-returns `pos_type(off_type(-1))`.
 ``` cpp
 pos_type seekpos(pos_type sp,
                  ios_base::openmode which
                    = ios_base::in | ios_base::out) override;
 ```
@@ -6093,10 +7139,12 @@ converted according to `loc` until another call of `imbue`.
 characters. This in turn may require the implementation to be able to
 reconstruct the original contents of the file.
 ### Class template `basic_ifstream` <a id="ifstream">[[ifstream]]</a>
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_ifstream : public basic_istream<charT, traits> {
   public:
@@ -6112,18 +7160,19 @@ namespace std {
                             ios_base::openmode mode = ios_base::in);
     explicit basic_ifstream(const filesystem::path::value_type* s,
                             ios_base::openmode mode = ios_base::in);// wide systems only; see [fstream.syn]
     explicit basic_ifstream(const string& s,
                             ios_base::openmode mode = ios_base::in);
- explicit basic_ifstream(const filesystem::path& s,
- ios_base::openmode mode = ios_base::in);
     basic_ifstream(const basic_ifstream&) = delete;
     basic_ifstream(basic_ifstream&& rhs);
-    // [ifstream.assign], assign and swap
     basic_ifstream& operator=(const basic_ifstream&) = delete;
     basic_ifstream& operator=(basic_ifstream&& rhs);
     void swap(basic_ifstream& rhs);
     // [ifstream.members], members
     basic_filebuf<charT, traits>* rdbuf() const;
@@ -6132,17 +7181,14 @@ namespace std {
     void open(const filesystem::path::value_type* s,
               ios_base::openmode mode = ios_base::in);  // wide systems only; see [fstream.syn]
     void open(const string& s, ios_base::openmode mode = ios_base::in);
     void open(const filesystem::path& s, ios_base::openmode mode = ios_base::in);
     void close();
   private:
     basic_filebuf<charT, traits> sb;    // exposition only
   };
-  template<class charT, class traits>
-    void swap(basic_ifstream<charT, traits>& x,
-              basic_ifstream<charT, traits>& y);
 }
 ```
 The class `basic_ifstream<charT, traits>` supports reading from named
 files. It uses a `basic_filebuf<{}charT, traits>` object to control the
@@ -6175,38 +7221,44 @@ with `basic_filebuf<charT, traits>()` [[filebuf.cons]], then calls
 pointer, calls `setstate(failbit)`.
 ``` cpp
 explicit basic_ifstream(const string& s,
                         ios_base::openmode mode = ios_base::in);
-explicit basic_ifstream(const filesystem::path& s,
-                        ios_base::openmode mode = ios_base::in);
 ```
 *Effects:* Equivalent to: `basic_ifstream(s.c_str(), mode)`.
 ``` cpp
 basic_ifstream(basic_ifstream&& rhs);
 ```
 *Effects:* Move constructs the base class, and the contained
 `basic_filebuf`. Then calls
 `basic_istream<charT, traits>::set_rdbuf(addressof(sb))` to install the
 contained `basic_filebuf`.
-#### Assignment and swap <a id="ifstream.assign">[[ifstream.assign]]</a>
 ``` cpp
 void swap(basic_ifstream& rhs);
 ```
 *Effects:* Exchanges the state of `*this` and `rhs` by calling
 `basic_istream<charT, traits>::swap(rhs)` and `sb.swap(rhs.sb)`.
 ``` cpp
 template<class charT, class traits>
-  void swap(basic_ifstream<charT, traits>& x,
-            basic_ifstream<charT, traits>& y);
 ```
 *Effects:* Equivalent to: `x.swap(y)`.
 #### Member functions <a id="ifstream.members">[[ifstream.members]]</a>
@@ -6249,10 +7301,12 @@ void close();
 pointer, calls `setstate(failbit)` (which may throw
 `ios_base::failure`) [[iostate.flags]].
 ### Class template `basic_ofstream` <a id="ofstream">[[ofstream]]</a>
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_ofstream : public basic_ostream<charT, traits> {
   public:
@@ -6268,18 +7322,19 @@ namespace std {
                             ios_base::openmode mode = ios_base::out);
     explicit basic_ofstream(const filesystem::path::value_type* s,  // wide systems only; see [fstream.syn]
                             ios_base::openmode mode = ios_base::out);
     explicit basic_ofstream(const string& s,
                             ios_base::openmode mode = ios_base::out);
- explicit basic_ofstream(const filesystem::path& s,
- ios_base::openmode mode = ios_base::out);
     basic_ofstream(const basic_ofstream&) = delete;
     basic_ofstream(basic_ofstream&& rhs);
-    // [ofstream.assign], assign and swap
     basic_ofstream& operator=(const basic_ofstream&) = delete;
     basic_ofstream& operator=(basic_ofstream&& rhs);
     void swap(basic_ofstream& rhs);
     // [ofstream.members], members
     basic_filebuf<charT, traits>* rdbuf() const;
@@ -6288,17 +7343,14 @@ namespace std {
     void open(const filesystem::path::value_type* s,
               ios_base::openmode mode = ios_base::out);     // wide systems only; see [fstream.syn]
     void open(const string& s, ios_base::openmode mode = ios_base::out);
     void open(const filesystem::path& s, ios_base::openmode mode = ios_base::out);
     void close();
   private:
     basic_filebuf<charT, traits> sb;    // exposition only
   };
-  template<class charT, class traits>
-    void swap(basic_ofstream<charT, traits>& x,
-              basic_ofstream<charT, traits>& y);
 }
 ```
 The class `basic_ofstream<charT, traits>` supports writing to named
 files. It uses a `basic_filebuf<{}charT, traits>` object to control the
@@ -6331,38 +7383,44 @@ with `basic_filebuf<charT, traits>()` [[filebuf.cons]], then calls
 null pointer, calls `setstate(failbit)`.
 ``` cpp
 explicit basic_ofstream(const string& s,
                         ios_base::openmode mode = ios_base::out);
-explicit basic_ofstream(const filesystem::path& s,
-                        ios_base::openmode mode = ios_base::out);
 ```
 *Effects:* Equivalent to: `basic_ofstream(s.c_str(), mode)`.
 ``` cpp
 basic_ofstream(basic_ofstream&& rhs);
 ```
 *Effects:* Move constructs the base class, and the contained
 `basic_filebuf`. Then calls
 `basic_ostream<charT, traits>::set_rdbuf(addressof(sb))` to install the
 contained `basic_filebuf`.
-#### Assignment and swap <a id="ofstream.assign">[[ofstream.assign]]</a>
 ``` cpp
 void swap(basic_ofstream& rhs);
 ```
 *Effects:* Exchanges the state of `*this` and `rhs` by calling
 `basic_ostream<charT, traits>::swap(rhs)` and `sb.swap(rhs.sb)`.
 ``` cpp
 template<class charT, class traits>
-  void swap(basic_ofstream<charT, traits>& x,
-            basic_ofstream<charT, traits>& y);
 ```
 *Effects:* Equivalent to: `x.swap(y)`.
 #### Member functions <a id="ofstream.members">[[ofstream.members]]</a>
@@ -6405,10 +7463,12 @@ void open(const filesystem::path& s, ios_base::openmode mode = ios_base::out);
 *Effects:* Calls `open(s.c_str(), mode)`.
 ### Class template `basic_fstream` <a id="fstream">[[fstream]]</a>
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_fstream : public basic_iostream<charT, traits> {
   public:
@@ -6427,19 +7487,19 @@ namespace std {
       const filesystem::path::value_type* s,
       ios_base::openmode mode = ios_base::in|ios_base::out);    // wide systems only; see [fstream.syn]
     explicit basic_fstream(
       const string& s,
       ios_base::openmode mode = ios_base::in | ios_base::out);
- explicit basic_fstream(
-      const filesystem::path& s,
-      ios_base::openmode mode = ios_base::in | ios_base::out);
     basic_fstream(const basic_fstream&) = delete;
     basic_fstream(basic_fstream&& rhs);
-    // [fstream.assign], assign and swap
     basic_fstream& operator=(const basic_fstream&) = delete;
     basic_fstream& operator=(basic_fstream&& rhs);
     void swap(basic_fstream& rhs);
     // [fstream.members], members
     basic_filebuf<charT, traits>* rdbuf() const;
     bool is_open() const;
@@ -6458,14 +7518,10 @@ namespace std {
     void close();
   private:
     basic_filebuf<charT, traits> sb;    // exposition only
   };
-  template<class charT, class traits>
-    void swap(basic_fstream<charT, traits>& x,
-              basic_fstream<charT, traits>& y);
 }
 ```
 The class template `basic_fstream<charT, traits>` supports reading and
 writing from named files. It uses a `basic_filebuf<charT, traits>`
@@ -6501,27 +7557,33 @@ explicit basic_fstream(
 ``` cpp
 explicit basic_fstream(
   const string& s,
   ios_base::openmode mode = ios_base::in | ios_base::out);
-explicit basic_fstream(
-  const filesystem::path& s,
-  ios_base::openmode mode = ios_base::in | ios_base::out);
 ```
 *Effects:* Equivalent to: `basic_fstream(s.c_str(), mode)`.
 ``` cpp
 basic_fstream(basic_fstream&& rhs);
 ```
 *Effects:* Move constructs the base class, and the contained
 `basic_filebuf`. Then calls
 `basic_istream<charT, traits>::set_rdbuf(addressof(sb))` to install the
 contained `basic_filebuf`.
-#### Assignment and swap <a id="fstream.assign">[[fstream.assign]]</a>
 ``` cpp
 void swap(basic_fstream& rhs);
 ```
@@ -6592,10 +7654,15 @@ pointer, calls `setstate(failbit)` (which may throw
 namespace std {
   template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
     class basic_syncbuf;
   using syncbuf = basic_syncbuf<char>;
   using wsyncbuf = basic_syncbuf<wchar_t>;
   template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
     class basic_osyncstream;
@@ -6651,15 +7718,10 @@ namespace std {
   private:
     streambuf_type* wrapped;    // exposition only
     bool emit_on_sync{};        // exposition only
   };
-  // [syncstream.syncbuf.special], specialized algorithms
-  template<class charT, class traits, class Allocator>
-    void swap(basic_syncbuf<charT, traits, Allocator>&,
-              basic_syncbuf<charT, traits, Allocator>&);
 }
 ```
 Class template `basic_syncbuf` stores character data written to it,
 known as the associated output, into internal buffers allocated using
@@ -6675,28 +7737,27 @@ wrapped stream buffer object.
 basic_syncbuf(streambuf_type* obuf, const Allocator& allocator);
 ```
 *Effects:* Sets `wrapped` to `obuf`.
-*Remarks:* A copy of `allocator` is used to allocate memory for internal
-buffers holding the associated output.
-*Throws:* Nothing unless an exception is thrown by the construction of a
-mutex or by memory allocation.
 *Ensures:* `get_wrapped() == obuf` and `get_allocator() == allocator`
 are `true`.
 ``` cpp
 basic_syncbuf(basic_syncbuf&& other);
 ```
 *Ensures:* The value returned by `this->get_wrapped()` is the value
 returned by `other.get_wrapped()` prior to calling this constructor.
 Output stored in `other` prior to calling this constructor will be
-stored in `*this` afterwards.
-`other.rdbuf()->pbase() == other.rdbuf()->pptr()` and
 `other.get_wrapped() == nullptr` are `true`.
 *Remarks:* This constructor disassociates `other` from its wrapped
 stream buffer, ensuring destruction of `other` produces no output.
@@ -6710,34 +7771,34 @@ stream buffer, ensuring destruction of `other` produces no output.
 destructor catches and ignores that exception.
 #### Assignment and swap <a id="syncstream.syncbuf.assign">[[syncstream.syncbuf.assign]]</a>
 ``` cpp
-basic_syncbuf& operator=(basic_syncbuf&& rhs) noexcept;
 ```
 *Effects:* Calls `emit()` then move assigns from `rhs`. After the move
 assignment `*this` has the observable state it would have had if it had
 been move constructed from `rhs` [[syncstream.syncbuf.cons]].
-*Returns:* `*this`.
 *Ensures:*
 - `rhs.get_wrapped() == nullptr` is `true`.
 - `this->get_allocator() == rhs.get_allocator()` is `true` when
   ``` cpp
   allocator_traits<Allocator>::propagate_on_container_move_assignment::value
   ```
   is `true`; otherwise, the allocator is unchanged.
 *Remarks:* This assignment operator disassociates `rhs` from its wrapped
 stream buffer, ensuring destruction of `rhs` produces no output.
 ``` cpp
-void swap(basic_syncbuf& other) noexcept;
 ```
 *Preconditions:* Either
 `allocator_traits<Allocator>::propagate_on_container_swap::value` is
 `true` or `this->get_allocator() == other.get_allocator()` is `true`.
@@ -6754,25 +7815,25 @@ bool emit();
 stream buffer `*wrapped`, so that it appears in the output stream as a
 contiguous sequence of characters. `wrapped->pubsync()` is called if and
 only if a call was made to `sync()` since the most recent call to
 `emit()`, if any.
 *Returns:* `true` if all of the following conditions hold; otherwise
 `false`:
 - `wrapped == nullptr` is `false`.
 - All of the characters in the associated output were successfully
   transferred.
 - The call to `wrapped->pubsync()` (if any) succeeded.
-*Ensures:* On success, the associated output is empty.
-*Synchronization:* All `emit()` calls transferring characters to the
-same stream buffer object appear to execute in a total order consistent
-with the “happens before” relation [[intro.races]], where each `emit()`
-call synchronizes with subsequent `emit()` calls in that total order.
 *Remarks:* May call member functions of `wrapped` while holding a lock
 uniquely associated with `wrapped`.
 ``` cpp
 streambuf_type* get_wrapped() const noexcept;
@@ -6811,11 +7872,11 @@ otherwise `0`.
 #### Specialized algorithms <a id="syncstream.syncbuf.special">[[syncstream.syncbuf.special]]</a>
 ``` cpp
 template<class charT, class traits, class Allocator>
   void swap(basic_syncbuf<charT, traits, Allocator>& a,
-            basic_syncbuf<charT, traits, Allocator>& b) noexcept;
 ```
 *Effects:* Equivalent to `a.swap(b)`.
 ### Class template `basic_osyncstream` <a id="syncstream.osyncstream">[[syncstream.osyncstream]]</a>
@@ -6847,11 +7908,11 @@ namespace std {
       : basic_osyncstream(os, Allocator()) {}
     basic_osyncstream(basic_osyncstream&&) noexcept;
     ~basic_osyncstream();
     // assignment
-    basic_osyncstream& operator=(basic_osyncstream&&) noexcept;
     // [syncstream.osyncstream.members], member functions
     void emit();
     streambuf_type* get_wrapped() const noexcept;
     syncbuf_type* rdbuf() const noexcept { return const_cast<syncbuf_type*>(addressof(sb)); }
@@ -6860,12 +7921,12 @@ namespace std {
     syncbuf_type sb;    // exposition only
   };
 }
 ```
-`Allocator` shall meet the *Cpp17Allocator* requirements (
-[[cpp17.allocator]]).
 [*Example 1*:
 A named variable can be used within a block statement for streaming.
@@ -6900,13 +7961,13 @@ basic_osyncstream(streambuf_type* buf, const Allocator& allocator);
 ```
 *Effects:* Initializes `sb` from `buf` and `allocator`. Initializes the
 base class with `basic_ostream<charT, traits>(addressof(sb))`.
-[*Note 1*: The member functions of the provided stream buffer might be
-called from `emit()` while a lock is held. Care should be taken to
-ensure that this does not result in deadlock. — *end note*]
 *Ensures:* `get_wrapped() == buf` is `true`.
 ``` cpp
 basic_osyncstream(basic_osyncstream&& other) noexcept;
@@ -6915,20 +7976,22 @@ basic_osyncstream(basic_osyncstream&& other) noexcept;
 *Effects:* Move constructs the base class and `sb` from the
 corresponding subobjects of `other`, and calls
 `basic_ostream<charT, traits>::set_rdbuf(addressof(sb))`.
 *Ensures:* The value returned by `get_wrapped()` is the value returned
-by `os.get_wrapped()` prior to calling this constructor.
 `nullptr == other.get_wrapped()` is `true`.
 #### Member functions <a id="syncstream.osyncstream.members">[[syncstream.osyncstream.members]]</a>
 ``` cpp
 void emit();
 ```
-*Effects:* Calls `sb.emit()`. If that call returns `false`, calls
 `setstate(ios_base::badbit)`.
 [*Example 1*:
 A flush on a `basic_osyncstream` does not flush immediately:
@@ -7038,18 +8101,20 @@ can be thought of as a raw pointer to a file. If the file pointed to
 does not exist, the symbolic link is said to be a “dangling” symbolic
 link. — *end note*]
 ### Conformance <a id="fs.conformance">[[fs.conformance]]</a>
 Conformance is specified in terms of behavior. Ideal behavior is not
 always implementable, so the conformance subclauses take that into
 account.
 #### POSIX conformance <a id="fs.conform.9945">[[fs.conform.9945]]</a>
-Some behavior is specified by reference to POSIX [[fs.norm.ref]]. How
-such behavior is actually implemented is unspecified.
 [*Note 1*: This constitutes an “as if” rule allowing implementations to
 call native operating system or other APIs. — *end note*]
 Implementations should provide such behavior as it is defined by POSIX.
@@ -7088,26 +8153,20 @@ system.
 #### File system race behavior <a id="fs.race.behavior">[[fs.race.behavior]]</a>
 A *file system race* is the condition that occurs when multiple threads,
 processes, or computers interleave access and modification of the same
 object within a file system. Behavior is undefined if calls to functions
-provided by subclause  [[fs.race.behavior]] introduce a file system
-race.
 If the possibility of a file system race would make it unreliable for a
 program to test for a precondition before calling a function described
 herein, *Preconditions:* is not specified for the function.
 [*Note 1*: As a design practice, preconditions are not specified when
 it is unreasonable for a program to detect them prior to calling the
 function. — *end note*]
-### Normative references <a id="fs.norm.ref">[[fs.norm.ref]]</a>
-Subclause  [[filesystems]] mentions commercially available operating
-systems for purposes of exposition.[^41]
 ### Requirements <a id="fs.req">[[fs.req]]</a>
 Throughout subclause  [[filesystems]], `char`, `wchar_t`, `char8_t`,
 `char16_t`, and `char32_t` are collectively called *encoded character
 types*.
@@ -7124,17 +8183,11 @@ value type that is one of the encoded character types.
 character set and encoding. Since `signed char` and `unsigned char` have
 no implied character set and encoding, they are not included as
 permitted types. — *end note*]
 Template parameters named `Allocator` shall meet the *Cpp17Allocator*
-requirements ([[cpp17.allocator]]).
-#### Namespaces and headers <a id="fs.req.namespace">[[fs.req.namespace]]</a>
-Unless otherwise specified, references to entities described in
-subclause  [[filesystems]] are assumed to be qualified with
-`::std::filesystem::`.
 ### Header `<filesystem>` synopsis <a id="fs.filesystem.syn">[[fs.filesystem.syn]]</a>
 ``` cpp
 #include <compare>              // see [compare.syn]
@@ -7156,18 +8209,18 @@ namespace std::filesystem {
   // [fs.class.directory.iterator], directory iterators
   class directory_iterator;
   // [fs.dir.itr.nonmembers], range access for directory iterators
   directory_iterator begin(directory_iterator iter) noexcept;
-  directory_iterator end(const directory_iterator&) noexcept;
   // [fs.class.rec.dir.itr], recursive directory iterators
   class recursive_directory_iterator;
   // [fs.rec.dir.itr.nonmembers], range access for recursive directory iterators
   recursive_directory_iterator begin(recursive_directory_iterator iter) noexcept;
-  recursive_directory_iterator end(const recursive_directory_iterator&) noexcept;
   // [fs.class.file.status], file status
   class file_status;
   struct space_info {
@@ -7333,10 +8386,28 @@ namespace std::filesystem {
   path temp_directory_path(error_code& ec);
   path weakly_canonical(const path& p);
   path weakly_canonical(const path& p, error_code& ec);
 }
 ```
 Implementations should ensure that the resolution and range of
 `file_time_type` reflect the operating system dependent resolution and
 range of file time values.
@@ -7387,10 +8458,12 @@ follows, unless otherwise specified:
   appropriate for the specific operating system dependent error.
   Otherwise, `clear()` is called on the `error_code&` argument.
 ### Class `path` <a id="fs.class.path">[[fs.class.path]]</a>
 An object of class `path` represents a path and contains a pathname.
 Such an object is concerned only with the lexical and syntactic aspects
 of a path. The path does not necessarily exist in external storage, and
 the pathname is not necessarily valid for the current operating system
 or for a particular file system.
@@ -7412,22 +8485,22 @@ elements of a path that determine if it is absolute are operating system
 dependent. A *relative path* is a path that is not absolute, and as
 such, only unambiguously identifies the location of a file when resolved
 relative to an implied starting location. The elements of a path that
 determine if it is relative are operating system dependent.
-[*Note 2*: Pathnames “.” and “..” are relative paths. — *end note*]
 A *pathname* is a character string that represents the name of a path.
 Pathnames are formatted according to the generic pathname format grammar
 [[fs.path.generic]] or according to an operating system dependent
 *native pathname format* accepted by the host operating system.
 *Pathname resolution* is the operating system dependent mechanism for
 resolving a pathname to a particular file in a file hierarchy. There may
 be multiple pathnames that resolve to the same file.
-[*Example 1*: POSIX specifies the mechanism in section 4.11, Pathname
 resolution. — *end example*]
 ``` cpp
 namespace std::filesystem {
   class path {
@@ -7645,13 +8718,13 @@ consisting solely of one and two period characters respectively, have
 special meaning. The following characteristics of filenames are
 operating system dependent:
 - The permitted characters. \[*Example 1*: Some operating systems
   prohibit the ASCII control characters (0x00 – 0x1F) in
-  filenames. — *end example*] \[*Note 1*: For wide portability, users
- may wish to limit *filename* characters to the POSIX Portable Filename
-  Character Set:
   `A B C D E F G H I J K L M N O P Q R S T U V W X Y Z`
   `a b c d e f g h i j k l m n o p q r s t u v w x y z`
   `0 1 2 3 4 5 6 7 8 9 . _ -` — *end note*]
 - The maximum permitted length.
 - Filenames that are not permitted.
@@ -7676,11 +8749,11 @@ A *root-name* identifies the starting location for pathname resolution
 required.
 [*Note 2*: Many operating systems define a name beginning with two
 *directory-separator* characters as a *root-name* that identifies
 network or other resource locations. Some operating systems define a
-single letter followed by a colon as a drive specifier – a *root-name*
 identifying a specific device such as a disk drive. — *end note*]
 If a *root-name* is otherwise ambiguous, the possibility with the
 longest sequence of characters is chosen.
@@ -7692,11 +8765,11 @@ longest sequence of characters is chosen.
 1.  If the path is empty, stop.
 2.  Replace each slash character in the *root-name* with a
     *preferred-separator*.
 3.  Replace each *directory-separator* with a *preferred-separator*.
-    \[*Note 4*: The generic pathname grammar [[fs.path.generic]] defines
     *directory-separator* as one or more slashes and
     *preferred-separator*s. — *end note*]
 4.  Remove each dot filename and any immediately following
     *directory-separator*.
 5.  As long as any appear, remove a non-dot-dot filename immediately
@@ -7736,11 +8809,11 @@ path using either a pathname in the generic format [[fs.path.generic]]
 or a pathname in the native format [[fs.class.path]]. Such an argument
 is taken to be in the generic format if and only if it matches the
 generic format and is not acceptable to the operating system as a native
 path.
-[*Note 2*: Some operating systems may have no unambiguous way to
 distinguish between native format and generic format arguments. This is
 by design as it simplifies use for operating systems that do not require
 disambiguation. An implementation for an operating system where
 disambiguation is required is permitted to distinguish between the
 formats. — *end note*]
@@ -7759,11 +8832,11 @@ differently from paths for directories, the path shall be treated as a
 directory path if its last element is a *directory-separator*, otherwise
 it shall be treated as a path to a regular file.
 [*Note 4*: A path stores a native format pathname
 [[fs.path.native.obs]] and acts as if it also stores a generic format
-pathname, related as given below. The implementation may generate the
 generic format pathname based on the native format pathname (and
 possibly other information) when requested. — *end note*]
 When a path is constructed from or is assigned a single representation
 separate from any path, the other representation is selected by the
@@ -7781,11 +8854,11 @@ the result of converting *p*. — *end note*]
 The *native encoding* of an ordinary character string is the operating
 system dependent current encoding for pathnames [[fs.class.path]]. The
 *native encoding* for wide character strings is the
 implementation-defined execution wide-character set encoding
-[[lex.charset]].
 For member function arguments that take character sequences representing
 paths and for member functions returning strings, value type and
 encoding conversion is performed if the value type of the argument or
 return value differs from `path::value_type`. For the argument or return
@@ -7799,12 +8872,12 @@ determined by its value type:
   return values is performed. For Windows-based operating systems, the
   native ordinary encoding is determined by calling a Windows API
   function. — *end note*] \[*Note 7*: This results in behavior
   identical to other C and C++ standard library functions that perform
   file operations using ordinary character strings to identify paths.
-  Changing this behavior would be surprising and error
-  prone. — *end note*]
 - `wchar_t`: The encoding is the native wide encoding. The method of
   conversion is unspecified. \[*Note 8*: For Windows-based operating
   systems `path::value_type` is `wchar_t` so no conversion from
   `wchar_t` value type arguments or to `wchar_t` value type return
   values is performed. — *end note*]
@@ -7848,11 +8921,11 @@ participate in overload resolution unless `Source` denotes a type other
 than `path`, and either
 - `Source` is a specialization of `basic_string` or `basic_string_view`,
   or
 - the *qualified-id* `iterator_traits<decay_t<Source>>::value_type` is
-  valid and denotes a possibly `const` encoded character type
   [[temp.deduct]].
 [*Note 1*: See path conversions [[fs.path.cvt]] for how the value types
 above and their encodings convert to `path::value_type` and its
 encoding. — *end note*]
@@ -8087,12 +9160,12 @@ template<class Source>
 ```
 *Effects:* Appends `path(x).native()` to the pathname in the native
 format.
-[*Note 2*: This directly manipulates the value of `native()` and may
-not be portable between operating systems. — *end note*]
 *Returns:* `*this`.
 ``` cpp
 path& operator+=(value_type x);
@@ -8241,14 +9314,10 @@ const value_type* c_str() const noexcept;
 operator string_type() const;
 ```
 *Returns:* `native()`.
-[*Note 3*: Conversion to `string_type` is provided so that an object of
-class `path` can be given as an argument to existing standard library
-file stream constructors and open functions. — *end note*]
 ``` cpp
 template<class EcharT, class traits = char_traits<EcharT>,
          class Allocator = allocator<EcharT>>
   basic_string<EcharT, traits, Allocator>
     string(const Allocator& a = Allocator()) const;
@@ -8448,17 +9517,17 @@ path(".bar").extension();               // yields "" and stem() is ".bar"
 path("..bar").extension();              // yields ".bar" and stem() is "."
 ```
 — *end example*]
-[*Note 4*: The period is included in the return value so that it is
 possible to distinguish between no extension and an empty
 extension. — *end note*]
-[*Note 5*: On non-POSIX operating systems, for a path `p`, it may not
-be the case that `p.stem() + p.extension() == p.filename()`, even though
-the generic format pathnames are the same. — *end note*]
 ##### Query <a id="fs.path.query">[[fs.path.query]]</a>
 ``` cpp
 [[nodiscard]] bool empty() const noexcept;
@@ -8557,25 +9626,21 @@ slashes, but that does not affect `path` equality.
 ``` cpp
 path lexically_relative(const path& base) const;
 ```
-*Returns:* `*this` made relative to `base`. Does not
-resolve [[fs.class.path]] symlinks. Does not first
-normalize [[fs.path.generic]] `*this` or `base`.
 *Effects:* If:
 - `root_name() != base.root_name()` is `true`, or
 - `is_absolute() != base.is_absolute()` is `true`, or
 - `!has_root_directory() && base.has_root_directory()` is `true`, or
 - any *filename* in `relative_path()` or `base.relative_path()` can be
   interpreted as a *root-name*,
 returns `path()`.
-[*Note 6*: On a POSIX implementation, no *filename* in a
 *relative-path* is acceptable as a *root-name*. — *end note*]
 Determines the first mismatched element of `*this` and `base` as if by:
 ``` cpp
@@ -8593,10 +9658,14 @@ Then,
 - returns an object of class `path` that is default-constructed,
   followed by
   - application of `operator/=(path(".."))` `n` times, and then
   - application of `operator/=` for each element in \[`a`, `end()`).
 [*Example 11*:
 ``` cpp
 assert(path("/a/d").lexically_relative("/a/b/c") == "../../d");
 assert(path("/a/b/c").lexically_relative("/a/d") == "../b/c");
@@ -8610,28 +9679,28 @@ The above assertions will succeed. On Windows, the returned path’s
 *directory-separator* characters will be backslashes rather than
 slashes, but that does not affect `path` equality.
 — *end example*]
-[*Note 7*: If symlink following semantics are desired, use the
 operational function `relative()`. — *end note*]
-[*Note 8*: If normalization [[fs.path.generic]] is needed to ensure
 consistent matching of elements, apply `lexically_normal()` to `*this`,
 `base`, or both. — *end note*]
 ``` cpp
 path lexically_proximate(const path& base) const;
 ```
 *Returns:* If the value of `lexically_relative(base)` is not an empty
 path, return it. Otherwise return `*this`.
-[*Note 9*: If symlink following semantics are desired, use the
 operational function `proximate()`. — *end note*]
-[*Note 10*: If normalization [[fs.path.generic]] is needed to ensure
 consistent matching of elements, apply `lexically_normal()` to `*this`,
 `base`, or both. — *end note*]
 #### Iterators <a id="fs.path.itr">[[fs.path.itr]]</a>
@@ -8736,14 +9805,10 @@ Path equality and path equivalence have different semantics.
 - Equivalence is determined by the `equivalent()` non-member function,
   which determines if two paths resolve [[fs.class.path]] to the same
   file system entity. \[*Example 2*: `equivalent("foo", "bar")` will be
   `true` when both paths resolve to the same file. — *end example*]
-Programmers wishing to determine if two paths are “the same” must decide
-if “the same” means “the same representation” or “resolve to the same
-actual file”, and choose the appropriate function accordingly.
 — *end note*]
 ``` cpp
 friend strong_ordering operator<=>(const path& lhs, const path& rhs) noexcept;
 ```
@@ -8754,12 +9819,24 @@ friend strong_ordering operator<=>(const path& lhs, const path& rhs) noexcept;
 friend path operator/(const path& lhs, const path& rhs);
 ```
 *Effects:* Equivalent to: `return path(lhs) /= rhs;`
 ### Class `filesystem_error` <a id="fs.class.filesystem.error">[[fs.class.filesystem.error]]</a>
 ``` cpp
 namespace std::filesystem {
   class filesystem_error : public system_error {
   public:
     filesystem_error(const string& what_arg, error_code ec);
@@ -8845,22 +9922,41 @@ and `path2` in the native format in the returned string.
 #### Enum `path::format` <a id="fs.enum.path.format">[[fs.enum.path.format]]</a>
 This enum specifies constants used to identify the format of the
 character sequence, with the meanings listed in [[fs.enum.path.format]].
-[*Note 1*: For POSIX-based systems, native and generic formats are
-equivalent and the character sequence should always be interpreted in
-the same way. — *end note*]
 #### Enum class `file_type` <a id="fs.enum.file.type">[[fs.enum.file.type]]</a>
 This enum class specifies constants used to identify file types, with
 the meanings listed in [[fs.enum.file.type]]. The values of the
 constants are distinct.
-[*Note 1*: The file not being found is not considered an error while
-determining the type of a file. — *end note*]
 #### Enum class `copy_options` <a id="fs.enum.copy.opts">[[fs.enum.copy.opts]]</a>
 The `enum class` type `copy_options` is a bitmask type [[bitmask.types]]
 that specifies bitmask constants used to control the semantics of copy
@@ -8871,16 +9967,16 @@ exposition; implementations shall provide only a single definition.
 Every other constant in the table represents a distinct bitmask element.
 **Table: Enum class `copy_options`** <a id="fs.enum.copy.opts">[fs.enum.copy.opts]</a>
 | Constant             | Meaning                                                                                                                                              |
-| -------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `none`               | (Default) Error; file already exists.                                                                                                                |
 | `skip_existing`      | Do not overwrite existing file, do not report an error.                                                                                              |
 | `overwrite_existing` | Overwrite the existing file.                                                                                                                         |
-| `update_existing`    | Overwrite the existing file if it is older than the replacement file. \ohdrx{2}{Option group controlling `copy` function effects for sub-directories} |
-| `recursive`          | Recursively copy sub-directories and their contents. \ohdrx{2}{Option group controlling `copy` function effects for symbolic links}                   |
 | `copy_symlinks`      | Copy symbolic links as symbolic links rather than copying the files that they point to.                                                              |
 | `skip_symlinks`      | Ignore symbolic links. \ohdrx{2}{Option group controlling `copy` function effects for choosing the form of copying}                                  |
 | `directories_only`   | Copy directory structure only, do not copy non-directory files.                                                                                      |
 | `create_symlinks`    | Make symbolic links instead of copies of files. The source path shall be an absolute path unless the destination path is in the current directory.   |
 | `create_hard_links`  | Make hard links instead of copies of files.                                                                                                          |
@@ -8929,12 +10025,12 @@ permissions operations, with the meanings listed in
 **Table: Enum class `perm_options`** <a id="fs.enum.perm.opts">[fs.enum.perm.opts]</a>
 | Name       | Meaning                                                                                                                                                 |
 | ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `replace`  | `permissions` shall replace the file's permission bits with `perm`                                                                                      |
-| `add`      | `permissions` shall replace the file's permission bits with the bitwise \logop{OR} of `perm` and the file's current permission bits.                    |
-| `remove`   | `permissions` shall replace the file's permission bits with the bitwise \logop{AND} of the complement of `perm` and the file's current permission bits. |
 | `nofollow` | `permissions` shall change the permissions of a symbolic link itself rather than the permissions of the file the link resolves to.                      |
 #### Enum class `directory_options` <a id="fs.enum.dir.opts">[[fs.enum.dir.opts]]</a>
@@ -8953,10 +10049,12 @@ every other constant in the table represents a distinct bitmask element.
 | `skip_permission_denied`   | Skip directories that would otherwise result in permission denied. |
 ### Class `file_status` <a id="fs.class.file.status">[[fs.class.file.status]]</a>
 ``` cpp
 namespace std::filesystem {
   class file_status {
   public:
     // [fs.file.status.cons], constructors and destructor
@@ -9025,10 +10123,12 @@ void permissions(perms prms) noexcept;
 *Ensures:* `permissions() == prms`.
 ### Class `directory_entry` <a id="fs.class.directory.entry">[[fs.class.directory.entry]]</a>
 ``` cpp
 namespace std::filesystem {
   class directory_entry {
   public:
     // [fs.dir.entry.cons], constructors and destructor
@@ -9084,10 +10184,15 @@ namespace std::filesystem {
     file_status symlink_status(error_code& ec) const noexcept;
     bool operator==(const directory_entry& rhs) const noexcept;
     strong_ordering operator<=>(const directory_entry& rhs) const noexcept;
   private:
     filesystem::path pathobject;        // exposition only
     friend class directory_iterator;    // exposition only
   };
 }
@@ -9190,13 +10295,12 @@ unspecified.
 *Throws:* As specified in  [[fs.err.report]].
 [*Note 1*: Implementations of `directory_iterator`
 [[fs.class.directory.iterator]] are prohibited from directly or
-indirectly calling the `refresh` function since it must access the
-external file system, and the objective of caching is to avoid
-unnecessary file system accesses. — *end note*]
 #### Observers <a id="fs.dir.entry.obs">[[fs.dir.entry.obs]]</a>
 Unqualified function names in the *Returns:* elements of the
 `directory_entry` observers described below refer to members of the
@@ -9361,18 +10465,30 @@ bool operator==(const directory_entry& rhs) const noexcept;
 strong_ordering operator<=>(const directory_entry& rhs) const noexcept;
 ```
 *Returns:* `pathobject <=> rhs.pathobject`.
 ### Class `directory_iterator` <a id="fs.class.directory.iterator">[[fs.class.directory.iterator]]</a>
 An object of type `directory_iterator` provides an iterator for a
 sequence of `directory_entry` elements representing the path and any
 cached attribute values [[fs.class.directory.entry]] for each file in a
 directory or in an *implementation-defined* directory-like file type.
-[*Note 1*: For iteration into sub-directories, see class
 `recursive_directory_iterator` [[fs.class.rec.dir.itr]]. — *end note*]
 ``` cpp
 namespace std::filesystem {
   class directory_iterator {
@@ -9400,10 +10516,14 @@ namespace std::filesystem {
     const directory_entry& operator*() const;
     const directory_entry* operator->() const;
     directory_iterator&    operator++();
     directory_iterator&    increment(error_code& ec);
     // other members as required by [input.iterators], input iterators
   };
 }
 ```
@@ -9422,12 +10542,12 @@ Two end iterators are always equal. An end iterator shall not be equal
 to a non-end iterator.
 The result of calling the `path()` member of the `directory_entry`
 object obtained by dereferencing a `directory_iterator` is a reference
 to a `path` object composed of the directory argument from which the
-iterator was constructed with filename of the directory entry appended
-as if by `operator/=`.
 Directory iteration shall not yield directory entries for the current
 (dot) and parent (dot-dot) directories.
 The order of directory entries obtained by dereferencing successive
@@ -9442,21 +10562,21 @@ call any `directory_entry` `refresh` function.
 [*Note 2*: The exact mechanism for storing cached attribute values is
 not exposed to users. For exposition, class `directory_iterator` is
 shown in [[fs.class.directory.entry]] as a friend of class
 `directory_entry`. — *end note*]
-[*Note 3*: Programs performing directory iteration may wish to test if
-the path obtained by dereferencing a directory iterator actually exists.
-It could be a symbolic link to a non-existent file. Programs recursively
-walking directory trees for purposes of removing and renaming entries
-may wish to avoid following symbolic links. — *end note*]
 [*Note 4*: If a file is removed from or added to a directory after the
 construction of a `directory_iterator` for the directory, it is
 unspecified whether or not subsequently incrementing the iterator will
 ever result in an iterator referencing the removed or added directory
-entry. See POSIX `readdir_r`. — *end note*]
 #### Members <a id="fs.dir.itr.members">[[fs.dir.itr.members]]</a>
 ``` cpp
 directory_iterator() noexcept;
@@ -9530,21 +10650,23 @@ directory_iterator begin(directory_iterator iter) noexcept;
 ```
 *Returns:* `iter`.
 ``` cpp
-directory_iterator end(const directory_iterator&) noexcept;
 ```
 *Returns:* `directory_iterator()`.
 ### Class `recursive_directory_iterator` <a id="fs.class.rec.dir.itr">[[fs.class.rec.dir.itr]]</a>
 An object of type `recursive_directory_iterator` provides an iterator
 for a sequence of `directory_entry` elements representing the files in a
 directory or in an *implementation-defined* directory-like file type,
-and its sub-directories.
 ``` cpp
 namespace std::filesystem {
   class recursive_directory_iterator {
   public:
@@ -9584,10 +10706,14 @@ namespace std::filesystem {
     void pop();
     void pop(error_code& ec);
     void disable_recursion_pending();
     // other members as required by [input.iterators], input iterators
   };
 }
 ```
@@ -9597,11 +10723,12 @@ results in undefined behavior.
 The behavior of a `recursive_directory_iterator` is the same as a
 `directory_iterator` unless otherwise specified.
 [*Note 1*: If the directory structure being iterated over contains
-cycles then the end iterator may be unreachable. — *end note*]
 #### Members <a id="fs.rec.dir.itr.members">[[fs.rec.dir.itr.members]]</a>
 ``` cpp
 recursive_directory_iterator() noexcept;
@@ -9632,13 +10759,13 @@ error.
 `directory_options` argument, otherwise
 `options() == directory_options::none`.
 *Throws:* As specified in  [[fs.err.report]].
-[*Note 1*: To iterate over the current directory, use
-`recursive_directory_iterator(".")` rather than
-`recursive_directory_iterator("")`. — *end note*]
 [*Note 2*: By default, `recursive_directory_iterator` does not follow
 directory symlinks. To follow directory symlinks, specify `options` as
 `directory_options::follow_directory_symlink`. — *end note*]
@@ -9775,40 +10902,42 @@ void disable_recursion_pending();
 recursion into a directory. — *end note*]
 #### Non-member functions <a id="fs.rec.dir.itr.nonmembers">[[fs.rec.dir.itr.nonmembers]]</a>
 These functions enable use of `recursive_directory_iterator` with
-range-based for statements.
 ``` cpp
 recursive_directory_iterator begin(recursive_directory_iterator iter) noexcept;
 ```
 *Returns:* `iter`.
 ``` cpp
-recursive_directory_iterator end(const recursive_directory_iterator&) noexcept;
 ```
 *Returns:* `recursive_directory_iterator()`.
 ### Filesystem operation functions <a id="fs.op.funcs">[[fs.op.funcs]]</a>
 Filesystem operation functions query or modify files, including
 directories, in external storage.
 [*Note 1*: Because hardware failures, network failures, file system
 races [[fs.race.behavior]], and many other kinds of errors occur
-frequently in file system operations, users should be aware that any
-filesystem operation function, no matter how apparently innocuous, may
-encounter an error; see  [[fs.err.report]]. — *end note*]
 #### Absolute <a id="fs.op.absolute">[[fs.op.absolute]]</a>
 ``` cpp
-path absolute(const path& p);
-path absolute(const path& p, error_code& ec);
 ```
 *Effects:* Composes an absolute path referencing the same file system
 location as `p` according to the operating system [[fs.conform.os]].
@@ -9818,12 +10947,12 @@ location as `p` according to the operating system [[fs.conform.os]].
 [*Note 1*: For the returned path, `rp`, `rp.is_absolute()` is `true`
 unless an error occurs. — *end note*]
 *Throws:* As specified in  [[fs.err.report]].
-[*Note 2*: To resolve symlinks, or perform other sanitization which
-might require queries to secondary storage, such as hard disks, consider
 `canonical` [[fs.op.canonical]]. — *end note*]
 [*Note 3*: Implementations are strongly encouraged to not query
 secondary storage, and not consider `!exists(p)` an
 error. — *end note*]
@@ -9834,12 +10963,12 @@ simply `current_path()/p`. For Windows-based operating systems,
 `GetFullPathNameW`. — *end example*]
 #### Canonical <a id="fs.op.canonical">[[fs.op.canonical]]</a>
 ``` cpp
-path canonical(const path& p);
-path canonical(const path& p, error_code& ec);
 ```
 *Effects:* Converts `p` to an absolute path that has no symbolic link,
 dot, or dot-dot elements in its pathname in the generic format.
@@ -9852,24 +10981,24 @@ error occurs.
 *Remarks:* `!exists(p)` is an error.
 #### Copy <a id="fs.op.copy">[[fs.op.copy]]</a>
 ``` cpp
-void copy(const path& from, const path& to);
 ```
 *Effects:* Equivalent to `copy(from, to, copy_options::none)`.
 ``` cpp
-void copy(const path& from, const path& to, error_code& ec);
 ```
 *Effects:* Equivalent to `copy(from, to, copy_options::none, ec)`.
 ``` cpp
-void copy(const path& from, const path& to, copy_options options);
-void copy(const path& from, const path& to, copy_options options,
           error_code& ec);
 ```
 *Preconditions:* At most one element from each option
 group [[fs.enum.copy.opts]] is set in `options`.
@@ -10006,22 +11135,22 @@ would result in:
 — *end example*]
 #### Copy file <a id="fs.op.copy.file">[[fs.op.copy.file]]</a>
 ``` cpp
-bool copy_file(const path& from, const path& to);
-bool copy_file(const path& from, const path& to, error_code& ec);
 ```
 *Returns:* `copy_file(from, to, copy_options::none)` or
 `copy_file(from, to, copy_options::none, ec)`, respectively.
 *Throws:* As specified in  [[fs.err.report]].
 ``` cpp
-bool copy_file(const path& from, const path& to, copy_options options);
-bool copy_file(const path& from, const path& to, copy_options options,
                error_code& ec);
 ```
 *Preconditions:* At most one element from each option
 group [[fs.enum.copy.opts]] is set in `options`.
@@ -10056,12 +11185,12 @@ signature with argument `ec` returns `false` if an error occurs.
 *Complexity:* At most one direct or indirect invocation of `status(to)`.
 #### Copy symlink <a id="fs.op.copy.symlink">[[fs.op.copy.symlink]]</a>
 ``` cpp
-void copy_symlink(const path& existing_symlink, const path& new_symlink);
-void copy_symlink(const path& existing_symlink, const path& new_symlink,
                   error_code& ec) noexcept;
 ```
 *Effects:* Equivalent to
 *`function`*`(read_symlink(existing_symlink), new_symlink)` or
@@ -10072,12 +11201,12 @@ respectively, where in each case *`function`* is `create_symlink` or
 *Throws:* As specified in  [[fs.err.report]].
 #### Create directories <a id="fs.op.create.directories">[[fs.op.create.directories]]</a>
 ``` cpp
-bool create_directories(const path& p);
-bool create_directories(const path& p, error_code& ec);
 ```
 *Effects:* Calls `create_directory()` for each element of `p` that does
 not exist.
@@ -10089,12 +11218,12 @@ resolves to, otherwise `false`.
 *Complexity:* 𝑂(n) where *n* is the number of elements of `p`.
 #### Create directory <a id="fs.op.create.directory">[[fs.op.create.directory]]</a>
 ``` cpp
-bool create_directory(const path& p);
-bool create_directory(const path& p, error_code& ec) noexcept;
 ```
 *Effects:* Creates the directory `p` resolves to, as if by POSIX `mkdir`
 with a second argument of `static_cast<int>(perms::all)`. If `mkdir`
 fails because `p` resolves to an existing directory, no error is
@@ -10103,12 +11232,12 @@ reported. Otherwise on failure an error is reported.
 *Returns:* `true` if a new directory was created, otherwise `false`.
 *Throws:* As specified in  [[fs.err.report]].
 ``` cpp
-bool create_directory(const path& p, const path& existing_p);
-bool create_directory(const path& p, const path& existing_p, error_code& ec) noexcept;
 ```
 *Effects:* Creates the directory `p` resolves to, with attributes copied
 from directory `existing_p`. The set of attributes copied is operating
 system dependent. If `mkdir` fails because `p` resolves to an existing
@@ -10128,12 +11257,12 @@ from directory `existing_p`, otherwise `false`.
 *Throws:* As specified in  [[fs.err.report]].
 #### Create directory symlink <a id="fs.op.create.dir.symlk">[[fs.op.create.dir.symlk]]</a>
 ``` cpp
-void create_directory_symlink(const path& to, const path& new_symlink);
-void create_directory_symlink(const path& to, const path& new_symlink,
                               error_code& ec) noexcept;
 ```
 *Effects:* Establishes the postcondition, as if by POSIX `symlink()`.
@@ -10141,24 +11270,24 @@ void create_directory_symlink(const path& to, const path& new_symlink,
 an unspecified representation of `to`.
 *Throws:* As specified in  [[fs.err.report]].
 [*Note 1*: Some operating systems require symlink creation to identify
-that the link is to a directory. Portable code should use
-`create_directory_symlink()` to create directory symlinks rather than
-`create_symlink()` — *end note*]
 [*Note 2*: Some operating systems do not support symbolic links at all
 or support them only for regular files. Some file systems (such as the
 FAT file system) do not support symbolic links regardless of the
 operating system. — *end note*]
 #### Create hard link <a id="fs.op.create.hard.lk">[[fs.op.create.hard.lk]]</a>
 ``` cpp
-void create_hard_link(const path& to, const path& new_hard_link);
-void create_hard_link(const path& to, const path& new_hard_link,
                                       error_code& ec) noexcept;
 ```
 *Effects:* Establishes the postcondition, as if by POSIX `link()`.
@@ -10176,12 +11305,12 @@ system. Some file systems limit the number of links per
 file. — *end note*]
 #### Create symlink <a id="fs.op.create.symlink">[[fs.op.create.symlink]]</a>
 ``` cpp
-void create_symlink(const path& to, const path& new_symlink);
-void create_symlink(const path& to, const path& new_symlink,
                     error_code& ec) noexcept;
 ```
 *Effects:* Establishes the postcondition, as if by POSIX `symlink()`.
@@ -10196,12 +11325,12 @@ FAT file system) do not support symbolic links regardless of the
 operating system. — *end note*]
 #### Current path <a id="fs.op.current.path">[[fs.op.current.path]]</a>
 ``` cpp
-path current_path();
-path current_path(error_code& ec);
 ```
 *Returns:* The absolute path of the current working directory, whose
 pathname in the native format is obtained as if by POSIX `getcwd()`. The
 signature with argument `ec` returns `path()` if an error occurs.
@@ -10215,61 +11344,61 @@ resolution for relative paths.
 [*Note 1*: The `current_path()` name was chosen to emphasize that the
 returned value is a path, not just a single directory
 name. — *end note*]
 [*Note 2*: The current path as returned by many operating systems is a
-dangerous global variable. It may be changed unexpectedly by third-party
 or system library functions, or by another thread. — *end note*]
 ``` cpp
-void current_path(const path& p);
-void current_path(const path& p, error_code& ec) noexcept;
 ```
 *Effects:* Establishes the postcondition, as if by POSIX `chdir()`.
 *Ensures:* `equivalent(p, current_path())`.
 *Throws:* As specified in  [[fs.err.report]].
 [*Note 3*: The current path for many operating systems is a dangerous
-global state. It may be changed unexpectedly by a third-party or system
 library functions, or by another thread. — *end note*]
 #### Equivalent <a id="fs.op.equivalent">[[fs.op.equivalent]]</a>
 ``` cpp
-bool equivalent(const path& p1, const path& p2);
-bool equivalent(const path& p1, const path& p2, error_code& ec) noexcept;
 ```
-*Returns:* `true`, if `p1` and `p2` resolve to the same file system
-entity, otherwise `false`. The signature with argument `ec` returns
-`false` if an error occurs.
 Two paths are considered to resolve to the same file system entity if
 two candidate entities reside on the same device at the same location.
 [*Note 1*: On POSIX platforms, this is determined as if by the values
 of the POSIX `stat` class, obtained as if by `stat()` for the two paths,
 having equal `st_dev` values and equal `st_ino` values. — *end note*]
 *Remarks:* `!exists(p1) || !exists(p2)` is an error.
-*Throws:* As specified in  [[fs.err.report]].
 #### Exists <a id="fs.op.exists">[[fs.op.exists]]</a>
 ``` cpp
-bool exists(file_status s) noexcept;
 ```
 *Returns:* `status_known(s) && s.type() != file_type::not_found`.
 ``` cpp
-bool exists(const path& p);
-bool exists(const path& p, error_code& ec) noexcept;
 ```
 Let `s` be a `file_status`, determined as if by `status(p)` or
 `status(p, ec)`, respectively.
@@ -10281,12 +11410,12 @@ Let `s` be a `file_status`, determined as if by `status(p)` or
 *Throws:* As specified in  [[fs.err.report]].
 #### File size <a id="fs.op.file.size">[[fs.op.file.size]]</a>
 ``` cpp
-uintmax_t file_size(const path& p);
-uintmax_t file_size(const path& p, error_code& ec) noexcept;
 ```
 *Effects:* If `exists(p)` is `false`, an error is
 reported [[fs.err.report]].
@@ -10303,30 +11432,30 @@ an error occurs.
 *Throws:* As specified in  [[fs.err.report]].
 #### Hard link count <a id="fs.op.hard.lk.ct">[[fs.op.hard.lk.ct]]</a>
 ``` cpp
-uintmax_t hard_link_count(const path& p);
-uintmax_t hard_link_count(const path& p, error_code& ec) noexcept;
 ```
 *Returns:* The number of hard links for `p`. The signature with argument
 `ec` returns `static_cast<uintmax_t>(-1)` if an error occurs.
 *Throws:* As specified in  [[fs.err.report]].
 #### Is block file <a id="fs.op.is.block.file">[[fs.op.is.block.file]]</a>
 ``` cpp
-bool is_block_file(file_status s) noexcept;
 ```
 *Returns:* `s.type() == file_type::block`.
 ``` cpp
-bool is_block_file(const path& p);
-bool is_block_file(const path& p, error_code& ec) noexcept;
 ```
 *Returns:* `is_block_file(status(p))` or `is_block_file(status(p, ec))`,
 respectively. The signature with argument `ec` returns `false` if an
 error occurs.
@@ -10334,18 +11463,18 @@ error occurs.
 *Throws:* As specified in  [[fs.err.report]].
 #### Is character file <a id="fs.op.is.char.file">[[fs.op.is.char.file]]</a>
 ``` cpp
-bool is_character_file(file_status s) noexcept;
 ```
 *Returns:* `s.type() == file_type::character`.
 ``` cpp
-bool is_character_file(const path& p);
-bool is_character_file(const path& p, error_code& ec) noexcept;
 ```
 *Returns:* `is_character_file(status(p))` or
 `is_character_file(status(p, ec))`, respectively.
 The signature with argument `ec` returns `false` if an error occurs.
@@ -10353,18 +11482,18 @@ The signature with argument `ec` returns `false` if an error occurs.
 *Throws:* As specified in  [[fs.err.report]].
 #### Is directory <a id="fs.op.is.directory">[[fs.op.is.directory]]</a>
 ``` cpp
-bool is_directory(file_status s) noexcept;
 ```
 *Returns:* `s.type() == file_type::directory`.
 ``` cpp
-bool is_directory(const path& p);
-bool is_directory(const path& p, error_code& ec) noexcept;
 ```
 *Returns:* `is_directory(status(p))` or `is_directory(status(p, ec))`,
 respectively. The signature with argument `ec` returns `false` if an
 error occurs.
@@ -10372,12 +11501,12 @@ error occurs.
 *Throws:* As specified in  [[fs.err.report]].
 #### Is empty <a id="fs.op.is.empty">[[fs.op.is.empty]]</a>
 ``` cpp
-bool is_empty(const path& p);
-bool is_empty(const path& p, error_code& ec);
 ```
 *Effects:*
 - Determine `file_status s`, as if by `status(p)` or `status(p, ec)`,
@@ -10400,18 +11529,18 @@ bool is_empty(const path& p, error_code& ec);
 *Throws:* As specified in  [[fs.err.report]].
 #### Is fifo <a id="fs.op.is.fifo">[[fs.op.is.fifo]]</a>
 ``` cpp
-bool is_fifo(file_status s) noexcept;
 ```
 *Returns:* `s.type() == file_type::fifo`.
 ``` cpp
-bool is_fifo(const path& p);
-bool is_fifo(const path& p, error_code& ec) noexcept;
 ```
 *Returns:* `is_fifo(status(p))` or `is_fifo(status(p, ec))`,
 respectively. The signature with argument `ec` returns `false` if an
 error occurs.
@@ -10419,19 +11548,19 @@ error occurs.
 *Throws:* As specified in  [[fs.err.report]].
 #### Is other <a id="fs.op.is.other">[[fs.op.is.other]]</a>
 ``` cpp
-bool is_other(file_status s) noexcept;
 ```
 *Returns:*
 `exists(s) && !is_regular_file(s) && !is_directory(s) && !is_symlink(s)`.
 ``` cpp
-bool is_other(const path& p);
-bool is_other(const path& p, error_code& ec) noexcept;
 ```
 *Returns:* `is_other(status(p))` or `is_other(status(p, ec))`,
 respectively. The signature with argument `ec` returns `false` if an
 error occurs.
@@ -10439,26 +11568,26 @@ error occurs.
 *Throws:* As specified in  [[fs.err.report]].
 #### Is regular file <a id="fs.op.is.regular.file">[[fs.op.is.regular.file]]</a>
 ``` cpp
-bool is_regular_file(file_status s) noexcept;
 ```
 *Returns:* `s.type() == file_type::regular`.
 ``` cpp
-bool is_regular_file(const path& p);
 ```
 *Returns:* `is_regular_file(status(p))`.
 *Throws:* `filesystem_error` if `status(p)` would throw
 `filesystem_error`.
 ``` cpp
-bool is_regular_file(const path& p, error_code& ec) noexcept;
 ```
 *Effects:* Sets `ec` as if by `status(p, ec)`.
 [*Note 1*: `file_type::none`, `file_type::not_found` and
@@ -10469,18 +11598,18 @@ between cases, call the `status` function directly. — *end note*]
 occurs.
 #### Is socket <a id="fs.op.is.socket">[[fs.op.is.socket]]</a>
 ``` cpp
-bool is_socket(file_status s) noexcept;
 ```
 *Returns:* `s.type() == file_type::socket`.
 ``` cpp
-bool is_socket(const path& p);
-bool is_socket(const path& p, error_code& ec) noexcept;
 ```
 *Returns:* `is_socket(status(p))` or `is_socket(status(p, ec))`,
 respectively. The signature with argument `ec` returns `false` if an
 error occurs.
@@ -10488,18 +11617,18 @@ error occurs.
 *Throws:* As specified in  [[fs.err.report]].
 #### Is symlink <a id="fs.op.is.symlink">[[fs.op.is.symlink]]</a>
 ``` cpp
-bool is_symlink(file_status s) noexcept;
 ```
 *Returns:* `s.type() == file_type::symlink`.
 ``` cpp
-bool is_symlink(const path& p);
-bool is_symlink(const path& p, error_code& ec) noexcept;
 ```
 *Returns:* `is_symlink(symlink_status(p))` or
 `is_symlink(symlink_status(p, ec))`, respectively. The signature with
 argument `ec` returns `false` if an error occurs.
@@ -10507,74 +11636,74 @@ argument `ec` returns `false` if an error occurs.
 *Throws:* As specified in  [[fs.err.report]].
 #### Last write time <a id="fs.op.last.write.time">[[fs.op.last.write.time]]</a>
 ``` cpp
-file_time_type last_write_time(const path& p);
-file_time_type last_write_time(const path& p, error_code& ec) noexcept;
 ```
 *Returns:* The time of last data modification of `p`, determined as if
 by the value of the POSIX `stat` class member `st_mtime` obtained as if
 by POSIX `stat()`. The signature with argument `ec` returns
 `file_time_type::min()` if an error occurs.
 *Throws:* As specified in  [[fs.err.report]].
 ``` cpp
-void last_write_time(const path& p, file_time_type new_time);
-void last_write_time(const path& p, file_time_type new_time,
                      error_code& ec) noexcept;
 ```
 *Effects:* Sets the time of last data modification of the file resolved
 to by `p` to `new_time`, as if by POSIX `futimens()`.
 *Throws:* As specified in  [[fs.err.report]].
 [*Note 1*: A postcondition of `last_write_time(p) == new_time` is not
-specified since it might not hold for file systems with coarse time
-granularity. — *end note*]
 #### Permissions <a id="fs.op.permissions">[[fs.op.permissions]]</a>
 ``` cpp
-void permissions(const path& p, perms prms, perm_options opts=perm_options::replace);
-void permissions(const path& p, perms prms, error_code& ec) noexcept;
-void permissions(const path& p, perms prms, perm_options opts, error_code& ec);
 ```
 *Preconditions:* Exactly one of the `perm_options` constants `replace`,
 `add`, or `remove` is present in `opts`.
-*Remarks:* The second signature behaves as if it had an additional
-parameter `perm_options` `opts` with an argument of
-`perm_options::replace`.
 *Effects:* Applies the action specified by `opts` to the file `p`
 resolves to, or to file `p` itself if `p` is a symbolic link and
 `perm_options::nofollow` is set in `opts`. The action is applied as if
 by POSIX `fchmodat()`.
 [*Note 1*: Conceptually permissions are viewed as bits, but the actual
-implementation may use some other mechanism. — *end note*]
 *Throws:* As specified in  [[fs.err.report]].
 #### Proximate <a id="fs.op.proximate">[[fs.op.proximate]]</a>
 ``` cpp
-path proximate(const path& p, error_code& ec);
 ```
 *Returns:* `proximate(p, current_path(), ec)`.
 *Throws:* As specified in  [[fs.err.report]].
 ``` cpp
-path proximate(const path& p, const path& base = current_path());
-path proximate(const path& p, const path& base, error_code& ec);
 ```
 *Returns:* For the first form:
 ``` cpp
@@ -10592,12 +11721,12 @@ or `path()` at the first error occurrence, if any.
 *Throws:* As specified in  [[fs.err.report]].
 #### Read symlink <a id="fs.op.read.symlink">[[fs.op.read.symlink]]</a>
 ``` cpp
-path read_symlink(const path& p);
-path read_symlink(const path& p, error_code& ec);
 ```
 *Returns:* If `p` resolves to a symbolic link, a `path` object
 containing the contents of that symbolic link. The signature with
 argument `ec` returns `path()` if an error occurs.
@@ -10608,20 +11737,20 @@ argument `ec` returns `path()` if an error occurs.
 link. — *end note*]
 #### Relative <a id="fs.op.relative">[[fs.op.relative]]</a>
 ``` cpp
-path relative(const path& p, error_code& ec);
 ```
 *Returns:* `relative(p, current_path(), ec)`.
 *Throws:* As specified in  [[fs.err.report]].
 ``` cpp
-path relative(const path& p, const path& base = current_path());
-path relative(const path& p, const path& base, error_code& ec);
 ```
 *Returns:* For the first form:
 ``` cpp
@@ -10639,12 +11768,12 @@ or `path()` at the first error occurrence, if any.
 *Throws:* As specified in  [[fs.err.report]].
 #### Remove <a id="fs.op.remove">[[fs.op.remove]]</a>
 ``` cpp
-bool remove(const path& p);
-bool remove(const path& p, error_code& ec) noexcept;
 ```
 *Effects:* If `exists(symlink_status(p, ec))`, the file `p` is removed
 as if by POSIX `remove()`.
@@ -10659,12 +11788,12 @@ with argument `ec` returns `false` if an error occurs.
 *Throws:* As specified in  [[fs.err.report]].
 #### Remove all <a id="fs.op.remove.all">[[fs.op.remove.all]]</a>
 ``` cpp
-uintmax_t remove_all(const path& p);
-uintmax_t remove_all(const path& p, error_code& ec);
 ```
 *Effects:* Recursively deletes the contents of `p` if it exists, then
 deletes file `p` itself, as if by POSIX `remove()`.
@@ -10679,25 +11808,25 @@ returns `static_cast< uintmax_t>(-1)` if an error occurs.
 *Throws:* As specified in  [[fs.err.report]].
 #### Rename <a id="fs.op.rename">[[fs.op.rename]]</a>
 ``` cpp
-void rename(const path& old_p, const path& new_p);
-void rename(const path& old_p, const path& new_p, error_code& ec) noexcept;
 ```
 *Effects:* Renames `old_p` to `new_p`, as if by POSIX `rename()`.
 [*Note 1*:
 - If `old_p` and `new_p` resolve to the same existing file, no action is
   taken.
-- Otherwise, the rename may include the following effects:
   - if `new_p` resolves to an existing non-directory file, `new_p` is
     removed; otherwise,
   - if `new_p` resolves to an existing directory, `new_p` is removed if
-    empty on POSIX compliant operating systems but may be an error on
     other operating systems.
 A symbolic link is itself renamed, rather than the file it resolves to.
 — *end note*]
@@ -10705,24 +11834,24 @@ A symbolic link is itself renamed, rather than the file it resolves to.
 *Throws:* As specified in  [[fs.err.report]].
 #### Resize file <a id="fs.op.resize.file">[[fs.op.resize.file]]</a>
 ``` cpp
-void resize_file(const path& p, uintmax_t new_size);
-void resize_file(const path& p, uintmax_t new_size, error_code& ec) noexcept;
 ```
 *Effects:* Causes the size that would be returned by `file_size(p)` to
 be equal to `new_size`, as if by POSIX `truncate()`.
 *Throws:* As specified in  [[fs.err.report]].
 #### Space <a id="fs.op.space">[[fs.op.space]]</a>
 ``` cpp
-space_info space(const path& p);
-space_info space(const path& p, error_code& ec) noexcept;
 ```
 *Returns:* An object of type `space_info`. The value of the `space_info`
 object is determined as if by using POSIX `statvfs` to obtain a POSIX
 `struct statvfs`, and then multiplying its `f_blocks`, `f_bfree`, and
@@ -10735,16 +11864,16 @@ members are set to `static_cast<uintmax_t>(-1)` if an error occurs.
 *Throws:* As specified in  [[fs.err.report]].
 *Remarks:* The value of member `space_info::available` is operating
 system dependent.
-[*Note 1*: `available` may be less than `free`. — *end note*]
 #### Status <a id="fs.op.status">[[fs.op.status]]</a>
 ``` cpp
-file_status status(const path& p);
 ```
 *Effects:* As if:
 ``` cpp
@@ -10762,11 +11891,11 @@ return result;
 [*Note 1*: `result` values of `file_status(file_type::not_found)` and
 `file_status(file_type::unknown)` are not considered failures and do not
 cause an exception to be thrown. — *end note*]
 ``` cpp
-file_status status(const path& p, error_code& ec) noexcept;
 ```
 *Effects:* If possible, determines the attributes of the file `p`
 resolves to, as if by using POSIX `stat()` to obtain a POSIX
 `struct stat`. If, during attribute determination, the underlying file
@@ -10827,20 +11956,20 @@ determined as if by converting the `st_mode` member of the obtained
 pathname resolution continues using the contents of the symbolic link.
 #### Status known <a id="fs.op.status.known">[[fs.op.status.known]]</a>
 ``` cpp
-bool status_known(file_status s) noexcept;
 ```
 *Returns:* `s.type() != file_type::none`.
 #### Symlink status <a id="fs.op.symlink.status">[[fs.op.symlink.status]]</a>
 ``` cpp
-file_status symlink_status(const path& p);
-file_status symlink_status(const path& p, error_code& ec) noexcept;
 ```
 *Effects:* Same as `status()`, above, except that the attributes of `p`
 are determined as if by using POSIX `lstat()` to obtain a POSIX
 `struct stat`.
@@ -10852,19 +11981,19 @@ determined as if by converting the `st_mode` member of the obtained
 *Returns:* Same as `status()`, above, except that if the attributes
 indicate a symbolic link, as if by POSIX `S_ISLNK`, returns
 `file_status(file_type::symlink, prms)`. The signature with argument
 `ec` returns `file_status(file_type::none)` if an error occurs.
 *Remarks:* Pathname resolution terminates if `p` names a symbolic link.
-*Throws:* As specified in  [[fs.err.report]].
 #### Temporary directory path <a id="fs.op.temp.dir.path">[[fs.op.temp.dir.path]]</a>
 ``` cpp
-path temp_directory_path();
-path temp_directory_path(error_code& ec);
 ```
 Let `p` be an unspecified directory path suitable for temporary files.
 *Effects:* If `exists(p)` is `false` or `is_directory(p)` is `false`, an
@@ -10883,17 +12012,14 @@ return the path reported by the Windows `GetTempPath` API
 function. — *end example*]
 #### Weakly canonical <a id="fs.op.weakly.canonical">[[fs.op.weakly.canonical]]</a>
 ``` cpp
-path weakly_canonical(const path& p);
-path weakly_canonical(const path& p, error_code& ec);
 ```
-*Returns:* `p` with symlinks resolved and the result
-normalized [[fs.path.generic]].
 *Effects:* Using `status(p)` or `status(p, ec)`, respectively, to
 determine existence, return a path composed by `operator/=` from the
 result of calling `canonical()` with a path argument composed of the
 leading elements of `p` that exist, if any, followed by the elements of
 `p` that do not exist, if any. For the first form, `canonical()` is
@@ -10901,12 +12027,12 @@ called without an `error_code` argument. For the second form,
 `canonical()` is called with `ec` as an `error_code` argument, and
 `path()` is returned at the first error occurrence, if any.
 *Ensures:* The returned path is in normal form [[fs.path.generic]].
-*Remarks:* Implementations should avoid unnecessary normalization such
-as when `canonical` has already been called on the entirety of `p`.
 *Throws:* As specified in  [[fs.err.report]].
 ## C library files <a id="c.files">[[c.files]]</a>
@@ -11000,19 +12126,19 @@ See also: ISO C 7.21
 #include <cstdint>  // see [cstdint.syn]
 namespace std {
   using imaxdiv_t = see below;
-  intmax_t imaxabs(intmax_t j);
-  imaxdiv_t imaxdiv(intmax_t numer, intmax_t denom);
   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); // optional, see below
-  imaxdiv_t div(intmax_t, intmax_t); // optional, see below
 }
 #define PRIdN see below
 #define PRIiN see below
 #define PRIoN see below
@@ -11073,73 +12199,97 @@ namespace std {
 The contents and meaning of the header `<cinttypes>` are the same as the
 C standard library header `<inttypes.h>`, with the following changes:
 - The header `<cinttypes>` includes the header `<cstdint>` instead of
   `<stdint.h>`, and
 - if and only if the type `intmax_t` designates an extended integer type
   [[basic.fundamental]], the following function signatures are added:
   ``` cpp
-  intmax_t abs(intmax_t);
-  imaxdiv_t div(intmax_t, intmax_t);
   ```
   which shall have the same semantics as the function signatures
-  `intmax_t imaxabs(intmax_t)` and
-  `imaxdiv_t imaxdiv(intmax_t, intmax_t)`, respectively.
 See also: ISO C 7.8
 <!-- Link reference definitions -->
 [adjustfield.manip]: #adjustfield.manip
 [basefield.manip]: #basefield.manip
 [basic.fundamental]: basic.md#basic.fundamental
 [basic.ios.cons]: #basic.ios.cons
 [basic.ios.copyfmt]: #basic.ios.copyfmt
 [basic.ios.members]: #basic.ios.members
 [basic.start.main]: basic.md#basic.start.main
 [bidirectional.iterators]: iterators.md#bidirectional.iterators
 [bitmask.types]: library.md#bitmask.types
 [c.files]: #c.files
 [char.traits]: strings.md#char.traits
 [cinttypes.syn]: #cinttypes.syn
 [container.requirements.general]: containers.md#container.requirements.general
-[cpp17.allocator]: #cpp17.allocator
 [cpp17.copyassignable]: #cpp17.copyassignable
 [cpp17.copyconstructible]: #cpp17.copyconstructible
 [cpp17.defaultconstructible]: #cpp17.defaultconstructible
 [cpp17.destructible]: #cpp17.destructible
 [cpp17.equalitycomparable]: #cpp17.equalitycomparable
 [cstdio.syn]: #cstdio.syn
-[defns.ntcts]: library.md#defns.ntcts
 [enumerated.types]: library.md#enumerated.types
 [error.reporting]: #error.reporting
 [ext.manip]: #ext.manip
 [file.streams]: #file.streams
 [filebuf]: #filebuf
 [filebuf.assign]: #filebuf.assign
 [filebuf.cons]: #filebuf.cons
 [filebuf.members]: #filebuf.members
 [filebuf.open.modes]: #filebuf.open.modes
 [filebuf.seekoff]: #filebuf.seekoff
 [filebuf.virtuals]: #filebuf.virtuals
 [filesystems]: #filesystems
 [floatfield.manip]: #floatfield.manip
 [fmtflags.manip]: #fmtflags.manip
 [fmtflags.state]: #fmtflags.state
 [fpos]: #fpos
 [fpos.members]: #fpos.members
 [fpos.operations]: #fpos.operations
 [fs.class.directory.entry]: #fs.class.directory.entry
 [fs.class.directory.iterator]: #fs.class.directory.iterator
 [fs.class.file.status]: #fs.class.file.status
 [fs.class.filesystem.error]: #fs.class.filesystem.error
 [fs.class.path]: #fs.class.path
 [fs.class.rec.dir.itr]: #fs.class.rec.dir.itr
 [fs.conform.9945]: #fs.conform.9945
 [fs.conform.os]: #fs.conform.os
 [fs.conformance]: #fs.conformance
 [fs.dir.entry.cons]: #fs.dir.entry.cons
 [fs.dir.entry.mods]: #fs.dir.entry.mods
 [fs.dir.entry.obs]: #fs.dir.entry.obs
 [fs.dir.itr.members]: #fs.dir.itr.members
 [fs.dir.itr.nonmembers]: #fs.dir.itr.nonmembers
 [fs.enum]: #fs.enum
@@ -11154,11 +12304,10 @@ See also: ISO C 7.8
 [fs.file.status.mods]: #fs.file.status.mods
 [fs.file.status.obs]: #fs.file.status.obs
 [fs.filesystem.error.members]: #fs.filesystem.error.members
 [fs.filesystem.syn]: #fs.filesystem.syn
 [fs.general]: #fs.general
-[fs.norm.ref]: #fs.norm.ref
 [fs.op.absolute]: #fs.op.absolute
 [fs.op.canonical]: #fs.op.canonical
 [fs.op.copy]: #fs.op.copy
 [fs.op.copy.file]: #fs.op.copy.file
 [fs.op.copy.symlink]: #fs.op.copy.symlink
@@ -11170,10 +12319,11 @@ See also: ISO C 7.8
 [fs.op.current.path]: #fs.op.current.path
 [fs.op.equivalent]: #fs.op.equivalent
 [fs.op.exists]: #fs.op.exists
 [fs.op.file.size]: #fs.op.file.size
 [fs.op.funcs]: #fs.op.funcs
 [fs.op.hard.lk.ct]: #fs.op.hard.lk.ct
 [fs.op.is.block.file]: #fs.op.is.block.file
 [fs.op.is.char.file]: #fs.op.is.char.file
 [fs.op.is.directory]: #fs.op.is.directory
 [fs.op.is.empty]: #fs.op.is.empty
@@ -11206,10 +12356,11 @@ See also: ISO C 7.8
 [fs.path.decompose]: #fs.path.decompose
 [fs.path.fmt.cvt]: #fs.path.fmt.cvt
 [fs.path.gen]: #fs.path.gen
 [fs.path.generic]: #fs.path.generic
 [fs.path.generic.obs]: #fs.path.generic.obs
 [fs.path.io]: #fs.path.io
 [fs.path.itr]: #fs.path.itr
 [fs.path.member]: #fs.path.member
 [fs.path.modifiers]: #fs.path.modifiers
 [fs.path.native.obs]: #fs.path.native.obs
@@ -11219,31 +12370,34 @@ See also: ISO C 7.8
 [fs.path.type.cvt]: #fs.path.type.cvt
 [fs.race.behavior]: #fs.race.behavior
 [fs.rec.dir.itr.members]: #fs.rec.dir.itr.members
 [fs.rec.dir.itr.nonmembers]: #fs.rec.dir.itr.nonmembers
 [fs.req]: #fs.req
-[fs.req.namespace]: #fs.req.namespace
 [fstream]: #fstream
-[fstream.assign]: #fstream.assign
 [fstream.cons]: #fstream.cons
 [fstream.members]: #fstream.members
 [fstream.syn]: #fstream.syn
 [ifstream]: #ifstream
-[ifstream.assign]: #ifstream.assign
 [ifstream.cons]: #ifstream.cons
 [ifstream.members]: #ifstream.members
 [input.iterators]: iterators.md#input.iterators
 [input.output]: #input.output
 [input.output.general]: #input.output.general
 [input.streams]: #input.streams
 [intro.multithread]: basic.md#intro.multithread
 [intro.races]: basic.md#intro.races
 [iomanip.syn]: #iomanip.syn
 [ios]: #ios
 [ios.base]: #ios.base
 [ios.base.callback]: #ios.base.callback
 [ios.base.cons]: #ios.base.cons
 [ios.base.locales]: #ios.base.locales
 [ios.base.storage]: #ios.base.storage
 [ios.failure]: #ios.failure
 [ios.fmtflags]: #ios.fmtflags
 [ios.fmtflags.const]: #ios.fmtflags.const
@@ -11266,72 +12420,108 @@ See also: ISO C 7.8
 [iostream.limits.imbue]: #iostream.limits.imbue
 [iostream.objects]: #iostream.objects
 [iostream.objects.overview]: #iostream.objects.overview
 [iostream.syn]: #iostream.syn
 [iostreamclass]: #iostreamclass
 [iostreams.base]: #iostreams.base
 [iostreams.limits.pos]: #iostreams.limits.pos
 [iostreams.requirements]: #iostreams.requirements
 [iostreams.summary]: #iostreams.summary
 [iostreams.threadsafety]: #iostreams.threadsafety
 [istream]: #istream
 [istream.assign]: #istream.assign
 [istream.cons]: #istream.cons
 [istream.extractors]: #istream.extractors
 [istream.formatted]: #istream.formatted
 [istream.formatted.arithmetic]: #istream.formatted.arithmetic
 [istream.formatted.reqmts]: #istream.formatted.reqmts
 [istream.manip]: #istream.manip
 [istream.rvalue]: #istream.rvalue
 [istream.sentry]: #istream.sentry
 [istream.syn]: #istream.syn
 [istream.unformatted]: #istream.unformatted
 [istringstream]: #istringstream
-[istringstream.assign]: #istringstream.assign
 [istringstream.cons]: #istringstream.cons
 [istringstream.members]: #istringstream.members
 [lex.charset]: lex.md#lex.charset
 [locale.codecvt.virtuals]: localization.md#locale.codecvt.virtuals
 [locale.num.get]: localization.md#locale.num.get
 [namespace.std]: library.md#namespace.std
 [narrow.stream.objects]: #narrow.stream.objects
 [numeric.limits]: support.md#numeric.limits
 [ofstream]: #ofstream
-[ofstream.assign]: #ofstream.assign
 [ofstream.cons]: #ofstream.cons
 [ofstream.members]: #ofstream.members
 [ostream]: #ostream
 [ostream.assign]: #ostream.assign
 [ostream.cons]: #ostream.cons
 [ostream.formatted]: #ostream.formatted
 [ostream.formatted.reqmts]: #ostream.formatted.reqmts
 [ostream.inserters]: #ostream.inserters
 [ostream.inserters.arithmetic]: #ostream.inserters.arithmetic
 [ostream.inserters.character]: #ostream.inserters.character
 [ostream.manip]: #ostream.manip
 [ostream.rvalue]: #ostream.rvalue
 [ostream.seeks]: #ostream.seeks
 [ostream.sentry]: #ostream.sentry
 [ostream.syn]: #ostream.syn
 [ostream.unformatted]: #ostream.unformatted
 [ostringstream]: #ostringstream
-[ostringstream.assign]: #ostringstream.assign
 [ostringstream.cons]: #ostringstream.cons
 [ostringstream.members]: #ostringstream.members
 [output.streams]: #output.streams
 [quoted.manip]: #quoted.manip
 [res.on.data.races]: library.md#res.on.data.races
 [res.on.exception.handling]: library.md#res.on.exception.handling
 [sstream.syn]: #sstream.syn
 [std.ios.manip]: #std.ios.manip
 [std.manip]: #std.manip
 [stream.buffers]: #stream.buffers
 [stream.types]: #stream.types
 [streambuf]: #streambuf
 [streambuf.assign]: #streambuf.assign
 [streambuf.buffer]: #streambuf.buffer
 [streambuf.cons]: #streambuf.cons
 [streambuf.get.area]: #streambuf.get.area
 [streambuf.locales]: #streambuf.locales
 [streambuf.members]: #streambuf.members
 [streambuf.protected]: #streambuf.protected
 [streambuf.pub.get]: #streambuf.pub.get
@@ -11349,19 +12539,21 @@ See also: ISO C 7.8
 [string.classes]: strings.md#string.classes
 [string.streams]: #string.streams
 [stringbuf]: #stringbuf
 [stringbuf.assign]: #stringbuf.assign
 [stringbuf.cons]: #stringbuf.cons
 [stringbuf.members]: #stringbuf.members
 [stringbuf.seekoff.newoff]: #stringbuf.seekoff.newoff
 [stringbuf.seekoff.pos]: #stringbuf.seekoff.pos
 [stringbuf.virtuals]: #stringbuf.virtuals
 [strings]: strings.md#strings
 [stringstream]: #stringstream
-[stringstream.assign]: #stringstream.assign
 [stringstream.cons]: #stringstream.cons
 [stringstream.members]: #stringstream.members
 [syncstream]: #syncstream
 [syncstream.osyncstream]: #syncstream.osyncstream
 [syncstream.osyncstream.cons]: #syncstream.osyncstream.cons
 [syncstream.osyncstream.members]: #syncstream.osyncstream.members
 [syncstream.osyncstream.overview]: #syncstream.osyncstream.overview
@@ -11372,71 +12564,73 @@ See also: ISO C 7.8
 [syncstream.syncbuf.members]: #syncstream.syncbuf.members
 [syncstream.syncbuf.overview]: #syncstream.syncbuf.overview
 [syncstream.syncbuf.special]: #syncstream.syncbuf.special
 [syncstream.syncbuf.virtuals]: #syncstream.syncbuf.virtuals
 [temp.deduct]: temp.md#temp.deduct
 [wide.stream.objects]: #wide.stream.objects
-[^1]: It is the implementation’s responsibility to implement headers so
     that including `<iosfwd>` and other headers does not violate the
     rules about multiple occurrences of default arguments.
-[^2]: If it is possible for them to do so, implementations should
-    initialize the objects earlier than required.
-[^3]: Constructors and destructors for objects with static storage
     duration can access these objects to read input from `stdin` or
     write output to `stdout` or `stderr`.
-[^4]: Typically `long long`.
-[^5]: `streamsize` is used in most places where ISO C would use
-    `size_t`.
-[^6]: This implies that operations on a standard iostream object can be
     mixed arbitrarily with operations on the corresponding stdio stream.
     In practical terms, synchronization usually means that a standard
     iostream object and a standard stdio object share a buffer.
-[^7]: An implementation is free to implement both the integer array
     pointed at by `iarray` and the pointer array pointed at by `parray`
     as sparse data structures, possibly with a one-element cache for
     each.
 [^8]: For example, because it cannot allocate space.
-[^9]: For example, because it cannot allocate space.
-[^10]: This suggests an infinite amount of copying, but the
     implementation can keep track of the maximum element of the arrays
     that is nonzero.
-[^11]: Checking `badbit` also for `fail()` is historical practice.
-[^12]: The function signature `dec(ios_base&)` can be called by the
     function signature
     `basic_ostream& stream::operator<<(ios_base& (*)(ios_base&))` to
     permit expressions of the form `cout << dec` to change the format
     flags stored in `cout`.
-[^13]: The default constructor is protected for class `basic_streambuf`
-    to assure that only objects for classes derived from this class may
     be constructed.
-[^14]: `underflow` or `uflow` might fail by throwing an exception
     prematurely. The intention is not only that the calls will not
     return `eof()` but that they will return “immediately”.
 [^15]: Classes derived from `basic_streambuf` can provide more efficient
     ways to implement `xsgetn()` and `xsputn()` by overriding these
     definitions from the base class.
-[^16]: That is, for each class derived from an instance of
-    `basic_streambuf` in this Clause ([[stringbuf]],
- [[filebuf]]), a specification of how consuming a character
- effects the associated output sequence is given. There is no
- requirement on a program-defined class.
 [^17]: Typically, `overflow` returns `c` to indicate success, except
     when `traits::eq_int_type(c, traits::eof())` returns `true`, in
     which case it returns `traits::not_eof(c)`.
@@ -11445,76 +12639,67 @@ See also: ISO C 7.8
     specified.
 [^19]: The `sentry` constructor and destructor can also perform
     additional implementation-dependent operations.
-[^20]: This is done without causing an `ios_base::failure` to be thrown.
-[^21]: See, for example, the function signature
     `ws(basic_istream&)`[[istream.manip]].
-[^22]: See, for example, the function signature
     `dec(ios_base&)`[[basefield.manip]].
-[^23]: This is done without causing an `ios_base::failure` to be thrown.
 [^24]: Note that this function is not overloaded on types `signed char`
     and `unsigned char`.
-[^25]: Note that this function is not overloaded on types `signed char`
-    and `unsigned char`.
-[^26]: Note that this function is not overloaded on types `signed char`
-    and `unsigned char`.
-[^27]: Since the final input character is “extracted”, it is counted in
     the `gcount()`, even though it is not stored.
-[^28]: This allows an input line which exactly fills the buffer, without
     setting `failbit`. This is different behavior than the historical
     AT&T implementation.
-[^29]: This implies an empty input line will not cause `failbit` to be
     set.
-[^30]: Note that this function is not overloaded on types `signed char`
     and `unsigned char`.
-[^31]: The call `os.tie()->flush()` does not necessarily occur if the
     function can determine that no synchronization is necessary.
-[^32]: The `sentry` constructor and destructor can also perform
     additional implementation-dependent operations.
-[^33]: without causing an `ios_base::failure` to be thrown.
-[^34]: See, for example, the function signature
     `endl(basic_ostream&)`[[ostream.manip]].
-[^35]: See, for example, the function signature
     `dec(ios_base&)`[[basefield.manip]].
-[^36]: without causing an `ios_base::failure` to be thrown.
-[^37]: Note that this function is not overloaded on types `signed char`
     and `unsigned char`.
-[^38]: Note that this function is not overloaded on types `signed char`
     and `unsigned char`.
-[^39]: The expression `cin >> resetiosflags(ios_base::skipws)` clears
     `ios_base::skipws` in the format flags stored in the
     `basic_istream<charT, traits>` object `cin` (the same as
     `cin >> noskipws`), and the expression
     `cout << resetiosflags(ios_base::showbase)` clears
     `ios_base::showbase` in the format flags stored in the
     `basic_ostream<charT, traits>` object `cout` (the same as
     `cout << noshowbase`).
-[^40]: The macro `SEEK_END` is defined, and the function signatures
     `fopen(const char*, const char*)` and `fseek(FILE*, long, int)` are
     declared, in `<cstdio>`.
-[^41]: POSIX® is a registered trademark of The IEEE. Windows® is a
-    registered trademark of Microsoft Corporation. This information is
-    given for the convenience of users of this document and does not
-    constitute an endorsement by ISO or IEC of these products.

 summarized in [[iostreams.summary]].
 **Table: Input/output library summary** <a id="iostreams.summary">[iostreams.summary]</a>
 | Subclause                  |                             | Header                                           |
+| -------------------------- | --------------------------- | ------------------------------------------------ |
 | [[iostreams.requirements]] | Requirements                |                                                  |
 | [[iostream.forward]]       | Forward declarations        | `<iosfwd>`                                       |
 | [[iostream.objects]]       | Standard iostream objects   | `<iostream>`                                     |
 | [[iostreams.base]]         | Iostreams base classes      | `<ios>`                                          |
 | [[stream.buffers]]         | Stream buffers              | `<streambuf>`                                    |
+| [[iostream.format]]        | Formatting and manipulators | `<istream>`, `<ostream>`, `<iomanip>`, `<print>` |
 | [[string.streams]]         | String streams              | `<sstream>`                                      |
+| [[span.streams]]           | Span-based streams          | `<spanstream>`                                   |
 | [[file.streams]]           | File streams                | `<fstream>`                                      |
 | [[syncstream]]             | Synchronized output streams | `<syncstream>`                                   |
 | [[filesystems]]            | File systems                | `<filesystem>`                                   |
 | [[c.files]]                | C library files             | `<cstdio>`, `<cinttypes>`                        |
 ## Iostreams requirements <a id="iostreams.requirements">[[iostreams.requirements]]</a>
 ### Imbue limitations <a id="iostream.limits.imbue">[[iostream.limits.imbue]]</a>
 No function described in [[input.output]] except for `ios_base::imbue`
 or `basic_streambuf::imbue` to be called. If any user function called
 from a function declared in [[input.output]] or as an overriding virtual
 function of any class declared in [[input.output]] calls `imbue`, the
 behavior is undefined.
+### Types <a id="stream.types">[[stream.types]]</a>
+``` cpp
+using streamoff = implementation-defined  // type of streamoff;
+```
+The type `streamoff` is a synonym for one of the signed basic integral
+types of sufficient size to represent the maximum possible file size for
+the operating system.[^1]
+``` cpp
+using streamsize = implementation-defined;
+```
+The type `streamsize` is a synonym for one of the signed basic integral
+types. It is used to represent the number of characters transferred in
+an I/O operation, or the size of I/O buffers.[^2]
 ### Positioning type limitations <a id="iostreams.limits.pos">[[iostreams.limits.pos]]</a>
 The classes of [[input.output]] with template arguments `charT` and
 `traits` behave as described if `traits::pos_type` and
 `traits::off_type` are `streampos` and `streamoff` respectively. Except
 as noted explicitly below, their behavior when `traits::pos_type` and
 `traits::off_type` are other types is *implementation-defined*.
+[*Note 1*: For each of the specializations of `char_traits` defined in
+[[char.traits.specializations]], `state_type` denotes `mbstate_t`,
+`pos_type` denotes `fpos<mbstate_t>`, and `off_type` denotes
+`streamoff`. — *end note*]
 In the classes of [[input.output]], a template parameter with name
 `charT` represents a member of the set of types containing `char`,
 `wchar_t`, and any other *implementation-defined* character types that
 meet the requirements for a character on which any of the iostream
 components can be instantiated.
 ### Thread safety <a id="iostreams.threadsafety">[[iostreams.threadsafety]]</a>
+Concurrent access to a stream object
+[[string.streams]], [[file.streams]], stream buffer object
+[[stream.buffers]], or C Library stream [[c.files]] by multiple threads
+may result in a data race [[intro.multithread]] unless otherwise
+specified [[iostream.objects]].
 [*Note 1*: Data races result in undefined behavior
 [[intro.multithread]]. — *end note*]
 If one thread makes a library call *a* that writes a value to a stream
     class basic_ostringstream;
   template<class charT, class traits = char_traits<charT>,
            class Allocator = allocator<charT>>
     class basic_stringstream;
+  template<class charT, class traits = char_traits<charT>>
+    class basic_spanbuf;
+  template<class charT, class traits = char_traits<charT>>
+    class basic_ispanstream;
+  template<class charT, class traits = char_traits<charT>>
+    class basic_ospanstream;
+  template<class charT, class traits = char_traits<charT>>
+    class basic_spanstream;
   template<class charT, class traits = char_traits<charT>>
     class basic_filebuf;
   template<class charT, class traits = char_traits<charT>>
     class basic_ifstream;
   template<class charT, class traits = char_traits<charT>>
   using stringbuf     = basic_stringbuf<char>;
   using istringstream = basic_istringstream<char>;
   using ostringstream = basic_ostringstream<char>;
   using stringstream  = basic_stringstream<char>;
+  using spanbuf     = basic_spanbuf<char>;
+  using ispanstream = basic_ispanstream<char>;
+  using ospanstream = basic_ospanstream<char>;
+  using spanstream  = basic_spanstream<char>;
   using filebuf  = basic_filebuf<char>;
   using ifstream = basic_ifstream<char>;
   using ofstream = basic_ofstream<char>;
   using fstream  = basic_fstream<char>;
   using wstringbuf     = basic_stringbuf<wchar_t>;
   using wistringstream = basic_istringstream<wchar_t>;
   using wostringstream = basic_ostringstream<wchar_t>;
   using wstringstream  = basic_stringstream<wchar_t>;
+  using wspanbuf     = basic_spanbuf<wchar_t>;
+  using wispanstream = basic_ispanstream<wchar_t>;
+  using wospanstream = basic_ospanstream<wchar_t>;
+  using wspanstream  = basic_spanstream<wchar_t>;
   using wfilebuf  = basic_filebuf<wchar_t>;
   using wifstream = basic_ifstream<wchar_t>;
   using wofstream = basic_ofstream<wchar_t>;
   using wfstream  = basic_fstream<wchar_t>;
 }
 ```
 Default template arguments are described as appearing both in `<iosfwd>`
 and in the synopsis of other headers but it is well-formed to include
+both `<iosfwd>` and one or more of the other headers.[^3]
 ### Overview <a id="iostream.forward.overview">[[iostream.forward.overview]]</a>
 The class template specialization `basic_ios<charT, traits>` serves as a
 virtual base class for the class templates `basic_istream`,
 and includes all the headers necessary to use these objects.
 The objects are constructed and the associations are established at some
 time prior to or during the first time an object of class
 `ios_base::Init` is constructed, and in any case before the body of
+`main` [[basic.start.main]] begins execution. The objects are not
+destroyed during program execution.[^4]
+*Recommended practice:* If it is possible for them to do so,
+implementations should initialize the objects earlier than required.
+The results of including `<iostream>` in a translation unit shall be as
+if `<iostream>` defined an instance of `ios_base::Init` with static
+storage duration. Each C++ library module [[std.modules]] in a hosted
+implementation shall behave as if it contains an interface unit that
+defines an unexported `ios_base::Init` variable with ordered
+initialization [[basic.start.dynamic]].
+[*Note 1*: As a result, the definition of that variable is
+appearance-ordered before any declaration following the point of
+importation of a C++ library module. Whether such a definition exists is
+unobservable by a program that does not reference any of the standard
+iostream objects. — *end note*]
 Mixing operations on corresponding wide- and narrow-character streams
 follows the same semantics as mixing such operations on `FILE`s, as
 specified in the C standard library.
 Concurrent access to a synchronized [[ios.members.static]] standard
 iostream object’s formatted and unformatted input [[istream]] and output
 [[ostream]] functions or a standard C stream by multiple threads does
 not result in a data race [[intro.multithread]].
+[*Note 2*: Unsynchronized concurrent use of these objects and streams
+by multiple threads can result in interleaved characters. — *end note*]
 See also: ISO C 7.21.2
 ### Narrow stream objects <a id="narrow.stream.objects">[[narrow.stream.objects]]</a>
   error_condition make_error_condition(io_errc e) noexcept;
   const error_category& iostream_category() noexcept;
 }
 ```
 ### Class `ios_base` <a id="ios.base">[[ios.base]]</a>
+#### General <a id="ios.base.general">[[ios.base.general]]</a>
 ``` cpp
 namespace std {
   class ios_base {
   public:
     class failure;              // see below
     using openmode = T3;
     static constexpr openmode app = unspecified;
     static constexpr openmode ate = unspecified;
     static constexpr openmode binary = unspecified;
     static constexpr openmode in = unspecified;
+    static constexpr openmode noreplace = unspecified;
     static constexpr openmode out = unspecified;
     static constexpr openmode trunc = unspecified;
     // [ios.seekdir], seekdir
     using seekdir = T4;
 elements indicated in [[ios.openmode]].
 **Table: `openmode` effects** <a id="ios.openmode">[ios.openmode]</a>
 | Element     | Effect(s) if set                                                  |
+| ----------- | ----------------------------------------------------------------- |
 | `app`       | seek to end before each write                                     |
 | `ate`       | open and seek to end immediately after opening                    |
 | `binary`    | perform input and output in binary mode (as opposed to text mode) |
 | `in`        | open for input                                                    |
+| `noreplace` | open in exclusive mode                                            |
 | `out`       | open for output                                                   |
 | `trunc`     | truncate an existing stream when opening                          |
 ##### Type `ios_base::seekdir` <a id="ios.seekdir">[[ios.seekdir]]</a>
   public:
     Init();
     Init(const Init&) = default;
     ~Init();
     Init& operator=(const Init&) = default;
   private:
     static int init_cnt;        // exposition only
   };
 }
 ```
 ``` cpp
 static bool sync_with_stdio(bool sync = true);
 ```
 *Effects:* If any input or output operation has occurred using the
 standard streams prior to the call, the effect is
 *implementation-defined*. Otherwise, called with a `false` argument, it
 allows the standard streams to operate independently of the standard C
 streams.
+*Returns:* `true` if the previous state of the standard iostream
+objects [[iostream.objects]] was synchronized and otherwise returns
+`false`. The first time it is called, the function returns `true`.
+*Remarks:* When a standard iostream object `str` is *synchronized* with
+a standard stdio stream `f`, the effect of inserting a character `c` by
 ``` cpp
 fputc(f, c);
 ```
 ``` cpp
 str.rdbuf()->sputbackc(c);
 ```
+for any sequence of characters.[^5]
 #### Storage functions <a id="ios.base.storage">[[ios.base.storage]]</a>
 ``` cpp
 static int xalloc();
 *Effects:* If `iarray` is a null pointer, allocates an array of `long`
 of unspecified size and stores a pointer to its first element in
 `iarray`. The function then extends the array pointed at by `iarray` as
 necessary to include the element `iarray[idx]`. Each newly allocated
 element of the array is initialized to zero. The reference returned is
+invalid after any other operation on the object.[^6]
+However, the value of the storage referred to is retained, so that until
+the next call to `copyfmt`, calling `iword` with the same index yields
+another reference to the same value. If the function fails[^7]
+and `*this` is a base class subobject of a `basic_ios<>` object or
+subobject, the effect is equivalent to calling
+`basic_ios<>::setstate(badbit)` on the derived object (which may throw
+`failure`).
 *Returns:* On success `iarray[idx]`. On failure, a valid `long&`
 initialized to 0.
 ``` cpp
 *Effects:* If `parray` is a null pointer, allocates an array of pointers
 to `void` of unspecified size and stores a pointer to its first element
 in `parray`. The function then extends the array pointed at by `parray`
 as necessary to include the element `parray[idx]`. Each newly allocated
 element of the array is initialized to a null pointer. The reference
+returned is invalid after any other operation on the object. However,
 the value of the storage referred to is retained, so that until the next
 call to `copyfmt`, calling `pword` with the same index yields another
+reference to the same value. If the function fails[^8]
+and `*this` is a base class subobject of a `basic_ios<>` object or
+subobject, the effect is equivalent to calling
+`basic_ios<>::setstate(badbit)` on the derived object (which may throw
+`failure`).
 *Returns:* On success `parray[idx]`. On failure a valid `void*&`
 initialized to 0.
 *Remarks:* After a subsequent call to `pword(int)` for the same object,
 ```
 *Effects:* Calls each registered callback pair `(fn, idx)`
 [[ios.base.callback]] as `(*fn)(erase_event, *this, idx)` at such time
 that any `ios_base` member function called from within `fn` has
+well-defined results. Then, any memory obtained is deallocated.
 ### Class template `fpos` <a id="fpos">[[fpos]]</a>
 ``` cpp
 namespace std {
   template<class stateT> class fpos {
   public:
     // [fpos.members], members
     stateT state() const;
     void state(stateT);
+  private:
     stateT st;                  // exposition only
   };
 }
 ```
 [[cpp17.copyconstructible]]), *Cpp17CopyAssignable* (
 [[cpp17.copyassignable]]), and *Cpp17Destructible* (
 [[cpp17.destructible]]) requirements. If
 `is_trivially_copy_constructible_v<stateT>` is `true`, then
 `fpos<stateT>` has a trivial copy constructor. If
+`is_trivially_copy_assignable_v<stateT>` is `true`, then `fpos<stateT>`
 has a trivial copy assignment operator. If
 `is_trivially_destructible_v<stateT>` is `true`, then `fpos<stateT>` has
 a trivial destructor. All specializations of `fpos` meet the
 *Cpp17DefaultConstructible*, *Cpp17CopyConstructible*,
 *Cpp17CopyAssignable*, *Cpp17Destructible*, and
 *Cpp17EqualityComparable* ([[cpp17.equalitycomparable]]) requirements.
 In addition, the expressions shown in [[fpos.operations]] are valid and
 have the indicated semantics. In that table,
+- `P` refers to a specialization of `fpos`,
 - `p` and `q` refer to values of type `P` or `const P`,
 - `pl` and `ql` refer to modifiable lvalues of type `P`,
 - `O` refers to type `streamoff`, and
+- `o` and `o2` refer to values of type `streamoff` or `const streamoff`.
 Stream operations that return a value of type `traits::pos_type` return
 `P(O(-1))` as an invalid value to signal an error. If this value is used
 as an argument to any `istream`, `ostream`, or `streambuf` member that
 accepts a value of type `traits::pos_type` then the behavior of that
     void init(basic_streambuf<charT, traits>* sb);
     void move(basic_ios& rhs);
     void move(basic_ios&& rhs);
     void swap(basic_ios& rhs) noexcept;
     void set_rdbuf(basic_streambuf<charT, traits>* sb);
   };
 }
 ```
 #### Constructors <a id="basic.ios.cons">[[basic.ios.cons]]</a>
   `(*fn)(erase_event, *this, idx)`;
 - then, assigns to the member objects of `*this` the corresponding
   member objects of `rhs`, except that
   - `rdstate()`, `rdbuf()`, and `exceptions()` are left unchanged;
   - the contents of arrays pointed at by `pword` and `iword` are copied,
+    not the pointers themselves;[^9] and
   - if any newly stored pointer values in `*this` point at objects
     stored outside the object `rhs` and those objects are destroyed when
     `rhs` is destroyed, the newly stored pointer values are altered to
     point at newly constructed copies of the objects;
 - then, calls each callback pair that was copied from `rhs` as
 ``` cpp
 void clear(iostate state = goodbit);
 ```
 *Effects:* If
 `((state | (rdbuf() ? goodbit : badbit)) & exceptions()) == 0`, returns.
 Otherwise, the function throws an object of class `ios_base::failure`
 [[ios.failure]], constructed with *implementation-defined* argument
 values.
+*Ensures:* If `rdbuf() != 0` then `state == rdstate()`; otherwise
+`rdstate() == (state | ios_base::badbit)`.
 ``` cpp
 void setstate(iostate state);
 ```
 *Effects:* Calls `clear(rdstate() | state)` (which may throw
 ``` cpp
 bool fail() const;
 ```
+*Returns:* `true` if `failbit` or `badbit` is set in `rdstate()`.[^10]
 ``` cpp
 bool bad() const;
 ```
 ``` cpp
 void exceptions(iostate except);
 ```
 *Effects:* Calls `clear(rdstate())`.
+*Ensures:* `except == exceptions()`.
 ### `ios_base` manipulators <a id="std.ios.manip">[[std.ios.manip]]</a>
 #### `fmtflags` manipulators <a id="fmtflags.manip">[[fmtflags.manip]]</a>
 Each function specified in this subclause is a designated addressable
 ios_base& dec(ios_base& str);
 ```
 *Effects:* Calls `str.setf(ios_base::dec, ios_base::basefield)`.
+*Returns:* `str`.[^11]
 ``` cpp
 ios_base& hex(ios_base& str);
 ```
 *Effects:* Calls
 `str.setf(ios_base::fixed | ios_base::scientific, ios_base::floatfield)`.
 *Returns:* `str`.
+[*Note 1*: `ios_base::hex` cannot be used to specify a hexadecimal
+floating-point format, because it is not part of `ios_base::floatfield`
+([[ios.fmtflags.const]]). — *end note*]
 ``` cpp
 ios_base& defaultfloat(ios_base& str);
 ```
   shall have a defined value and is the next element to read (to get, or
   to obtain a character value, from the sequence).
 ### Class template `basic_streambuf` <a id="streambuf">[[streambuf]]</a>
+#### General <a id="streambuf.general">[[streambuf.general]]</a>
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_streambuf {
   public:
 ``` cpp
 basic_streambuf();
 ```
+*Effects:* Initializes:[^12]
 - all pointer member objects to null pointers,
+- the `getloc()` member to a copy of the global locale, `locale()`, at
+ the time of construction.
 *Remarks:* Once the `getloc()` member is initialized, results of calling
 locale member functions, and of members of facets so obtained, can
 safely be cached until the next time the member `imbue` is called.
 basic_streambuf* setbuf(char_type* s, streamsize n);
 ```
 *Effects:* Influences stream buffering in a way that is defined
 separately for each class derived from `basic_streambuf` in this
+Clause [[stringbuf.virtuals]], [[filebuf.virtuals]].
 *Default behavior:* Does nothing. Returns `this`.
 ``` cpp
 pos_type seekoff(off_type off, ios_base::seekdir way,
                   = ios_base::in | ios_base::out);
 ```
 *Effects:* Alters the stream positions within one or more of the
 controlled sequences in a way that is defined separately for each class
+derived from `basic_streambuf` in this
+Clause [[stringbuf.virtuals]], [[filebuf.virtuals]].
 *Default behavior:* Returns `pos_type(off_type(-1))`.
 ``` cpp
 pos_type seekpos(pos_type sp,
                   = ios_base::in | ios_base::out);
 ```
 *Effects:* Alters the stream positions within one or more of the
 controlled sequences in a way that is defined separately for each class
+derived from `basic_streambuf` in this
+Clause [[stringbuf]], [[filebuf]].
 *Default behavior:* Returns `pos_type(off_type(-1))`.
 ``` cpp
 int sync();
 *Default behavior:* Returns zero.
 ##### Get area <a id="streambuf.virt.get">[[streambuf.virt.get]]</a>
 ``` cpp
+streamsize showmanyc();
 ```
+[^13]
 *Returns:* An estimate of the number of characters available in the
 sequence, or -1. If it returns a positive value, then successive calls
 to `underflow()` will not return `traits::eof()` until at least that
 number of characters have been extracted from the stream. If
 `showmanyc()` returns -1, then calls to `underflow()` or `uflow()` will
 ``` cpp
 int_type underflow();
 ```
 The *pending sequence* of characters is defined as the concatenation of
 - the empty sequence if `gptr()` is null, otherwise the characters in
   \[`gptr()`, `egptr()`), followed by
 - some (possibly empty) sequence of characters read from the input
   in which case the characters in \[`eback()`, `gptr()`) agree with the
   last `gptr() - eback()` characters of the backup sequence, or
 - the characters in \[`gptr() - n`, `gptr()`) agree with the backup
   sequence (where `n` is the length of the backup sequence).
+*Returns:* `traits::to_int_type(c)`, where `c` is the first *character*
+of the *pending sequence*, without moving the input sequence position
+past it. If the pending sequence is null then the function returns
+`traits::eof()` to indicate failure.
 *Default behavior:* Returns `traits::eof()`.
+*Remarks:* The public members of `basic_streambuf` call this virtual
+function only if `gptr()` is null or `gptr() >= egptr()`.
 ``` cpp
 int_type uflow();
 ```
 *Preconditions:* The constraints are the same as for `underflow()`,
 sequence to the backup sequence, and the pending sequence is not empty
 before the transfer.
 *Default behavior:* Calls `underflow()`. If `underflow()` returns
 `traits::eof()`, returns `traits::eof()`. Otherwise, returns the value
+of `traits::to_int_type(*gptr())` and increments the value of the next
 pointer for the input sequence.
 *Returns:* `traits::eof()` to indicate failure.
 ##### Putback <a id="streambuf.virt.pback">[[streambuf.virt.pback]]</a>
 ``` cpp
 int_type pbackfail(int_type c = traits::eof());
 ```
 The *pending sequence* is defined as for `underflow()`, with the
 modifications that
 - If `traits::eq_int_type(c, traits::eof())` returns `true`, then the
   input sequence is backed up one character before the pending sequence
 *Ensures:* On return, the constraints of `gptr()`, `eback()`, and
 `pptr()` are the same as for `underflow()`.
 *Returns:* `traits::eof()` to indicate failure. Failure may occur
 because the input sequence could not be backed up, or if for some other
+reason the pointers cannot be set consistent with the constraints.
 `pbackfail()` is called only when put back has really failed.
 Returns some value other than `traits::eof()` to indicate success.
 *Default behavior:* Returns `traits::eof()`.
+*Remarks:* The public functions of `basic_streambuf` call this virtual
+function only when `gptr()` is null, `gptr() == eback()`, or
+`traits::eq(traits::to_char_type(c), gptr()[-1])` returns `false`. Other
+calls shall also satisfy that constraint.
 ##### Put area <a id="streambuf.virt.put">[[streambuf.virt.put]]</a>
 ``` cpp
 streamsize xsputn(const char_type* s, streamsize n);
 ```
 - the empty sequence if `pbase()` is null, otherwise the
   `pptr() - pbase()` characters beginning at `pbase()`, followed by
 - the empty sequence if `traits::eq_int_type(c, traits::eof())` returns
   `true`, otherwise the sequence consisting of `c`.
 *Preconditions:* Every overriding definition of this virtual function
 obeys the following constraints:
 - The effect of consuming a character on the associated output sequence
   is specified.[^16]
 Otherwise, returns some value other than `traits::eof()` to indicate
 success.[^17]
 *Default behavior:* Returns `traits::eof()`.
+*Remarks:* The member functions `sputc()` and `sputn()` call this
+function in case that no room can be found in the put buffer enough to
+accommodate the argument character sequence.
 ## Formatting and manipulators <a id="iostream.format">[[iostream.format]]</a>
 ### Header `<istream>` synopsis <a id="istream.syn">[[istream.syn]]</a>
 ``` cpp
   using wiostream = basic_iostream<wchar_t>;
   template<class charT, class traits>
     basic_istream<charT, traits>& ws(basic_istream<charT, traits>& is);
+  template<class Istream, class T>
+ Istream&& operator>>(Istream&& is, T&& x);
 }
 ```
 ### Header `<ostream>` synopsis <a id="ostream.syn">[[ostream.syn]]</a>
   template<class charT, class traits>
     basic_ostream<charT, traits>& noemit_on_flush(basic_ostream<charT, traits>& os);
   template<class charT, class traits>
     basic_ostream<charT, traits>& flush_emit(basic_ostream<charT, traits>& os);
+  template<class Ostream, class T>
+ Ostream&& operator<<(Ostream&& os, const T& x);
+  // [ostream.formatted.print], print functions
+  template<class... Args>
+    void print(ostream& os, format_string<Args...> fmt, Args&&... args);
+  template<class... Args>
+    void println(ostream& os, format_string<Args...> fmt, Args&&... args);
+  void vprint_unicode(ostream& os, string_view fmt, format_args args);
+  void vprint_nonunicode(ostream& os, string_view fmt, format_args args);
 }
 ```
 ### Header `<iomanip>` synopsis <a id="iomanip.syn">[[iomanip.syn]]</a>
 ``` cpp
 namespace std {
+  unspecified resetiosflags(ios_base::fmtflags mask);
+ unspecified setiosflags  (ios_base::fmtflags mask);
+ unspecified setbase(int base);
+ template<class charT> unspecified setfill(charT c);
+ unspecified setprecision(int n);
+ unspecified setw(int n);
+ template<class moneyT> unspecified get_money(moneyT& mon, bool intl = false);
+  template<class moneyT> unspecified put_money(const moneyT& mon, bool intl = false);
+  template<class charT> unspecified get_time(tm* tmb, const charT* fmt);
+  template<class charT> unspecified put_time(const tm* tmb, const charT* fmt);
   template<class charT>
+ unspecified quoted(const charT* s, charT delim = charT('"'), charT escape = charT('\\'));
   template<class charT, class traits, class Allocator>
+ unspecified quoted(const basic_string<charT, traits, Allocator>& s,
     \itcorr                   charT delim = charT('"'), charT escape = charT('\\'));
   template<class charT, class traits, class Allocator>
+ unspecified quoted(basic_string<charT, traits, Allocator>& s,
     \itcorr                   charT delim = charT('"'), charT escape = charT('\\'));
   template<class charT, class traits>
+ unspecified quoted(basic_string_view<charT, traits> s,
     \itcorr                   charT delim = charT('"'), charT escape = charT('\\'));
 }
 ```
+### Header `<print>` synopsis <a id="print.syn">[[print.syn]]</a>
+``` cpp
+namespace std {
+  // [print.fun], print functions
+  template<class... Args>
+    void print(format_string<Args...> fmt, Args&&... args);
+  template<class... Args>
+    void print(FILE* stream, format_string<Args...> fmt, Args&&... args);
+  template<class... Args>
+    void println(format_string<Args...> fmt, Args&&... args);
+  template<class... Args>
+    void println(FILE* stream, format_string<Args...> fmt, Args&&... args);
+  void vprint_unicode(string_view fmt, format_args args);
+  void vprint_unicode(FILE* stream, string_view fmt, format_args args);
+  void vprint_nonunicode(string_view fmt, format_args args);
+  void vprint_nonunicode(FILE* stream, string_view fmt, format_args args);
+}
+```
 ### Input streams <a id="input.streams">[[input.streams]]</a>
+#### General <a id="input.streams.general">[[input.streams.general]]</a>
+The header `<istream>` defines two class templates and a function
+template that control input from a stream buffer, along with a function
+template that extracts from stream rvalues.
 #### Class template `basic_istream` <a id="istream">[[istream]]</a>
+##### General <a id="istream.general">[[istream.general]]</a>
+When a function is specified with a type placeholder of
+`extended-floating-point-type`, the implementation provides overloads
+for all cv-unqualified extended floating-point types
+[[basic.fundamental]] in lieu of `extended-floating-{point-type}`.
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_istream : virtual public basic_ios<charT, traits> {
   public:
     // [istream.sentry], prefix/suffix
     class sentry;
     // [istream.formatted], formatted input
+    basic_istream& operator>>(basic_istream& (*pf)(basic_istream&));
+    basic_istream& operator>>(basic_ios<charT, traits>& (*pf)(basic_ios<charT, traits>&));
+    basic_istream& operator>>(ios_base& (*pf)(ios_base&));
+    basic_istream& operator>>(bool& n);
+    basic_istream& operator>>(short& n);
+    basic_istream& operator>>(unsigned short& n);
+    basic_istream& operator>>(int& n);
+    basic_istream& operator>>(unsigned int& n);
+    basic_istream& operator>>(long& n);
+    basic_istream& operator>>(unsigned long& n);
+    basic_istream& operator>>(long long& n);
+    basic_istream& operator>>(unsigned long long& n);
+    basic_istream& operator>>(float& f);
+    basic_istream& operator>>(double& f);
+    basic_istream& operator>>(long double& f);
+    basic_istream& operator>>(extended-floating-point-type& f);
+    basic_istream& operator>>(void*& p);
+    basic_istream& operator>>(basic_streambuf<char_type, traits>* sb);
     // [istream.unformatted], unformatted input
     streamsize gcount() const;
     int_type get();
+    basic_istream& get(char_type& c);
+    basic_istream& get(char_type* s, streamsize n);
+    basic_istream& get(char_type* s, streamsize n, char_type delim);
+    basic_istream& get(basic_streambuf<char_type, traits>& sb);
+    basic_istream& get(basic_streambuf<char_type, traits>& sb, char_type delim);
+    basic_istream& getline(char_type* s, streamsize n);
+    basic_istream& getline(char_type* s, streamsize n, char_type delim);
+    basic_istream& ignore(streamsize n = 1, int_type delim = traits::eof());
     int_type       peek();
+    basic_istream& read    (char_type* s, streamsize n);
     streamsize     readsome(char_type* s, streamsize n);
+    basic_istream& putback(char_type c);
+    basic_istream& unget();
     int sync();
     pos_type tellg();
+    basic_istream& seekg(pos_type);
+    basic_istream& seekg(off_type, ios_base::seekdir);
   protected:
     // [istream.cons], copy/move constructor
     basic_istream(const basic_istream&) = delete;
     basic_istream(basic_istream&& rhs);
+    // [istream.assign], assignment and swap
     basic_istream& operator=(const basic_istream&) = delete;
     basic_istream& operator=(basic_istream&& rhs);
     void swap(basic_istream& rhs);
   };
 *formatted input functions* (or *extractors*) and the *unformatted input
 functions.* Both groups of input functions are described as if they
 obtain (or *extract*) input *characters* by calling `rdbuf()->sbumpc()`
 or `rdbuf()->sgetc()`. They may use other public members of `istream`.
 ##### Constructors <a id="istream.cons">[[istream.cons]]</a>
 ``` cpp
 explicit basic_istream(basic_streambuf<charT, traits>* sb);
 ```
 ##### Class `basic_istream::sentry` <a id="istream.sentry">[[istream.sentry]]</a>
 ``` cpp
 namespace std {
+  template<class charT, class traits>
   class basic_istream<charT, traits>::sentry {
     bool ok_;                   // exposition only
   public:
+    explicit sentry(basic_istream& is, bool noskipws = false);
     ~sentry();
     explicit operator bool() const { return ok_; }
     sentry(const sentry&) = delete;
     sentry& operator=(const sentry&) = delete;
   };
 The class `sentry` defines a class that is responsible for doing
 exception safe prefix and suffix operations.
 ``` cpp
+explicit sentry(basic_istream& is, bool noskipws = false);
 ```
 *Effects:* If `is.good()` is `false`, calls `is.setstate(failbit)`.
 Otherwise, prepares for formatted or unformatted input. First, if
 `is.tie()` is not a null pointer, the function calls `is.tie()->flush()`
 to synchronize the output sequence with any associated external C
 stream. Except that this call can be suppressed if the put area of
 `is.tie()` is empty. Further an implementation is allowed to defer the
 call to `flush` until a call of `is.rdbuf()->underflow()` occurs. If no
 such call occurs before the `sentry` object is destroyed, the call to
+`flush` may be eliminated entirely.[^18]
+If `noskipws` is zero and `is.flags() & ios_base::skipws` is nonzero,
+the function extracts and discards each character as long as the next
+available input character `c` is a whitespace character. If
+`is.rdbuf()->sbumpc()` or `is.rdbuf()->sgetc()` returns `traits::eof()`,
+the function calls `setstate(failbit | eofbit)` (which may throw
+`ios_base::failure`).
 *Remarks:* The constructor
 ``` cpp
+explicit sentry(basic_istream& is, bool noskipws = false)
 ```
 uses the currently imbued locale in `is`, to determine whether the next
 input character is whitespace or not.
 #### Formatted input functions <a id="istream.formatted">[[istream.formatted]]</a>
 ##### Common requirements <a id="istream.formatted.reqmts">[[istream.formatted.reqmts]]</a>
 Each formatted input function begins execution by constructing an object
+of type `ios_base::iostate`, termed the local error state, and
+initializing it to `ios_base::goodbit`. It then creates an object of
+class `sentry` with the `noskipws` (second) argument `false`. If the
 `sentry` object returns `true`, when converted to a value of type
+`bool`, the function endeavors to obtain the requested input. Otherwise,
+if the `sentry` constructor exits by throwing an exception or if the
+`sentry` object produces `false` when converted to a value of type
+`bool`, the function returns without attempting to obtain any input. If
+`rdbuf()->sbumpc()` or `rdbuf()->sgetc()` returns `traits::eof()`, then
+`ios_base::eofbit` is set in the local error state and the input
+function stops trying to obtain the requested input. If an exception is
+thrown during input then `ios_base::badbit` is set in the local error
+state, `*this`’s error state is set to the local error state, and the
+exception is rethrown if `(exceptions() & badbit) != 0`. After
+extraction is done, the input function calls `setstate`, which sets
+`*this`’s error state to the local error state, and may throw an
+exception. In any case, the formatted input function destroys the
+`sentry` object. If no exception has been thrown, it returns `*this`.
 ##### Arithmetic extractors <a id="istream.formatted.arithmetic">[[istream.formatted.arithmetic]]</a>
 ``` cpp
+basic_istream& operator>>(unsigned short& val);
+basic_istream& operator>>(unsigned int& val);
+basic_istream& operator>>(long& val);
+basic_istream& operator>>(unsigned long& val);
+basic_istream& operator>>(long long& val);
+basic_istream& operator>>(unsigned long long& val);
+basic_istream& operator>>(float& val);
+basic_istream& operator>>(double& val);
+basic_istream& operator>>(long double& val);
+basic_istream& operator>>(bool& val);
+basic_istream& operator>>(void*& val);
 ```
 As in the case of the inserters, these extractors depend on the locale’s
 `num_get<>` [[locale.num.get]] object to perform parsing the input
 stream data. These extractors behave as formatted input functions (as
+described in  [[istream.formatted.reqmts]]). After a `sentry` object is
 constructed, the conversion occurs as if performed by the following code
+fragment, where `state` represents the input function’s local error
+state:
 ``` cpp
 using numget = num_get<charT, istreambuf_iterator<charT, traits>>;
+use_facet<numget>(loc).get(*this, 0, *this, state, val);
 ```
 In the above fragment, `loc` stands for the private member of the
 `basic_ios` class.
 Class `locale` relies on this type as its interface to `istream`, so
 that it does not need to depend directly on `istream`.
 ``` cpp
+basic_istream& operator>>(short& val);
 ```
 The conversion occurs as if performed by the following code fragment
 (using the same notation as for the preceding code fragment):
 ``` cpp
 using numget = num_get<charT, istreambuf_iterator<charT, traits>>;
 long lval;
+use_facet<numget>(loc).get(*this, 0, *this, state, lval);
 if (lval < numeric_limits<short>::min()) {
+ state |= ios_base::failbit;
   val = numeric_limits<short>::min();
 } else if (numeric_limits<short>::max() < lval) {
+ state |= ios_base::failbit;
   val = numeric_limits<short>::max();
 }  else
   val = static_cast<short>(lval);
 ```
 ``` cpp
+basic_istream& operator>>(int& val);
 ```
 The conversion occurs as if performed by the following code fragment
 (using the same notation as for the preceding code fragment):
 ``` cpp
 using numget = num_get<charT, istreambuf_iterator<charT, traits>>;
 long lval;
+use_facet<numget>(loc).get(*this, 0, *this, state, lval);
 if (lval < numeric_limits<int>::min()) {
+ state |= ios_base::failbit;
   val = numeric_limits<int>::min();
 } else if (numeric_limits<int>::max() < lval) {
+ state |= ios_base::failbit;
   val = numeric_limits<int>::max();
 }  else
   val = static_cast<int>(lval);
 ```
+``` cpp
+basic_istream& operator>>(extended-floating-point-type& val);
+```
+If the floating-point conversion rank of
+*`extended-floating-point-type`* is not less than or equal to that of
+`long double`, then an invocation of the operator function is
+conditionally supported with *implementation-defined* semantics.
+Otherwise, let `FP` be a standard floating-point type:
+- if the floating-point conversion rank of
+  *`extended-floating-point-type`* is less than or equal to that of
+  `float`, then `FP` is `float`,
+- otherwise, if the floating-point conversion rank of
+  *`extended-floating-point-type`* is less than or equal to that of
+  `double`, then `FP` is `double`,
+- otherwise, `FP` is `long double`.
+The conversion occurs as if performed by the following code fragment
+(using the same notation as for the preceding code fragment):
+``` cpp
+using numget = num_get<charT, istreambuf_iterator<charT, traits>>;
+FP fval;
+use_facet<numget>(loc).get(*this, 0, *this, state, fval);
+if (fval < -numeric_limits<extended-floating-point-type>::max()) {
+  state |= ios_base::failbit;
+  val = -numeric_limits<extended-floating-point-type>::max();
+} else if (numeric_limits<extended-floating-point-type>::max() < fval) {
+  state |= ios_base::failbit;
+  val = numeric_limits<extended-floating-point-type>::max();
+} else {
+  val = static_cast<extended-floating-point-type>(fval);
+}
+```
+[*Note 2*: When the extended floating-point type has a floating-point
+conversion rank that is not equal to the rank of any standard
+floating-point type, then double rounding during the conversion can
+result in inaccurate results. `from_chars` can be used in situations
+where maximum accuracy is important. — *end note*]
 ##### `basic_istream::operator>>` <a id="istream.extractors">[[istream.extractors]]</a>
 ``` cpp
+basic_istream& operator>>(basic_istream& (*pf)(basic_istream&));
 ```
 *Effects:* None. This extractor does not behave as a formatted input
 function (as described in  [[istream.formatted.reqmts]]).
+*Returns:* `pf(*this)`. [^20]
 ``` cpp
+basic_istream& operator>>(basic_ios<charT, traits>& (*pf)(basic_ios<charT, traits>&));
 ```
 *Effects:* Calls `pf(*this)`. This extractor does not behave as a
 formatted input function (as described
 in  [[istream.formatted.reqmts]]).
 *Returns:* `*this`.
 ``` cpp
+basic_istream& operator>>(ios_base& (*pf)(ios_base&));
 ```
+*Effects:* Calls `pf(*this)`.[^21]
+This extractor does not behave as a formatted input function (as
+described in  [[istream.formatted.reqmts]]).
 *Returns:* `*this`.
 ``` cpp
 template<class charT, class traits, size_t N>
 `operator>>` then stores a null byte (`charT()`) in the next position,
 which may be the first position if no characters were extracted.
 `operator>>` then calls `width(0)`.
+If the function extracted no characters, `ios_base::failbit` is set in
+the input function’s local error state before `setstate` is called.
 *Returns:* `in`.
 ``` cpp
 template<class charT, class traits>
 template<class traits>
   basic_istream<char, traits>& operator>>(basic_istream<char, traits>& in, signed char& c);
 ```
 *Effects:* Behaves like a formatted input member (as described
+in  [[istream.formatted.reqmts]]) of `in`. A character is extracted from
+`in`, if one is available, and stored in `c`. Otherwise,
+`ios_base::failbit` is set in the input function’s local error state
+before `setstate` is called.
 *Returns:* `in`.
 ``` cpp
+basic_istream& operator>>(basic_streambuf<charT, traits>* sb);
 ```
 *Effects:* Behaves as an unformatted input
 function [[istream.unformatted]]. If `sb` is null, calls
 `setstate(failbit)`, which may throw `ios_base::failure`
+[[iostate.flags]]. After a `sentry` object is constructed, extracts
 characters from `*this` and inserts them in the output sequence
 controlled by `sb`. Characters are extracted and inserted until any of
 the following occurs:
 - end-of-file occurs on the input sequence;
 - inserting in the output sequence fails (in which case the character to
   be inserted is not extracted);
 - an exception occurs (in which case the exception is caught).
+If the function inserts no characters, `ios_base::failbit` is set in the
+input function’s local error state before `setstate` is called.
 *Returns:* `*this`.
 #### Unformatted input functions <a id="istream.unformatted">[[istream.unformatted]]</a>
 Each unformatted input function begins execution by constructing an
+object of type `ios_base::iostate`, termed the local error state, and
+initializing it to `ios_base::goodbit`. It then creates an object of
+class `sentry` with the default argument `noskipws` (second) argument
+`true`. If the `sentry` object returns `true`, when converted to a value
+of type `bool`, the function endeavors to obtain the requested input.
+Otherwise, if the `sentry` constructor exits by throwing an exception or
+if the `sentry` object produces `false`, when converted to a value of
+type `bool`, the function returns without attempting to obtain any
+input. In either case the number of extracted characters is set to 0;
+unformatted input functions taking a character array of nonzero size as
+an argument shall also store a null character (using `charT()`) in the
+first location of the array. If `rdbuf()->sbumpc()` or
+`rdbuf()->sgetc()` returns `traits::eof()`, then `ios_base::eofbit` is
+set in the local error state and the input function stops trying to
+obtain the requested input. If an exception is thrown during input then
+`ios_base::badbit` is set in the local error state, `*this`’s error
+state is set to the local error state, and the exception is rethrown if
+`(exceptions() & badbit) != 0`. If no exception has been thrown it
+stores the number of characters extracted in a member object. After
+extraction is done, the input function calls `setstate`, which sets
+`*this`’s error state to the local error state, and may throw an
+exception. In any event the `sentry` object is destroyed before leaving
+the unformatted input function.
 ``` cpp
 streamsize gcount() const;
 ```
 *Effects:* None. This member function does not behave as an unformatted
 input function (as described above).
 *Returns:* The number of characters extracted by the last unformatted
+input member function called for the object. If the number cannot be
+represented, returns `numeric_limits<streamsize>::max()`.
 ``` cpp
 int_type get();
 ```
 *Effects:* Behaves as an unformatted input function (as described
+above). After constructing a `sentry` object, extracts a character `c`,
+if one is available. Otherwise, `ios_base::failbit` is set in the input
+function’s local error state before `setstate` is called.
 *Returns:* `c` if available, otherwise `traits::eof()`.
 ``` cpp
+basic_istream& get(char_type& c);
 ```
 *Effects:* Behaves as an unformatted input function (as described
+above). After constructing a `sentry` object, extracts a character, if
+one is available, and assigns it to `c`.[^22]
+Otherwise, `ios_base::failbit` is set in the input function’s local
+error state before `setstate` is called.
 *Returns:* `*this`.
 ``` cpp
+basic_istream& get(char_type* s, streamsize n, char_type delim);
 ```
 *Effects:* Behaves as an unformatted input function (as described
+above). After constructing a `sentry` object, extracts characters and
 stores them into successive locations of an array whose first element is
+designated by `s`.[^23]
+Characters are extracted and stored until any of the following occurs:
 - `n` is less than one or `n - 1` characters are stored;
+- end-of-file occurs on the input sequence;
 - `traits::eq(c, delim)` for the next available input character `c` (in
   which case `c` is not extracted).
+If the function stores no characters, `ios_base::failbit` is set in the
+input function’s local error state before `setstate` is called. In any
+case, if `n` is greater than zero it then stores a null character into
+the next successive location of the array.
 *Returns:* `*this`.
 ``` cpp
+basic_istream& get(char_type* s, streamsize n);
 ```
 *Effects:* Calls `get(s, n, widen(’\n’))`.
 *Returns:* Value returned by the call.
 ``` cpp
+basic_istream& get(basic_streambuf<char_type, traits>& sb, char_type delim);
 ```
 *Effects:* Behaves as an unformatted input function (as described
+above). After constructing a `sentry` object, extracts characters and
 inserts them in the output sequence controlled by `sb`. Characters are
 extracted and inserted until any of the following occurs:
 - end-of-file occurs on the input sequence;
 - inserting in the output sequence fails (in which case the character to
 - `traits::eq(c, delim)` for the next available input character `c` (in
   which case `c` is not extracted);
 - an exception occurs (in which case, the exception is caught but not
   rethrown).
+If the function inserts no characters, `ios_base::failbit` is set in the
+input function’s local error state before `setstate` is called.
 *Returns:* `*this`.
 ``` cpp
+basic_istream& get(basic_streambuf<char_type, traits>& sb);
 ```
 *Effects:* Calls `get(sb, widen(’\n’))`.
 *Returns:* Value returned by the call.
 ``` cpp
+basic_istream& getline(char_type* s, streamsize n, char_type delim);
 ```
 *Effects:* Behaves as an unformatted input function (as described
+above). After constructing a `sentry` object, extracts characters and
 stores them into successive locations of an array whose first element is
+designated by `s`.[^24]
+Characters are extracted and stored until one of the following occurs:
+1.  end-of-file occurs on the input sequence;
 2.  `traits::eq(c, delim)` for the next available input character `c`
     (in which case the input character is extracted but not
+    stored);[^25]
 3.  `n` is less than one or `n - 1` characters are stored (in which case
     the function calls `setstate(failbit)`).
+These conditions are tested in the order shown.[^26]
+If the function extracts no characters, `ios_base::failbit` is set in
+the input function’s local error state before `setstate` is called.[^27]
 In any case, if `n` is greater than zero, it then stores a null
 character (using `charT()`) into the next successive location of the
 array.
 ```
 — *end example*]
 ``` cpp
+basic_istream& getline(char_type* s, streamsize n);
 ```
 *Returns:* `getline(s, n, widen(’\n’))`
 ``` cpp
+basic_istream& ignore(streamsize n = 1, int_type delim = traits::eof());
 ```
 *Effects:* Behaves as an unformatted input function (as described
+above). After constructing a `sentry` object, extracts characters and
 discards them. Characters are extracted until any of the following
 occurs:
 - `n != numeric_limits<streamsize>::max()` [[numeric.limits]] and `n`
   characters have been extracted so far
   calls `setstate(eofbit)`, which may throw `ios_base::failure`
   [[iostate.flags]]);
 - `traits::eq_int_type(traits::to_int_type(c), delim)` for the next
   available input character `c` (in which case `c` is extracted).
+[*Note 1*: The last condition will never occur if
+`traits::eq_int_type(delim, traits::eof())`. — *end note*]
 *Returns:* `*this`.
 ``` cpp
 int_type peek();
 ```
 *Effects:* Behaves as an unformatted input function (as described
+above). After constructing a `sentry` object, reads but does not extract
 the current input character.
 *Returns:* `traits::eof()` if `good()` is `false`. Otherwise, returns
 `rdbuf()->sgetc()`.
 ``` cpp
+basic_istream& read(char_type* s, streamsize n);
 ```
 *Effects:* Behaves as an unformatted input function (as described
+above). After constructing a `sentry` object, if `!good()` calls
 `setstate(failbit)` which may throw an exception, and return. Otherwise
 extracts characters and stores them into successive locations of an
+array whose first element is designated by `s`.[^28]
+Characters are extracted and stored until either of the following
+occurs:
 - `n` characters are stored;
 - end-of-file occurs on the input sequence (in which case the function
   calls `setstate(failbit | eofbit)`, which may throw
   `ios_base::failure` [[iostate.flags]]).
 ``` cpp
 streamsize readsome(char_type* s, streamsize n);
 ```
 *Effects:* Behaves as an unformatted input function (as described
+above). After constructing a `sentry` object, if `!good()` calls
 `setstate(failbit)` which may throw an exception, and return. Otherwise
 extracts characters and stores them into successive locations of an
 array whose first element is designated by `s`. If
 `rdbuf()->in_avail() == -1`, calls `setstate(eofbit)` (which may throw
 `ios_base::failure` [[iostate.flags]]), and extracts no characters;
 - If `rdbuf()->in_avail() > 0`, extracts `min(rdbuf()->in_avail(), n))`.
 *Returns:* The number of characters extracted.
 ``` cpp
+basic_istream& putback(char_type c);
 ```
 *Effects:* Behaves as an unformatted input function (as described
 above), except that the function first clears `eofbit`. After
+constructing a `sentry` object, if `!good()` calls `setstate(failbit)`
 which may throw an exception, and return. If `rdbuf()` is not null,
 calls `rdbuf()->sputbackc(c)`. If `rdbuf()` is null, or if `sputbackc`
 returns `traits::eof()`, calls `setstate(badbit)` (which may throw
 `ios_base::failure` [[iostate.flags]]).
 [*Note 2*: This function extracts no characters, so the value returned
 by the next call to `gcount()` is 0. — *end note*]
 *Returns:* `*this`.
+``` cpp
+basic_istream& unget();
+```
+*Effects:* Behaves as an unformatted input function (as described
+above), except that the function first clears `eofbit`. After
+constructing a `sentry` object, if `!good()` calls `setstate(failbit)`
+which may throw an exception, and return. If `rdbuf()` is not null,
+calls `rdbuf()->sungetc()`. If `rdbuf()` is null, or if `sungetc`
+returns `traits::eof()`, calls `setstate(badbit)` (which may throw
+`ios_base::failure` [[iostate.flags]]).
+[*Note 3*: This function extracts no characters, so the value returned
+by the next call to `gcount()` is 0. — *end note*]
+*Returns:* `*this`.
 ``` cpp
 int sync();
 ```
 *Effects:* Behaves as an unformatted input function (as described
 above), except that it does not count the number of characters extracted
 and does not affect the value returned by subsequent calls to
+`gcount()`. After constructing a `sentry` object, if `rdbuf()` is a null
 pointer, returns `-1`. Otherwise, calls `rdbuf()->pubsync()` and, if
 that function returns `-1` calls `setstate(badbit)` (which may throw
 `ios_base::failure` [[iostate.flags]], and returns `-1`. Otherwise,
 returns zero.
 *Effects:* Behaves as an unformatted input function (as described
 above), except that it does not count the number of characters extracted
 and does not affect the value returned by subsequent calls to
 `gcount()`.
+*Returns:* After constructing a `sentry` object, if `fail() != false`,
 returns `pos_type(-1)` to indicate failure. Otherwise, returns
 `rdbuf()->pubseekoff(0, cur, in)`.
 ``` cpp
+basic_istream& seekg(pos_type pos);
 ```
 *Effects:* Behaves as an unformatted input function (as described
 above), except that the function first clears `eofbit`, it does not
 count the number of characters extracted, and it does not affect the
 value returned by subsequent calls to `gcount()`. After constructing a
+`sentry` object, if `fail() != true`, executes
 `rdbuf()->pubseekpos(pos, ios_base::in)`. In case of failure, the
 function calls `setstate(failbit)` (which may throw
 `ios_base::failure`).
 *Returns:* `*this`.
 ``` cpp
+basic_istream& seekg(off_type off, ios_base::seekdir dir);
 ```
 *Effects:* Behaves as an unformatted input function (as described
 above), except that the function first clears `eofbit`, does not count
 the number of characters extracted, and does not affect the value
+returned by subsequent calls to `gcount()`. After constructing a
+`sentry` object, if `fail() != true`, executes
 `rdbuf()->pubseekoff(off, dir, ios_base::in)`. In case of failure, the
 function calls `setstate(failbit)` (which may throw
 `ios_base::failure`).
 *Returns:* `*this`.
 ```
 *Effects:* Behaves as an unformatted input
 function [[istream.unformatted]], except that it does not count the
 number of characters extracted and does not affect the value returned by
+subsequent calls to `is.gcount()`. After constructing a `sentry` object
 extracts characters as long as the next available character `c` is
 whitespace or until there are no more characters in the sequence.
 Whitespace characters are distinguished with the same criterion as used
 by `sentry::sentry` [[istream.sentry]]. If `ws` stops extracting
 characters because there are no more available it sets `eofbit`, but not
 template<class Istream, class T>
   Istream&& operator>>(Istream&& is, T&& x);
 ```
 *Constraints:* The expression `is >> std::forward<T>(x)` is well-formed
+when treated as an unevaluated operand [[term.unevaluated.operand]] and
+`Istream` is publicly and unambiguously derived from `ios_base`.
 *Effects:* Equivalent to:
 ``` cpp
 is >> std::forward<T>(x);
 return std::move(is);
 ```
 #### Class template `basic_iostream` <a id="iostreamclass">[[iostreamclass]]</a>
+##### General <a id="iostreamclass.general">[[iostreamclass.general]]</a>
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_iostream
     : public basic_istream<charT, traits>,
   protected:
     // [iostream.cons], constructor
     basic_iostream(const basic_iostream&) = delete;
     basic_iostream(basic_iostream&& rhs);
+    // [iostream.assign], assignment and swap
     basic_iostream& operator=(const basic_iostream&) = delete;
     basic_iostream& operator=(basic_iostream&& rhs);
     void swap(basic_iostream& rhs);
   };
 }
 ``` cpp
 basic_iostream(basic_iostream&& rhs);
 ```
 *Effects:* Move constructs from the rvalue `rhs` by constructing the
+`basic_istream` base class with `std::move(rhs)`.
 ##### Destructor <a id="iostream.dest">[[iostream.dest]]</a>
 ``` cpp
 virtual ~basic_iostream();
 *Effects:* Calls `basic_istream<charT, traits>::swap(rhs)`.
 ### Output streams <a id="output.streams">[[output.streams]]</a>
+#### General <a id="output.streams.general">[[output.streams.general]]</a>
+The header `<ostream>` defines a class template and several function
+templates that control output to a stream buffer, along with a function
+template that inserts into stream rvalues.
 #### Class template `basic_ostream` <a id="ostream">[[ostream]]</a>
+##### General <a id="ostream.general">[[ostream.general]]</a>
+When a function has a parameter type `extended-floating-point-type`, the
+implementation provides overloads for all cv-unqualified extended
+floating-point types [[basic.fundamental]].
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_ostream : virtual public basic_ios<charT, traits> {
   public:
     // [ostream.sentry], prefix/suffix
     class sentry;
     // [ostream.formatted], formatted output
+    basic_ostream& operator<<(basic_ostream& (*pf)(basic_ostream&));
+    basic_ostream& operator<<(basic_ios<charT, traits>& (*pf)(basic_ios<charT, traits>&));
+    basic_ostream& operator<<(ios_base& (*pf)(ios_base&));
+    basic_ostream& operator<<(bool n);
+    basic_ostream& operator<<(short n);
+    basic_ostream& operator<<(unsigned short n);
+    basic_ostream& operator<<(int n);
+    basic_ostream& operator<<(unsigned int n);
+    basic_ostream& operator<<(long n);
+    basic_ostream& operator<<(unsigned long n);
+    basic_ostream& operator<<(long long n);
+    basic_ostream& operator<<(unsigned long long n);
+    basic_ostream& operator<<(float f);
+    basic_ostream& operator<<(double f);
+    basic_ostream& operator<<(long double f);
+    basic_ostream& operator<<(extended-floating-point-type f);
+    basic_ostream& operator<<(const void* p);
+    basic_ostream& operator<<(const volatile void* p);
+    basic_ostream& operator<<(nullptr_t);
+    basic_ostream& operator<<(basic_streambuf<char_type, traits>* sb);
     // [ostream.unformatted], unformatted output
+    basic_ostream& put(char_type c);
+    basic_ostream& write(const char_type* s, streamsize n);
+    basic_ostream& flush();
     // [ostream.seeks], seeks
     pos_type tellp();
+    basic_ostream& seekp(pos_type);
+    basic_ostream& seekp(off_type, ios_base::seekdir);
   protected:
     // [ostream.cons], copy/move constructor
     basic_ostream(const basic_ostream&) = delete;
     basic_ostream(basic_ostream&& rhs);
+    // [ostream.assign], assignment and swap
     basic_ostream& operator=(const basic_ostream&) = delete;
     basic_ostream& operator=(basic_ostream&& rhs);
     void swap(basic_ostream& rhs);
   };
 ##### Class `basic_ostream::sentry` <a id="ostream.sentry">[[ostream.sentry]]</a>
 ``` cpp
 namespace std {
+  template<class charT, class traits>
   class basic_ostream<charT, traits>::sentry {
     bool ok_;       // exposition only
   public:
+    explicit sentry(basic_ostream& os);
     ~sentry();
     explicit operator bool() const { return ok_; }
     sentry(const sentry&) = delete;
     sentry& operator=(const sentry&) = delete;
 The class `sentry` defines a class that is responsible for doing
 exception safe prefix and suffix operations.
 ``` cpp
+explicit sentry(basic_ostream& os);
 ```
 If `os.good()` is nonzero, prepares for formatted or unformatted output.
+If `os.tie()` is not a null pointer, calls `os.tie()->flush()`.[^29]
 If, after any preparation is completed, `os.good()` is `true`,
 `ok_ == true` otherwise, `ok_ == false`. During preparation, the
 constructor may call `setstate(failbit)` (which may throw
+`ios_base::failure` [[iostate.flags]]).[^30]
 ``` cpp
 ~sentry();
 ```
 *Returns:* If `fail() != false`, returns `pos_type(-1)` to indicate
 failure. Otherwise, returns `rdbuf()->pubseekoff(0, cur, out)`.
 ``` cpp
+basic_ostream& seekp(pos_type pos);
 ```
 *Effects:* If `fail() != true`, executes
 `rdbuf()->pubseekpos(pos, ios_base::out)`. In case of failure, the
 function calls `setstate(failbit)` (which may throw
 `ios_base::failure`).
 *Returns:* `*this`.
 ``` cpp
+basic_ostream& seekp(off_type off, ios_base::seekdir dir);
 ```
 *Effects:* If `fail() != true`, executes
 `rdbuf()->pubseekoff(off, dir, ios_base::out)`. In case of failure, the
 function calls `setstate(failbit)` (which may throw
 #### Formatted output functions <a id="ostream.formatted">[[ostream.formatted]]</a>
 ##### Common requirements <a id="ostream.formatted.reqmts">[[ostream.formatted.reqmts]]</a>
 Each formatted output function begins execution by constructing an
+object of class `sentry`. If that object returns `true` when converted
 to a value of type `bool`, the function endeavors to generate the
 requested output. If the generation fails, then the formatted output
+function does `setstate(ios_base::failbit)`, which can throw an
 exception. If an exception is thrown during output, then
+`ios_base::badbit` is set[^31]
+in `*this`’s error state. If `(exceptions()&badbit) != 0` then the
+exception is rethrown. Whether or not an exception is thrown, the
+`sentry` object is destroyed before leaving the formatted output
+function. If no exception is thrown, the result of the formatted output
+function is `*this`.
 The descriptions of the individual formatted output functions describe
 how they perform output and do not mention the `sentry` object.
 If a formatted output function of a stream `os` determines padding, it
 they are placed before the character sequence.
 ##### Arithmetic inserters <a id="ostream.inserters.arithmetic">[[ostream.inserters.arithmetic]]</a>
 ``` cpp
+basic_ostream& operator<<(bool val);
+basic_ostream& operator<<(short val);
+basic_ostream& operator<<(unsigned short val);
+basic_ostream& operator<<(int val);
+basic_ostream& operator<<(unsigned int val);
+basic_ostream& operator<<(long val);
+basic_ostream& operator<<(unsigned long val);
+basic_ostream& operator<<(long long val);
+basic_ostream& operator<<(unsigned long long val);
+basic_ostream& operator<<(float val);
+basic_ostream& operator<<(double val);
+basic_ostream& operator<<(long double val);
+basic_ostream& operator<<(const void* val);
 ```
 *Effects:* The classes `num_get<>` and `num_put<>` handle
 locale-dependent numeric formatting and parsing. These inserter
 functions use the imbued `locale` value to perform numeric formatting.
 from which to obtain other facets. If `failed` is `true` then does
 `setstate(badbit)`, which may throw an exception, and returns.
 *Returns:* `*this`.
+``` cpp
+basic_ostream& operator<<(const volatile void* p);
+```
+*Effects:* Equivalent to:
+`return operator<<(const_cast<const void*>(p));`
+``` cpp
+basic_ostream& operator<<(extended-floating-point-type val);
+```
+*Effects:* If the floating-point conversion rank of
+*`extended-floating-point-type`* is less than or equal to that of
+`double`, the formatting conversion occurs as if it performed the
+following code fragment:
+``` cpp
+bool failed = use_facet<
+  num_put<charT, ostreambuf_iterator<charT, traits>>
+    >(getloc()).put(*this, *this, fill(),
+      static_cast<double>(val)).failed();
+```
+Otherwise, if the floating-point conversion rank of
+*`extended-floating-point-type`* is less than or equal to that of
+`long double`, the formatting conversion occurs as if it performed the
+following code fragment:
+``` cpp
+bool failed = use_facet<
+  num_put<charT, ostreambuf_iterator<charT, traits>>
+    >(getloc()).put(*this, *this, fill(),
+      static_cast<long double>(val)).failed();
+```
+Otherwise, an invocation of the operator function is conditionally
+supported with *implementation-defined* semantics.
+If `failed` is `true` then does `setstate(badbit)`, which may throw an
+exception, and returns.
+*Returns:* `*this`.
 ##### `basic_ostream::operator<<` <a id="ostream.inserters">[[ostream.inserters]]</a>
 ``` cpp
+basic_ostream& operator<<(basic_ostream& (*pf)(basic_ostream&));
 ```
 *Effects:* None. Does not behave as a formatted output function (as
 described in  [[ostream.formatted.reqmts]]).
+*Returns:* `pf(*this)`.[^32]
 ``` cpp
+basic_ostream& operator<<(basic_ios<charT, traits>& (*pf)(basic_ios<charT, traits>&));
 ```
 *Effects:* Calls `pf(*this)`. This inserter does not behave as a
 formatted output function (as described
 in  [[ostream.formatted.reqmts]]).
+*Returns:* `*this`.[^33]
 ``` cpp
+basic_ostream& operator<<(ios_base& (*pf)(ios_base&));
 ```
 *Effects:* Calls `pf(*this)`. This inserter does not behave as a
 formatted output function (as described
 in  [[ostream.formatted.reqmts]]).
 *Returns:* `*this`.
 ``` cpp
+basic_ostream& operator<<(basic_streambuf<charT, traits>* sb);
 ```
 *Effects:* Behaves as an unformatted output
+function [[ostream.unformatted]]. After the `sentry` object is
 constructed, if `sb` is null calls `setstate(badbit)` (which may throw
 `ios_base::failure`).
 Gets characters from `sb` and inserts them in `*this`. Characters are
 read from `sb` and inserted until any of the following occurs:
 exception is rethrown.
 *Returns:* `*this`.
 ``` cpp
+basic_ostream& operator<<(nullptr_t);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 in  [[ostream.formatted.reqmts]]. Inserts `seq` into `out`. Calls
 `width(0)`.
 *Returns:* `out`.
+##### Print <a id="ostream.formatted.print">[[ostream.formatted.print]]</a>
+``` cpp
+template<class... Args>
+  void print(ostream& os, format_string<Args...> fmt, Args&&... args);
+```
+*Effects:* If the ordinary literal encoding [[lex.charset]] is UTF-8,
+equivalent to:
+``` cpp
+vprint_unicode(os, fmt.str, make_format_args(std::forward<Args>(args)...));
+```
+Otherwise, equivalent to:
+``` cpp
+vprint_nonunicode(os, fmt.str, make_format_args(std::forward<Args>(args)...));
+```
+``` cpp
+template<class... Args>
+  void println(ostream& os, format_string<Args...> fmt, Args&&... args);
+```
+*Effects:* Equivalent to:
+``` cpp
+print(os, "{}\n", format(fmt, std::forward<Args>(args)...));
+```
+``` cpp
+void vprint_unicode(ostream& os, string_view fmt, format_args args);
+void vprint_nonunicode(ostream& os, string_view fmt, format_args args);
+```
+*Effects:* Behaves as a formatted output
+function [[ostream.formatted.reqmts]] of `os`, except that:
+- failure to generate output is reported as specified below, and
+- any exception thrown by the call to `vformat` is propagated without
+  regard to the value of `os.exceptions()` and without turning on
+  `ios_base::badbit` in the error state of `os`.
+After constructing a `sentry` object, the function initializes an
+automatic variable via
+``` cpp
+string out = vformat(os.getloc(), fmt, args);
+```
+If the function is `vprint_unicode` and `os` is a stream that refers to
+a terminal capable of displaying Unicode which is determined in an
+implementation-defined manner, writes `out` to the terminal using the
+native Unicode API; if `out` contains invalid code units, the behavior
+is undefined and implementations are encouraged to diagnose it. If the
+native Unicode API is used, the function flushes `os` before writing
+`out`. Otherwise (if `os` is not such a stream or the function is
+`vprint_nonunicode`), inserts the character sequence \[`out.begin()`,
+`out.end()`) into `os`. If writing to the terminal or inserting into
+`os` fails, calls `os.setstate(ios_base::badbit)` (which may throw
+`ios_base::failure`).
+*Recommended practice:* For `vprint_unicode`, if invoking the native
+Unicode API requires transcoding, implementations should substitute
+invalid code units with U+fffd (replacement character) per the Unicode
+Standard, Chapter 3.9 ‘U+fffd‘ Substitution in Conversion.
 #### Unformatted output functions <a id="ostream.unformatted">[[ostream.unformatted]]</a>
 Each unformatted output function begins execution by constructing an
+object of class `sentry`. If that object returns `true`, while
 converting to a value of type `bool`, the function endeavors to generate
 the requested output. If an exception is thrown during output, then
+`ios_base::badbit` is set[^34]
+in `*this`’s error state. If `(exceptions() & badbit) != 0` then the
+exception is rethrown. In any case, the unformatted output function ends
+by destroying the `sentry` object, then, if no exception was thrown,
+returning the value specified for the unformatted output function.
 ``` cpp
+basic_ostream& put(char_type c);
 ```
 *Effects:* Behaves as an unformatted output function (as described
+above). After constructing a `sentry` object, inserts the character `c`,
+if possible.[^35]
 Otherwise, calls `setstate(badbit)` (which may throw `ios_base::failure`
 [[iostate.flags]]).
 *Returns:* `*this`.
 ``` cpp
 basic_ostream& write(const char_type* s, streamsize n);
 ```
 *Effects:* Behaves as an unformatted output function (as described
+above). After constructing a `sentry` object, obtains characters to
+insert from successive locations of an array whose first element is
+designated by `s`.[^36]
+Characters are inserted until either of the following occurs:
 - `n` characters are inserted;
 - inserting in the output sequence fails (in which case the function
   calls `setstate(badbit)`, which may throw `ios_base::failure`
   [[iostate.flags]]).
 ``` cpp
 basic_ostream& flush();
 ```
 *Effects:* Behaves as an unformatted output function (as described
+above). If `rdbuf()` is not a null pointer, constructs a `sentry`
+object. If that object returns `true` when converted to a value of type
+`bool` the function calls `rdbuf()->pubsync()`. If that function returns
+-1 calls `setstate(badbit)` (which may throw `ios_base::failure`
+[[iostate.flags]]). Otherwise, if the `sentry` object returns `false`,
 does nothing.
 *Returns:* `*this`.
 #### Standard manipulators <a id="ostream.manip">[[ostream.manip]]</a>
   basic_ostream<charT, traits>& flush_emit(basic_ostream<charT, traits>& os);
 ```
 *Effects:* Calls `os.flush()`. Then, if `os.rdbuf()` is a
 `basic_syncbuf<charT, traits, Allocator>*`, called `buf` for the purpose
+of exposition, behaves as an unformatted output
+function [[ostream.unformatted]] of `os`. After constructing a `sentry`
+object, calls `buf->emit()`. If that call returns `false`, calls
+`os.setstate(ios_base::badbit)`.
 *Returns:* `os`.
 #### Rvalue stream insertion <a id="ostream.rvalue">[[ostream.rvalue]]</a>
 *Returns:* An object of unspecified type such that if `out` is an object
 of type `basic_ostream<charT, traits>` then the expression
 `out << resetiosflags(mask)` behaves as if it called `f(out, mask)`, or
 if `in` is an object of type `basic_istream<charT, traits>` then the
 expression `in >> resetiosflags(mask)` behaves as if it called
+`f(in, mask)`, where the function `f` is defined as:[^37]
 ``` cpp
 void f(ios_base& str, ios_base::fmtflags mask) {
   // reset specified flags
   str.setf(ios_base::fmtflags(0), mask);
 The expression `out << put_money(mon, intl)` has type
 `basic_ostream<charT, traits>&` and value `out`.
 ``` cpp
+template<class charT> unspecified get_time(tm* tmb, const charT* fmt);
 ```
 *Preconditions:* The argument `tmb` is a valid pointer to an object of
+type `tm`, and \[`fmt`, `fmt + char_traits<charT>::length(fmt)`) is a
+valid range.
 *Returns:* An object of unspecified type such that if `in` is an object
 of type `basic_istream<charT, traits>` then the expression
 `in >> get_time(tmb, fmt)` behaves as if it called `f(in, tmb, fmt)`,
 where the function `f` is defined as:
 ``` cpp
 template<class charT, class traits>
+void f(basic_ios<charT, traits>& str, tm* tmb, const charT* fmt) {
   using Iter    = istreambuf_iterator<charT, traits>;
   using TimeGet = time_get<charT, Iter>;
   ios_base::iostate err = ios_base::goodbit;
   const TimeGet& tg = use_facet<TimeGet>(str.getloc());
 The expression `in >> get_time(tmb, fmt)` has type
 `basic_istream<charT, traits>&` and value `in`.
 ``` cpp
+template<class charT> unspecified put_time(const tm* tmb, const charT* fmt);
 ```
 *Preconditions:* The argument `tmb` is a valid pointer to an object of
+type `tm`, and \[`fmt`, `fmt + char_traits<charT>::length(fmt)`) is a
+valid range.
 *Returns:* An object of unspecified type such that if `out` is an object
 of type `basic_ostream<charT, traits>` then the expression
 `out << put_time(tmb, fmt)` behaves as if it called `f(out, tmb, fmt)`,
 where the function `f` is defined as:
 ``` cpp
 template<class charT, class traits>
+void f(basic_ios<charT, traits>& str, const tm* tmb, const charT* fmt) {
   using Iter    = ostreambuf_iterator<charT, traits>;
   using TimePut = time_put<charT, Iter>;
   const TimePut& tp = use_facet<TimePut>(str.getloc());
   const Iter end = tp.put(Iter(str.rdbuf()), str, str.fill(), tmb,
 - The expression `in >> quoted(s, delim, escape)` has type
   `basic_istream<charT, traits>&` and value `in`.
 - The expression `out << quoted(s, delim, escape)` has type
   `basic_ostream<charT, traits>&` and value `out`.
+### Print functions <a id="print.fun">[[print.fun]]</a>
+``` cpp
+template<class... Args>
+  void print(format_string<Args...> fmt, Args&&... args);
+```
+*Effects:* Equivalent to:
+``` cpp
+print(stdout, fmt, std::forward<Args>(args)...);
+```
+``` cpp
+template<class... Args>
+  void print(FILE* stream, format_string<Args...> fmt, Args&&... args);
+```
+*Effects:* If the ordinary literal encoding [[lex.charset]] is UTF-8,
+equivalent to:
+``` cpp
+vprint_unicode(stream, fmt.str, make_format_args(std::forward<Args>(args)...));
+```
+Otherwise, equivalent to:
+``` cpp
+vprint_nonunicode(stream, fmt.str, make_format_args(std::forward<Args>(args)...));
+```
+``` cpp
+template<class... Args>
+  void println(format_string<Args...> fmt, Args&&... args);
+```
+*Effects:* Equivalent to:
+``` cpp
+println(stdout, fmt, std::forward<Args>(args)...);
+```
+``` cpp
+template<class... Args>
+  void println(FILE* stream, format_string<Args...> fmt, Args&&... args);
+```
+*Effects:* Equivalent to:
+``` cpp
+print(stream, "{}\n", format(fmt, std::forward<Args>(args)...));
+```
+``` cpp
+void vprint_unicode(string_view fmt, format_args args);
+```
+*Effects:* Equivalent to:
+``` cpp
+vprint_unicode(stdout, fmt, args);
+```
+``` cpp
+void vprint_unicode(FILE* stream, string_view fmt, format_args args);
+```
+*Preconditions:* `stream` is a valid pointer to an output C stream.
+*Effects:* The function initializes an automatic variable via
+``` cpp
+string out = vformat(fmt, args);
+```
+If `stream` refers to a terminal capable of displaying Unicode, writes
+`out` to the terminal using the native Unicode API; if `out` contains
+invalid code units, the behavior is undefined and implementations are
+encouraged to diagnose it. Otherwise writes `out` to `stream` unchanged.
+If the native Unicode API is used, the function flushes `stream` before
+writing `out`.
+[*Note 1*: On POSIX and Windows, `stream` referring to a terminal means
+that, respectively, `isatty(fileno(stream))` and
+`GetConsoleMode(_get_osfhandle(_fileno(stream)), ...)` return
+nonzero. — *end note*]
+[*Note 2*: On Windows, the native Unicode API is
+`WriteConsoleW`. — *end note*]
+*Throws:* Any exception thrown by the call to `vformat`
+[[format.err.report]]. `system_error` if writing to the terminal or
+`stream` fails. May throw `bad_alloc`.
+*Recommended practice:* If invoking the native Unicode API requires
+transcoding, implementations should substitute invalid code units with
+U+fffd (replacement character) per the Unicode Standard, Chapter 3.9
+‘U+fffd‘ Substitution in Conversion.
+``` cpp
+void vprint_nonunicode(string_view fmt, format_args args);
+```
+*Effects:* Equivalent to:
+``` cpp
+vprint_nonunicode(stdout, fmt, args);
+```
+``` cpp
+void vprint_nonunicode(FILE* stream, string_view fmt, format_args args);
+```
+*Preconditions:* `stream` is a valid pointer to an output C stream.
+*Effects:* Writes the result of `vformat(fmt, args)` to `stream`.
+*Throws:* Any exception thrown by the call to `vformat`
+[[format.err.report]]. `system_error` if writing to `stream` fails. May
+throw `bad_alloc`.
 ## String-based streams <a id="string.streams">[[string.streams]]</a>
 ### Header `<sstream>` synopsis <a id="sstream.syn">[[sstream.syn]]</a>
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>,
            class Allocator = allocator<charT>>
     class basic_stringbuf;
+  template<class charT, class traits, class Allocator>
+    void swap(basic_stringbuf<charT, traits, Allocator>& x,
+              basic_stringbuf<charT, traits, Allocator>& y) noexcept(noexcept(x.swap(y)));
   using stringbuf  = basic_stringbuf<char>;
   using wstringbuf = basic_stringbuf<wchar_t>;
   template<class charT, class traits = char_traits<charT>,
            class Allocator = allocator<charT>>
     class basic_istringstream;
+  template<class charT, class traits, class Allocator>
+    void swap(basic_istringstream<charT, traits, Allocator>& x,
+              basic_istringstream<charT, traits, Allocator>& y);
   using istringstream  = basic_istringstream<char>;
   using wistringstream = basic_istringstream<wchar_t>;
   template<class charT, class traits = char_traits<charT>,
            class Allocator = allocator<charT>>
     class basic_ostringstream;
+  template<class charT, class traits, class Allocator>
+    void swap(basic_ostringstream<charT, traits, Allocator>& x,
+              basic_ostringstream<charT, traits, Allocator>& y);
   using ostringstream  = basic_ostringstream<char>;
   using wostringstream = basic_ostringstream<wchar_t>;
   template<class charT, class traits = char_traits<charT>,
            class Allocator = allocator<charT>>
     class basic_stringstream;
+  template<class charT, class traits, class Allocator>
+    void swap(basic_stringstream<charT, traits, Allocator>& x,
+              basic_stringstream<charT, traits, Allocator>& y);
   using stringstream  = basic_stringstream<char>;
   using wstringstream = basic_stringstream<wchar_t>;
 }
 ```
 associate stream buffers with objects of class `basic_string`, as
 described in  [[string.classes]].
 ### Class template `basic_stringbuf` <a id="stringbuf">[[stringbuf]]</a>
+#### General <a id="stringbuf.general">[[stringbuf.general]]</a>
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>,
            class Allocator = allocator<charT>>
   class basic_stringbuf : public basic_streambuf<charT, traits> {
         ios_base::openmode which = ios_base::in | ios_base::out);
     basic_stringbuf(const basic_stringbuf&) = delete;
     basic_stringbuf(basic_stringbuf&& rhs);
     basic_stringbuf(basic_stringbuf&& rhs, const Allocator& a);
+    // [stringbuf.assign], assignment and swap
     basic_stringbuf& operator=(const basic_stringbuf&) = delete;
     basic_stringbuf& operator=(basic_stringbuf&& rhs);
     void swap(basic_stringbuf& rhs) noexcept(see below);
     // [stringbuf.members], getters and setters
   private:
     ios_base::openmode mode;                        // exposition only
     basic_string<charT, traits, Allocator> buf;     // exposition only
     void init_buf_ptrs();                           // exposition only
   };
 }
 ```
 The class `basic_stringbuf` is derived from `basic_streambuf` to
 associate possibly the input sequence and possibly the output sequence
 void swap(basic_stringbuf& rhs) noexcept(see below);
 ```
 *Preconditions:*
 `allocator_traits<Allocator>::propagate_on_container_swap::value` is
+`true` or `get_allocator() == rhs.get_allocator()` is `true`.
 *Effects:* Exchanges the state of `*this` and `rhs`.
+*Remarks:* The exception specification is equivalent to:
 `allocator_traits<Allocator>::propagate_on_container_swap::value ||`
 `allocator_traits<Allocator>::is_always_equal::value`.
 ``` cpp
 template<class charT, class traits, class Allocator>
   - otherwise `pptr() == pbase()` is `true`.
 - If `ios_base::in` is set in `mode`, `eback()` points to `buf.front()`,
   and `(gptr() == eback() && egptr() == eback() + buf.size())` is
   `true`.
+[*Note 1*: For efficiency reasons, stream buffer operations can violate
+invariants of `buf` while it is held encapsulated in the
 `basic_stringbuf`, e.g., by writing to characters in the range
 \[`buf.data() + buf.size()`, `buf.data() + buf.capacity()`). All
 operations retrieving a `basic_string` from `buf` ensure that the
 `basic_string` invariants hold on the returned value. — *end note*]
 ``` cpp
 basic_string<charT, traits, Allocator> str() &&;
 ```
+*Ensures:* The underlying character sequence `buf` is empty and
+`pbase()`, `pptr()`, `epptr()`, `eback()`, `gptr()`, and `egptr()` are
+initialized as if by calling `init_buf_ptrs()` with an empty `buf`.
 *Returns:* A `basic_string<charT, traits, Allocator>` object move
 constructed from the `basic_stringbuf`’s underlying character sequence
 in `buf`. This can be achieved by first adjusting `buf` to have the same
 content as `view()`.
 ``` cpp
 basic_string_view<charT, traits> view() const noexcept;
 ```
 Let `sv` be `basic_string_view<charT, traits>`.
   input sequence has a putback position available, and if
   `traits::eq(to_char_type(c), gptr()[-1])` returns `true`, assigns
   `gptr() - 1` to `gptr()`. Returns: `c`.
 - If `traits::eq_int_type(c, traits::eof())` returns `false` and if the
   input sequence has a putback position available, and if `mode` `&`
+  `ios_base::out` is nonzero, assigns `c` to `*–gptr()`. Returns: `c`.
 - If `traits::eq_int_type(c, traits::eof())` returns `true` and if the
   input sequence has a putback position available, assigns `gptr() - 1`
   to `gptr()`. Returns: `traits::not_eof(c)`.
 *Returns:* As specified above, or `traits::eof()` to indicate failure.
   function calls `sputc(c)`. Signals success by returning `c`.
 - If `traits::eq_int_type(c, traits::eof())` returns `true`, there is no
   character to append. Signals success by returning a value other than
   `traits::eof()`.
+*Returns:* As specified above, or `traits::eof()` to indicate failure.
 *Remarks:* The function can alter the number of write positions
 available as a result of any call.
 The function can make a write position available only if `ios_base::out`
 is set in `mode`. To make a write position available, the function
 reallocates (or initially allocates) an array object with a sufficient
 number of elements to hold the current array object (if any), plus at
 least one additional write position. If `ios_base::in` is set in `mode`,
 *Returns:* `sp` to indicate success, or `pos_type(off_type(-1))` to
 indicate failure.
 ``` cpp
+basic_streambuf<charT, traits>* setbuf(charT* s, streamsize n) override;
 ```
 *Effects:* *implementation-defined*, except that `setbuf(0, 0)` has no
 effect.
 *Returns:* `this`.
 ### Class template `basic_istringstream` <a id="istringstream">[[istringstream]]</a>
+#### General <a id="istringstream.general">[[istringstream.general]]</a>
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>,
            class Allocator = allocator<charT>>
   class basic_istringstream : public basic_istream<charT, traits> {
         const basic_string<charT, traits, SAlloc>& s,
         ios_base::openmode which = ios_base::in);
     basic_istringstream(const basic_istringstream&) = delete;
     basic_istringstream(basic_istringstream&& rhs);
     basic_istringstream& operator=(const basic_istringstream&) = delete;
     basic_istringstream& operator=(basic_istringstream&& rhs);
+    // [istringstream.swap], swap
     void swap(basic_istringstream& rhs);
     // [istringstream.members], members
     basic_stringbuf<charT, traits, Allocator>* rdbuf() const;
     basic_string<charT, traits, Allocator> str() const &;
     void str(basic_string<charT, traits, Allocator>&& s);
   private:
     basic_stringbuf<charT, traits, Allocator> sb;   // exposition only
   };
 }
 ```
 The class `basic_istringstream<charT, traits, Allocator>` supports
 reading objects of class `basic_string<{}charT, traits, Allocator>`. It
   ios_base::openmode which = ios_base::in);
 ```
 *Effects:* Initializes the base class with
 `basic_istream<charT, traits>(addressof(sb))` [[istream]] and `sb` with
+`basic_stringbuf<charT, traits, Allocator>(s, which | ios_base::in)`
+[[stringbuf.cons]].
 ``` cpp
 basic_istringstream(ios_base::openmode which, const Allocator& a);
 ```
     ios_base::openmode which, const Allocator& a);
 ```
 *Effects:* Initializes the base class with
 `basic_istream<charT, traits>(addressof(sb))` [[istream]] and `sb` with
+`basic_stringbuf<charT, traits, Allocator>(s, which | ios_base::in, a)`
+[[stringbuf.cons]].
 ``` cpp
 template<class SAlloc>
   explicit basic_istringstream(
     const basic_string<charT, traits, SAlloc>& s,
 by move constructing the base class, and the contained
 `basic_stringbuf`. Then calls
 `basic_istream<charT, traits>::set_rdbuf(addressof(sb))` to install the
 contained `basic_stringbuf`.
+#### Swap <a id="istringstream.swap">[[istringstream.swap]]</a>
 ``` cpp
 void swap(basic_istringstream& rhs);
 ```
 *Effects:* Equivalent to: `rdbuf()->str(std::move(s));`
 ### Class template `basic_ostringstream` <a id="ostringstream">[[ostringstream]]</a>
+#### General <a id="ostringstream.general">[[ostringstream.general]]</a>
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>,
            class Allocator = allocator<charT>>
   class basic_ostringstream : public basic_ostream<charT, traits> {
         const basic_string<charT, traits, SAlloc>& s,
         ios_base::openmode which = ios_base::out);
     basic_ostringstream(const basic_ostringstream&) = delete;
     basic_ostringstream(basic_ostringstream&& rhs);
     basic_ostringstream& operator=(const basic_ostringstream&) = delete;
     basic_ostringstream& operator=(basic_ostringstream&& rhs);
+    // [ostringstream.swap], swap
     void swap(basic_ostringstream& rhs);
     // [ostringstream.members], members
     basic_stringbuf<charT, traits, Allocator>* rdbuf() const;
     void str(basic_string<charT, traits, Allocator>&& s);
    private:
     basic_stringbuf<charT, traits, Allocator> sb;   // exposition only
   };
 }
 ```
 The class `basic_ostringstream<charT, traits, Allocator>` supports
 writing objects of class `basic_string<{}charT, traits, Allocator>`. It
   ios_base::openmode which = ios_base::out);
 ```
 *Effects:* Initializes the base class with
 `basic_ostream<charT, traits>(addressof(sb))` [[ostream]] and `sb` with
+`basic_stringbuf<charT, traits, Allocator>(s, which | ios_base::out)`
+[[stringbuf.cons]].
 ``` cpp
 basic_ostringstream(ios_base::openmode which, const Allocator& a);
 ```
 *Effects:* Initializes the base class with
 `basic_ostream<charT, traits>(addressof(sb))` [[ostream]] and `sb` with
+`basic_stringbuf<charT, traits, Allocator>(which | ios_base::out, a)`
+[[stringbuf.cons]].
 ``` cpp
 explicit basic_ostringstream(
   basic_string<charT, traits, Allocator>&& s,
   ios_base::openmode which = ios_base::out);
     ios_base::openmode which, const Allocator& a);
 ```
 *Effects:* Initializes the base class with
 `basic_ostream<charT, traits>(addressof(sb))` [[ostream]] and `sb` with
+`basic_stringbuf<charT, traits, Allocator>(s, which | ios_base::out, a)`
+[[stringbuf.cons]].
 ``` cpp
 template<class SAlloc>
   explicit basic_ostringstream(
     const basic_string<charT, traits, SAlloc>& s,
 *Constraints:* `is_same_v<SAlloc,Allocator>` is `false`.
 *Effects:* Initializes the base class with
 `basic_ostream<charT, traits>(addressof(sb))` [[ostream]] and `sb` with
+`basic_stringbuf<charT, traits, Allocator>(s, which | ios_base::out)`
+[[stringbuf.cons]].
 ``` cpp
 basic_ostringstream(basic_ostringstream&& rhs);
 ```
 by move constructing the base class, and the contained
 `basic_stringbuf`. Then calls
 `basic_ostream<charT, traits>::set_rdbuf(addressof(sb))` to install the
 contained `basic_stringbuf`.
+#### Swap <a id="ostringstream.swap">[[ostringstream.swap]]</a>
 ``` cpp
 void swap(basic_ostringstream& rhs);
 ```
 *Effects:* Equivalent to: `rdbuf()->str(std::move(s));`
 ### Class template `basic_stringstream` <a id="stringstream">[[stringstream]]</a>
+#### General <a id="stringstream.general">[[stringstream.general]]</a>
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>,
            class Allocator = allocator<charT>>
   class basic_stringstream : public basic_iostream<charT, traits> {
         const basic_string<charT, traits, SAlloc>& s,
         ios_base::openmode which = ios_base::out | ios_base::in);
     basic_stringstream(const basic_stringstream&) = delete;
     basic_stringstream(basic_stringstream&& rhs);
     basic_stringstream& operator=(const basic_stringstream&) = delete;
     basic_stringstream& operator=(basic_stringstream&& rhs);
+    // [stringstream.swap], swap
     void swap(basic_stringstream& rhs);
     // [stringstream.members], members
     basic_stringbuf<charT, traits, Allocator>* rdbuf() const;
     void str(basic_string<charT, traits, Allocator>&& s);
   private:
     basic_stringbuf<charT, traits> sb;  // exposition only
   };
 }
 ```
 The class template `basic_stringstream<charT, traits>` supports reading
 and writing from objects of class
 by move constructing the base class, and the contained
 `basic_stringbuf`. Then calls
 `basic_istream<charT, traits>::set_rdbuf(addressof(sb))` to install the
 contained `basic_stringbuf`.
+#### Swap <a id="stringstream.swap">[[stringstream.swap]]</a>
 ``` cpp
 void swap(basic_stringstream& rhs);
 ```
 void str(basic_string<charT, traits, Allocator>&& s);
 ```
 *Effects:* Equivalent to: `rdbuf()->str(std::move(s));`
+## Span-based streams <a id="span.streams">[[span.streams]]</a>
+### Overview <a id="span.streams.overview">[[span.streams.overview]]</a>
+The header `<spanstream>` defines class templates and types that
+associate stream buffers with objects whose types are specializations of
+`span` as described in [[views.span]].
+[*Note 1*: A user of these classes is responsible for ensuring that the
+character sequence represented by the given `span` outlives the use of
+the sequence by objects of the classes in subclause [[span.streams]].
+Using multiple `basic_spanbuf` objects referring to overlapping
+underlying sequences from different threads, where at least one
+`basic_spanbuf` object is used for writing to the sequence, results in a
+data race. — *end note*]
+### Header `<spanstream>` synopsis <a id="spanstream.syn">[[spanstream.syn]]</a>
+``` cpp
+namespace std {
+  template<class charT, class traits = char_traits<charT>>
+    class basic_spanbuf;
+  template<class charT, class traits>
+    void swap(basic_spanbuf<charT, traits>& x, basic_spanbuf<charT, traits>& y);
+  using spanbuf = basic_spanbuf<char>;
+  using wspanbuf = basic_spanbuf<wchar_t>;
+  template<class charT, class traits = char_traits<charT>>
+    class basic_ispanstream;
+  template<class charT, class traits>
+    void swap(basic_ispanstream<charT, traits>& x, basic_ispanstream<charT, traits>& y);
+  using ispanstream = basic_ispanstream<char>;
+  using wispanstream = basic_ispanstream<wchar_t>;
+  template<class charT, class traits = char_traits<charT>>
+    class basic_ospanstream;
+  template<class charT, class traits>
+    void swap(basic_ospanstream<charT, traits>& x, basic_ospanstream<charT, traits>& y);
+  using ospanstream = basic_ospanstream<char>;
+  using wospanstream = basic_ospanstream<wchar_t>;
+  template<class charT, class traits = char_traits<charT>>
+    class basic_spanstream;
+  template<class charT, class traits>
+    void swap(basic_spanstream<charT, traits>& x, basic_spanstream<charT, traits>& y);
+  using spanstream = basic_spanstream<char>;
+  using wspanstream = basic_spanstream<wchar_t>;
+}
+```
+### Class template `basic_spanbuf` <a id="spanbuf">[[spanbuf]]</a>
+#### General <a id="spanbuf.general">[[spanbuf.general]]</a>
+``` cpp
+namespace std {
+  template<class charT, class traits = char_traits<charT>>
+  class basic_spanbuf
+    : public basic_streambuf<charT, traits> {
+  public:
+    using char_type   = charT;
+    using int_type    = typename traits::int_type;
+    using pos_type    = typename traits::pos_type;
+    using off_type    = typename traits::off_type;
+    using traits_type = traits;
+    // [spanbuf.cons], constructors
+    basic_spanbuf() : basic_spanbuf(ios_base::in | ios_base::out) {}
+    explicit basic_spanbuf(ios_base::openmode which)
+      : basic_spanbuf(std::span<charT>(), which) {}
+    explicit basic_spanbuf(std::span<charT> s,
+                           ios_base::openmode which = ios_base::in | ios_base::out);
+    basic_spanbuf(const basic_spanbuf&) = delete;
+    basic_spanbuf(basic_spanbuf&& rhs);
+    // [spanbuf.assign], assignment and swap
+    basic_spanbuf& operator=(const basic_spanbuf&) = delete;
+    basic_spanbuf& operator=(basic_spanbuf&& rhs);
+    void swap(basic_spanbuf& rhs);
+    // [spanbuf.members], member functions
+    std::span<charT> span() const noexcept;
+    void span(std::span<charT> s) noexcept;
+  protected:
+    // [spanbuf.virtuals], overridden virtual functions
+    basic_streambuf<charT, traits>* setbuf(charT*, streamsize) override;
+    pos_type seekoff(off_type off, ios_base::seekdir way,
+                     ios_base::openmode which = ios_base::in | ios_base::out) override;
+    pos_type seekpos(pos_type sp,
+                     ios_base::openmode which = ios_base::in | ios_base::out) override;
+  private:
+    ios_base::openmode mode;            // exposition only
+    std::span<charT> buf;               // exposition only
+};
+}
+```
+The class template `basic_spanbuf` is derived from `basic_streambuf` to
+associate possibly the input sequence and possibly the output sequence
+with a sequence of arbitrary characters. The sequence is provided by an
+object of class `span<charT>`.
+For the sake of exposition, the maintained data is presented here as:
+- `ios_base::openmode mode`, has `in` set if the input sequence can be
+  read, and `out` set if the output sequence can be written.
+- `std::span<charT> buf` is the view to the underlying character
+  sequence.
+#### Constructors <a id="spanbuf.cons">[[spanbuf.cons]]</a>
+``` cpp
+explicit basic_spanbuf(std::span<charT> s,
+                       ios_base::openmode which = ios_base::in | ios_base::out);
+```
+*Effects:* Initializes the base class with `basic_streambuf()`
+[[streambuf.cons]], and *mode* with `which`. Initializes the internal
+pointers as if calling `span(s)`.
+``` cpp
+basic_spanbuf(basic_spanbuf&& rhs);
+```
+*Effects:* Initializes the base class with `std::move(rhs)` and *mode*
+with `std::move(rhs.`*`mode`*`)` and *buf* with
+`std::move(rhs.`*`buf`*`)`. The sequence pointers in `*this` (`eback()`,
+`gptr()`, `egptr()`, `pbase()`, `pptr()`, `epptr()`) obtain the values
+which `rhs` had. It is *implementation-defined* whether
+`rhs.`*`buf`*`.empty()` returns `true` after the move.
+*Ensures:* Let `rhs_p` refer to the state of `rhs` just prior to this
+construction.
+- `span().data() == rhs_p.span().data()`
+- `span().size() == rhs_p.span().size()`
+- `eback() == rhs_p.eback()`
+- `gptr() == rhs_p.gptr()`
+- `egptr() == rhs_p.egptr()`
+- `pbase() == rhs_p.pbase()`
+- `pptr() == rhs_p.pptr()`
+- `epptr() == rhs_p.epptr()`
+- `getloc() == rhs_p.getloc()`
+#### Assignment and swap <a id="spanbuf.assign">[[spanbuf.assign]]</a>
+``` cpp
+basic_spanbuf& operator=(basic_spanbuf&& rhs);
+```
+*Effects:* Equivalent to:
+``` cpp
+basic_spanbuf tmp{std::move(rhs)};
+this->swap(tmp);
+return *this;
+```
+``` cpp
+void swap(basic_spanbuf& rhs);
+```
+*Effects:* Equivalent to:
+``` cpp
+basic_streambuf<charT, traits>::swap(rhs);
+std::swap(mode, rhs.mode);
+std::swap(buf, rhs.buf);
+```
+``` cpp
+template<class charT, class traits>
+  void swap(basic_spanbuf<charT, traits>& x, basic_spanbuf<charT, traits>& y);
+```
+*Effects:* Equivalent to `x.swap(y)`.
+#### Member functions <a id="spanbuf.members">[[spanbuf.members]]</a>
+``` cpp
+std::span<charT> span() const noexcept;
+```
+*Returns:* If `ios_base::out` is set in *mode*, returns
+`std::span<charT>(pbase(), pptr())`, otherwise returns *buf*.
+[*Note 1*: In contrast to `basic_stringbuf`, the underlying sequence
+never grows and is not owned. An owning copy can be obtained by
+converting the result to `basic_string<charT>`. — *end note*]
+``` cpp
+void span(std::span<charT> s) noexcept;
+```
+*Effects:* *`buf`*` = s`. Initializes the input and output sequences
+according to *mode*.
+*Ensures:*
+- If `ios_base::out` is set in *mode*,
+  `pbase() == s.data() && epptr() == pbase() + s.size()` is `true`;
+  - in addition, if `ios_base::ate` is set in *mode*,
+    `pptr() == pbase() + s.size()` is `true`,
+  - otherwise `pptr() == pbase()` is `true`.
+- If `ios_base::in` is set in *mode*,
+  `eback() == s.data() && gptr() == eback() && egptr() == eback() + s.size()`
+  is `true`.
+#### Overridden virtual functions <a id="spanbuf.virtuals">[[spanbuf.virtuals]]</a>
+[*Note 1*: Because the underlying buffer is of fixed size, neither
+`overflow`, `underflow`, nor `pbackfail` can provide useful
+behavior. — *end note*]
+``` cpp
+pos_type seekoff(off_type off, ios_base::seekdir way,
+                 ios_base::openmode which = ios_base::in | ios_base::out) override;
+```
+*Effects:* Alters the stream position within one or both of the
+controlled sequences, if possible, as follows:
+- If `ios_base::in` is set in `which`, positions the input sequence;
+  `xnext` is `gptr()`, `xbeg` is `eback()`.
+- If `ios_base::out` is set in `which`, positions the output sequence;
+  `xnext` is `pptr()`, `xbeg` is `pbase()`.
+If both `ios_base::in` and `ios_base::out` are set in `which` and `way`
+is `ios_base::cur`, the positioning operation fails.
+For a sequence to be positioned, if its next pointer `xnext` (either
+`gptr()` or `pptr()`) is a null pointer and the new offset `newoff` as
+computed below is nonzero, the positioning operation fails. Otherwise,
+the function determines `baseoff` as a value of type `off_type` as
+follows:
+- `0` when `way` is `ios_base::beg`;
+- `(pptr() - pbase())` for the output sequence, or `(gptr() - eback())`
+  for the input sequence when `way` is `ios_base::cur`;
+- when `way` is `ios_base::end` :
+  - `(pptr() - pbase())` if `ios_base::out` is set in *mode* and
+    `ios_base::in` is not set in *mode*,
+  - `buf.size()` otherwise.
+If `baseoff` + `off` would overflow, or if `baseoff` + `off` is less
+than zero, or if `baseoff` + `off` is greater than *`buf`*`.size()`, the
+positioning operation fails. Otherwise, the function computes
+``` cpp
+off_type newoff = baseoff + off;
+```
+and assigns `xbeg + newoff` to the next pointer `xnext`.
+*Returns:* `pos_type(off_type(-1))` if the positioning operation fails;
+`pos_type(newoff)` otherwise.
+``` cpp
+pos_type seekpos(pos_type sp, ios_base::openmode which = ios_base::in | ios_base::out) override;
+```
+*Effects:* Equivalent to:
+``` cpp
+return seekoff(off_type(sp), ios_base::beg, which);
+```
+``` cpp
+basic_streambuf<charT, traits>* setbuf(charT* s, streamsize n) override;
+```
+*Effects:* Equivalent to:
+``` cpp
+this->span(std::span<charT>(s, n));
+return this;
+```
+### Class template `basic_ispanstream` <a id="ispanstream">[[ispanstream]]</a>
+#### General <a id="ispanstream.general">[[ispanstream.general]]</a>
+``` cpp
+namespace std {
+  template<class charT, class traits = char_traits<charT>>
+  class basic_ispanstream
+    : public basic_istream<charT, traits> {
+  public:
+    using char_type   = charT;
+    using int_type    = typename traits::int_type;
+    using pos_type    = typename traits::pos_type;
+    using off_type    = typename traits::off_type;
+    using traits_type = traits;
+    // [ispanstream.cons], constructors
+    explicit basic_ispanstream(std::span<charT> s,
+                               ios_base::openmode which = ios_base::in);
+    basic_ispanstream(const basic_ispanstream&) = delete;
+    basic_ispanstream(basic_ispanstream&& rhs);
+    template<class ROS> explicit basic_ispanstream(ROS&& s);
+    basic_ispanstream& operator=(const basic_ispanstream&) = delete;
+    basic_ispanstream& operator=(basic_ispanstream&& rhs);
+    // [ispanstream.swap], swap
+    void swap(basic_ispanstream& rhs);
+    // [ispanstream.members], member functions
+    basic_spanbuf<charT, traits>* rdbuf() const noexcept;
+    std::span<const charT> span() const noexcept;
+    void span(std::span<charT> s) noexcept;
+    template<class ROS> void span(ROS&& s) noexcept;
+  private:
+    basic_spanbuf<charT, traits> sb;    // exposition only
+  };
+}
+```
+[*Note 1*: Constructing an `ispanstream` from a *string-literal*
+includes the termination character `'\0'` in the underlying
+`spanbuf`. — *end note*]
+#### Constructors <a id="ispanstream.cons">[[ispanstream.cons]]</a>
+``` cpp
+explicit basic_ispanstream(std::span<charT> s, ios_base::openmode which = ios_base::in);
+```
+*Effects:* Initializes the base class with
+`basic_istream<charT, traits>(addressof(sb))` and `sb` with
+`basic_spanbuf<charT, traits>(s, which | ios_base::in)`
+[[spanbuf.cons]].
+``` cpp
+basic_ispanstream(basic_ispanstream&& rhs);
+```
+*Effects:* Initializes the base class with `std::move(rhs)` and `sb`
+with `std::move(rhs.sb)`. Next,
+`basic_istream<charT, traits>::set_rdbuf(addressof(sb))` is called to
+install the contained `basic_spanbuf`.
+``` cpp
+template<class ROS> explicit basic_ispanstream(ROS&& s)
+```
+*Constraints:* `ROS` models `ranges::borrowed_range`.
+`!convertible_to<ROS, std::span<charT>> && convertible_to<ROS, std::span<charT const>>`
+is `true`.
+*Effects:* Let `sp` be `std::span<const charT>(std::forward<ROS>(s))`.
+Equivalent to
+``` cpp
+basic_ispanstream(std::span<charT>(const_cast<charT*>(sp.data()), sp.size()))
+```
+#### Swap <a id="ispanstream.swap">[[ispanstream.swap]]</a>
+``` cpp
+void swap(basic_ispanstream& rhs);
+```
+*Effects:* Equivalent to:
+``` cpp
+basic_istream<charT, traits>::swap(rhs);
+sb.swap(rhs.sb);
+```
+``` cpp
+template<class charT, class traits>
+  void swap(basic_ispanstream<charT, traits>& x, basic_ispanstream<charT, traits>& y);
+```
+*Effects:* Equivalent to `x.swap(y)`.
+#### Member functions <a id="ispanstream.members">[[ispanstream.members]]</a>
+``` cpp
+basic_spanbuf<charT, traits>* rdbuf() const noexcept;
+```
+*Effects:* Equivalent to:
+``` cpp
+return const_cast<basic_spanbuf<charT, traits>*>(addressof(sb));
+```
+``` cpp
+std::span<const charT> span() const noexcept;
+```
+*Effects:* Equivalent to: `return rdbuf()->span();`
+``` cpp
+void span(std::span<charT> s) noexcept;
+```
+*Effects:* Equivalent to `rdbuf()->span(s)`.
+``` cpp
+template<class ROS> void span(ROS&& s) noexcept;
+```
+*Constraints:* `ROS` models `ranges::borrowed_range`.
+`(!convertible_to<ROS, std::span<charT>>) && convertible_to<ROS, std::span<const charT>>`
+is `true`.
+*Effects:* Let `sp` be `std::span<const charT>(std::forward<ROS>(s))`.
+Equivalent to:
+``` cpp
+this->span(std::span<charT>(const_cast<charT*>(sp.data()), sp.size()))
+```
+### Class template `basic_ospanstream` <a id="ospanstream">[[ospanstream]]</a>
+#### General <a id="ospanstream.general">[[ospanstream.general]]</a>
+``` cpp
+namespace std {
+  template<class charT, class traits = char_traits<charT>>
+  class basic_ospanstream
+    : public basic_ostream<charT, traits> {
+  public:
+    using char_type   = charT;
+    using int_type    = typename traits::int_type;
+    using pos_type    = typename traits::pos_type;
+    using off_type    = typename traits::off_type;
+    using traits_type = traits;
+    // [ospanstream.cons], constructors
+    explicit basic_ospanstream(std::span<charT> s,
+                               ios_base::openmode which = ios_base::out);
+    basic_ospanstream(const basic_ospanstream&) = delete;
+    basic_ospanstream(basic_ospanstream&& rhs);
+    basic_ospanstream& operator=(const basic_ospanstream&) = delete;
+    basic_ospanstream& operator=(basic_ospanstream&& rhs);
+    // [ospanstream.swap], swap
+    void swap(basic_ospanstream& rhs);
+    // [ospanstream.members], member functions
+    basic_spanbuf<charT, traits>* rdbuf() const noexcept;
+    std::span<charT> span() const noexcept;
+    void span(std::span<charT> s) noexcept;
+  private:
+    basic_spanbuf<charT, traits> sb;    // exposition only
+  };
+}
+```
+#### Constructors <a id="ospanstream.cons">[[ospanstream.cons]]</a>
+``` cpp
+explicit basic_ospanstream(std::span<charT> s,
+                           ios_base::openmode which = ios_base::out);
+```
+*Effects:* Initializes the base class with
+`basic_ostream<charT, traits>(addressof(sb))` and `sb` with
+`basic_spanbuf<charT, traits>(s, which | ios_base::out)`
+[[spanbuf.cons]].
+``` cpp
+basic_ospanstream(basic_ospanstream&& rhs) noexcept;
+```
+*Effects:* Initializes the base class with `std::move(rhs)` and `sb`
+with `std::move(rhs.sb)`. Next,
+`basic_ostream<charT, traits>::set_rdbuf(addressof(sb))` is called to
+install the contained `basic_spanbuf`.
+#### Swap <a id="ospanstream.swap">[[ospanstream.swap]]</a>
+``` cpp
+void swap(basic_ospanstream& rhs);
+```
+*Effects:* Equivalent to:
+``` cpp
+basic_ostream<charT, traits>::swap(rhs);
+sb.swap(rhs.sb);
+```
+``` cpp
+template<class charT, class traits>
+  void swap(basic_ospanstream<charT, traits>& x, basic_ospanstream<charT, traits>& y);
+```
+*Effects:* Equivalent to `x.swap(y)`.
+#### Member functions <a id="ospanstream.members">[[ospanstream.members]]</a>
+``` cpp
+basic_spanbuf<charT, traits>* rdbuf() const noexcept;
+```
+*Effects:* Equivalent to:
+``` cpp
+return const_cast<basic_spanbuf<charT, traits>*>(addressof(sb));
+```
+``` cpp
+std::span<charT> span() const noexcept;
+```
+*Effects:* Equivalent to: `return rdbuf()->span();`
+``` cpp
+void span(std::span<charT> s) noexcept;
+```
+*Effects:* Equivalent to `rdbuf()->span(s)`.
+### Class template `basic_spanstream` <a id="spanstream">[[spanstream]]</a>
+#### General <a id="spanstream.general">[[spanstream.general]]</a>
+``` cpp
+namespace std {
+  template<class charT, class traits = char_traits<charT>>
+  class basic_spanstream
+    : public basic_iostream<charT, traits> {
+  public:
+    using char_type   = charT;
+    using int_type    = typename traits::int_type;
+    using pos_type    = typename traits::pos_type;
+    using off_type    = typename traits::off_type;
+    using traits_type = traits;
+    // [spanstream.cons], constructors
+    explicit basic_spanstream(std::span<charT> s,
+                              ios_base::openmode which = ios_base::out | ios_base::in);
+    basic_spanstream(const basic_spanstream&) = delete;
+    basic_spanstream(basic_spanstream&& rhs);
+    basic_spanstream& operator=(const basic_spanstream&) = delete;
+    basic_spanstream& operator=(basic_spanstream&& rhs);
+    // [spanstream.swap], swap
+    void swap(basic_spanstream& rhs);
+    // [spanstream.members], members
+    basic_spanbuf<charT, traits>* rdbuf() const noexcept;
+    std::span<charT> span() const noexcept;
+    void span(std::span<charT> s) noexcept;
+  private:
+    basic_spanbuf<charT, traits> sb;    // exposition only
+  };
+}
+```
+#### Constructors <a id="spanstream.cons">[[spanstream.cons]]</a>
+``` cpp
+explicit basic_spanstream(std::span<charT> s,
+                          ios_base::openmode which = ios_base::out | ios_bas::in);
+```
+*Effects:* Initializes the base class with
+`basic_iostream<charT, traits>(addressof(sb))` and `sb` with
+`basic_spanbuf<charT, traits>(s, which)` [[spanbuf.cons]].
+``` cpp
+basic_spanstream(basic_spanstream&& rhs);
+```
+*Effects:* Initializes the base class with `std::move(rhs)` and `sb`
+with `std::move(rhs.sb)`. Next,
+`basic_iostream<charT, traits>::set_rdbuf(addressof(sb))` is called to
+install the contained `basic_spanbuf`.
+#### Swap <a id="spanstream.swap">[[spanstream.swap]]</a>
+``` cpp
+void swap(basic_spanstream& rhs);
+```
+*Effects:* Equivalent to:
+``` cpp
+basic_iostream<charT, traits>::swap(rhs);
+sb.swap(rhs.sb);
+```
+``` cpp
+template<class charT, class traits>
+  void swap(basic_spanstream<charT, traits>& x, basic_spanstream<charT, traits>& y);
+```
+*Effects:* Equivalent to `x.swap(y)`.
+#### Member functions <a id="spanstream.members">[[spanstream.members]]</a>
+``` cpp
+basic_spanbuf<charT, traits>* rdbuf() const noexcept;
+```
+*Effects:* Equivalent to:
+``` cpp
+return const_cast<basic_spanbuf<charT, traits>*>(addressof(sb));
+```
+``` cpp
+std::span<charT> span() const noexcept;
+```
+*Effects:* Equivalent to: `return rdbuf()->span();`
+``` cpp
+void span(std::span<charT> s) noexcept;
+```
+*Effects:* Equivalent to `rdbuf()->span(s)`.
 ## File-based streams <a id="file.streams">[[file.streams]]</a>
 ### Header `<fstream>` synopsis <a id="fstream.syn">[[fstream.syn]]</a>
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>>
     class basic_filebuf;
+  template<class charT, class traits>
+    void swap(basic_filebuf<charT, traits>& x, basic_filebuf<charT, traits>& y);
   using filebuf  = basic_filebuf<char>;
   using wfilebuf = basic_filebuf<wchar_t>;
   template<class charT, class traits = char_traits<charT>>
     class basic_ifstream;
+  template<class charT, class traits>
+    void swap(basic_ifstream<charT, traits>& x, basic_ifstream<charT, traits>& y);
   using ifstream  = basic_ifstream<char>;
   using wifstream = basic_ifstream<wchar_t>;
   template<class charT, class traits = char_traits<charT>>
     class basic_ofstream;
+  template<class charT, class traits>
+    void swap(basic_ofstream<charT, traits>& x, basic_ofstream<charT, traits>& y);
   using ofstream  = basic_ofstream<char>;
   using wofstream = basic_ofstream<wchar_t>;
   template<class charT, class traits = char_traits<charT>>
     class basic_fstream;
+  template<class charT, class traits>
+    void swap(basic_fstream<charT, traits>& x, basic_fstream<charT, traits>& y);
   using fstream  = basic_fstream<char>;
   using wfstream = basic_fstream<wchar_t>;
 }
 ```
 file typically holds multibyte character sequences and the
 `basic_filebuf` object converts those multibyte sequences into wide
 character sequences. — *end note*]
 In subclause  [[file.streams]], member functions taking arguments of
+`const filesystem::path::value_type*` are only provided on systems where
+`filesystem::path::value_type` [[fs.class.path]] is not `char`.
 [*Note 2*: These functions enable class `path` support for systems with
 a wide native path character type, such as `wchar_t`. — *end note*]
 ### Class template `basic_filebuf` <a id="filebuf">[[filebuf]]</a>
+#### General <a id="filebuf.general">[[filebuf.general]]</a>
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_filebuf : public basic_streambuf<charT, traits> {
   public:
     basic_filebuf();
     basic_filebuf(const basic_filebuf&) = delete;
     basic_filebuf(basic_filebuf&& rhs);
     virtual ~basic_filebuf();
+    // [filebuf.assign], assignment and swap
     basic_filebuf& operator=(const basic_filebuf&) = delete;
     basic_filebuf& operator=(basic_filebuf&& rhs);
     void swap(basic_filebuf& rhs);
     // [filebuf.members], members
                      ios_base::openmode which
                       = ios_base::in | ios_base::out) override;
     int      sync() override;
     void     imbue(const locale& loc) override;
   };
 }
 ```
 The class `basic_filebuf<charT, traits>` associates both the input
 sequence and the output sequence with a file.
 *Effects:* Exchanges the state of `*this` and `rhs`.
 ``` cpp
 template<class charT, class traits>
+  void swap(basic_filebuf<charT, traits>& x, basic_filebuf<charT, traits>& y);
 ```
 *Effects:* Equivalent to: `x.swap(y)`.
 #### Member functions <a id="filebuf.members">[[filebuf.members]]</a>
 [[filebuf.open.modes]]. If `mode` is not some combination of flags shown
 in the table then the open fails.
 **Table: File open modes** <a id="filebuf.open.modes">[filebuf.open.modes]</a>
+| `binary` | `in` | `out` | `trunc` | `app` | `noreplace` | `stdio` equivalent |
+| -------- | ---- | ----- | ------- | ----- | ----------- | ------------------ |
+|          |      | +     |         |       |             | `"w"` |
+|          |      | +     |         |       | + | `"wx"` |
+|          |      | +     | +       |       |             | `"w"` |
+|          |      | +     | +       |       | +           | `"wx"` |
+|          |      | + |         | +     |             | `"a"` |
+|          | |       |         | +     | | `"a"` |
+|          | +    |       |         |       |             | `"r"` |
+|          | +    | +     |         | |             | `"r+"` |
+|          | +    | +     | + | | | `"w+"` |
+|          | + | +     | +       |       | + | `"w+x"` |
+|          | + | +     |         | +     |             | `"a+"` |
+|          | + | |         | +     | | `"a+"` |
+| +        |      | + |         |       |             | `"wb"` |
+| +        | | +     |         |       | +           | `"wbx"` |
+| +        | | +     | +       |       |             | `"wb"` |
+| +        |      | + | + | | + | `"wbx"` |
+| +        |      | + |         | +     |             | `"ab"` |
+| +        |      |       |         | +     |             | `"ab"`             |
+| +        | +    |       |         |       |             | `"rb"`             |
+| +        | +    | +     |         |       |             | `"r+b"`            |
+| +        | +    | +     | +       |       |             | `"w+b"`            |
+| +        | +    | +     | +       |       | +           | `"w+bx"`           |
+| +        | +    | +     |         | +     |             | `"a+b"`            |
+| +        | +    |       |         | +     |             | `"a+b"`            |
 If the open operation succeeds and `ios_base::ate` is set in `mode`,
 positions the file to the end (as if by calling
 `fseek(file, 0, SEEK_END)`, where `file` is the pointer returned by
+calling `fopen`).[^38]
 If the repositioning operation fails, calls `close()` and returns a null
 pointer to indicate failure.
 *Returns:* `this` if successful, a null pointer otherwise.
 `fclose(file)`). If any of the calls made by the function, including
 `fclose`, fails, `close` fails by returning a null pointer. If one of
 these calls throws an exception, the exception is caught and rethrown
 after closing the file.
+*Ensures:* `is_open() == false`.
 *Returns:* `this` on success, a null pointer otherwise.
 #### Overridden virtual functions <a id="filebuf.virtuals">[[filebuf.virtuals]]</a>
 ``` cpp
 streamsize showmanyc() override;
 ```
 *Effects:* Behaves the same as `basic_streambuf::showmanyc()`
 [[streambuf.virtuals]].
+*Remarks:* An implementation may provide an overriding definition for
+this function signature if it can determine whether more characters can
 be read from the input sequence.
 ``` cpp
 int_type underflow() override;
 ```
 and if the last operation was output, then update the output sequence
 and write any unshift sequence. Next, seek to the new position: if
 `width > 0`, call `fseek(file, width * off, whence)`, otherwise call
 `fseek(file, 0, whence)`.
+*Returns:* A newly constructed `pos_type` object that stores the
+resultant stream position, if possible. If the positioning operation
+fails, or if the object cannot represent the resultant stream position,
+returns `pos_type(off_type(-1))`.
 *Remarks:* “The last operation was output” means either the last virtual
 operation was overflow or the put buffer is non-empty. “Write any
 unshift sequence” means, if `width` if less than zero then call
 `a_codecvt.unshift(state, xbuf, xbuf+XSIZE, xbuf_end)` and output the
 resulting unshift sequence. The function determines one of three values
 | ---------------- | ------------------ |
 | `basic_ios::beg` | `SEEK_SET`         |
 | `basic_ios::cur` | `SEEK_CUR`         |
 | `basic_ios::end` | `SEEK_END`         |
 ``` cpp
 pos_type seekpos(pos_type sp,
                  ios_base::openmode which
                    = ios_base::in | ios_base::out) override;
 ```
 characters. This in turn may require the implementation to be able to
 reconstruct the original contents of the file.
 ### Class template `basic_ifstream` <a id="ifstream">[[ifstream]]</a>
+#### General <a id="ifstream.general">[[ifstream.general]]</a>
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_ifstream : public basic_istream<charT, traits> {
   public:
                             ios_base::openmode mode = ios_base::in);
     explicit basic_ifstream(const filesystem::path::value_type* s,
                             ios_base::openmode mode = ios_base::in);// wide systems only; see [fstream.syn]
     explicit basic_ifstream(const string& s,
                             ios_base::openmode mode = ios_base::in);
+ template<class T>
+      explicit basic_ifstream(const T& s, ios_base::openmode mode = ios_base::in);
     basic_ifstream(const basic_ifstream&) = delete;
     basic_ifstream(basic_ifstream&& rhs);
     basic_ifstream& operator=(const basic_ifstream&) = delete;
     basic_ifstream& operator=(basic_ifstream&& rhs);
+    // [ifstream.swap], swap
     void swap(basic_ifstream& rhs);
     // [ifstream.members], members
     basic_filebuf<charT, traits>* rdbuf() const;
     void open(const filesystem::path::value_type* s,
               ios_base::openmode mode = ios_base::in);  // wide systems only; see [fstream.syn]
     void open(const string& s, ios_base::openmode mode = ios_base::in);
     void open(const filesystem::path& s, ios_base::openmode mode = ios_base::in);
     void close();
   private:
     basic_filebuf<charT, traits> sb;    // exposition only
   };
 }
 ```
 The class `basic_ifstream<charT, traits>` supports reading from named
 files. It uses a `basic_filebuf<{}charT, traits>` object to control the
 pointer, calls `setstate(failbit)`.
 ``` cpp
 explicit basic_ifstream(const string& s,
                         ios_base::openmode mode = ios_base::in);
 ```
 *Effects:* Equivalent to: `basic_ifstream(s.c_str(), mode)`.
+``` cpp
+template<class T>
+  explicit basic_ifstream(const T& s, ios_base::openmode mode = ios_base::in);
+```
+*Constraints:* `is_same_v<T, filesystem::path>` is `true`.
+*Effects:* Equivalent to: `basic_ifstream(s.c_str(), mode)`.
 ``` cpp
 basic_ifstream(basic_ifstream&& rhs);
 ```
 *Effects:* Move constructs the base class, and the contained
 `basic_filebuf`. Then calls
 `basic_istream<charT, traits>::set_rdbuf(addressof(sb))` to install the
 contained `basic_filebuf`.
+#### Swap <a id="ifstream.swap">[[ifstream.swap]]</a>
 ``` cpp
 void swap(basic_ifstream& rhs);
 ```
 *Effects:* Exchanges the state of `*this` and `rhs` by calling
 `basic_istream<charT, traits>::swap(rhs)` and `sb.swap(rhs.sb)`.
 ``` cpp
 template<class charT, class traits>
+  void swap(basic_ifstream<charT, traits>& x, basic_ifstream<charT, traits>& y);
 ```
 *Effects:* Equivalent to: `x.swap(y)`.
 #### Member functions <a id="ifstream.members">[[ifstream.members]]</a>
 pointer, calls `setstate(failbit)` (which may throw
 `ios_base::failure`) [[iostate.flags]].
 ### Class template `basic_ofstream` <a id="ofstream">[[ofstream]]</a>
+#### General <a id="ofstream.general">[[ofstream.general]]</a>
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_ofstream : public basic_ostream<charT, traits> {
   public:
                             ios_base::openmode mode = ios_base::out);
     explicit basic_ofstream(const filesystem::path::value_type* s,  // wide systems only; see [fstream.syn]
                             ios_base::openmode mode = ios_base::out);
     explicit basic_ofstream(const string& s,
                             ios_base::openmode mode = ios_base::out);
+ template<class T>
+      explicit basic_ofstream(const T& s, ios_base::openmode mode = ios_base::out);
     basic_ofstream(const basic_ofstream&) = delete;
     basic_ofstream(basic_ofstream&& rhs);
     basic_ofstream& operator=(const basic_ofstream&) = delete;
     basic_ofstream& operator=(basic_ofstream&& rhs);
+    // [ofstream.swap], swap
     void swap(basic_ofstream& rhs);
     // [ofstream.members], members
     basic_filebuf<charT, traits>* rdbuf() const;
     void open(const filesystem::path::value_type* s,
               ios_base::openmode mode = ios_base::out);     // wide systems only; see [fstream.syn]
     void open(const string& s, ios_base::openmode mode = ios_base::out);
     void open(const filesystem::path& s, ios_base::openmode mode = ios_base::out);
     void close();
   private:
     basic_filebuf<charT, traits> sb;    // exposition only
   };
 }
 ```
 The class `basic_ofstream<charT, traits>` supports writing to named
 files. It uses a `basic_filebuf<{}charT, traits>` object to control the
 null pointer, calls `setstate(failbit)`.
 ``` cpp
 explicit basic_ofstream(const string& s,
                         ios_base::openmode mode = ios_base::out);
 ```
 *Effects:* Equivalent to: `basic_ofstream(s.c_str(), mode)`.
+``` cpp
+template<class T>
+  explicit basic_ofstream(const T& s, ios_base::openmode mode = ios_base::out);
+```
+*Constraints:* `is_same_v<T, filesystem::path>` is `true`.
+*Effects:* Equivalent to: `basic_ofstream(s.c_str(), mode)`.
 ``` cpp
 basic_ofstream(basic_ofstream&& rhs);
 ```
 *Effects:* Move constructs the base class, and the contained
 `basic_filebuf`. Then calls
 `basic_ostream<charT, traits>::set_rdbuf(addressof(sb))` to install the
 contained `basic_filebuf`.
+#### Swap <a id="ofstream.swap">[[ofstream.swap]]</a>
 ``` cpp
 void swap(basic_ofstream& rhs);
 ```
 *Effects:* Exchanges the state of `*this` and `rhs` by calling
 `basic_ostream<charT, traits>::swap(rhs)` and `sb.swap(rhs.sb)`.
 ``` cpp
 template<class charT, class traits>
+  void swap(basic_ofstream<charT, traits>& x, basic_ofstream<charT, traits>& y);
 ```
 *Effects:* Equivalent to: `x.swap(y)`.
 #### Member functions <a id="ofstream.members">[[ofstream.members]]</a>
 *Effects:* Calls `open(s.c_str(), mode)`.
 ### Class template `basic_fstream` <a id="fstream">[[fstream]]</a>
+#### General <a id="fstream.general">[[fstream.general]]</a>
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_fstream : public basic_iostream<charT, traits> {
   public:
       const filesystem::path::value_type* s,
       ios_base::openmode mode = ios_base::in|ios_base::out);    // wide systems only; see [fstream.syn]
     explicit basic_fstream(
       const string& s,
       ios_base::openmode mode = ios_base::in | ios_base::out);
+ template<class T>
+ explicit basic_fstream(const T& s, ios_base::openmode mode = ios_base::in | ios_base::out);
     basic_fstream(const basic_fstream&) = delete;
     basic_fstream(basic_fstream&& rhs);
     basic_fstream& operator=(const basic_fstream&) = delete;
     basic_fstream& operator=(basic_fstream&& rhs);
+    // [fstream.swap], swap
     void swap(basic_fstream& rhs);
     // [fstream.members], members
     basic_filebuf<charT, traits>* rdbuf() const;
     bool is_open() const;
     void close();
   private:
     basic_filebuf<charT, traits> sb;    // exposition only
   };
 }
 ```
 The class template `basic_fstream<charT, traits>` supports reading and
 writing from named files. It uses a `basic_filebuf<charT, traits>`
 ``` cpp
 explicit basic_fstream(
   const string& s,
   ios_base::openmode mode = ios_base::in | ios_base::out);
 ```
 *Effects:* Equivalent to: `basic_fstream(s.c_str(), mode)`.
+``` cpp
+template<class T>
+  explicit basic_fstream(const T& s, ios_base::openmode mode = ios_base::in | ios_base::out);
+```
+*Constraints:* `is_same_v<T, filesystem::path>` is `true`.
+*Effects:* Equivalent to: `basic_fstream(s.c_str(), mode)`.
 ``` cpp
 basic_fstream(basic_fstream&& rhs);
 ```
 *Effects:* Move constructs the base class, and the contained
 `basic_filebuf`. Then calls
 `basic_istream<charT, traits>::set_rdbuf(addressof(sb))` to install the
 contained `basic_filebuf`.
+#### Swap <a id="fstream.swap">[[fstream.swap]]</a>
 ``` cpp
 void swap(basic_fstream& rhs);
 ```
 namespace std {
   template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
     class basic_syncbuf;
+  // [syncstream.syncbuf.special], specialized algorithms
+  template<class charT, class traits, class Allocator>
+    void swap(basic_syncbuf<charT, traits, Allocator>&,
+              basic_syncbuf<charT, traits, Allocator>&);
   using syncbuf = basic_syncbuf<char>;
   using wsyncbuf = basic_syncbuf<wchar_t>;
   template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
     class basic_osyncstream;
   private:
     streambuf_type* wrapped;    // exposition only
     bool emit_on_sync{};        // exposition only
   };
 }
 ```
 Class template `basic_syncbuf` stores character data written to it,
 known as the associated output, into internal buffers allocated using
 basic_syncbuf(streambuf_type* obuf, const Allocator& allocator);
 ```
 *Effects:* Sets `wrapped` to `obuf`.
 *Ensures:* `get_wrapped() == obuf` and `get_allocator() == allocator`
 are `true`.
+*Throws:* Nothing unless an exception is thrown by the construction of a
+mutex or by memory allocation.
+*Remarks:* A copy of `allocator` is used to allocate memory for internal
+buffers holding the associated output.
 ``` cpp
 basic_syncbuf(basic_syncbuf&& other);
 ```
 *Ensures:* The value returned by `this->get_wrapped()` is the value
 returned by `other.get_wrapped()` prior to calling this constructor.
 Output stored in `other` prior to calling this constructor will be
+stored in `*this` afterwards. `other.pbase() == other.pptr()` and
 `other.get_wrapped() == nullptr` are `true`.
 *Remarks:* This constructor disassociates `other` from its wrapped
 stream buffer, ensuring destruction of `other` produces no output.
 destructor catches and ignores that exception.
 #### Assignment and swap <a id="syncstream.syncbuf.assign">[[syncstream.syncbuf.assign]]</a>
 ``` cpp
+basic_syncbuf& operator=(basic_syncbuf&& rhs);
 ```
 *Effects:* Calls `emit()` then move assigns from `rhs`. After the move
 assignment `*this` has the observable state it would have had if it had
 been move constructed from `rhs` [[syncstream.syncbuf.cons]].
 *Ensures:*
 - `rhs.get_wrapped() == nullptr` is `true`.
 - `this->get_allocator() == rhs.get_allocator()` is `true` when
   ``` cpp
   allocator_traits<Allocator>::propagate_on_container_move_assignment::value
   ```
   is `true`; otherwise, the allocator is unchanged.
+*Returns:* `*this`.
 *Remarks:* This assignment operator disassociates `rhs` from its wrapped
 stream buffer, ensuring destruction of `rhs` produces no output.
 ``` cpp
+void swap(basic_syncbuf& other);
 ```
 *Preconditions:* Either
 `allocator_traits<Allocator>::propagate_on_container_swap::value` is
 `true` or `this->get_allocator() == other.get_allocator()` is `true`.
 stream buffer `*wrapped`, so that it appears in the output stream as a
 contiguous sequence of characters. `wrapped->pubsync()` is called if and
 only if a call was made to `sync()` since the most recent call to
 `emit()`, if any.
+*Synchronization:* All `emit()` calls transferring characters to the
+same stream buffer object appear to execute in a total order consistent
+with the “happens before” relation [[intro.races]], where each `emit()`
+call synchronizes with subsequent `emit()` calls in that total order.
+*Ensures:* On success, the associated output is empty.
 *Returns:* `true` if all of the following conditions hold; otherwise
 `false`:
 - `wrapped == nullptr` is `false`.
 - All of the characters in the associated output were successfully
   transferred.
 - The call to `wrapped->pubsync()` (if any) succeeded.
 *Remarks:* May call member functions of `wrapped` while holding a lock
 uniquely associated with `wrapped`.
 ``` cpp
 streambuf_type* get_wrapped() const noexcept;
 #### Specialized algorithms <a id="syncstream.syncbuf.special">[[syncstream.syncbuf.special]]</a>
 ``` cpp
 template<class charT, class traits, class Allocator>
   void swap(basic_syncbuf<charT, traits, Allocator>& a,
+            basic_syncbuf<charT, traits, Allocator>& b);
 ```
 *Effects:* Equivalent to `a.swap(b)`.
 ### Class template `basic_osyncstream` <a id="syncstream.osyncstream">[[syncstream.osyncstream]]</a>
       : basic_osyncstream(os, Allocator()) {}
     basic_osyncstream(basic_osyncstream&&) noexcept;
     ~basic_osyncstream();
     // assignment
+    basic_osyncstream& operator=(basic_osyncstream&&);
     // [syncstream.osyncstream.members], member functions
     void emit();
     streambuf_type* get_wrapped() const noexcept;
     syncbuf_type* rdbuf() const noexcept { return const_cast<syncbuf_type*>(addressof(sb)); }
     syncbuf_type sb;    // exposition only
   };
 }
 ```
+`Allocator` shall meet the *Cpp17Allocator* requirements
+[[allocator.requirements.general]].
 [*Example 1*:
 A named variable can be used within a block statement for streaming.
 ```
 *Effects:* Initializes `sb` from `buf` and `allocator`. Initializes the
 base class with `basic_ostream<charT, traits>(addressof(sb))`.
+[*Note 1*: The member functions of the provided stream buffer can be
+called from `emit()` while a lock is held, which might result in a
+deadlock if used incautiously. — *end note*]
 *Ensures:* `get_wrapped() == buf` is `true`.
 ``` cpp
 basic_osyncstream(basic_osyncstream&& other) noexcept;
 *Effects:* Move constructs the base class and `sb` from the
 corresponding subobjects of `other`, and calls
 `basic_ostream<charT, traits>::set_rdbuf(addressof(sb))`.
 *Ensures:* The value returned by `get_wrapped()` is the value returned
+by `other.get_wrapped()` prior to calling this constructor.
 `nullptr == other.get_wrapped()` is `true`.
 #### Member functions <a id="syncstream.osyncstream.members">[[syncstream.osyncstream.members]]</a>
 ``` cpp
 void emit();
 ```
+*Effects:* Behaves as an unformatted output
+function [[ostream.unformatted]]. After constructing a `sentry` object,
+calls `sb.emit()`. If that call returns `false`, calls
 `setstate(ios_base::badbit)`.
 [*Example 1*:
 A flush on a `basic_osyncstream` does not flush immediately:
 does not exist, the symbolic link is said to be a “dangling” symbolic
 link. — *end note*]
 ### Conformance <a id="fs.conformance">[[fs.conformance]]</a>
+#### General <a id="fs.conformance.general">[[fs.conformance.general]]</a>
 Conformance is specified in terms of behavior. Ideal behavior is not
 always implementable, so the conformance subclauses take that into
 account.
 #### POSIX conformance <a id="fs.conform.9945">[[fs.conform.9945]]</a>
+Some behavior is specified by reference to POSIX. How such behavior is
+actually implemented is unspecified.
 [*Note 1*: This constitutes an “as if” rule allowing implementations to
 call native operating system or other APIs. — *end note*]
 Implementations should provide such behavior as it is defined by POSIX.
 #### File system race behavior <a id="fs.race.behavior">[[fs.race.behavior]]</a>
 A *file system race* is the condition that occurs when multiple threads,
 processes, or computers interleave access and modification of the same
 object within a file system. Behavior is undefined if calls to functions
+provided by subclause  [[filesystems]] introduce a file system race.
 If the possibility of a file system race would make it unreliable for a
 program to test for a precondition before calling a function described
 herein, *Preconditions:* is not specified for the function.
 [*Note 1*: As a design practice, preconditions are not specified when
 it is unreasonable for a program to detect them prior to calling the
 function. — *end note*]
 ### Requirements <a id="fs.req">[[fs.req]]</a>
 Throughout subclause  [[filesystems]], `char`, `wchar_t`, `char8_t`,
 `char16_t`, and `char32_t` are collectively called *encoded character
 types*.
 character set and encoding. Since `signed char` and `unsigned char` have
 no implied character set and encoding, they are not included as
 permitted types. — *end note*]
 Template parameters named `Allocator` shall meet the *Cpp17Allocator*
+requirements [[allocator.requirements.general]].
 ### Header `<filesystem>` synopsis <a id="fs.filesystem.syn">[[fs.filesystem.syn]]</a>
 ``` cpp
 #include <compare>              // see [compare.syn]
   // [fs.class.directory.iterator], directory iterators
   class directory_iterator;
   // [fs.dir.itr.nonmembers], range access for directory iterators
   directory_iterator begin(directory_iterator iter) noexcept;
+  directory_iterator end(directory_iterator) noexcept;
   // [fs.class.rec.dir.itr], recursive directory iterators
   class recursive_directory_iterator;
   // [fs.rec.dir.itr.nonmembers], range access for recursive directory iterators
   recursive_directory_iterator begin(recursive_directory_iterator iter) noexcept;
+  recursive_directory_iterator end(recursive_directory_iterator) noexcept;
   // [fs.class.file.status], file status
   class file_status;
   struct space_info {
   path temp_directory_path(error_code& ec);
   path weakly_canonical(const path& p);
   path weakly_canonical(const path& p, error_code& ec);
 }
+// [fs.path.hash], hash support
+namespace std {
+  template<class T> struct hash;
+  template<> struct hash<filesystem::path>;
+}
+namespace std::ranges {
+  template<>
+    inline constexpr bool enable_borrowed_range<filesystem::directory_iterator> = true;
+  template<>
+    inline constexpr bool enable_borrowed_range<filesystem::recursive_directory_iterator> = true;
+  template<>
+    inline constexpr bool enable_view<filesystem::directory_iterator> = true;
+  template<>
+    inline constexpr bool enable_view<filesystem::recursive_directory_iterator> = true;
+}
 ```
 Implementations should ensure that the resolution and range of
 `file_time_type` reflect the operating system dependent resolution and
 range of file time values.
   appropriate for the specific operating system dependent error.
   Otherwise, `clear()` is called on the `error_code&` argument.
 ### Class `path` <a id="fs.class.path">[[fs.class.path]]</a>
+#### General <a id="fs.class.path.general">[[fs.class.path.general]]</a>
 An object of class `path` represents a path and contains a pathname.
 Such an object is concerned only with the lexical and syntactic aspects
 of a path. The path does not necessarily exist in external storage, and
 the pathname is not necessarily valid for the current operating system
 or for a particular file system.
 dependent. A *relative path* is a path that is not absolute, and as
 such, only unambiguously identifies the location of a file when resolved
 relative to an implied starting location. The elements of a path that
 determine if it is relative are operating system dependent.
+[*Note 2*: Pathnames “.” and “..” are relative paths. — *end note*]
 A *pathname* is a character string that represents the name of a path.
 Pathnames are formatted according to the generic pathname format grammar
 [[fs.path.generic]] or according to an operating system dependent
 *native pathname format* accepted by the host operating system.
 *Pathname resolution* is the operating system dependent mechanism for
 resolving a pathname to a particular file in a file hierarchy. There may
 be multiple pathnames that resolve to the same file.
+[*Example 1*: POSIX specifies the mechanism in section 4.12, Pathname
 resolution. — *end example*]
 ``` cpp
 namespace std::filesystem {
   class path {
 special meaning. The following characteristics of filenames are
 operating system dependent:
 - The permitted characters. \[*Example 1*: Some operating systems
   prohibit the ASCII control characters (0x00 – 0x1F) in
+  filenames. — *end example*] \[*Note 1*: Wider portability can be
+ achieved by limiting *filename* characters to the POSIX Portable
+ Filename Character Set:
   `A B C D E F G H I J K L M N O P Q R S T U V W X Y Z`
   `a b c d e f g h i j k l m n o p q r s t u v w x y z`
   `0 1 2 3 4 5 6 7 8 9 . _ -` — *end note*]
 - The maximum permitted length.
 - Filenames that are not permitted.
 required.
 [*Note 2*: Many operating systems define a name beginning with two
 *directory-separator* characters as a *root-name* that identifies
 network or other resource locations. Some operating systems define a
+single letter followed by a colon as a drive specifier — a *root-name*
 identifying a specific device such as a disk drive. — *end note*]
 If a *root-name* is otherwise ambiguous, the possibility with the
 longest sequence of characters is chosen.
 1.  If the path is empty, stop.
 2.  Replace each slash character in the *root-name* with a
     *preferred-separator*.
 3.  Replace each *directory-separator* with a *preferred-separator*.
+    \[*Note 4*: The generic pathname grammar defines
     *directory-separator* as one or more slashes and
     *preferred-separator*s. — *end note*]
 4.  Remove each dot filename and any immediately following
     *directory-separator*.
 5.  As long as any appear, remove a non-dot-dot filename immediately
 or a pathname in the native format [[fs.class.path]]. Such an argument
 is taken to be in the generic format if and only if it matches the
 generic format and is not acceptable to the operating system as a native
 path.
+[*Note 2*: Some operating systems have no unambiguous way to
 distinguish between native format and generic format arguments. This is
 by design as it simplifies use for operating systems that do not require
 disambiguation. An implementation for an operating system where
 disambiguation is required is permitted to distinguish between the
 formats. — *end note*]
 directory path if its last element is a *directory-separator*, otherwise
 it shall be treated as a path to a regular file.
 [*Note 4*: A path stores a native format pathname
 [[fs.path.native.obs]] and acts as if it also stores a generic format
+pathname, related as given below. The implementation can generate the
 generic format pathname based on the native format pathname (and
 possibly other information) when requested. — *end note*]
 When a path is constructed from or is assigned a single representation
 separate from any path, the other representation is selected by the
 The *native encoding* of an ordinary character string is the operating
 system dependent current encoding for pathnames [[fs.class.path]]. The
 *native encoding* for wide character strings is the
 implementation-defined execution wide-character set encoding
+[[character.seq]].
 For member function arguments that take character sequences representing
 paths and for member functions returning strings, value type and
 encoding conversion is performed if the value type of the argument or
 return value differs from `path::value_type`. For the argument or return
   return values is performed. For Windows-based operating systems, the
   native ordinary encoding is determined by calling a Windows API
   function. — *end note*] \[*Note 7*: This results in behavior
   identical to other C and C++ standard library functions that perform
   file operations using ordinary character strings to identify paths.
+  Changing this behavior would be surprising and
+ error-prone. — *end note*]
 - `wchar_t`: The encoding is the native wide encoding. The method of
   conversion is unspecified. \[*Note 8*: For Windows-based operating
   systems `path::value_type` is `wchar_t` so no conversion from
   `wchar_t` value type arguments or to `wchar_t` value type return
   values is performed. — *end note*]
 than `path`, and either
 - `Source` is a specialization of `basic_string` or `basic_string_view`,
   or
 - the *qualified-id* `iterator_traits<decay_t<Source>>::value_type` is
+  valid and denotes a possibly const encoded character type
   [[temp.deduct]].
 [*Note 1*: See path conversions [[fs.path.cvt]] for how the value types
 above and their encodings convert to `path::value_type` and its
 encoding. — *end note*]
 ```
 *Effects:* Appends `path(x).native()` to the pathname in the native
 format.
+[*Note 2*: This directly manipulates the value of `native()`, which is
+not necessarily portable between operating systems. — *end note*]
 *Returns:* `*this`.
 ``` cpp
 path& operator+=(value_type x);
 operator string_type() const;
 ```
 *Returns:* `native()`.
 ``` cpp
 template<class EcharT, class traits = char_traits<EcharT>,
          class Allocator = allocator<EcharT>>
   basic_string<EcharT, traits, Allocator>
     string(const Allocator& a = Allocator()) const;
 path("..bar").extension();              // yields ".bar" and stem() is "."
 ```
 — *end example*]
+[*Note 3*: The period is included in the return value so that it is
 possible to distinguish between no extension and an empty
 extension. — *end note*]
+[*Note 4*: On non-POSIX operating systems, for a path `p`, it is
+possible that `p.stem() + p.extension() == p.filename()` is `false`,
+even though the generic format pathnames are the same. — *end note*]
 ##### Query <a id="fs.path.query">[[fs.path.query]]</a>
 ``` cpp
 [[nodiscard]] bool empty() const noexcept;
 ``` cpp
 path lexically_relative(const path& base) const;
 ```
 *Effects:* If:
 - `root_name() != base.root_name()` is `true`, or
 - `is_absolute() != base.is_absolute()` is `true`, or
 - `!has_root_directory() && base.has_root_directory()` is `true`, or
 - any *filename* in `relative_path()` or `base.relative_path()` can be
   interpreted as a *root-name*,
 returns `path()`.
+[*Note 5*: On a POSIX implementation, no *filename* in a
 *relative-path* is acceptable as a *root-name*. — *end note*]
 Determines the first mismatched element of `*this` and `base` as if by:
 ``` cpp
 - returns an object of class `path` that is default-constructed,
   followed by
   - application of `operator/=(path(".."))` `n` times, and then
   - application of `operator/=` for each element in \[`a`, `end()`).
+*Returns:* `*this` made relative to `base`. Does not
+resolve [[fs.class.path]] symlinks. Does not first
+normalize [[fs.path.generic]] `*this` or `base`.
 [*Example 11*:
 ``` cpp
 assert(path("/a/d").lexically_relative("/a/b/c") == "../../d");
 assert(path("/a/b/c").lexically_relative("/a/d") == "../b/c");
 *directory-separator* characters will be backslashes rather than
 slashes, but that does not affect `path` equality.
 — *end example*]
+[*Note 6*: If symlink following semantics are desired, use the
 operational function `relative()`. — *end note*]
+[*Note 7*: If normalization [[fs.path.generic]] is needed to ensure
 consistent matching of elements, apply `lexically_normal()` to `*this`,
 `base`, or both. — *end note*]
 ``` cpp
 path lexically_proximate(const path& base) const;
 ```
 *Returns:* If the value of `lexically_relative(base)` is not an empty
 path, return it. Otherwise return `*this`.
+[*Note 8*: If symlink following semantics are desired, use the
 operational function `proximate()`. — *end note*]
+[*Note 9*: If normalization [[fs.path.generic]] is needed to ensure
 consistent matching of elements, apply `lexically_normal()` to `*this`,
 `base`, or both. — *end note*]
 #### Iterators <a id="fs.path.itr">[[fs.path.itr]]</a>
 - Equivalence is determined by the `equivalent()` non-member function,
   which determines if two paths resolve [[fs.class.path]] to the same
   file system entity. \[*Example 2*: `equivalent("foo", "bar")` will be
   `true` when both paths resolve to the same file. — *end example*]
 — *end note*]
 ``` cpp
 friend strong_ordering operator<=>(const path& lhs, const path& rhs) noexcept;
 ```
 friend path operator/(const path& lhs, const path& rhs);
 ```
 *Effects:* Equivalent to: `return path(lhs) /= rhs;`
+#### Hash support <a id="fs.path.hash">[[fs.path.hash]]</a>
+``` cpp
+template<> struct hash<filesystem::path>;
+```
+For an object `p` of type `filesystem::path`,
+`hash<filesystem::path>()(p)` evaluates to the same result as
+`filesystem::hash_value(p)`.
 ### Class `filesystem_error` <a id="fs.class.filesystem.error">[[fs.class.filesystem.error]]</a>
+#### General <a id="fs.class.filesystem.error.general">[[fs.class.filesystem.error.general]]</a>
 ``` cpp
 namespace std::filesystem {
   class filesystem_error : public system_error {
   public:
     filesystem_error(const string& what_arg, error_code ec);
 #### Enum `path::format` <a id="fs.enum.path.format">[[fs.enum.path.format]]</a>
 This enum specifies constants used to identify the format of the
 character sequence, with the meanings listed in [[fs.enum.path.format]].
+**Table: Enum `path::format`** <a id="fs.enum.path.format">[fs.enum.path.format]</a>
+| Name             | Meaning                                                                                                                                                                                                                                                                                                                                               |
+| ---------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `native_format`  | The native pathname format.                                                                                                                                                                                                                                                                                                                           |
+| `generic_format` | The generic pathname format.                                                                                                                                                                                                                                                                                                                          |
+| `auto_format`    | The interpretation of the format of the character sequence is implementation-defined. The implementation may inspect the content of the character sequence to determine the format. Recommended practice: For POSIX-based systems, native and generic formats are equivalent and the character sequence should always be interpreted in the same way. |
 #### Enum class `file_type` <a id="fs.enum.file.type">[[fs.enum.file.type]]</a>
 This enum class specifies constants used to identify file types, with
 the meanings listed in [[fs.enum.file.type]]. The values of the
 constants are distinct.
+**Table: Enum class `file_type`** <a id="fs.enum.file.type">[fs.enum.file.type]</a>
+| Constant                 | Meaning                                                                                                                                                                                                                     |
+| ------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `none`                   | The type of the file has not been determined or an error occurred while trying to determine the type.                                                                                                                       |
+| `not_found`              | Pseudo-type indicating the file was not found. *The file not being found is not considered an error while determining the type of a file.*                                                                                  |
+| `regular`                | Regular file                                                                                                                                                                                                                |
+| `directory`              | Directory file                                                                                                                                                                                                              |
+| `symlink`                | Symbolic link file                                                                                                                                                                                                          |
+| `block`                  | Block special file                                                                                                                                                                                                          |
+| `character`              | Character special file                                                                                                                                                                                                      |
+| `fifo`                   | FIFO or pipe file                                                                                                                                                                                                           |
+| `socket`                 | Socket file                                                                                                                                                                                                                 |
+| `implementation-defined` | Implementations that support file systems having file types in addition to the above `file_type` types shall supply implementation-defined `file_type` constants to separately identify each of those additional file types |
+| `unknown`                | The file exists but the type cannot be determined                                                                                                                                                                           |
 #### Enum class `copy_options` <a id="fs.enum.copy.opts">[[fs.enum.copy.opts]]</a>
 The `enum class` type `copy_options` is a bitmask type [[bitmask.types]]
 that specifies bitmask constants used to control the semantics of copy
 Every other constant in the table represents a distinct bitmask element.
 **Table: Enum class `copy_options`** <a id="fs.enum.copy.opts">[fs.enum.copy.opts]</a>
 | Constant             | Meaning                                                                                                                                              |
+| -------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `none`               | (Default) Error; file already exists.                                                                                                                |
 | `skip_existing`      | Do not overwrite existing file, do not report an error.                                                                                              |
 | `overwrite_existing` | Overwrite the existing file.                                                                                                                         |
+| `update_existing`    | Overwrite the existing file if it is older than the replacement file. \ohdrx{2}{Option group controlling `copy` function effects for subdirectories} |
+| `recursive`          | Recursively copy subdirectories and their contents. \ohdrx{2}{Option group controlling `copy` function effects for symbolic links}                   |
 | `copy_symlinks`      | Copy symbolic links as symbolic links rather than copying the files that they point to.                                                              |
 | `skip_symlinks`      | Ignore symbolic links. \ohdrx{2}{Option group controlling `copy` function effects for choosing the form of copying}                                  |
 | `directories_only`   | Copy directory structure only, do not copy non-directory files.                                                                                      |
 | `create_symlinks`    | Make symbolic links instead of copies of files. The source path shall be an absolute path unless the destination path is in the current directory.   |
 | `create_hard_links`  | Make hard links instead of copies of files.                                                                                                          |
 **Table: Enum class `perm_options`** <a id="fs.enum.perm.opts">[fs.enum.perm.opts]</a>
 | Name       | Meaning                                                                                                                                                 |
 | ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `replace`  | `permissions` shall replace the file's permission bits with `perm`                                                                                      |
+| `add`      | `permissions` shall replace the file's permission bits with the bitwise \logop{or} of `perm` and the file's current permission bits.                    |
+| `remove`   | `permissions` shall replace the file's permission bits with the bitwise \logop{and} of the complement of `perm` and the file's current permission bits. |
 | `nofollow` | `permissions` shall change the permissions of a symbolic link itself rather than the permissions of the file the link resolves to.                      |
 #### Enum class `directory_options` <a id="fs.enum.dir.opts">[[fs.enum.dir.opts]]</a>
 | `skip_permission_denied`   | Skip directories that would otherwise result in permission denied. |
 ### Class `file_status` <a id="fs.class.file.status">[[fs.class.file.status]]</a>
+#### General <a id="fs.class.file.status.general">[[fs.class.file.status.general]]</a>
 ``` cpp
 namespace std::filesystem {
   class file_status {
   public:
     // [fs.file.status.cons], constructors and destructor
 *Ensures:* `permissions() == prms`.
 ### Class `directory_entry` <a id="fs.class.directory.entry">[[fs.class.directory.entry]]</a>
+#### General <a id="fs.class.directory.entry.general">[[fs.class.directory.entry.general]]</a>
 ``` cpp
 namespace std::filesystem {
   class directory_entry {
   public:
     // [fs.dir.entry.cons], constructors and destructor
     file_status symlink_status(error_code& ec) const noexcept;
     bool operator==(const directory_entry& rhs) const noexcept;
     strong_ordering operator<=>(const directory_entry& rhs) const noexcept;
+    // [fs.dir.entry.io], inserter
+    template<class charT, class traits>
+      friend basic_ostream<charT, traits>&
+        operator<<(basic_ostream<charT, traits>& os, const directory_entry& d);
   private:
     filesystem::path pathobject;        // exposition only
     friend class directory_iterator;    // exposition only
   };
 }
 *Throws:* As specified in  [[fs.err.report]].
 [*Note 1*: Implementations of `directory_iterator`
 [[fs.class.directory.iterator]] are prohibited from directly or
+indirectly calling the `refresh` function as described in
+[[fs.class.directory.iterator.general]]. — *end note*]
 #### Observers <a id="fs.dir.entry.obs">[[fs.dir.entry.obs]]</a>
 Unqualified function names in the *Returns:* elements of the
 `directory_entry` observers described below refer to members of the
 strong_ordering operator<=>(const directory_entry& rhs) const noexcept;
 ```
 *Returns:* `pathobject <=> rhs.pathobject`.
+#### Inserter <a id="fs.dir.entry.io">[[fs.dir.entry.io]]</a>
+``` cpp
+template<class charT, class traits>
+  friend basic_ostream<charT, traits>&
+    operator<<(basic_ostream<charT, traits>& os, const directory_entry& d);
+```
+*Effects:* Equivalent to: `return os << d.path();`
 ### Class `directory_iterator` <a id="fs.class.directory.iterator">[[fs.class.directory.iterator]]</a>
+#### General <a id="fs.class.directory.iterator.general">[[fs.class.directory.iterator.general]]</a>
 An object of type `directory_iterator` provides an iterator for a
 sequence of `directory_entry` elements representing the path and any
 cached attribute values [[fs.class.directory.entry]] for each file in a
 directory or in an *implementation-defined* directory-like file type.
+[*Note 1*: For iteration into subdirectories, see class
 `recursive_directory_iterator` [[fs.class.rec.dir.itr]]. — *end note*]
 ``` cpp
 namespace std::filesystem {
   class directory_iterator {
     const directory_entry& operator*() const;
     const directory_entry* operator->() const;
     directory_iterator&    operator++();
     directory_iterator&    increment(error_code& ec);
+    bool operator==(default_sentinel_t) const noexcept {
+      return *this == directory_iterator();
+    }
     // other members as required by [input.iterators], input iterators
   };
 }
 ```
 to a non-end iterator.
 The result of calling the `path()` member of the `directory_entry`
 object obtained by dereferencing a `directory_iterator` is a reference
 to a `path` object composed of the directory argument from which the
+iterator was constructed with the filename of the directory entry
+appended as if by `operator/=`.
 Directory iteration shall not yield directory entries for the current
 (dot) and parent (dot-dot) directories.
 The order of directory entries obtained by dereferencing successive
 [*Note 2*: The exact mechanism for storing cached attribute values is
 not exposed to users. For exposition, class `directory_iterator` is
 shown in [[fs.class.directory.entry]] as a friend of class
 `directory_entry`. — *end note*]
+[*Note 3*: A path obtained by dereferencing a directory iterator might
+not actually exist; it could be a symbolic link to a non-existent file.
+Recursively walking directory trees for purposes of removing and
+renaming entries might invalidate symbolic links that are being
+followed. — *end note*]
 [*Note 4*: If a file is removed from or added to a directory after the
 construction of a `directory_iterator` for the directory, it is
 unspecified whether or not subsequently incrementing the iterator will
 ever result in an iterator referencing the removed or added directory
+entry. See POSIX `readdir`. — *end note*]
 #### Members <a id="fs.dir.itr.members">[[fs.dir.itr.members]]</a>
 ``` cpp
 directory_iterator() noexcept;
 ```
 *Returns:* `iter`.
 ``` cpp
+directory_iterator end(directory_iterator) noexcept;
 ```
 *Returns:* `directory_iterator()`.
 ### Class `recursive_directory_iterator` <a id="fs.class.rec.dir.itr">[[fs.class.rec.dir.itr]]</a>
+#### General <a id="fs.class.rec.dir.itr.general">[[fs.class.rec.dir.itr.general]]</a>
 An object of type `recursive_directory_iterator` provides an iterator
 for a sequence of `directory_entry` elements representing the files in a
 directory or in an *implementation-defined* directory-like file type,
+and its subdirectories.
 ``` cpp
 namespace std::filesystem {
   class recursive_directory_iterator {
   public:
     void pop();
     void pop(error_code& ec);
     void disable_recursion_pending();
+    bool operator==(default_sentinel_t) const noexcept {
+      return *this == recursive_directory_iterator();
+    }
     // other members as required by [input.iterators], input iterators
   };
 }
 ```
 The behavior of a `recursive_directory_iterator` is the same as a
 `directory_iterator` unless otherwise specified.
 [*Note 1*: If the directory structure being iterated over contains
+cycles then it is possible that the end iterator is
+unreachable. — *end note*]
 #### Members <a id="fs.rec.dir.itr.members">[[fs.rec.dir.itr.members]]</a>
 ``` cpp
 recursive_directory_iterator() noexcept;
 `directory_options` argument, otherwise
 `options() == directory_options::none`.
 *Throws:* As specified in  [[fs.err.report]].
+[*Note 1*: Use `recursive_directory_iterator(".")` rather than
+`recursive_directory_iterator("")` to iterate over the current
+directory. — *end note*]
 [*Note 2*: By default, `recursive_directory_iterator` does not follow
 directory symlinks. To follow directory symlinks, specify `options` as
 `directory_options::follow_directory_symlink`. — *end note*]
 recursion into a directory. — *end note*]
 #### Non-member functions <a id="fs.rec.dir.itr.nonmembers">[[fs.rec.dir.itr.nonmembers]]</a>
 These functions enable use of `recursive_directory_iterator` with
+range-based `for` statements.
 ``` cpp
 recursive_directory_iterator begin(recursive_directory_iterator iter) noexcept;
 ```
 *Returns:* `iter`.
 ``` cpp
+recursive_directory_iterator end(recursive_directory_iterator) noexcept;
 ```
 *Returns:* `recursive_directory_iterator()`.
 ### Filesystem operation functions <a id="fs.op.funcs">[[fs.op.funcs]]</a>
+#### General <a id="fs.op.funcs.general">[[fs.op.funcs.general]]</a>
 Filesystem operation functions query or modify files, including
 directories, in external storage.
 [*Note 1*: Because hardware failures, network failures, file system
 races [[fs.race.behavior]], and many other kinds of errors occur
+frequently in file system operations, any filesystem operation function,
+no matter how apparently innocuous, can encounter an error; see
+[[fs.err.report]]. — *end note*]
 #### Absolute <a id="fs.op.absolute">[[fs.op.absolute]]</a>
 ``` cpp
+path filesystem::absolute(const path& p);
+path filesystem::absolute(const path& p, error_code& ec);
 ```
 *Effects:* Composes an absolute path referencing the same file system
 location as `p` according to the operating system [[fs.conform.os]].
 [*Note 1*: For the returned path, `rp`, `rp.is_absolute()` is `true`
 unless an error occurs. — *end note*]
 *Throws:* As specified in  [[fs.err.report]].
+[*Note 2*: To resolve symlinks or perform other sanitization that can
+involve queries to secondary storage, such as hard disks, consider
 `canonical` [[fs.op.canonical]]. — *end note*]
 [*Note 3*: Implementations are strongly encouraged to not query
 secondary storage, and not consider `!exists(p)` an
 error. — *end note*]
 `GetFullPathNameW`. — *end example*]
 #### Canonical <a id="fs.op.canonical">[[fs.op.canonical]]</a>
 ``` cpp
+path filesystem::canonical(const path& p);
+path filesystem::canonical(const path& p, error_code& ec);
 ```
 *Effects:* Converts `p` to an absolute path that has no symbolic link,
 dot, or dot-dot elements in its pathname in the generic format.
 *Remarks:* `!exists(p)` is an error.
 #### Copy <a id="fs.op.copy">[[fs.op.copy]]</a>
 ``` cpp
+void filesystem::copy(const path& from, const path& to);
 ```
 *Effects:* Equivalent to `copy(from, to, copy_options::none)`.
 ``` cpp
+void filesystem::copy(const path& from, const path& to, error_code& ec);
 ```
 *Effects:* Equivalent to `copy(from, to, copy_options::none, ec)`.
 ``` cpp
+void filesystem::copy(const path& from, const path& to, copy_options options);
+void filesystem::copy(const path& from, const path& to, copy_options options,
           error_code& ec);
 ```
 *Preconditions:* At most one element from each option
 group [[fs.enum.copy.opts]] is set in `options`.
 — *end example*]
 #### Copy file <a id="fs.op.copy.file">[[fs.op.copy.file]]</a>
 ``` cpp
+bool filesystem::copy_file(const path& from, const path& to);
+bool filesystem::copy_file(const path& from, const path& to, error_code& ec);
 ```
 *Returns:* `copy_file(from, to, copy_options::none)` or
 `copy_file(from, to, copy_options::none, ec)`, respectively.
 *Throws:* As specified in  [[fs.err.report]].
 ``` cpp
+bool filesystem::copy_file(const path& from, const path& to, copy_options options);
+bool filesystem::copy_file(const path& from, const path& to, copy_options options,
                error_code& ec);
 ```
 *Preconditions:* At most one element from each option
 group [[fs.enum.copy.opts]] is set in `options`.
 *Complexity:* At most one direct or indirect invocation of `status(to)`.
 #### Copy symlink <a id="fs.op.copy.symlink">[[fs.op.copy.symlink]]</a>
 ``` cpp
+void filesystem::copy_symlink(const path& existing_symlink, const path& new_symlink);
+void filesystem::copy_symlink(const path& existing_symlink, const path& new_symlink,
                   error_code& ec) noexcept;
 ```
 *Effects:* Equivalent to
 *`function`*`(read_symlink(existing_symlink), new_symlink)` or
 *Throws:* As specified in  [[fs.err.report]].
 #### Create directories <a id="fs.op.create.directories">[[fs.op.create.directories]]</a>
 ``` cpp
+bool filesystem::create_directories(const path& p);
+bool filesystem::create_directories(const path& p, error_code& ec);
 ```
 *Effects:* Calls `create_directory()` for each element of `p` that does
 not exist.
 *Complexity:* 𝑂(n) where *n* is the number of elements of `p`.
 #### Create directory <a id="fs.op.create.directory">[[fs.op.create.directory]]</a>
 ``` cpp
+bool filesystem::create_directory(const path& p);
+bool filesystem::create_directory(const path& p, error_code& ec) noexcept;
 ```
 *Effects:* Creates the directory `p` resolves to, as if by POSIX `mkdir`
 with a second argument of `static_cast<int>(perms::all)`. If `mkdir`
 fails because `p` resolves to an existing directory, no error is
 *Returns:* `true` if a new directory was created, otherwise `false`.
 *Throws:* As specified in  [[fs.err.report]].
 ``` cpp
+bool filesystem::create_directory(const path& p, const path& existing_p);
+bool filesystem::create_directory(const path& p, const path& existing_p, error_code& ec) noexcept;
 ```
 *Effects:* Creates the directory `p` resolves to, with attributes copied
 from directory `existing_p`. The set of attributes copied is operating
 system dependent. If `mkdir` fails because `p` resolves to an existing
 *Throws:* As specified in  [[fs.err.report]].
 #### Create directory symlink <a id="fs.op.create.dir.symlk">[[fs.op.create.dir.symlk]]</a>
 ``` cpp
+void filesystem::create_directory_symlink(const path& to, const path& new_symlink);
+void filesystem::create_directory_symlink(const path& to, const path& new_symlink,
                               error_code& ec) noexcept;
 ```
 *Effects:* Establishes the postcondition, as if by POSIX `symlink()`.
 an unspecified representation of `to`.
 *Throws:* As specified in  [[fs.err.report]].
 [*Note 1*: Some operating systems require symlink creation to identify
+that the link is to a directory. Thus, `create_symlink()` (instead of
+`create_directory_symlink()`) cannot be used reliably to create
+directory symlinks. — *end note*]
 [*Note 2*: Some operating systems do not support symbolic links at all
 or support them only for regular files. Some file systems (such as the
 FAT file system) do not support symbolic links regardless of the
 operating system. — *end note*]
 #### Create hard link <a id="fs.op.create.hard.lk">[[fs.op.create.hard.lk]]</a>
 ``` cpp
+void filesystem::create_hard_link(const path& to, const path& new_hard_link);
+void filesystem::create_hard_link(const path& to, const path& new_hard_link,
                                       error_code& ec) noexcept;
 ```
 *Effects:* Establishes the postcondition, as if by POSIX `link()`.
 file. — *end note*]
 #### Create symlink <a id="fs.op.create.symlink">[[fs.op.create.symlink]]</a>
 ``` cpp
+void filesystem::create_symlink(const path& to, const path& new_symlink);
+void filesystem::create_symlink(const path& to, const path& new_symlink,
                     error_code& ec) noexcept;
 ```
 *Effects:* Establishes the postcondition, as if by POSIX `symlink()`.
 operating system. — *end note*]
 #### Current path <a id="fs.op.current.path">[[fs.op.current.path]]</a>
 ``` cpp
+path filesystem::current_path();
+path filesystem::current_path(error_code& ec);
 ```
 *Returns:* The absolute path of the current working directory, whose
 pathname in the native format is obtained as if by POSIX `getcwd()`. The
 signature with argument `ec` returns `path()` if an error occurs.
 [*Note 1*: The `current_path()` name was chosen to emphasize that the
 returned value is a path, not just a single directory
 name. — *end note*]
 [*Note 2*: The current path as returned by many operating systems is a
+dangerous global variable and can be changed unexpectedly by third-party
 or system library functions, or by another thread. — *end note*]
 ``` cpp
+void filesystem::current_path(const path& p);
+void filesystem::current_path(const path& p, error_code& ec) noexcept;
 ```
 *Effects:* Establishes the postcondition, as if by POSIX `chdir()`.
 *Ensures:* `equivalent(p, current_path())`.
 *Throws:* As specified in  [[fs.err.report]].
 [*Note 3*: The current path for many operating systems is a dangerous
+global state and can be changed unexpectedly by third-party or system
 library functions, or by another thread. — *end note*]
 #### Equivalent <a id="fs.op.equivalent">[[fs.op.equivalent]]</a>
 ``` cpp
+bool filesystem::equivalent(const path& p1, const path& p2);
+bool filesystem::equivalent(const path& p1, const path& p2, error_code& ec) noexcept;
 ```
 Two paths are considered to resolve to the same file system entity if
 two candidate entities reside on the same device at the same location.
 [*Note 1*: On POSIX platforms, this is determined as if by the values
 of the POSIX `stat` class, obtained as if by `stat()` for the two paths,
 having equal `st_dev` values and equal `st_ino` values. — *end note*]
+*Returns:* `true`, if `p1` and `p2` resolve to the same file system
+entity, otherwise `false`. The signature with argument `ec` returns
+`false` if an error occurs.
+*Throws:* As specified in  [[fs.err.report]].
 *Remarks:* `!exists(p1) || !exists(p2)` is an error.
 #### Exists <a id="fs.op.exists">[[fs.op.exists]]</a>
 ``` cpp
+bool filesystem::exists(file_status s) noexcept;
 ```
 *Returns:* `status_known(s) && s.type() != file_type::not_found`.
 ``` cpp
+bool filesystem::exists(const path& p);
+bool filesystem::exists(const path& p, error_code& ec) noexcept;
 ```
 Let `s` be a `file_status`, determined as if by `status(p)` or
 `status(p, ec)`, respectively.
 *Throws:* As specified in  [[fs.err.report]].
 #### File size <a id="fs.op.file.size">[[fs.op.file.size]]</a>
 ``` cpp
+uintmax_t filesystem::file_size(const path& p);
+uintmax_t filesystem::file_size(const path& p, error_code& ec) noexcept;
 ```
 *Effects:* If `exists(p)` is `false`, an error is
 reported [[fs.err.report]].
 *Throws:* As specified in  [[fs.err.report]].
 #### Hard link count <a id="fs.op.hard.lk.ct">[[fs.op.hard.lk.ct]]</a>
 ``` cpp
+uintmax_t filesystem::hard_link_count(const path& p);
+uintmax_t filesystem::hard_link_count(const path& p, error_code& ec) noexcept;
 ```
 *Returns:* The number of hard links for `p`. The signature with argument
 `ec` returns `static_cast<uintmax_t>(-1)` if an error occurs.
 *Throws:* As specified in  [[fs.err.report]].
 #### Is block file <a id="fs.op.is.block.file">[[fs.op.is.block.file]]</a>
 ``` cpp
+bool filesystem::is_block_file(file_status s) noexcept;
 ```
 *Returns:* `s.type() == file_type::block`.
 ``` cpp
+bool filesystem::is_block_file(const path& p);
+bool filesystem::is_block_file(const path& p, error_code& ec) noexcept;
 ```
 *Returns:* `is_block_file(status(p))` or `is_block_file(status(p, ec))`,
 respectively. The signature with argument `ec` returns `false` if an
 error occurs.
 *Throws:* As specified in  [[fs.err.report]].
 #### Is character file <a id="fs.op.is.char.file">[[fs.op.is.char.file]]</a>
 ``` cpp
+bool filesystem::is_character_file(file_status s) noexcept;
 ```
 *Returns:* `s.type() == file_type::character`.
 ``` cpp
+bool filesystem::is_character_file(const path& p);
+bool filesystem::is_character_file(const path& p, error_code& ec) noexcept;
 ```
 *Returns:* `is_character_file(status(p))` or
 `is_character_file(status(p, ec))`, respectively.
 The signature with argument `ec` returns `false` if an error occurs.
 *Throws:* As specified in  [[fs.err.report]].
 #### Is directory <a id="fs.op.is.directory">[[fs.op.is.directory]]</a>
 ``` cpp
+bool filesystem::is_directory(file_status s) noexcept;
 ```
 *Returns:* `s.type() == file_type::directory`.
 ``` cpp
+bool filesystem::is_directory(const path& p);
+bool filesystem::is_directory(const path& p, error_code& ec) noexcept;
 ```
 *Returns:* `is_directory(status(p))` or `is_directory(status(p, ec))`,
 respectively. The signature with argument `ec` returns `false` if an
 error occurs.
 *Throws:* As specified in  [[fs.err.report]].
 #### Is empty <a id="fs.op.is.empty">[[fs.op.is.empty]]</a>
 ``` cpp
+bool filesystem::is_empty(const path& p);
+bool filesystem::is_empty(const path& p, error_code& ec);
 ```
 *Effects:*
 - Determine `file_status s`, as if by `status(p)` or `status(p, ec)`,
 *Throws:* As specified in  [[fs.err.report]].
 #### Is fifo <a id="fs.op.is.fifo">[[fs.op.is.fifo]]</a>
 ``` cpp
+bool filesystem::is_fifo(file_status s) noexcept;
 ```
 *Returns:* `s.type() == file_type::fifo`.
 ``` cpp
+bool filesystem::is_fifo(const path& p);
+bool filesystem::is_fifo(const path& p, error_code& ec) noexcept;
 ```
 *Returns:* `is_fifo(status(p))` or `is_fifo(status(p, ec))`,
 respectively. The signature with argument `ec` returns `false` if an
 error occurs.
 *Throws:* As specified in  [[fs.err.report]].
 #### Is other <a id="fs.op.is.other">[[fs.op.is.other]]</a>
 ``` cpp
+bool filesystem::is_other(file_status s) noexcept;
 ```
 *Returns:*
 `exists(s) && !is_regular_file(s) && !is_directory(s) && !is_symlink(s)`.
 ``` cpp
+bool filesystem::is_other(const path& p);
+bool filesystem::is_other(const path& p, error_code& ec) noexcept;
 ```
 *Returns:* `is_other(status(p))` or `is_other(status(p, ec))`,
 respectively. The signature with argument `ec` returns `false` if an
 error occurs.
 *Throws:* As specified in  [[fs.err.report]].
 #### Is regular file <a id="fs.op.is.regular.file">[[fs.op.is.regular.file]]</a>
 ``` cpp
+bool filesystem::is_regular_file(file_status s) noexcept;
 ```
 *Returns:* `s.type() == file_type::regular`.
 ``` cpp
+bool filesystem::is_regular_file(const path& p);
 ```
 *Returns:* `is_regular_file(status(p))`.
 *Throws:* `filesystem_error` if `status(p)` would throw
 `filesystem_error`.
 ``` cpp
+bool filesystem::is_regular_file(const path& p, error_code& ec) noexcept;
 ```
 *Effects:* Sets `ec` as if by `status(p, ec)`.
 [*Note 1*: `file_type::none`, `file_type::not_found` and
 occurs.
 #### Is socket <a id="fs.op.is.socket">[[fs.op.is.socket]]</a>
 ``` cpp
+bool filesystem::is_socket(file_status s) noexcept;
 ```
 *Returns:* `s.type() == file_type::socket`.
 ``` cpp
+bool filesystem::is_socket(const path& p);
+bool filesystem::is_socket(const path& p, error_code& ec) noexcept;
 ```
 *Returns:* `is_socket(status(p))` or `is_socket(status(p, ec))`,
 respectively. The signature with argument `ec` returns `false` if an
 error occurs.
 *Throws:* As specified in  [[fs.err.report]].
 #### Is symlink <a id="fs.op.is.symlink">[[fs.op.is.symlink]]</a>
 ``` cpp
+bool filesystem::is_symlink(file_status s) noexcept;
 ```
 *Returns:* `s.type() == file_type::symlink`.
 ``` cpp
+bool filesystem::is_symlink(const path& p);
+bool filesystem::is_symlink(const path& p, error_code& ec) noexcept;
 ```
 *Returns:* `is_symlink(symlink_status(p))` or
 `is_symlink(symlink_status(p, ec))`, respectively. The signature with
 argument `ec` returns `false` if an error occurs.
 *Throws:* As specified in  [[fs.err.report]].
 #### Last write time <a id="fs.op.last.write.time">[[fs.op.last.write.time]]</a>
 ``` cpp
+file_time_type filesystem::last_write_time(const path& p);
+file_time_type filesystem::last_write_time(const path& p, error_code& ec) noexcept;
 ```
 *Returns:* The time of last data modification of `p`, determined as if
 by the value of the POSIX `stat` class member `st_mtime` obtained as if
 by POSIX `stat()`. The signature with argument `ec` returns
 `file_time_type::min()` if an error occurs.
 *Throws:* As specified in  [[fs.err.report]].
 ``` cpp
+void filesystem::last_write_time(const path& p, file_time_type new_time);
+void filesystem::last_write_time(const path& p, file_time_type new_time,
                      error_code& ec) noexcept;
 ```
 *Effects:* Sets the time of last data modification of the file resolved
 to by `p` to `new_time`, as if by POSIX `futimens()`.
 *Throws:* As specified in  [[fs.err.report]].
 [*Note 1*: A postcondition of `last_write_time(p) == new_time` is not
+specified because it does not necessarily hold for file systems with
+coarse time granularity. — *end note*]
 #### Permissions <a id="fs.op.permissions">[[fs.op.permissions]]</a>
 ``` cpp
+void filesystem::permissions(const path& p, perms prms, perm_options opts=perm_options::replace);
+void filesystem::permissions(const path& p, perms prms, error_code& ec) noexcept;
+void filesystem::permissions(const path& p, perms prms, perm_options opts, error_code& ec);
 ```
 *Preconditions:* Exactly one of the `perm_options` constants `replace`,
 `add`, or `remove` is present in `opts`.
 *Effects:* Applies the action specified by `opts` to the file `p`
 resolves to, or to file `p` itself if `p` is a symbolic link and
 `perm_options::nofollow` is set in `opts`. The action is applied as if
 by POSIX `fchmodat()`.
 [*Note 1*: Conceptually permissions are viewed as bits, but the actual
+implementation can use some other mechanism. — *end note*]
 *Throws:* As specified in  [[fs.err.report]].
+*Remarks:* The second signature behaves as if it had an additional
+parameter `perm_options` `opts` with an argument of
+`perm_options::replace`.
 #### Proximate <a id="fs.op.proximate">[[fs.op.proximate]]</a>
 ``` cpp
+path filesystem::proximate(const path& p, error_code& ec);
 ```
 *Returns:* `proximate(p, current_path(), ec)`.
 *Throws:* As specified in  [[fs.err.report]].
 ``` cpp
+path filesystem::proximate(const path& p, const path& base = current_path());
+path filesystem::proximate(const path& p, const path& base, error_code& ec);
 ```
 *Returns:* For the first form:
 ``` cpp
 *Throws:* As specified in  [[fs.err.report]].
 #### Read symlink <a id="fs.op.read.symlink">[[fs.op.read.symlink]]</a>
 ``` cpp
+path filesystem::read_symlink(const path& p);
+path filesystem::read_symlink(const path& p, error_code& ec);
 ```
 *Returns:* If `p` resolves to a symbolic link, a `path` object
 containing the contents of that symbolic link. The signature with
 argument `ec` returns `path()` if an error occurs.
 link. — *end note*]
 #### Relative <a id="fs.op.relative">[[fs.op.relative]]</a>
 ``` cpp
+path filesystem::relative(const path& p, error_code& ec);
 ```
 *Returns:* `relative(p, current_path(), ec)`.
 *Throws:* As specified in  [[fs.err.report]].
 ``` cpp
+path filesystem::relative(const path& p, const path& base = current_path());
+path filesystem::relative(const path& p, const path& base, error_code& ec);
 ```
 *Returns:* For the first form:
 ``` cpp
 *Throws:* As specified in  [[fs.err.report]].
 #### Remove <a id="fs.op.remove">[[fs.op.remove]]</a>
 ``` cpp
+bool filesystem::remove(const path& p);
+bool filesystem::remove(const path& p, error_code& ec) noexcept;
 ```
 *Effects:* If `exists(symlink_status(p, ec))`, the file `p` is removed
 as if by POSIX `remove()`.
 *Throws:* As specified in  [[fs.err.report]].
 #### Remove all <a id="fs.op.remove.all">[[fs.op.remove.all]]</a>
 ``` cpp
+uintmax_t filesystem::remove_all(const path& p);
+uintmax_t filesystem::remove_all(const path& p, error_code& ec);
 ```
 *Effects:* Recursively deletes the contents of `p` if it exists, then
 deletes file `p` itself, as if by POSIX `remove()`.
 *Throws:* As specified in  [[fs.err.report]].
 #### Rename <a id="fs.op.rename">[[fs.op.rename]]</a>
 ``` cpp
+void filesystem::rename(const path& old_p, const path& new_p);
+void filesystem::rename(const path& old_p, const path& new_p, error_code& ec) noexcept;
 ```
 *Effects:* Renames `old_p` to `new_p`, as if by POSIX `rename()`.
 [*Note 1*:
 - If `old_p` and `new_p` resolve to the same existing file, no action is
   taken.
+- Otherwise, the rename can include the following effects:
   - if `new_p` resolves to an existing non-directory file, `new_p` is
     removed; otherwise,
   - if `new_p` resolves to an existing directory, `new_p` is removed if
+    empty on POSIX compliant operating systems but might be an error on
     other operating systems.
 A symbolic link is itself renamed, rather than the file it resolves to.
 — *end note*]
 *Throws:* As specified in  [[fs.err.report]].
 #### Resize file <a id="fs.op.resize.file">[[fs.op.resize.file]]</a>
 ``` cpp
+void filesystem::resize_file(const path& p, uintmax_t new_size);
+void filesystem::resize_file(const path& p, uintmax_t new_size, error_code& ec) noexcept;
 ```
 *Effects:* Causes the size that would be returned by `file_size(p)` to
 be equal to `new_size`, as if by POSIX `truncate()`.
 *Throws:* As specified in  [[fs.err.report]].
 #### Space <a id="fs.op.space">[[fs.op.space]]</a>
 ``` cpp
+space_info filesystem::space(const path& p);
+space_info filesystem::space(const path& p, error_code& ec) noexcept;
 ```
 *Returns:* An object of type `space_info`. The value of the `space_info`
 object is determined as if by using POSIX `statvfs` to obtain a POSIX
 `struct statvfs`, and then multiplying its `f_blocks`, `f_bfree`, and
 *Throws:* As specified in  [[fs.err.report]].
 *Remarks:* The value of member `space_info::available` is operating
 system dependent.
+[*Note 1*: `available` might be less than `free`. — *end note*]
 #### Status <a id="fs.op.status">[[fs.op.status]]</a>
 ``` cpp
+file_status filesystem::status(const path& p);
 ```
 *Effects:* As if:
 ``` cpp
 [*Note 1*: `result` values of `file_status(file_type::not_found)` and
 `file_status(file_type::unknown)` are not considered failures and do not
 cause an exception to be thrown. — *end note*]
 ``` cpp
+file_status filesystem::status(const path& p, error_code& ec) noexcept;
 ```
 *Effects:* If possible, determines the attributes of the file `p`
 resolves to, as if by using POSIX `stat()` to obtain a POSIX
 `struct stat`. If, during attribute determination, the underlying file
 pathname resolution continues using the contents of the symbolic link.
 #### Status known <a id="fs.op.status.known">[[fs.op.status.known]]</a>
 ``` cpp
+bool filesystem::status_known(file_status s) noexcept;
 ```
 *Returns:* `s.type() != file_type::none`.
 #### Symlink status <a id="fs.op.symlink.status">[[fs.op.symlink.status]]</a>
 ``` cpp
+file_status filesystem::symlink_status(const path& p);
+file_status filesystem::symlink_status(const path& p, error_code& ec) noexcept;
 ```
 *Effects:* Same as `status()`, above, except that the attributes of `p`
 are determined as if by using POSIX `lstat()` to obtain a POSIX
 `struct stat`.
 *Returns:* Same as `status()`, above, except that if the attributes
 indicate a symbolic link, as if by POSIX `S_ISLNK`, returns
 `file_status(file_type::symlink, prms)`. The signature with argument
 `ec` returns `file_status(file_type::none)` if an error occurs.
+*Throws:* As specified in  [[fs.err.report]].
 *Remarks:* Pathname resolution terminates if `p` names a symbolic link.
 #### Temporary directory path <a id="fs.op.temp.dir.path">[[fs.op.temp.dir.path]]</a>
 ``` cpp
+path filesystem::temp_directory_path();
+path filesystem::temp_directory_path(error_code& ec);
 ```
 Let `p` be an unspecified directory path suitable for temporary files.
 *Effects:* If `exists(p)` is `false` or `is_directory(p)` is `false`, an
 function. — *end example*]
 #### Weakly canonical <a id="fs.op.weakly.canonical">[[fs.op.weakly.canonical]]</a>
 ``` cpp
+path filesystem::weakly_canonical(const path& p);
+path filesystem::weakly_canonical(const path& p, error_code& ec);
 ```
 *Effects:* Using `status(p)` or `status(p, ec)`, respectively, to
 determine existence, return a path composed by `operator/=` from the
 result of calling `canonical()` with a path argument composed of the
 leading elements of `p` that exist, if any, followed by the elements of
 `p` that do not exist, if any. For the first form, `canonical()` is
 `canonical()` is called with `ec` as an `error_code` argument, and
 `path()` is returned at the first error occurrence, if any.
 *Ensures:* The returned path is in normal form [[fs.path.generic]].
+*Returns:* `p` with symlinks resolved and the result
+normalized [[fs.path.generic]].
 *Throws:* As specified in  [[fs.err.report]].
 ## C library files <a id="c.files">[[c.files]]</a>
 #include <cstdint>  // see [cstdint.syn]
 namespace std {
   using imaxdiv_t = see below;
+ constexpr intmax_t imaxabs(intmax_t j);
+ constexpr imaxdiv_t imaxdiv(intmax_t numer, intmax_t denom);
   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);
+ constexpr intmax_t abs(intmax_t); // optional, see below
+ constexpr imaxdiv_t div(intmax_t, intmax_t); // optional, see below
 }
 #define PRIdN see below
 #define PRIiN see below
 #define PRIoN see below
 The contents and meaning of the header `<cinttypes>` are the same as the
 C standard library header `<inttypes.h>`, with the following changes:
 - The header `<cinttypes>` includes the header `<cstdint>` instead of
   `<stdint.h>`, and
+- `intmax_t` and `uintmax_t` are not required to be able to represent
+  all values of extended integer types wider than `long long` and
+  `unsigned long long`, respectively, and
 - if and only if the type `intmax_t` designates an extended integer type
   [[basic.fundamental]], the following function signatures are added:
   ``` cpp
+ constexpr intmax_t abs(intmax_t);
+ constexpr imaxdiv_t div(intmax_t, intmax_t);
   ```
   which shall have the same semantics as the function signatures
+  `constexpr intmax_t imaxabs(intmax_t)` and
+  `constexpr imaxdiv_t imaxdiv(intmax_t, intmax_t)`, respectively.
 See also: ISO C 7.8
+Each of the `PRI` macros listed in this subclause is defined if and only
+if the implementation defines the corresponding *typedef-name* in
+[[cstdint.syn]]. Each of the `SCN` macros listed in this subclause is
+defined if and only if the implementation defines the corresponding
+*typedef-name* in  [[cstdint.syn]] and has a suitable `fscanf` length
+modifier for the type.
 <!-- Link reference definitions -->
 [adjustfield.manip]: #adjustfield.manip
+[allocator.requirements.general]: library.md#allocator.requirements.general
 [basefield.manip]: #basefield.manip
 [basic.fundamental]: basic.md#basic.fundamental
 [basic.ios.cons]: #basic.ios.cons
 [basic.ios.copyfmt]: #basic.ios.copyfmt
 [basic.ios.members]: #basic.ios.members
+[basic.start.dynamic]: basic.md#basic.start.dynamic
 [basic.start.main]: basic.md#basic.start.main
 [bidirectional.iterators]: iterators.md#bidirectional.iterators
 [bitmask.types]: library.md#bitmask.types
 [c.files]: #c.files
 [char.traits]: strings.md#char.traits
+[char.traits.specializations]: strings.md#char.traits.specializations
+[character.seq]: library.md#character.seq
 [cinttypes.syn]: #cinttypes.syn
 [container.requirements.general]: containers.md#container.requirements.general
 [cpp17.copyassignable]: #cpp17.copyassignable
 [cpp17.copyconstructible]: #cpp17.copyconstructible
 [cpp17.defaultconstructible]: #cpp17.defaultconstructible
 [cpp17.destructible]: #cpp17.destructible
 [cpp17.equalitycomparable]: #cpp17.equalitycomparable
+[cstdint.syn]: support.md#cstdint.syn
 [cstdio.syn]: #cstdio.syn
+[defns.ntcts]: intro.md#defns.ntcts
 [enumerated.types]: library.md#enumerated.types
 [error.reporting]: #error.reporting
 [ext.manip]: #ext.manip
 [file.streams]: #file.streams
 [filebuf]: #filebuf
 [filebuf.assign]: #filebuf.assign
 [filebuf.cons]: #filebuf.cons
+[filebuf.general]: #filebuf.general
 [filebuf.members]: #filebuf.members
 [filebuf.open.modes]: #filebuf.open.modes
 [filebuf.seekoff]: #filebuf.seekoff
 [filebuf.virtuals]: #filebuf.virtuals
 [filesystems]: #filesystems
 [floatfield.manip]: #floatfield.manip
 [fmtflags.manip]: #fmtflags.manip
 [fmtflags.state]: #fmtflags.state
+[format.err.report]: utilities.md#format.err.report
 [fpos]: #fpos
 [fpos.members]: #fpos.members
 [fpos.operations]: #fpos.operations
 [fs.class.directory.entry]: #fs.class.directory.entry
+[fs.class.directory.entry.general]: #fs.class.directory.entry.general
 [fs.class.directory.iterator]: #fs.class.directory.iterator
+[fs.class.directory.iterator.general]: #fs.class.directory.iterator.general
 [fs.class.file.status]: #fs.class.file.status
+[fs.class.file.status.general]: #fs.class.file.status.general
 [fs.class.filesystem.error]: #fs.class.filesystem.error
+[fs.class.filesystem.error.general]: #fs.class.filesystem.error.general
 [fs.class.path]: #fs.class.path
+[fs.class.path.general]: #fs.class.path.general
 [fs.class.rec.dir.itr]: #fs.class.rec.dir.itr
+[fs.class.rec.dir.itr.general]: #fs.class.rec.dir.itr.general
 [fs.conform.9945]: #fs.conform.9945
 [fs.conform.os]: #fs.conform.os
 [fs.conformance]: #fs.conformance
+[fs.conformance.general]: #fs.conformance.general
 [fs.dir.entry.cons]: #fs.dir.entry.cons
+[fs.dir.entry.io]: #fs.dir.entry.io
 [fs.dir.entry.mods]: #fs.dir.entry.mods
 [fs.dir.entry.obs]: #fs.dir.entry.obs
 [fs.dir.itr.members]: #fs.dir.itr.members
 [fs.dir.itr.nonmembers]: #fs.dir.itr.nonmembers
 [fs.enum]: #fs.enum
 [fs.file.status.mods]: #fs.file.status.mods
 [fs.file.status.obs]: #fs.file.status.obs
 [fs.filesystem.error.members]: #fs.filesystem.error.members
 [fs.filesystem.syn]: #fs.filesystem.syn
 [fs.general]: #fs.general
 [fs.op.absolute]: #fs.op.absolute
 [fs.op.canonical]: #fs.op.canonical
 [fs.op.copy]: #fs.op.copy
 [fs.op.copy.file]: #fs.op.copy.file
 [fs.op.copy.symlink]: #fs.op.copy.symlink
 [fs.op.current.path]: #fs.op.current.path
 [fs.op.equivalent]: #fs.op.equivalent
 [fs.op.exists]: #fs.op.exists
 [fs.op.file.size]: #fs.op.file.size
 [fs.op.funcs]: #fs.op.funcs
+[fs.op.funcs.general]: #fs.op.funcs.general
 [fs.op.hard.lk.ct]: #fs.op.hard.lk.ct
 [fs.op.is.block.file]: #fs.op.is.block.file
 [fs.op.is.char.file]: #fs.op.is.char.file
 [fs.op.is.directory]: #fs.op.is.directory
 [fs.op.is.empty]: #fs.op.is.empty
 [fs.path.decompose]: #fs.path.decompose
 [fs.path.fmt.cvt]: #fs.path.fmt.cvt
 [fs.path.gen]: #fs.path.gen
 [fs.path.generic]: #fs.path.generic
 [fs.path.generic.obs]: #fs.path.generic.obs
+[fs.path.hash]: #fs.path.hash
 [fs.path.io]: #fs.path.io
 [fs.path.itr]: #fs.path.itr
 [fs.path.member]: #fs.path.member
 [fs.path.modifiers]: #fs.path.modifiers
 [fs.path.native.obs]: #fs.path.native.obs
 [fs.path.type.cvt]: #fs.path.type.cvt
 [fs.race.behavior]: #fs.race.behavior
 [fs.rec.dir.itr.members]: #fs.rec.dir.itr.members
 [fs.rec.dir.itr.nonmembers]: #fs.rec.dir.itr.nonmembers
 [fs.req]: #fs.req
 [fstream]: #fstream
 [fstream.cons]: #fstream.cons
+[fstream.general]: #fstream.general
 [fstream.members]: #fstream.members
+[fstream.swap]: #fstream.swap
 [fstream.syn]: #fstream.syn
 [ifstream]: #ifstream
 [ifstream.cons]: #ifstream.cons
+[ifstream.general]: #ifstream.general
 [ifstream.members]: #ifstream.members
+[ifstream.swap]: #ifstream.swap
 [input.iterators]: iterators.md#input.iterators
 [input.output]: #input.output
 [input.output.general]: #input.output.general
 [input.streams]: #input.streams
+[input.streams.general]: #input.streams.general
 [intro.multithread]: basic.md#intro.multithread
 [intro.races]: basic.md#intro.races
 [iomanip.syn]: #iomanip.syn
 [ios]: #ios
 [ios.base]: #ios.base
 [ios.base.callback]: #ios.base.callback
 [ios.base.cons]: #ios.base.cons
+[ios.base.general]: #ios.base.general
 [ios.base.locales]: #ios.base.locales
 [ios.base.storage]: #ios.base.storage
 [ios.failure]: #ios.failure
 [ios.fmtflags]: #ios.fmtflags
 [ios.fmtflags.const]: #ios.fmtflags.const
 [iostream.limits.imbue]: #iostream.limits.imbue
 [iostream.objects]: #iostream.objects
 [iostream.objects.overview]: #iostream.objects.overview
 [iostream.syn]: #iostream.syn
 [iostreamclass]: #iostreamclass
+[iostreamclass.general]: #iostreamclass.general
 [iostreams.base]: #iostreams.base
 [iostreams.limits.pos]: #iostreams.limits.pos
 [iostreams.requirements]: #iostreams.requirements
 [iostreams.summary]: #iostreams.summary
 [iostreams.threadsafety]: #iostreams.threadsafety
+[ispanstream]: #ispanstream
+[ispanstream.cons]: #ispanstream.cons
+[ispanstream.general]: #ispanstream.general
+[ispanstream.members]: #ispanstream.members
+[ispanstream.swap]: #ispanstream.swap
 [istream]: #istream
 [istream.assign]: #istream.assign
 [istream.cons]: #istream.cons
 [istream.extractors]: #istream.extractors
 [istream.formatted]: #istream.formatted
 [istream.formatted.arithmetic]: #istream.formatted.arithmetic
 [istream.formatted.reqmts]: #istream.formatted.reqmts
+[istream.general]: #istream.general
 [istream.manip]: #istream.manip
 [istream.rvalue]: #istream.rvalue
 [istream.sentry]: #istream.sentry
 [istream.syn]: #istream.syn
 [istream.unformatted]: #istream.unformatted
 [istringstream]: #istringstream
 [istringstream.cons]: #istringstream.cons
+[istringstream.general]: #istringstream.general
 [istringstream.members]: #istringstream.members
+[istringstream.swap]: #istringstream.swap
 [lex.charset]: lex.md#lex.charset
 [locale.codecvt.virtuals]: localization.md#locale.codecvt.virtuals
 [locale.num.get]: localization.md#locale.num.get
 [namespace.std]: library.md#namespace.std
 [narrow.stream.objects]: #narrow.stream.objects
 [numeric.limits]: support.md#numeric.limits
 [ofstream]: #ofstream
 [ofstream.cons]: #ofstream.cons
+[ofstream.general]: #ofstream.general
 [ofstream.members]: #ofstream.members
+[ofstream.swap]: #ofstream.swap
+[ospanstream]: #ospanstream
+[ospanstream.cons]: #ospanstream.cons
+[ospanstream.general]: #ospanstream.general
+[ospanstream.members]: #ospanstream.members
+[ospanstream.swap]: #ospanstream.swap
 [ostream]: #ostream
 [ostream.assign]: #ostream.assign
 [ostream.cons]: #ostream.cons
 [ostream.formatted]: #ostream.formatted
+[ostream.formatted.print]: #ostream.formatted.print
 [ostream.formatted.reqmts]: #ostream.formatted.reqmts
+[ostream.general]: #ostream.general
 [ostream.inserters]: #ostream.inserters
 [ostream.inserters.arithmetic]: #ostream.inserters.arithmetic
 [ostream.inserters.character]: #ostream.inserters.character
 [ostream.manip]: #ostream.manip
 [ostream.rvalue]: #ostream.rvalue
 [ostream.seeks]: #ostream.seeks
 [ostream.sentry]: #ostream.sentry
 [ostream.syn]: #ostream.syn
 [ostream.unformatted]: #ostream.unformatted
 [ostringstream]: #ostringstream
 [ostringstream.cons]: #ostringstream.cons
+[ostringstream.general]: #ostringstream.general
 [ostringstream.members]: #ostringstream.members
+[ostringstream.swap]: #ostringstream.swap
 [output.streams]: #output.streams
+[output.streams.general]: #output.streams.general
+[print.fun]: #print.fun
+[print.syn]: #print.syn
 [quoted.manip]: #quoted.manip
 [res.on.data.races]: library.md#res.on.data.races
 [res.on.exception.handling]: library.md#res.on.exception.handling
+[span.streams]: #span.streams
+[span.streams.overview]: #span.streams.overview
+[spanbuf]: #spanbuf
+[spanbuf.assign]: #spanbuf.assign
+[spanbuf.cons]: #spanbuf.cons
+[spanbuf.general]: #spanbuf.general
+[spanbuf.members]: #spanbuf.members
+[spanbuf.virtuals]: #spanbuf.virtuals
+[spanstream]: #spanstream
+[spanstream.cons]: #spanstream.cons
+[spanstream.general]: #spanstream.general
+[spanstream.members]: #spanstream.members
+[spanstream.swap]: #spanstream.swap
+[spanstream.syn]: #spanstream.syn
 [sstream.syn]: #sstream.syn
 [std.ios.manip]: #std.ios.manip
 [std.manip]: #std.manip
+[std.modules]: library.md#std.modules
 [stream.buffers]: #stream.buffers
 [stream.types]: #stream.types
 [streambuf]: #streambuf
 [streambuf.assign]: #streambuf.assign
 [streambuf.buffer]: #streambuf.buffer
 [streambuf.cons]: #streambuf.cons
+[streambuf.general]: #streambuf.general
 [streambuf.get.area]: #streambuf.get.area
 [streambuf.locales]: #streambuf.locales
 [streambuf.members]: #streambuf.members
 [streambuf.protected]: #streambuf.protected
 [streambuf.pub.get]: #streambuf.pub.get
 [string.classes]: strings.md#string.classes
 [string.streams]: #string.streams
 [stringbuf]: #stringbuf
 [stringbuf.assign]: #stringbuf.assign
 [stringbuf.cons]: #stringbuf.cons
+[stringbuf.general]: #stringbuf.general
 [stringbuf.members]: #stringbuf.members
 [stringbuf.seekoff.newoff]: #stringbuf.seekoff.newoff
 [stringbuf.seekoff.pos]: #stringbuf.seekoff.pos
 [stringbuf.virtuals]: #stringbuf.virtuals
 [strings]: strings.md#strings
 [stringstream]: #stringstream
 [stringstream.cons]: #stringstream.cons
+[stringstream.general]: #stringstream.general
 [stringstream.members]: #stringstream.members
+[stringstream.swap]: #stringstream.swap
 [syncstream]: #syncstream
 [syncstream.osyncstream]: #syncstream.osyncstream
 [syncstream.osyncstream.cons]: #syncstream.osyncstream.cons
 [syncstream.osyncstream.members]: #syncstream.osyncstream.members
 [syncstream.osyncstream.overview]: #syncstream.osyncstream.overview
 [syncstream.syncbuf.members]: #syncstream.syncbuf.members
 [syncstream.syncbuf.overview]: #syncstream.syncbuf.overview
 [syncstream.syncbuf.special]: #syncstream.syncbuf.special
 [syncstream.syncbuf.virtuals]: #syncstream.syncbuf.virtuals
 [temp.deduct]: temp.md#temp.deduct
+[term.unevaluated.operand]: expr.md#term.unevaluated.operand
+[views.span]: containers.md#views.span
 [wide.stream.objects]: #wide.stream.objects
+[^1]: Typically `long long`.
+[^2]: Most places where `streamsize` is used would use `size_t` in ISO
+    C, or `ssize_t` in POSIX.
+[^3]: It is the implementation’s responsibility to implement headers so
     that including `<iosfwd>` and other headers does not violate the
     rules about multiple occurrences of default arguments.
+[^4]: Constructors and destructors for objects with static storage
     duration can access these objects to read input from `stdin` or
     write output to `stdout` or `stderr`.
+[^5]: This implies that operations on a standard iostream object can be
     mixed arbitrarily with operations on the corresponding stdio stream.
     In practical terms, synchronization usually means that a standard
     iostream object and a standard stdio object share a buffer.
+[^6]: An implementation is free to implement both the integer array
     pointed at by `iarray` and the pointer array pointed at by `parray`
     as sparse data structures, possibly with a one-element cache for
     each.
+[^7]: For example, because it cannot allocate space.
 [^8]: For example, because it cannot allocate space.
+[^9]: This suggests an infinite amount of copying, but the
     implementation can keep track of the maximum element of the arrays
     that is nonzero.
+[^10]: Checking `badbit` also for `fail()` is historical practice.
+[^11]: The function signature `dec(ios_base&)` can be called by the
     function signature
     `basic_ostream& stream::operator<<(ios_base& (*)(ios_base&))` to
     permit expressions of the form `cout << dec` to change the format
     flags stored in `cout`.
+[^12]: The default constructor is protected for class `basic_streambuf`
+    to assure that only objects for classes derived from this class can
     be constructed.
+[^13]: The morphemes of `showmanyc` are “es-how-many-see”, not
+    “show-manic”.
+[^14]: `underflow` or `uflow` can fail by throwing an exception
     prematurely. The intention is not only that the calls will not
     return `eof()` but that they will return “immediately”.
 [^15]: Classes derived from `basic_streambuf` can provide more efficient
     ways to implement `xsgetn()` and `xsputn()` by overriding these
     definitions from the base class.
+[^16]: That is, for each class derived from a specialization of
+    `basic_streambuf` in this Clause [[stringbuf]], [[filebuf]],
+    a specification of how consuming a character effects the associated
+    output sequence is given. There is no requirement on a
+    program-defined class.
 [^17]: Typically, `overflow` returns `c` to indicate success, except
     when `traits::eq_int_type(c, traits::eof())` returns `true`, in
     which case it returns `traits::not_eof(c)`.
     specified.
 [^19]: The `sentry` constructor and destructor can also perform
     additional implementation-dependent operations.
+[^20]: See, for example, the function signature
     `ws(basic_istream&)`[[istream.manip]].
+[^21]: See, for example, the function signature
     `dec(ios_base&)`[[basefield.manip]].
+[^22]: Note that this function is not overloaded on types `signed char`
+    and `unsigned char`.
+[^23]: Note that this function is not overloaded on types `signed char`
+    and `unsigned char`.
 [^24]: Note that this function is not overloaded on types `signed char`
     and `unsigned char`.
+[^25]: Since the final input character is “extracted”, it is counted in
     the `gcount()`, even though it is not stored.
+[^26]: This allows an input line which exactly fills the buffer, without
     setting `failbit`. This is different behavior than the historical
     AT&T implementation.
+[^27]: This implies an empty input line will not cause `failbit` to be
     set.
+[^28]: Note that this function is not overloaded on types `signed char`
     and `unsigned char`.
+[^29]: The call `os.tie()->flush()` does not necessarily occur if the
     function can determine that no synchronization is necessary.
+[^30]: The `sentry` constructor and destructor can also perform
     additional implementation-dependent operations.
+[^31]: This is done without causing an `ios_base::failure` to be thrown.
+[^32]: See, for example, the function signature
     `endl(basic_ostream&)`[[ostream.manip]].
+[^33]: See, for example, the function signature
     `dec(ios_base&)`[[basefield.manip]].
+[^34]: This is done without causing an `ios_base::failure` to be thrown.
+[^35]: Note that this function is not overloaded on types `signed char`
     and `unsigned char`.
+[^36]: Note that this function is not overloaded on types `signed char`
     and `unsigned char`.
+[^37]: The expression `cin >> resetiosflags(ios_base::skipws)` clears
     `ios_base::skipws` in the format flags stored in the
     `basic_istream<charT, traits>` object `cin` (the same as
     `cin >> noskipws`), and the expression
     `cout << resetiosflags(ios_base::showbase)` clears
     `ios_base::showbase` in the format flags stored in the
     `basic_ostream<charT, traits>` object `cout` (the same as
     `cout << noshowbase`).
+[^38]: The macro `SEEK_END` is defined, and the function signatures
     `fopen(const char*, const char*)` and `fseek(FILE*, long, int)` are
     declared, in `<cstdio>`.

Diff to HTML by rtfpessoa