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

Files changed (1) hide show

tmp/tmpy4juhgm7/{from.md → to.md} +950 -507

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

@@ -71,13 +71,13 @@ as noted explicitly below, their behavior when `traits::pos_type` and
 `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
@@ -117,21 +117,17 @@ namespace std {
   template<class charT, class traits = char_traits<charT>>
     class basic_ostream;
   template<class charT, class traits = char_traits<charT>>
     class basic_iostream;
-  template<class charT, class traits = char_traits<charT>,
-           class Allocator = allocator<charT>>
     class basic_stringbuf;
-  template<class charT, class traits = char_traits<charT>,
-           class Allocator = allocator<charT>>
     class basic_istringstream;
-  template<class charT, class traits = char_traits<charT>,
-           class Allocator = allocator<charT>>
     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>>
@@ -148,15 +144,13 @@ namespace std {
   template<class charT, class traits = char_traits<charT>>
     class basic_ofstream;
   template<class charT, class traits = char_traits<charT>>
     class basic_fstream;
-  template<class charT, class traits = char_traits<charT>,
-           class Allocator = allocator<charT>>
     class basic_syncbuf;
-  template<class charT, class traits = char_traits<charT>,
-           class Allocator = allocator<charT>>
     class basic_osyncstream;
   template<class charT, class traits = char_traits<charT>>
     class istreambuf_iterator;
   template<class charT, class traits = char_traits<charT>>
@@ -294,11 +288,14 @@ namespace std {
 In this Clause, the type name `FILE` refers to the type `FILE` declared
 in `<cstdio>`.
 The header `<iostream>` declares objects that associate objects with the
 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. The objects are not
@@ -330,11 +327,11 @@ iostream object’s formatted and unformatted input [[istream]] and output
 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>
 ``` cpp
 istream cin;
@@ -416,15 +413,19 @@ the object `stderr`, declared in `<cstdio>`.
 ``` cpp
 #include <iosfwd>   // see [iosfwd.syn]
 namespace std {
   using streamoff  = implementation-defined;
   using streamsize = implementation-defined;
   template<class stateT> class fpos;
   class ios_base;
   template<class charT, class traits = char_traits<charT>>
     class basic_ios;
   // [std.ios.manip], manipulators
   ios_base& boolalpha  (ios_base& str);
@@ -626,11 +627,11 @@ namespace std {
 An implementation is permitted to define `ios_base::failure` as a
 synonym for a class with equivalent functionality to class
 `ios_base::failure` shown in this subclause.
 [*Note 1*: When `ios_base::failure` is a synonym for another type, that
-type is required to provide a nested type `failure` to emulate the
 injected-class-name. — *end note*]
 The class `failure` defines the base class for the types of all objects
 thrown as exceptions, by functions in the iostreams library, to report
 errors detected during stream buffer operations.
@@ -770,27 +771,19 @@ namespace std {
   public:
     Init();
     Init(const Init&) = default;
     ~Init();
     Init& operator=(const Init&) = default;
-  private:
-    static int init_cnt;        // exposition only
   };
 }
 ```
 The class `Init` describes an object whose construction ensures the
 construction of the eight objects declared in `<iostream>`
 [[iostream.objects]] that associate file stream buffers with the
 standard C streams provided for by the functions declared in `<cstdio>`.
-For the sake of exposition, the maintained data is presented here as:
-- `static int init_cnt`, counts the number of constructor and destructor
-  calls for class `Init`, initialized to zero.
 ``` cpp
 Init();
 ```
 *Effects:* Constructs and initializes the objects `cin`, `cout`, `cerr`,
@@ -957,25 +950,25 @@ for any sequence of characters.[^5]
 ``` cpp
 static int xalloc();
 ```
-*Returns:* `index` `++`.
 *Remarks:* Concurrent access to this function by multiple threads does
 not result in a data race [[intro.multithread]].
 ``` cpp
 long& iword(int idx);
 ```
 *Preconditions:* `idx` is a value obtained by a call to `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
@@ -984,28 +977,28 @@ 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
 void*& pword(int idx);
 ```
 *Preconditions:* `idx` is a value obtained by a call to `xalloc`.
-*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`).
@@ -1054,10 +1047,12 @@ destroyed, whichever comes first; otherwise the behavior is undefined.
 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
@@ -1074,17 +1069,17 @@ namespace std {
 ``` cpp
 void state(stateT s);
 ```
-*Effects:* Assigns `s` to `st`.
 ``` cpp
 stateT state() const;
 ```
-*Returns:* Current value of `st`.
 #### Requirements <a id="fpos.operations">[[fpos.operations]]</a>
 An `fpos` type specifies file position information. It holds a state
 object whose type is equal to the template parameter `stateT`. Type
@@ -1125,13 +1120,13 @@ function is undefined.
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_ios : public ios_base {
   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;
     // [iostate.flags], flags functions
     explicit operator bool() const;
     bool operator!() const;
@@ -1277,17 +1272,17 @@ locale imbue(const locale& loc);
 ``` cpp
 char narrow(char_type c, char dfault) const;
 ```
-*Returns:* `use_facet<ctype<char_type>>(getloc()).narrow(c, dfault)`
 ``` cpp
 char_type widen(char c) const;
 ```
-*Returns:* `use_facet<ctype<char_type>>(getloc()).widen(c)`
 ``` cpp
 char_type fill() const;
 ```
@@ -1423,11 +1418,11 @@ void setstate(iostate state);
 ``` cpp
 bool good() const;
 ```
-*Returns:* `rdstate() == 0`
 ``` cpp
 bool eof() const;
 ```
@@ -1709,10 +1704,11 @@ object’s `name` virtual function shall return a pointer to the string
 ### Header `<streambuf>` synopsis <a id="streambuf.syn">[[streambuf.syn]]</a>
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>>
     class basic_streambuf;
   using streambuf  = basic_streambuf<char>;
   using wstreambuf = basic_streambuf<wchar_t>;
 }
@@ -1780,13 +1776,13 @@ above:
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_streambuf {
   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;
     virtual ~basic_streambuf();
     // [streambuf.locales], locales
@@ -1868,13 +1864,13 @@ namespace std {
     virtual int_type   overflow(int_type c = traits::eof());
   };
 }
 ```
-The class template `basic_streambuf` serves as an abstract base class
-for deriving various *stream buffers* whose objects each control two
-*character sequences*:
 - a character *input sequence*;
 - a character *output sequence*.
 #### Constructors <a id="streambuf.cons">[[streambuf.cons]]</a>
@@ -2097,10 +2093,13 @@ void gbump(int n);
 ``` cpp
 void setg(char_type* gbeg, char_type* gnext, char_type* gend);
 ```
 *Ensures:* `gbeg == eback()`, `gnext == gptr()`, and `gend == egptr()`
 are all `true`.
 ##### Put area access <a id="streambuf.put.area">[[streambuf.put.area]]</a>
@@ -2130,10 +2129,12 @@ void pbump(int n);
 ``` cpp
 void setp(char_type* pbeg, char_type* pend);
 ```
 *Ensures:* `pbeg == pbase()`, `pbeg == pptr()`, and `pend == epptr()`
 are all `true`.
 #### Virtual functions <a id="streambuf.virtuals">[[streambuf.virtuals]]</a>
@@ -2389,40 +2390,46 @@ accommodate the argument character sequence.
 ### Header `<istream>` synopsis <a id="istream.syn">[[istream.syn]]</a>
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>>
     class basic_istream;
   using istream  = basic_istream<char>;
   using wistream = basic_istream<wchar_t>;
   template<class charT, class traits = char_traits<charT>>
     class basic_iostream;
   using iostream  = basic_iostream<char>;
   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>
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>>
     class basic_ostream;
   using ostream  = basic_ostream<char>;
   using wostream = basic_ostream<wchar_t>;
   template<class charT, class traits>
     basic_ostream<charT, traits>& endl(basic_ostream<charT, traits>& os);
   template<class charT, class traits>
     basic_ostream<charT, traits>& ends(basic_ostream<charT, traits>& os);
   template<class charT, class traits>
@@ -2433,39 +2440,45 @@ 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 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,
@@ -2491,18 +2504,22 @@ namespace std {
   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>
@@ -2526,13 +2543,13 @@ namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_istream : virtual public basic_ios<charT, traits> {
   public:
     // types (inherited from basic_ios[ios])
     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;
     // [istream.cons], constructor/destructor
     explicit basic_istream(basic_streambuf<charT, traits>* sb);
     virtual ~basic_istream();
@@ -2573,10 +2590,11 @@ namespace std {
     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);
@@ -2654,11 +2672,11 @@ virtual ~basic_istream();
 ``` cpp
 basic_istream& operator=(basic_istream&& rhs);
 ```
-*Effects:* Equivalent to: `swap(rhs)`.
 *Returns:* `*this`.
 ``` cpp
 void swap(basic_istream& rhs);
@@ -2726,12 +2744,12 @@ const ctype<charT>& ctype = use_facet<ctype<charT>>(is.getloc());
 if (ctype.is(ctype.space, c) != 0)
   // c is a whitespace character.
 ```
 If, after any preparation is completed, `is.good()` is `true`,
-`ok_ != false` otherwise, `ok_ == false`. During preparation, the
-constructor may call `setstate(failbit)` (which may throw
 `ios_base::failure` [[iostate.flags]]).[^19]
 ``` cpp
 ~sentry();
 ```
@@ -2740,11 +2758,11 @@ constructor may call `setstate(failbit)` (which may throw
 ``` cpp
 explicit operator bool() const;
 ```
-*Returns:* `ok_`.
 #### Formatted input functions <a id="istream.formatted">[[istream.formatted]]</a>
 ##### Common requirements <a id="istream.formatted.reqmts">[[istream.formatted.reqmts]]</a>
@@ -3178,11 +3196,11 @@ int main() {
 ``` 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());
 ```
@@ -3190,11 +3208,11 @@ basic_istream& ignore(streamsize n = 1, int_type delim = traits::eof());
 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
 - end-of-file occurs on the input sequence (in which case the function
   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).
@@ -3202,10 +3220,19 @@ occurs:
 [*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
@@ -3393,13 +3420,13 @@ namespace std {
   class basic_iostream
     : public basic_istream<charT, traits>,
       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;
     // [iostream.cons], constructor
     explicit basic_iostream(basic_streambuf<charT, traits>* sb);
@@ -3454,11 +3481,11 @@ virtual ~basic_iostream();
 ``` cpp
 basic_iostream& operator=(basic_iostream&& rhs);
 ```
-*Effects:* Equivalent to: `swap(rhs)`.
 ``` cpp
 void swap(basic_iostream& rhs);
 ```
@@ -3485,13 +3512,13 @@ namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_ostream : virtual public basic_ios<charT, traits> {
   public:
     // types (inherited from basic_ios[ios])
     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;
     // [ostream.cons], constructor/destructor
     explicit basic_ostream(basic_streambuf<char_type, traits>* sb);
     virtual ~basic_ostream();
@@ -3663,11 +3690,11 @@ virtual ~basic_ostream();
 ``` cpp
 basic_ostream& operator=(basic_ostream&& rhs);
 ```
-*Effects:* Equivalent to: `swap(rhs)`.
 *Returns:* `*this`.
 ``` cpp
 void swap(basic_ostream& rhs);
@@ -3703,28 +3730,29 @@ 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();
 ```
 If
 `(os.flags() & ios_base::unitbuf) && !uncaught_exceptions() && os.good()`
-is `true`, calls `os.rdbuf()->pubsync()`. If that function returns -1,
-sets `badbit` in `os.rdstate()` without propagating an exception.
 ``` cpp
 explicit operator bool() const;
 ```
-*Effects:* Returns `ok_`.
 ##### Seek members <a id="ostream.seeks">[[ostream.seeks]]</a>
 Each seek member function begins execution by constructing an object of
 class `sentry`. It returns by destroying the `sentry` object.
@@ -3779,16 +3807,16 @@ 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
 does so as follows. Given a `charT` character sequence `seq` where
-`charT` is the character type of the stream, if the length of `seq` is
-less than `os.width()`, then enough copies of `os.fill()` are added to
-this sequence as necessary to pad to a width of `os.width()` characters.
-If `(os.flags() & ios_base::adjustfield) == ios_base::left` is `true`,
-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
 basic_ostream& operator<<(bool val);
@@ -3813,59 +3841,52 @@ When `val` is of type `bool`, `long`, `unsigned long`, `long long`,
 `unsigned long long`, `double`, `long double`, or `const void*`, 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(), val).failed();
 ```
 When `val` is of type `short` the formatting conversion occurs as if it
 performed the following code fragment:
 ``` cpp
 ios_base::fmtflags baseflags = ios_base::flags() & ios_base::basefield;
-bool failed = use_facet<
- num_put<charT, ostreambuf_iterator<charT, traits>>
-    >(getloc()).put(*this, *this, fill(),
     baseflags == ios_base::oct || baseflags == ios_base::hex
       ? static_cast<long>(static_cast<unsigned short>(val))
       : static_cast<long>(val)).failed();
 ```
 When `val` is of type `int` the formatting conversion occurs as if it
 performed the following code fragment:
 ``` cpp
 ios_base::fmtflags baseflags = ios_base::flags() & ios_base::basefield;
-bool failed = use_facet<
- num_put<charT, ostreambuf_iterator<charT, traits>>
-    >(getloc()).put(*this, *this, fill(),
     baseflags == ios_base::oct || baseflags == ios_base::hex
       ? static_cast<long>(static_cast<unsigned int>(val))
       : static_cast<long>(val)).failed();
 ```
 When `val` is of type `unsigned short` or `unsigned int` 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<unsigned long>(val)).failed();
 ```
 When `val` is of type `float` 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();
 ```
 The first argument provides an object of the `ostreambuf_iterator<>`
 class which is an iterator for class `basic_ostream<>`. It bypasses
 `ostream`s and uses `streambuf`s directly. Class `locale` relies on
@@ -3893,26 +3914,22 @@ basic_ostream& operator<<(extended-floating-point-type val);
 *`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.
@@ -4006,15 +4023,15 @@ template<class traits>
   basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>& out, unsigned char c);
 ```
 *Effects:* Behaves as a formatted output
 function [[ostream.formatted.reqmts]] of `out`. Constructs a character
-sequence `seq`. If `c` has type `char` and the character type of the
-stream is not `char`, then `seq` consists of `out.widen(c)`; otherwise
-`seq` consists of `c`. Determines padding for `seq` as described
-in  [[ostream.formatted.reqmts]]. Inserts `seq` into `out`. Calls
-`os.width(0)`.
 *Returns:* `out`.
 ``` cpp
 template<class charT, class traits>
@@ -4064,28 +4081,38 @@ template<class... 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);
@@ -4097,28 +4124,29 @@ 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.
@@ -4179,11 +4207,11 @@ object. If that object returns `true` when converted to a value of type
 [[iostate.flags]]). Otherwise, if the `sentry` object returns `false`,
 does nothing.
 *Returns:* `*this`.
-#### Standard manipulators <a id="ostream.manip">[[ostream.manip]]</a>
 Each instantiation of any of the function templates specified in this
 subclause is a designated addressable function [[namespace.std]].
 ``` cpp
@@ -4225,11 +4253,11 @@ of exposition, calls `buf->set_emit_on_sync(true)`. Otherwise this
 manipulator has no effect.
 [*Note 1*: To work around the issue that the `Allocator` template
 argument cannot be deduced, implementations can introduce an
 intermediate base class to `basic_syncbuf` that manages its
-`emit_on_sync` flag. — *end note*]
 *Returns:* `os`.
 ``` cpp
 template<class charT, class traits>
@@ -4642,21 +4670,27 @@ 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);
@@ -4666,19 +4700,39 @@ template<class... Args>
 ``` 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);
 ```
@@ -4687,37 +4741,47 @@ void vprint_unicode(string_view fmt, format_args args);
 ``` 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
@@ -4733,17 +4797,30 @@ void vprint_nonunicode(string_view fmt, format_args args);
 ``` 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`.
@@ -4751,45 +4828,45 @@ throw `bad_alloc`.
 ### 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);
@@ -4807,18 +4884,17 @@ described in  [[string.classes]].
 #### 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> {
   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;
     using allocator_type = Allocator;
     // [stringbuf.cons], constructors
     basic_stringbuf() : basic_stringbuf(ios_base::in | ios_base::out) {}
@@ -4842,10 +4918,17 @@ namespace std {
         ios_base::openmode which, const Allocator& a);
     template<class SAlloc>
       explicit basic_stringbuf(
         const basic_string<charT, traits, SAlloc>& s,
         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
@@ -4864,10 +4947,12 @@ namespace std {
     void str(const basic_string<charT, traits, Allocator>& s);
     template<class SAlloc>
       void str(const basic_string<charT, traits, SAlloc>& s);
     void str(basic_string<charT, traits, Allocator>&& s);
   protected:
     // [stringbuf.virtuals], overridden virtual functions
     int_type underflow() override;
     int_type pbackfail(int_type c = traits::eof()) override;
@@ -4882,11 +4967,11 @@ namespace std {
                        = ios_base::in | ios_base::out) override;
   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
@@ -4900,22 +4985,22 @@ initialization 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.
 - `basic_string<charT, traits, Allocator> buf` contains the underlying
   character sequence.
-- `init_buf_ptrs()` sets the base class’ get area [[streambuf.get.area]]
   and put area [[streambuf.put.area]] pointers after initializing,
-  moving from, or assigning to `buf` accordingly.
 #### Constructors <a id="stringbuf.cons">[[stringbuf.cons]]</a>
 ``` cpp
 explicit basic_stringbuf(ios_base::openmode which);
 ```
 *Effects:* Initializes the base class with `basic_streambuf()`
-[[streambuf.cons]], and `mode` with `which`. It is
 *implementation-defined* whether the sequence pointers (`eback()`,
 `gptr()`, `egptr()`, `pbase()`, `pptr()`, `epptr()`) are initialized to
 null pointers.
 *Ensures:* `str().empty()` is `true`.
@@ -4925,43 +5010,43 @@ explicit basic_stringbuf(
   const basic_string<charT, traits, Allocator>& s,
   ios_base::openmode which = ios_base::in | ios_base::out);
 ```
 *Effects:* Initializes the base class with `basic_streambuf()`
-[[streambuf.cons]], `mode` with `which`, and `buf` with `s`, then calls
-`init_buf_ptrs()`.
 ``` cpp
 basic_stringbuf(ios_base::openmode which, const Allocator& a);
 ```
 *Effects:* Initializes the base class with `basic_streambuf()`
-[[streambuf.cons]], `mode` with `which`, and `buf` with `a`, then calls
-`init_buf_ptrs()`.
 *Ensures:* `str().empty()` is `true`.
 ``` cpp
 explicit basic_stringbuf(
   basic_string<charT, traits, Allocator>&& s,
   ios_base::openmode which = ios_base::in | ios_base::out);
 ```
 *Effects:* Initializes the base class with `basic_streambuf()`
-[[streambuf.cons]], `mode` with `which`, and `buf` with `std::move(s)`,
-then calls `init_buf_ptrs()`.
 ``` cpp
 template<class SAlloc>
   basic_stringbuf(
     const basic_string<charT, traits, SAlloc>& s,
     ios_base::openmode which, const Allocator& a);
 ```
 *Effects:* Initializes the base class with `basic_streambuf()`
-[[streambuf.cons]], `mode` with `which`, and `buf` with `{s,a}`, then
-calls `init_buf_ptrs()`.
 ``` cpp
 template<class SAlloc>
   explicit basic_stringbuf(
     const basic_string<charT, traits, SAlloc>& s,
@@ -4969,21 +5054,44 @@ template<class SAlloc>
 ```
 *Constraints:* `is_same_v<SAlloc, Allocator>` is `false`.
 *Effects:* Initializes the base class with `basic_streambuf()`
-[[streambuf.cons]], `mode` with `which`, and `buf` with `s`, then calls
-`init_buf_ptrs()`.
 ``` cpp
 basic_stringbuf(basic_stringbuf&& rhs);
 basic_stringbuf(basic_stringbuf&& rhs, const Allocator& a);
 ```
 *Effects:* Copy constructs the base class from `rhs` and initializes
-`mode` with `rhs.mode`. In the first form `buf` is initialized from
-`std::move(rhs).str()`. In the second form `buf` is initialized from
 `{std::move(rhs).str(), a}`. It is *implementation-defined* whether the
 sequence pointers in `*this` (`eback()`, `gptr()`, `egptr()`, `pbase()`,
 `pptr()`, `epptr()`) obtain the values which `rhs` had.
 *Ensures:* Let `rhs_p` refer to the state of `rhs` just prior to this
@@ -5026,19 +5134,19 @@ void swap(basic_stringbuf& rhs) noexcept(see below);
 *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>
   void swap(basic_stringbuf<charT, traits, Allocator>& x,
             basic_stringbuf<charT, traits, Allocator>& y) noexcept(noexcept(x.swap(y)));
 ```
-*Effects:* Equivalent to: `x.swap(y)`.
 #### Member functions <a id="stringbuf.members">[[stringbuf.members]]</a>
 The member functions getting the underlying character sequence all refer
 to a `high_mark` value, where `high_mark` represents the position one
@@ -5049,39 +5157,42 @@ of the `str` member functions passing a `basic_string` as an argument.
 In the latter case, all characters initialized prior to the call are now
 considered uninitialized (except for those characters re-initialized by
 the new `basic_string`).
 ``` cpp
-void init_buf_ptrs(); // exposition only
 ```
-*Effects:* Initializes the input and output sequences from `buf`
-according to `mode`.
 *Ensures:*
-- If `ios_base::out` is set in `mode`, `pbase()` points to `buf.front()`
-  and `epptr() >= pbase() + buf.size()` is `true`;
- - in addition, if `ios_base::ate` is set in `mode`,
-    `pptr() == pbase() + buf.size()` is `true`,
   - 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
 allocator_type get_allocator() const noexcept;
 ```
-*Returns:* `buf.get_allocator()`.
 ``` cpp
 basic_string<charT, traits, Allocator> str() const &;
 ```
@@ -5095,11 +5206,11 @@ return basic_string<charT, traits, Allocator>(view(), get_allocator());
 template<class SAlloc>
   basic_string<charT, traits, SAlloc> str(const SAlloc& sa) const;
 ```
 *Constraints:* `SAlloc` is a type that qualifies as an
-allocator [[container.requirements.general]].
 *Effects:* Equivalent to:
 ``` cpp
 return basic_string<charT, traits, SAlloc>(view(), sa);
@@ -5109,11 +5220,11 @@ return basic_string<charT, traits, SAlloc>(view(), sa);
 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()`.
@@ -5125,13 +5236,13 @@ basic_string_view<charT, traits> view() const noexcept;
 Let `sv` be `basic_string_view<charT, traits>`.
 *Returns:* A `sv` object referring to the `basic_stringbuf`’s underlying
 character sequence in `buf`:
-- If `ios_base::out` is set in `mode`, then
   `sv(pbase(), high_mark - pbase())` is returned.
-- Otherwise, if `ios_base::in` is set in `mode`, then
   `sv(eback(), egptr() - eback())` is returned.
 - Otherwise, `sv()` is returned.
 [*Note 2*: Using the returned `sv` object after destruction or
 invalidation of the character sequence underlying `*this` is undefined
@@ -5143,11 +5254,11 @@ void str(const basic_string<charT, traits, Allocator>& s);
 *Effects:* Equivalent to:
 ``` cpp
 buf = s;
-init_buf_ptrs();
 ```
 ``` cpp
 template<class SAlloc>
   void str(const basic_string<charT, traits, SAlloc>& s);
@@ -5157,22 +5268,39 @@ template<class SAlloc>
 *Effects:* Equivalent to:
 ``` cpp
 buf = s;
-init_buf_ptrs();
 ```
 ``` cpp
 void str(basic_string<charT, traits, Allocator>&& s);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 buf = std::move(s);
-init_buf_ptrs();
 ```
 #### Overridden virtual functions <a id="stringbuf.virtuals">[[stringbuf.virtuals]]</a>
 ``` cpp
@@ -5194,11 +5322,11 @@ sequence, if possible, in one of three ways:
 - If `traits::eq_int_type(c, traits::eof())` returns `false` and if the
   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)`.
@@ -5226,14 +5354,14 @@ sequence, if possible, in one of two ways:
 *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`,
 the function alters the read end pointer `egptr()` to point just past
 the new write position.
 ``` cpp
 pos_type seekoff(off_type off, ios_base::seekdir way,
@@ -5303,18 +5431,17 @@ effect.
 #### 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> {
   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;
     using allocator_type = Allocator;
     // [istringstream.cons], constructors
     basic_istringstream() : basic_istringstream(ios_base::in) {}
@@ -5336,10 +5463,16 @@ namespace std {
         ios_base::openmode which, const Allocator& a);
     template<class SAlloc>
       explicit basic_istringstream(
         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);
@@ -5357,10 +5490,12 @@ namespace std {
     void str(const basic_string<charT, traits, Allocator>& s);
     template<class SAlloc>
       void str(const basic_string<charT, traits, SAlloc>& s);
     void str(basic_string<charT, traits, Allocator>&& s);
   private:
     basic_stringbuf<charT, traits, Allocator> sb;   // exposition only
   };
 }
@@ -5370,51 +5505,54 @@ The class `basic_istringstream<charT, traits, Allocator>` supports
 reading objects of class `basic_string<{}charT, traits, Allocator>`. It
 uses a `basic_stringbuf<charT, traits, Allocator>` object to control the
 associated storage. For the sake of exposition, the maintained data is
 presented here as:
-- `sb`, the `stringbuf` object.
 #### Constructors <a id="istringstream.cons">[[istringstream.cons]]</a>
 ``` cpp
 explicit basic_istringstream(ios_base::openmode which);
 ```
 *Effects:* Initializes the base class with
-`basic_istream<charT, traits>(addressof(sb))` [[istream]] and `sb` with
-`basic_stringbuf<charT, traits, Allocator>(which | ios_base::in)`
 [[stringbuf.cons]].
 ``` cpp
 explicit basic_istringstream(
   const basic_string<charT, traits, Allocator>& s,
   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);
 ```
 *Effects:* Initializes the base class with
-`basic_istream<charT, traits>(addressof(sb))` [[istream]] and `sb` with
 `basic_stringbuf<charT, traits, Allocator>(which | ios_base::in, a)`
 [[stringbuf.cons]].
 ``` cpp
 explicit basic_istringstream(
   basic_string<charT, traits, Allocator>&& s,
   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>(std::move(s), which | ios_base::in)`
 [[stringbuf.cons]].
 ``` cpp
 template<class SAlloc>
@@ -5422,35 +5560,59 @@ template<class SAlloc>
     const basic_string<charT, traits, SAlloc>& s,
     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,
     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(basic_istringstream&& rhs);
 ```
 *Effects:* Move constructs from the rvalue `rhs`. This is accomplished
 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);
@@ -5467,20 +5629,20 @@ sb.swap(rhs.sb);
 template<class charT, class traits, class Allocator>
   void swap(basic_istringstream<charT, traits, Allocator>& x,
             basic_istringstream<charT, traits, Allocator>& y);
 ```
-*Effects:* Equivalent to: `x.swap(y)`.
 #### Member functions <a id="istringstream.members">[[istringstream.members]]</a>
 ``` cpp
 basic_stringbuf<charT, traits, Allocator>* rdbuf() const;
 ```
 *Returns:*
-`const_cast<basic_stringbuf<charT, traits, Allocator>*>(addressof(sb))`.
 ``` cpp
 basic_string<charT, traits, Allocator> str() const &;
 ```
@@ -5522,24 +5684,34 @@ template<class SAlloc>
 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>
 #### 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> {
   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;
     using allocator_type = Allocator;
     // [ostringstream.cons], constructors
     basic_ostringstream() : basic_ostringstream(ios_base::out) {}
@@ -5561,10 +5733,16 @@ namespace std {
         ios_base::openmode which, const Allocator& a);
     template<class SAlloc>
       explicit basic_ostringstream(
         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);
@@ -5583,10 +5761,12 @@ namespace std {
     void str(const basic_string<charT, traits, Allocator>& s);
     template<class SAlloc>
       void str(const basic_string<charT, traits, SAlloc>& s);
     void str(basic_string<charT, traits, Allocator>&& s);
    private:
     basic_stringbuf<charT, traits, Allocator> sb;   // exposition only
   };
 }
@@ -5595,51 +5775,54 @@ namespace std {
 The class `basic_ostringstream<charT, traits, Allocator>` supports
 writing objects of class `basic_string<{}charT, traits, Allocator>`. It
 uses a `basic_stringbuf` object to control the associated storage. For
 the sake of exposition, the maintained data is presented here as:
-- `sb`, the `stringbuf` object.
 #### Constructors <a id="ostringstream.cons">[[ostringstream.cons]]</a>
 ``` cpp
 explicit basic_ostringstream(ios_base::openmode which);
 ```
 *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)`
 [[stringbuf.cons]].
 ``` cpp
 explicit basic_ostringstream(
   const basic_string<charT, traits, Allocator>& s,
   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);
 ```
 *Effects:* Initializes the base class with
-`basic_ostream<charT, traits>(addressof(sb))` [[ostream]] and `sb` with
 `basic_stringbuf<charT, traits, Allocator>(std::move(s), which | ios_base::out)`
 [[stringbuf.cons]].
 ``` cpp
 template<class SAlloc>
@@ -5647,11 +5830,12 @@ template<class SAlloc>
     const basic_string<charT, traits, SAlloc>& s,
     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>
@@ -5661,23 +5845,44 @@ 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);
 ```
 *Effects:* Move constructs from the rvalue `rhs`. This is accomplished
 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);
@@ -5694,20 +5899,20 @@ sb.swap(rhs.sb);
 template<class charT, class traits, class Allocator>
   void swap(basic_ostringstream<charT, traits, Allocator>& x,
             basic_ostringstream<charT, traits, Allocator>& y);
 ```
-*Effects:* Equivalent to: `x.swap(y)`.
 #### Member functions <a id="ostringstream.members">[[ostringstream.members]]</a>
 ``` cpp
 basic_stringbuf<charT, traits, Allocator>* rdbuf() const;
 ```
 *Returns:*
-`const_cast<basic_stringbuf<charT, traits, Allocator>*>(addressof(sb))`.
 ``` cpp
 basic_string<charT, traits, Allocator> str() const &;
 ```
@@ -5749,24 +5954,34 @@ template<class SAlloc>
 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>
 #### 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> {
   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;
     using allocator_type = Allocator;
     // [stringstream.cons], constructors
     basic_stringstream() : basic_stringstream(ios_base::out | ios_base::in) {}
@@ -5788,10 +6003,17 @@ namespace std {
         ios_base::openmode which, const Allocator& a);
     template<class SAlloc>
       explicit basic_stringstream(
         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);
@@ -5810,13 +6032,15 @@ namespace std {
     void str(const basic_string<charT, traits, Allocator>& s);
     template<class SAlloc>
       void str(const basic_string<charT, traits, SAlloc>& s);
     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
@@ -5824,50 +6048,50 @@ and writing from objects of class
 `basic_string<charT, traits, Allocator>`. It uses a
 `basic_stringbuf<charT, traits, Allocator>` object to control the
 associated sequence. For the sake of exposition, the maintained data is
 presented here as
-- `sb`, the `stringbuf` object.
 #### Constructors <a id="stringstream.cons">[[stringstream.cons]]</a>
 ``` cpp
 explicit basic_stringstream(ios_base::openmode which);
 ```
 *Effects:* Initializes the base class with
-`basic_iostream<charT, traits>(addressof(sb))` [[iostream.cons]] and
-`sb` with `basic_stringbuf<charT, traits, Allocator>(which)`.
 ``` cpp
 explicit basic_stringstream(
   const basic_string<charT, traits, Allocator>& s,
   ios_base::openmode which = ios_base::out | ios_base::in);
 ```
 *Effects:* Initializes the base class with
-`basic_iostream<charT, traits>(addressof(sb))` [[iostream.cons]] and
-`sb` with `basic_stringbuf<charT, traits, Allocator>(s, which)`.
 ``` cpp
 basic_stringstream(ios_base::openmode which, const Allocator& a);
 ```
 *Effects:* Initializes the base class with
-`basic_iostream<charT, traits>(addressof(sb))` [[iostream.cons]] and
-`sb` with `basic_stringbuf<charT, traits, Allocator>(which, a)`
 [[stringbuf.cons]].
 ``` cpp
 explicit basic_stringstream(
   basic_string<charT, traits, Allocator>&& s,
   ios_base::openmode which = ios_base::out | ios_base::in);
 ```
 *Effects:* Initializes the base class with
-`basic_iostream<charT, traits>(addressof(sb))` [[iostream.cons]] and
-`sb` with
 `basic_stringbuf<charT, traits, Allocator>(std::move(s), which)`
 [[stringbuf.cons]].
 ``` cpp
 template<class SAlloc>
@@ -5875,12 +6099,12 @@ template<class SAlloc>
     const basic_string<charT, traits, SAlloc>& s,
     ios_base::openmode which, const Allocator& a);
 ```
 *Effects:* Initializes the base class with
-`basic_iostream<charT, traits>(addressof(sb))` [[iostream.cons]] and
-`sb` with `basic_stringbuf<charT, traits, Allocator>(s, which, a)`
 [[stringbuf.cons]].
 ``` cpp
 template<class SAlloc>
   explicit basic_stringstream(
@@ -5889,23 +6113,43 @@ template<class SAlloc>
 ```
 *Constraints:* `is_same_v<SAlloc, Allocator>` is `false`.
 *Effects:* Initializes the base class with
-`basic_iostream<charT, traits>(addressof(sb))` [[iostream.cons]] and
-`sb` with `basic_stringbuf<charT, traits, Allocator>(s, which)`
 [[stringbuf.cons]].
 ``` cpp
 basic_stringstream(basic_stringstream&& rhs);
 ```
 *Effects:* Move constructs from the rvalue `rhs`. This is accomplished
 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);
@@ -5922,20 +6166,20 @@ sb.swap(rhs.sb);
 template<class charT, class traits, class Allocator>
   void swap(basic_stringstream<charT, traits, Allocator>& x,
             basic_stringstream<charT, traits, Allocator>& y);
 ```
-*Effects:* Equivalent to: `x.swap(y)`.
 #### Member functions <a id="stringstream.members">[[stringstream.members]]</a>
 ``` cpp
 basic_stringbuf<charT, traits, Allocator>* rdbuf() const;
 ```
 *Returns:*
-`const_cast<basic_stringbuf<charT, traits, Allocator>*>(addressof(sb))`.
 ``` cpp
 basic_string<charT, traits, Allocator> str() const &;
 ```
@@ -5977,57 +6221,72 @@ template<class SAlloc>
 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);
@@ -6046,13 +6305,13 @@ 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)
@@ -6229,11 +6488,11 @@ follows:
 - `(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
@@ -6276,13 +6535,13 @@ 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);
@@ -6318,33 +6577,33 @@ includes the termination character `'\0'` in the underlying
 ``` 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()))
 ```
@@ -6402,11 +6661,11 @@ 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>
@@ -6416,13 +6675,13 @@ 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);
@@ -6453,22 +6712,22 @@ namespace std {
 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);
@@ -6521,13 +6780,13 @@ 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);
@@ -6558,21 +6817,21 @@ namespace std {
 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);
@@ -6620,37 +6879,41 @@ void span(std::span<charT> s) noexcept;
 ### 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);
@@ -6675,24 +6938,38 @@ In subclause  [[file.streams]], member functions taking arguments of
 `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:
     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;
     // [filebuf.cons], constructors/destructor
     basic_filebuf();
     basic_filebuf(const basic_filebuf&) = delete;
     basic_filebuf(basic_filebuf&& rhs);
@@ -6706,32 +6983,30 @@ namespace std {
     // [filebuf.members], members
     bool is_open() const;
     basic_filebuf* open(const char* s, ios_base::openmode mode);
     basic_filebuf* open(const filesystem::path::value_type* s,
                         ios_base::openmode mode);   // wide systems only; see [fstream.syn]
-    basic_filebuf* open(const string& s,
- ios_base::openmode mode);
-    basic_filebuf* open(const filesystem::path& s,
-                        ios_base::openmode mode);
     basic_filebuf* close();
   protected:
     // [filebuf.virtuals], overridden virtual functions
     streamsize showmanyc() override;
     int_type underflow() override;
     int_type uflow() override;
     int_type pbackfail(int_type c = traits::eof()) override;
     int_type overflow (int_type c = traits::eof()) override;
-    basic_streambuf<charT, traits>* setbuf(char_type* s,
-                                           streamsize n) 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;
     int sync() override;
     void imbue(const locale& loc) override;
   };
 }
 ```
@@ -6753,10 +7028,19 @@ In particular:
 An instance of `basic_filebuf` behaves as described in  [[filebuf]]
 provided `traits::pos_type` is `fpos<traits::{}state_type>`. Otherwise
 the behavior is undefined.
 In order to support file I/O and multibyte/wide character conversion,
 conversions are performed using members of a facet, referred to as
 `a_codecvt` in following subclauses, obtained as if by
 ``` cpp
@@ -6835,11 +7119,11 @@ void swap(basic_filebuf& 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>
 ``` cpp
 bool is_open() const;
@@ -6852,11 +7136,11 @@ non-null value) and there has been no intervening call to close.
 basic_filebuf* open(const char* s, ios_base::openmode mode);
 basic_filebuf* open(const filesystem::path::value_type* s,
                     ios_base::openmode mode);  // wide systems only; see [fstream.syn]
 ```
-*Preconditions:* `s` points to a NTCTS [[defns.ntcts]].
 *Effects:* If `is_open() != false`, returns a null pointer. Otherwise,
 initializes the `filebuf` as required. It then opens the file to which
 `s` resolves, if possible, as if by a call to `fopen` with the second
 argument determined from `mode & ~ios_base::ate` as indicated in
@@ -6929,10 +7213,18 @@ 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;
 ```
@@ -6954,11 +7246,11 @@ that a sequence of characters is read from the input sequence as if by
 reading from the associated file into an internal buffer (`extern_buf`)
 and then as if by doing:
 ``` cpp
 char         extern_buf[XSIZE];
-char*  extern_end;
 charT        intern_buf[ISIZE];
 charT*       intern_end;
 codecvt_base::result r =
   a_codecvt.in(state, extern_buf, extern_buf+XSIZE, extern_end,
                intern_buf, intern_buf+ISIZE, intern_end);
@@ -7019,11 +7311,11 @@ int_type overflow(int_type c = traits::eof()) override;
 of “consuming characters” is performed by first converting as if by:
 ``` cpp
 charT*       b = pbase();
 charT*       p = pptr();
-charT* end;
 char         xbuf[XSIZE];
 char*        xbuf_end;
 codecvt_base::result r =
   a_codecvt.out(state, b, p, end, xbuf, xbuf+XSIZE, xbuf_end);
 ```
@@ -7038,10 +7330,12 @@ and then
   to `p`. If output fails, fail (without repeating).
 - Otherwise output from `xbuf` to `xbuf_end`, and fail if output fails.
   At this point if `b != p` and `b == end` (`xbuf` isn’t large enough)
   then increase `XSIZE` and repeat from the beginning.
 *Returns:* `traits::not_eof(c)` to indicate success, and `traits::eof()`
 to indicate failure. If `is_open() == false`, the function always fails.
 ``` cpp
 basic_streambuf* setbuf(char_type* s, streamsize n) override;
@@ -7072,11 +7366,11 @@ 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
 for the argument `whence`, of type `int`, as indicated in
 [[filebuf.seekoff]].
@@ -7147,14 +7441,15 @@ reconstruct the original contents of the file.
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_ifstream : 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;
     // [ifstream.cons], constructors
     basic_ifstream();
     explicit basic_ifstream(const char* s,
                             ios_base::openmode mode = ios_base::in);
@@ -7173,10 +7468,11 @@ namespace std {
     // [ifstream.swap], swap
     void swap(basic_ifstream& rhs);
     // [ifstream.members], members
     basic_filebuf<charT, traits>* rdbuf() const;
     bool is_open() const;
     void open(const char* s, ios_base::openmode mode = ios_base::in);
     void open(const filesystem::path::value_type* s,
               ios_base::openmode mode = ios_base::in);  // wide systems only; see [fstream.syn]
@@ -7193,83 +7489,91 @@ namespace std {
 The class `basic_ifstream<charT, traits>` supports reading from named
 files. It uses a `basic_filebuf<{}charT, traits>` object to control the
 associated sequence. For the sake of exposition, the maintained data is
 presented here as:
-- `sb`, the `filebuf` object.
 #### Constructors <a id="ifstream.cons">[[ifstream.cons]]</a>
 ``` cpp
 basic_ifstream();
 ```
 *Effects:* Initializes the base class with
-`basic_istream<charT, traits>(addressof(sb))` [[istream.cons]] and `sb`
-with `basic_filebuf<charT, traits>()` [[filebuf.cons]].
 ``` cpp
 explicit basic_ifstream(const char* s,
                         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]
 ```
 *Effects:* Initializes the base class with
-`basic_istream<charT, traits>(addressof(sb))` [[istream.cons]] and `sb`
-with `basic_filebuf<charT, traits>()` [[filebuf.cons]], then calls
 `rdbuf()->open(s, mode | ios_base::in)`. If that function returns a null
 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>
 ``` cpp
 basic_filebuf<charT, traits>* rdbuf() const;
 ```
-*Returns:* `const_cast<basic_filebuf<charT, traits>*>(addressof(sb))`.
 ``` cpp
 bool is_open() const;
 ```
@@ -7309,14 +7613,15 @@ pointer, calls `setstate(failbit)` (which may throw
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_ofstream : 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;
     // [ofstream.cons], constructors
     basic_ofstream();
     explicit basic_ofstream(const char* s,
                             ios_base::openmode mode = ios_base::out);
@@ -7335,10 +7640,11 @@ namespace std {
     // [ofstream.swap], swap
     void swap(basic_ofstream& rhs);
     // [ofstream.members], members
     basic_filebuf<charT, traits>* rdbuf() const;
     bool is_open() const;
     void open(const char* s, ios_base::openmode mode = ios_base::out);
     void open(const filesystem::path::value_type* s,
               ios_base::openmode mode = ios_base::out);     // wide systems only; see [fstream.syn]
@@ -7355,83 +7661,91 @@ namespace std {
 The class `basic_ofstream<charT, traits>` supports writing to named
 files. It uses a `basic_filebuf<{}charT, traits>` object to control the
 associated sequence. For the sake of exposition, the maintained data is
 presented here as:
-- `sb`, the `filebuf` object.
 #### Constructors <a id="ofstream.cons">[[ofstream.cons]]</a>
 ``` cpp
 basic_ofstream();
 ```
 *Effects:* Initializes the base class with
-`basic_ostream<charT, traits>(addressof(sb))` [[ostream.cons]] and `sb`
-with `basic_filebuf<charT, traits>()` [[filebuf.cons]].
 ``` cpp
 explicit basic_ofstream(const char* s,
                         ios_base::openmode mode = ios_base::out);
 explicit basic_ofstream(const filesystem::path::value_type* s,
                         ios_base::openmode mode = ios_base::out); // wide systems only; see [fstream.syn]
 ```
 *Effects:* Initializes the base class with
-`basic_ostream<charT, traits>(addressof(sb))` [[ostream.cons]] and `sb`
-with `basic_filebuf<charT, traits>()` [[filebuf.cons]], then calls
 `rdbuf()->open(s, mode | ios_base::out)`. If that function returns a
 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>
 ``` cpp
 basic_filebuf<charT, traits>* rdbuf() const;
 ```
-*Returns:* `const_cast<basic_filebuf<charT, traits>*>(addressof(sb))`.
 ``` cpp
 bool is_open() const;
 ```
@@ -7471,14 +7785,15 @@ void open(const filesystem::path& s, ios_base::openmode mode = ios_base::out);
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_fstream : 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;
     // [fstream.cons], constructors
     basic_fstream();
     explicit basic_fstream(
       const char* s,
@@ -7500,10 +7815,12 @@ namespace std {
     // [fstream.swap], swap
     void swap(basic_fstream& rhs);
     // [fstream.members], members
     basic_filebuf<charT, traits>* rdbuf() const;
     bool is_open() const;
     void open(
       const char* s,
       ios_base::openmode mode = ios_base::in | ios_base::out);
     void open(
@@ -7526,21 +7843,21 @@ namespace std {
 The class template `basic_fstream<charT, traits>` supports reading and
 writing from named files. It uses a `basic_filebuf<charT, traits>`
 object to control the associated sequences. For the sake of exposition,
 the maintained data is presented here as:
-- `sb`, the `basic_filebuf` object.
 #### Constructors <a id="fstream.cons">[[fstream.cons]]</a>
 ``` cpp
 basic_fstream();
 ```
 *Effects:* Initializes the base class with
-`basic_iostream<charT, traits>(addressof(sb))` [[iostream.cons]] and
-`sb` with `basic_filebuf<charT, traits>()`.
 ``` cpp
 explicit basic_fstream(
   const char* s,
   ios_base::openmode mode = ios_base::in | ios_base::out);
@@ -7548,65 +7865,73 @@ explicit basic_fstream(
   const filesystem::path::value_type* s,
   ios_base::openmode mode = ios_base::in | ios_base::out);  // wide systems only; see [fstream.syn]
 ```
 *Effects:* Initializes the base class with
-`basic_iostream<charT, traits>(addressof(sb))` [[iostream.cons]] and
-`sb` with `basic_filebuf<charT, traits>()`. Then calls
 `rdbuf()->open(s, mode)`. If that function returns a null pointer, calls
 `setstate(failbit)`.
 ``` 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);
 ```
 *Effects:* Exchanges the state of `*this` and `rhs` by calling
-`basic_iostream<charT,traits>::swap(rhs)` and `sb.swap(rhs.sb)`.
 ``` cpp
 template<class charT, class traits>
   void swap(basic_fstream<charT, traits>& x,
             basic_fstream<charT, traits>& y);
 ```
-*Effects:* Equivalent to: `x.swap(y)`.
 #### Member functions <a id="fstream.members">[[fstream.members]]</a>
 ``` cpp
 basic_filebuf<charT, traits>* rdbuf() const;
 ```
-*Returns:* `const_cast<basic_filebuf<charT, traits>*>(addressof(sb))`.
 ``` cpp
 bool is_open() const;
 ```
@@ -7651,10 +7976,11 @@ pointer, calls `setstate(failbit)` (which may throw
 ``` cpp
 #include <ostream>  // see [ostream.syn]
 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>
@@ -7662,10 +7988,11 @@ namespace std {
               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;
   using osyncstream = basic_osyncstream<char>;
   using wosyncstream = basic_osyncstream<wchar_t>;
@@ -7683,13 +8010,13 @@ agents writing to the same stream.
 namespace std {
   template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
   class basic_syncbuf : 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;
     using allocator_type = Allocator;
     using streambuf_type = basic_streambuf<charT, traits>;
@@ -7716,11 +8043,11 @@ namespace std {
     // [syncstream.syncbuf.virtuals], overridden virtual functions
     int sync() override;
   private:
     streambuf_type* wrapped;    // exposition only
-    bool emit_on_sync{};        // exposition only
   };
 }
 ```
 Class template `basic_syncbuf` stores character data written to it,
@@ -7735,11 +8062,11 @@ wrapped stream buffer object.
 ``` cpp
 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
@@ -7810,13 +8137,13 @@ void swap(basic_syncbuf& other);
 ``` cpp
 bool emit();
 ```
 *Effects:* Atomically transfers the associated output of `*this` to the
-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()`
@@ -7825,23 +8152,23 @@ 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;
 ```
-*Returns:* `wrapped`.
 ``` cpp
 allocator_type get_allocator() const noexcept;
 ```
@@ -7850,22 +8177,22 @@ assignment operator.
 ``` cpp
 void set_emit_on_sync(bool b) noexcept;
 ```
-*Effects:* `emit_on_sync = b`.
 #### Overridden virtual functions <a id="syncstream.syncbuf.virtuals">[[syncstream.syncbuf.virtuals]]</a>
 ``` cpp
 int sync() override;
 ```
 *Effects:* Records that the wrapped stream buffer is to be flushed.
-Then, if `emit_on_sync` is `true`, calls `emit()`.
-[*Note 1*: If `emit_on_sync` is `false`, the actual flush is delayed
 until a call to `emit()`. — *end note*]
 *Returns:* If `emit()` was called and returned `false`, returns `-1`;
 otherwise `0`.
@@ -7887,13 +8214,13 @@ template<class charT, class traits, class Allocator>
 namespace std {
   template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
   class basic_osyncstream : 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;
     using allocator_type = Allocator;
     using streambuf_type = basic_streambuf<charT, traits>;
     using syncbuf_type   = basic_syncbuf<charT, traits, Allocator>;
@@ -7958,12 +8285,12 @@ In this example, `cout` is not flushed.
 ``` cpp
 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 can be
 called from `emit()` while a lock is held, which might result in a
 deadlock if used incautiously. — *end note*]
@@ -7971,13 +8298,13 @@ deadlock if used incautiously. — *end note*]
 ``` 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`.
@@ -7987,11 +8314,11 @@ by `other.get_wrapped()` prior to calling this constructor.
 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:
@@ -8030,11 +8357,11 @@ on the underlying stream.
 ``` cpp
 streambuf_type* get_wrapped() const noexcept;
 ```
-*Returns:* `sb.get_wrapped()`.
 [*Example 3*:
 Obtaining the wrapped stream buffer with `get_wrapped()` allows wrapping
 it again with an `osyncstream`. For example,
@@ -8387,26 +8714,29 @@ namespace std::filesystem {
   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
@@ -8496,12 +8826,12 @@ Pathnames are formatted according to the generic pathname format grammar
 *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 {
   public:
@@ -8584,22 +8914,24 @@ namespace std::filesystem {
     template<class EcharT, class traits = char_traits<EcharT>,
              class Allocator = allocator<EcharT>>
       basic_string<EcharT, traits, Allocator>
         string(const Allocator& a = Allocator()) const;
-    std::string    string() const;
     std::wstring   wstring() const;
     std::u8string  u8string() const;
     std::u16string u16string() const;
     std::u32string u32string() const;
     // [fs.path.generic.obs], generic format observers
     template<class EcharT, class traits = char_traits<EcharT>,
              class Allocator = allocator<EcharT>>
       basic_string<EcharT, traits, Allocator>
         generic_string(const Allocator& a = Allocator()) const;
-    std::string    generic_string() const;
     std::wstring   generic_wstring() const;
     std::u8string  generic_u8string() const;
     std::u16string generic_u16string() const;
     std::u32string generic_u32string() const;
@@ -8618,11 +8950,11 @@ namespace std::filesystem {
     path filename() const;
     path stem() const;
     path extension() const;
     // [fs.path.query], query
- [[nodiscard]] bool empty() const noexcept;
     bool has_root_name() const;
     bool has_root_directory() const;
     bool has_root_path() const;
     bool has_relative_path() const;
     bool has_parent_path() const;
@@ -8812,12 +9144,12 @@ 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*]
 Pathnames are converted as needed between the generic and native formats
 in an operating-system-dependent manner. Let *G(n)* and *N(g)* in a
 mathematical sense be the implementation’s functions that convert
@@ -8903,16 +9235,16 @@ named `Source` shall be one of:
   \[`source.begin()`, `source.end()`).
 - `basic_string_view<EcharT, traits>`. A function argument
   `const Source&` `source` shall have an effective range
   \[`source.begin()`, `source.end()`).
 - A type meeting the *Cpp17InputIterator* requirements that iterates
-  over a NTCTS. The value type shall be an encoded character type. A
   function argument `const Source&` `source` shall have an effective
   range \[`source`, `end`) where `end` is the first iterator value with
   an element value equal to `iterator_traits<Source>::value_type()`.
 - A character array that after array-to-pointer decay results in a
-  pointer to the start of a NTCTS. The value type shall be an encoded
   character type. A function argument `const Source&` `source` shall
   have an effective range \[`source`, `end`) where `end` is the first
   iterator value with an element value equal to
   `iterator_traits<decay_t<Source>>::value_type()`.
@@ -8938,11 +9270,11 @@ Arguments of type `Source` shall not be null pointers.
 ``` cpp
 path() noexcept;
 ```
-*Ensures:* `empty() == true`.
 ``` cpp
 path(const path& p);
 path(path&& p) noexcept;
 ```
@@ -9186,11 +9518,11 @@ template<class InputIterator>
 ``` cpp
 void clear() noexcept;
 ```
-*Ensures:* `empty() == true`.
 ``` cpp
 path& make_preferred();
 ```
@@ -9315,24 +9647,22 @@ 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;
 ```
 *Returns:* `native()`.
 *Remarks:* All memory allocation, including for the return value, shall
 be performed by `a`. Conversion, if any, is specified by
 [[fs.path.cvt]].
 ``` cpp
-std::string string() const;
 std::wstring wstring() const;
 std::u8string u8string() const;
 std::u16string u16string() const;
 std::u32string u32string() const;
 ```
@@ -9340,10 +9670,20 @@ std::u32string u32string() const;
 *Returns:* `native()`.
 *Remarks:* Conversion, if any, is performed as specified by
 [[fs.path.cvt]].
 ##### Generic format observers <a id="fs.path.generic.obs">[[fs.path.generic.obs]]</a>
 Generic format observer functions return strings formatted according to
 the generic pathname format [[fs.path.generic]]. A single slash (`'/'`)
 character is used as the *directory-separator*.
@@ -9359,34 +9699,42 @@ path("foo\\bar").generic_string()
 returns `"foo/bar"`.
 — *end example*]
 ``` cpp
-template<class EcharT, class traits = char_traits<EcharT>,
-         class Allocator = allocator<EcharT>>
-  basic_string<EcharT, traits, Allocator>
-    generic_string(const Allocator& a = Allocator()) const;
 ```
 *Returns:* The pathname in the generic format.
 *Remarks:* All memory allocation, including for the return value, shall
 be performed by `a`. Conversion, if any, is specified by
 [[fs.path.cvt]].
 ``` cpp
-std::string generic_string() const;
 std::wstring generic_wstring() const;
 std::u8string generic_u8string() const;
 std::u16string generic_u16string() const;
 std::u32string generic_u32string() const;
 ```
 *Returns:* The pathname in the generic format.
 *Remarks:* Conversion, if any, is specified by  [[fs.path.cvt]].
 ##### Compare <a id="fs.path.compare">[[fs.path.compare]]</a>
 ``` cpp
 int compare(const path& p) const noexcept;
 ```
@@ -9517,22 +9865,22 @@ path(".bar").extension();               // yields "" and stem() is ".bar"
 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;
 ```
 *Returns:* `true` if the pathname in the generic format is empty,
 otherwise `false`.
@@ -9636,11 +9984,11 @@ path lexically_relative(const path& base) const;
 - 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
@@ -9679,28 +10027,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 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>
@@ -9718,13 +10066,13 @@ iterators referring to elements of that object.
 For the elements of the pathname in the generic format, the forward
 traversal order is as follows:
 - The *root-name* element, if present.
-- The *root-directory* element, if present. \[*Note 1*: The generic
-  format is required to ensure lexicographical comparison works
- correctly. — *end note*]
 - Each successive *filename* element, if present.
 - An empty element, if a trailing non-root *directory-separator* is
   present.
 The backward traversal order is the reverse of forward traversal.
@@ -9819,10 +10167,79 @@ 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>;
 ```
@@ -9865,25 +10282,27 @@ with an error.
 filesystem_error(const string& what_arg, error_code ec);
 ```
 *Ensures:*
-- `code() == ec`,
-- `path1().empty() == true`,
-- `path2().empty() == true`, and
-- `string_view(what()).find(what_arg.c_str())` `!= string_view::npos`.
 ``` cpp
 filesystem_error(const string& what_arg, const path& p1, error_code ec);
 ```
 *Ensures:*
-- `code() == ec`,
 - `path1()` returns a reference to the stored copy of `p1`,
-- `path2().empty() == true`, and
-- `string_view(what()).find(what_arg.c_str())` `!= string_view::npos`.
 ``` cpp
 filesystem_error(const string& what_arg, const path& p1, const path& p2, error_code ec);
 ```
@@ -9940,11 +10359,11 @@ 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                                                                                                                                                                                                          |
@@ -9967,11 +10386,11 @@ 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 subdirectories} |
 | `recursive`          | Recursively copy subdirectories and their contents. \ohdrx{2}{Option group controlling `copy` function effects for symbolic links}                   |
@@ -9989,11 +10408,11 @@ specifies bitmask constants used to identify file permissions, with the
 meanings listed in [[fs.enum.perms]].
 **Table: Enum class `perms`** <a id="fs.enum.perms">[fs.enum.perms]</a>
 | Name                              | Value (octal) | POSIX macro | Definition or notes                                                                                              |
-| -------------- | ------------- | ----------- | ---------------------------------------------------------------------------------------------------------------- |
 | `none`         | `0`           |             | There are no permissions set for the file.                                                                       |
 | `owner_read`   | `0400`        | `S_IRUSR`   | Read permission, owner                                                                                           |
 | `owner_write`  | `0200`        | `S_IWUSR`   | Write permission, owner                                                                                          |
 | `owner_exec`   | `0100`        | `S_IXUSR`   | Execute/search permission, owner                                                                                 |
 | `owner_all`    | `0700`        | `S_IRWXU`   | Read, write, execute/search by owner;<br> `owner_read | owner_write | owner_exec`                                |
@@ -10023,11 +10442,11 @@ permissions operations, with the meanings listed in
 `permissions`.
 **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.                      |
@@ -10041,11 +10460,11 @@ directory traversal options, with the meanings listed in
 every other constant in the table represents a distinct bitmask element.
 **Table: Enum class `directory_options`** <a id="fs.enum.dir.opts">[fs.enum.dir.opts]</a>
 | Name                                                      | Meaning                                                            |
-| -------------------------- | ------------------------------------------------------------------ |
 | `none`                     | (Default) Skip directory symlinks, permission denied is an error.  |
 | `follow_directory_symlink` | Follow rather than skip directory symlinks.                        |
 | `skip_permission_denied`   | Skip directories that would otherwise result in permission denied. |
@@ -10190,12 +10609,11 @@ namespace std::filesystem {
     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
   };
 }
 ```
 A `directory_entry` object stores a `path` object and may store
@@ -10206,16 +10624,13 @@ Implementations should store such additional file attributes during
 directory iteration if their values are available and storing the values
 would allow the implementation to eliminate file system accesses by
 `directory_entry` observer functions [[fs.op.funcs]]. Such stored file
 attribute values are said to be *cached*.
-[*Note 1*: For purposes of exposition, class `directory_iterator`
-[[fs.class.directory.iterator]] is shown above as a friend of class
-`directory_entry`. Friendship allows the `directory_iterator`
-implementation to cache already available attribute values directly into
-a `directory_entry` object without the cost of an unneeded call to
-`refresh()`. — *end note*]
 [*Example 1*:
 ``` cpp
 using namespace std::filesystem;
@@ -10264,22 +10679,22 @@ directory_entry(const filesystem::path& p, error_code& ec);
 ``` cpp
 void assign(const filesystem::path& p);
 void assign(const filesystem::path& p, error_code& ec);
 ```
-*Effects:* Equivalent to `pathobject = p`, then `refresh()` or
 `refresh(ec)`, respectively. If an error occurs, the values of any
 cached attributes are unspecified.
 *Throws:* As specified in  [[fs.err.report]].
 ``` cpp
 void replace_filename(const filesystem::path& p);
 void replace_filename(const filesystem::path& p, error_code& ec);
 ```
-*Effects:* Equivalent to `pathobject.replace_filename(p)`, then
 `refresh()` or `refresh(ec)`, respectively. If an error occurs, the
 values of any cached attributes are unspecified.
 *Throws:* As specified in  [[fs.err.report]].
@@ -10309,11 +10724,11 @@ Unqualified function names in the *Returns:* elements of the
 ``` cpp
 const filesystem::path& path() const noexcept;
 operator const filesystem::path&() const noexcept;
 ```
-*Returns:* `pathobject`.
 ``` cpp
 bool exists() const;
 bool exists(error_code& ec) const noexcept;
 ```
@@ -10457,17 +10872,17 @@ file_status symlink_status(error_code& ec) const noexcept;
 ``` cpp
 bool operator==(const directory_entry& rhs) const noexcept;
 ```
-*Returns:* `pathobject == rhs.pathobject`.
 ``` cpp
 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>
@@ -10558,13 +10973,11 @@ the values of any cached attributes [[fs.class.directory.entry]] in the
 `directory_entry` element returned by `operator*()`.
 `directory_iterator` member functions shall not directly or indirectly
 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*: 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
@@ -10896,11 +11309,11 @@ required to be dereferenceable nor to be in the domain of `==`.
 void disable_recursion_pending();
 ```
 *Ensures:* `recursion_pending() == false`.
-[*Note 4*: `disable_recursion_pending``()` is used to prevent unwanted
 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
@@ -11026,11 +11439,11 @@ group [[fs.enum.copy.opts]] is set in `options`.
 Effects are then as follows:
 - If `f.type()` or `t.type()` is an implementation-defined file
   type [[fs.enum.file.type]], then the effects are
   *implementation-defined*.
-- Otherwise, an error is reported as specified in  [[fs.err.report]] if:
   - `exists(f)` is `false`, or
   - `equivalent(from, to)` is `true`, or
   - `is_other(f) || is_other(t)` is `true`, or
   - `is_directory(f) && is_regular_file(t)` is `true`.
 - Otherwise, if `is_symlink(f)`, then:
@@ -11093,21 +11506,21 @@ applicable.
 [*Example 1*:
 Given this directory structure:
-``` cpp
 /dir1
   file1
   file2
   dir2
     file3
 ```
 Calling `copy("/dir1", "/dir3")` would result in:
-``` cpp
 /dir1
   file1
   file2
   dir2
     file3
@@ -11117,11 +11530,11 @@ Calling `copy("/dir1", "/dir3")` would result in:
 ```
 Alternatively, calling `copy("/dir1", "/dir3", copy_options::recursive)`
 would result in:
-``` cpp
 /dir1
   file1
   file2
   dir2
     file3
@@ -11155,22 +11568,22 @@ bool filesystem::copy_file(const path& from, const path& to, copy_options option
 *Preconditions:* At most one element from each option
 group [[fs.enum.copy.opts]] is set in `options`.
 *Effects:* As follows:
-- Report an error as specified in  [[fs.err.report]] if:
   - `is_regular_file(from)` is `false`, or
   - `exists(to)` is `true` and `is_regular_file(to)` is `false`, or
   - `exists(to)` is `true` and `equivalent(from, to)` is `true`, or
   - `exists(to)` is `true` and
     ``` cpp
     (options & (copy_options::skip_existing |
                 copy_options::overwrite_existing |
                 copy_options::update_existing)) == copy_options::none
     ```
 - Otherwise, copy the contents and attributes of the file `from`
-  resolves to, to the file `to` resolves to, if:
   - `exists(to)` is `false`, or
   - `(options & copy_options::overwrite_existing) != copy_options::none`,
     or
   - `(options & copy_options::update_existing) `` `` != copy_options::none`
     and `from` is more recent than `to`, determined as if by use of the
@@ -11205,11 +11618,11 @@ respectively, where in each case *`function`* is `create_symlink` or
 ``` 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.
 *Returns:* `true` if a new directory was created for the directory `p`
 resolves to, otherwise `false`.
@@ -11262,21 +11675,21 @@ from directory `existing_p`, otherwise `false`.
 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()`.
 *Ensures:* `new_symlink` resolves to a symbolic link file that contains
 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*]
@@ -11287,11 +11700,11 @@ operating system. — *end note*]
 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()`.
 *Ensures:*
 - `exists(to) && exists(new_hard_link) && equivalent(to, new_hard_link)`
 - The contents of the file or directory `to` resolves to are unchanged.
@@ -11310,11 +11723,11 @@ file. — *end note*]
 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()`.
 *Ensures:* `new_symlink` resolves to a symbolic link file that contains
 an unspecified representation of `to`.
 *Throws:* As specified in  [[fs.err.report]].
@@ -11330,39 +11743,35 @@ operating system. — *end note*]
 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.
 *Throws:* As specified in  [[fs.err.report]].
 *Remarks:* The current working directory is the directory, associated
 with the process, that is used as the starting location in pathname
 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 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>
@@ -11373,11 +11782,11 @@ bool filesystem::equivalent(const path& p1, const path& p2, error_code& ec) noex
 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.
@@ -11421,11 +11830,11 @@ reported [[fs.err.report]].
 *Returns:*
 - If `is_regular_file(p)`, the size in bytes of the file `p` resolves
   to, determined as if by the value of the POSIX `stat` class member
-  `st_size` obtained as if by POSIX `stat()`.
 - Otherwise, the result is *implementation-defined*.
 The signature with argument `ec` returns `static_cast<uintmax_t>(-1)` if
 an error occurs.
@@ -11642,11 +12051,11 @@ 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
@@ -11654,11 +12063,11 @@ 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
@@ -11676,11 +12085,11 @@ void filesystem::permissions(const path& p, perms prms, perm_options opts, error
 `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]].
@@ -11773,19 +12182,20 @@ or `path()` at the first error occurrence, if any.
 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()`.
 [*Note 1*: A symbolic link is itself removed, rather than the file it
 resolves to. — *end note*]
 *Ensures:* `exists(symlink_status(p))` is `false`.
-*Returns:* `false` if `p` did not exist, otherwise `true`. The signature
-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>
@@ -11793,11 +12203,11 @@ with argument `ec` returns `false` if an error occurs.
 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()`.
 [*Note 1*: A symbolic link is itself removed, rather than the file it
 resolves to. — *end note*]
 *Ensures:* `exists(symlink_status(p))` is `false`.
@@ -11812,11 +12222,11 @@ returns `static_cast< uintmax_t>(-1)` if an error occurs.
 ``` 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.
@@ -11839,11 +12249,11 @@ A symbolic link is itself renamed, rather than the file it resolves to.
 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>
@@ -11872,11 +12282,11 @@ system dependent.
 ``` cpp
 file_status filesystem::status(const path& p);
 ```
-*Effects:* As if:
 ``` cpp
 error_code ec;
 file_status result = status(p, ec);
 if (result.type() == file_type::none)
@@ -11895,17 +12305,17 @@ 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
 system API reports an error, sets `ec` to indicate the specific error
 reported. Otherwise, `ec.clear()`.
 [*Note 2*: This allows users to inspect the specifics of underlying API
-errors even when the value returned by `status()` is not
 `file_status(file_type::none)`. — *end note*]
 Let `prms` denote the result of `(m & perms::mask)`, where `m` is
 determined as if by converting the `st_mode` member of the obtained
 `struct stat` to the type `perms`.
@@ -11968,19 +12378,19 @@ bool filesystem::status_known(file_status s) noexcept;
 ``` 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`.
 Let `prms` denote the result of `(m & perms::mask)`, where `m` is
 determined as if by converting the `st_mode` member of the obtained
 `struct stat` to the type `perms`.
-*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]].
@@ -12018,16 +12428,16 @@ 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
-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]].
 *Returns:* `p` with symlinks resolved and the result
 normalized [[fs.path.generic]].
@@ -12037,10 +12447,12 @@ normalized [[fs.path.generic]].
 ## C library files <a id="c.files">[[c.files]]</a>
 ### Header `<cstdio>` synopsis <a id="cstdio.syn">[[cstdio.syn]]</a>
 ``` cpp
 namespace std {
   using size_t = see [support.types.layout];
   using FILE = see below;
   using fpos_t = see below;
 }
@@ -12051,10 +12463,11 @@ namespace std {
 #define _IONBF see below
 #define BUFSIZ see below
 #define EOF see below
 #define FOPEN_MAX see below
 #define FILENAME_MAX see below
 #define L_tmpnam see below
 #define SEEK_CUR see below
 #define SEEK_END see below
 #define SEEK_SET see below
 #define TMP_MAX see below
@@ -12112,15 +12525,19 @@ namespace std {
 ```
 The contents and meaning of the header `<cstdio>` are the same as the C
 standard library header `<stdio.h>`.
 Calls to the function `tmpnam` with an argument that is a null pointer
 value may introduce a data race [[res.on.data.races]] with other calls
 to `tmpnam` with an argument that is a null pointer value.
-See also: ISO C 7.21
 ### Header `<cinttypes>` synopsis <a id="cinttypes.syn">[[cinttypes.syn]]</a>
 ``` cpp
 #include <cstdint>  // see [cstdint.syn]
@@ -12137,75 +12554,89 @@ namespace std {
   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
 #define PRIuN see below
 #define PRIxN see below
 #define PRIXN see below
 #define SCNdN see below
 #define SCNiN see below
 #define SCNoN see below
 #define SCNuN see below
 #define SCNxN see below
 #define PRIdLEASTN see below
 #define PRIiLEASTN see below
 #define PRIoLEASTN see below
 #define PRIuLEASTN see below
 #define PRIxLEASTN see below
 #define PRIXLEASTN see below
 #define SCNdLEASTN see below
 #define SCNiLEASTN see below
 #define SCNoLEASTN see below
 #define SCNuLEASTN see below
 #define SCNxLEASTN see below
 #define PRIdFASTN see below
 #define PRIiFASTN see below
 #define PRIoFASTN see below
 #define PRIuFASTN see below
 #define PRIxFASTN see below
 #define PRIXFASTN see below
 #define SCNdFASTN see below
 #define SCNiFASTN see below
 #define SCNoFASTN see below
 #define SCNuFASTN see below
 #define SCNxFASTN see below
 #define PRIdMAX see below
 #define PRIiMAX see below
 #define PRIoMAX see below
 #define PRIuMAX see below
 #define PRIxMAX see below
 #define PRIXMAX see below
 #define SCNdMAX see below
 #define SCNiMAX see below
 #define SCNoMAX see below
 #define SCNuMAX see below
 #define SCNxMAX see below
 #define PRIdPTR see below
 #define PRIiPTR see below
 #define PRIoPTR see below
 #define PRIuPTR see below
 #define PRIxPTR see below
 #define PRIXPTR see below
 #define SCNdPTR see below
 #define SCNiPTR see below
 #define SCNoPTR see below
 #define SCNuPTR see below
 #define SCNxPTR 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);
@@ -12220,11 +12651,13 @@ 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
@@ -12239,22 +12672,24 @@ modifier for the type.
 [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
@@ -12264,12 +12699,16 @@ modifier for the type.
 [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
@@ -12353,10 +12792,13 @@ modifier for the type.
 [fs.path.concat]: #fs.path.concat
 [fs.path.construct]: #fs.path.construct
 [fs.path.cvt]: #fs.path.cvt
 [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
@@ -12386,10 +12828,11 @@ modifier for the type.
 [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
@@ -12450,12 +12893,12 @@ modifier for the type.
 [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
@@ -12570,12 +13013,12 @@ modifier for the type.
 [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.
@@ -12587,11 +13030,11 @@ modifier for the type.
     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.
@@ -12624,11 +13067,11 @@ modifier for the type.
     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

 `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 container
+types [[defns.character.container]] 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
   template<class charT, class traits = char_traits<charT>>
     class basic_ostream;
   template<class charT, class traits = char_traits<charT>>
     class basic_iostream;
+  template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
     class basic_stringbuf;
+  template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
     class basic_istringstream;
+  template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
     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>>
   template<class charT, class traits = char_traits<charT>>
     class basic_ofstream;
   template<class charT, class traits = char_traits<charT>>
     class basic_fstream;
+  template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
     class basic_syncbuf;
+  template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
     class basic_osyncstream;
   template<class charT, class traits = char_traits<charT>>
     class istreambuf_iterator;
   template<class charT, class traits = char_traits<charT>>
 In this Clause, the type name `FILE` refers to the type `FILE` declared
 in `<cstdio>`.
 The header `<iostream>` declares objects that associate objects with the
 standard C streams provided for by the functions declared in `<cstdio>`,
+and includes all the headers necessary to use these objects. The dynamic
+types of the stream buffers initially associated with these objects are
+unspecified, but they have the behavior specified for
+`std::basic_filebuf<char>` or `std::basic_filebuf<wchar_t>`.
 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
 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.23.2
 ### Narrow stream objects <a id="narrow.stream.objects">[[narrow.stream.objects]]</a>
 ``` cpp
 istream cin;
 ``` cpp
 #include <iosfwd>   // see [iosfwd.syn]
 namespace std {
+  // [stream.types], types
   using streamoff  = implementation-defined;
   using streamsize = implementation-defined;
+  // [fpos], class template fpos
   template<class stateT> class fpos;
+  // [ios.base], class ios_base
   class ios_base;
+  // [ios], class template basic_ios
   template<class charT, class traits = char_traits<charT>>
     class basic_ios;
   // [std.ios.manip], manipulators
   ios_base& boolalpha  (ios_base& str);
 An implementation is permitted to define `ios_base::failure` as a
 synonym for a class with equivalent functionality to class
 `ios_base::failure` shown in this subclause.
 [*Note 1*: When `ios_base::failure` is a synonym for another type, that
+type needs to provide a nested type `failure` to emulate the
 injected-class-name. — *end note*]
 The class `failure` defines the base class for the types of all objects
 thrown as exceptions, by functions in the iostreams library, to report
 errors detected during stream buffer operations.
   public:
     Init();
     Init(const Init&) = default;
     ~Init();
     Init& operator=(const Init&) = default;
   };
 }
 ```
 The class `Init` describes an object whose construction ensures the
 construction of the eight objects declared in `<iostream>`
 [[iostream.objects]] that associate file stream buffers with the
 standard C streams provided for by the functions declared in `<cstdio>`.
 ``` cpp
 Init();
 ```
 *Effects:* Constructs and initializes the objects `cin`, `cout`, `cerr`,
 ``` cpp
 static int xalloc();
 ```
+*Returns:* *index* `++`.
 *Remarks:* Concurrent access to this function by multiple threads does
 not result in a data race [[intro.multithread]].
 ``` cpp
 long& iword(int idx);
 ```
 *Preconditions:* `idx` is a value obtained by a call to `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
 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
 void*& pword(int idx);
 ```
 *Preconditions:* `idx` is a value obtained by a call to `xalloc`.
+*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`).
 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>
+#### General <a id="fpos.general">[[fpos.general]]</a>
 ``` cpp
 namespace std {
   template<class stateT> class fpos {
   public:
     // [fpos.members], members
 ``` cpp
 void state(stateT s);
 ```
+*Effects:* Assigns `s` to *st*.
 ``` cpp
 stateT state() const;
 ```
+*Returns:* Current value of *st*.
 #### Requirements <a id="fpos.operations">[[fpos.operations]]</a>
 An `fpos` type specifies file position information. It holds a state
 object whose type is equal to the template parameter `stateT`. Type
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_ios : public ios_base {
   public:
     using char_type   = charT;
+    using int_type    = traits::int_type;
+    using pos_type    = traits::pos_type;
+    using off_type    = traits::off_type;
     using traits_type = traits;
     // [iostate.flags], flags functions
     explicit operator bool() const;
     bool operator!() const;
 ``` cpp
 char narrow(char_type c, char dfault) const;
 ```
+*Returns:* `use_facet<ctype<char_type>>(getloc()).narrow(c, dfault)`.
 ``` cpp
 char_type widen(char c) const;
 ```
+*Returns:* `use_facet<ctype<char_type>>(getloc()).widen(c)`.
 ``` cpp
 char_type fill() const;
 ```
 ``` cpp
 bool good() const;
 ```
+*Returns:* `rdstate() == 0`.
 ``` cpp
 bool eof() const;
 ```
 ### Header `<streambuf>` synopsis <a id="streambuf.syn">[[streambuf.syn]]</a>
 ``` cpp
 namespace std {
+  // [streambuf], class template basic_streambuf
   template<class charT, class traits = char_traits<charT>>
     class basic_streambuf;
   using streambuf  = basic_streambuf<char>;
   using wstreambuf = basic_streambuf<wchar_t>;
 }
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_streambuf {
   public:
     using char_type   = charT;
+    using int_type    = traits::int_type;
+    using pos_type    = traits::pos_type;
+    using off_type    = traits::off_type;
     using traits_type = traits;
     virtual ~basic_streambuf();
     // [streambuf.locales], locales
     virtual int_type   overflow(int_type c = traits::eof());
   };
 }
 ```
+The class template `basic_streambuf` serves as a base class for deriving
+various *stream buffers* whose objects each control two *character
+sequences*:
 - a character *input sequence*;
 - a character *output sequence*.
 #### Constructors <a id="streambuf.cons">[[streambuf.cons]]</a>
 ``` cpp
 void setg(char_type* gbeg, char_type* gnext, char_type* gend);
 ```
+*Preconditions:* \[`gbeg`, `gnext`), \[`gbeg`, `gend`), and \[`gnext`,
+`gend`) are all valid ranges.
 *Ensures:* `gbeg == eback()`, `gnext == gptr()`, and `gend == egptr()`
 are all `true`.
 ##### Put area access <a id="streambuf.put.area">[[streambuf.put.area]]</a>
 ``` cpp
 void setp(char_type* pbeg, char_type* pend);
 ```
+*Preconditions:* \[`pbeg`, `pend`) is a valid range.
 *Ensures:* `pbeg == pbase()`, `pbeg == pptr()`, and `pend == epptr()`
 are all `true`.
 #### Virtual functions <a id="streambuf.virtuals">[[streambuf.virtuals]]</a>
 ### Header `<istream>` synopsis <a id="istream.syn">[[istream.syn]]</a>
 ``` cpp
 namespace std {
+  // [istream], class template basic_istream
   template<class charT, class traits = char_traits<charT>>
     class basic_istream;
   using istream  = basic_istream<char>;
   using wistream = basic_istream<wchar_t>;
+  // [iostreamclass], class template basic_iostream
   template<class charT, class traits = char_traits<charT>>
     class basic_iostream;
   using iostream  = basic_iostream<char>;
   using wiostream = basic_iostream<wchar_t>;
+  // [istream.manip], standard basic_istream manipulators
   template<class charT, class traits>
     basic_istream<charT, traits>& ws(basic_istream<charT, traits>& is);
+  // [istream.rvalue], rvalue stream extraction
   template<class Istream, class T>
     Istream&& operator>>(Istream&& is, T&& x);
 }
 ```
 ### Header `<ostream>` synopsis <a id="ostream.syn">[[ostream.syn]]</a>
 ``` cpp
 namespace std {
+  // [ostream], class template basic_ostream
   template<class charT, class traits = char_traits<charT>>
     class basic_ostream;
   using ostream  = basic_ostream<char>;
   using wostream = basic_ostream<wchar_t>;
+  // [ostream.manip], standard basic_ostream manipulators
   template<class charT, class traits>
     basic_ostream<charT, traits>& endl(basic_ostream<charT, traits>& os);
   template<class charT, class traits>
     basic_ostream<charT, traits>& ends(basic_ostream<charT, traits>& os);
   template<class charT, class traits>
   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);
+  // [ostream.rvalue], rvalue stream insertion
   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 println(ostream& os);
   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 {
+  // [std.manip], standard manipulators
   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);
+  // [ext.manip], extended manipulators
   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);
+  // [quoted.manip], quoted manipulators
   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,
   template<class... Args>
     void print(FILE* stream, format_string<Args...> fmt, Args&&... args);
   template<class... Args>
     void println(format_string<Args...> fmt, Args&&... args);
+  void println();
   template<class... Args>
     void println(FILE* stream, format_string<Args...> fmt, Args&&... args);
+  void println(FILE* stream);
   void vprint_unicode(string_view fmt, format_args args);
   void vprint_unicode(FILE* stream, string_view fmt, format_args args);
+  void vprint_unicode_buffered(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);
+  void vprint_nonunicode_buffered(FILE* stream, string_view fmt, format_args args);
 }
 ```
 ### Input streams <a id="input.streams">[[input.streams]]</a>
   template<class charT, class traits = char_traits<charT>>
   class basic_istream : virtual public basic_ios<charT, traits> {
   public:
     // types (inherited from basic_ios[ios])
     using char_type   = charT;
+    using int_type    = traits::int_type;
+    using pos_type    = traits::pos_type;
+    using off_type    = traits::off_type;
     using traits_type = traits;
     // [istream.cons], constructor/destructor
     explicit basic_istream(basic_streambuf<charT, traits>* sb);
     virtual ~basic_istream();
     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());
+    basic_istream& ignore(streamsize n, char_type delim);
     int_type       peek();
     basic_istream& read    (char_type* s, streamsize n);
     streamsize     readsome(char_type* s, streamsize n);
     basic_istream& putback(char_type c);
 ``` cpp
 basic_istream& operator=(basic_istream&& rhs);
 ```
+*Effects:* Equivalent to `swap(rhs)`.
 *Returns:* `*this`.
 ``` cpp
 void swap(basic_istream& rhs);
 if (ctype.is(ctype.space, c) != 0)
   // c is a whitespace character.
 ```
 If, after any preparation is completed, `is.good()` is `true`,
+*`ok_`*` != false` otherwise, *`ok_`*` == false`. During preparation,
+the constructor may call `setstate(failbit)` (which may throw
 `ios_base::failure` [[iostate.flags]]).[^19]
 ``` cpp
 ~sentry();
 ```
 ``` cpp
 explicit operator bool() const;
 ```
+*Returns:* *ok\_*.
 #### Formatted input functions <a id="istream.formatted">[[istream.formatted]]</a>
 ##### Common requirements <a id="istream.formatted.reqmts">[[istream.formatted.reqmts]]</a>
 ``` 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());
 ```
 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;
 - end-of-file occurs on the input sequence (in which case the function
   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
+basic_istream& ignore(streamsize n, char_type delim);
+```
+*Constraints:* `is_same_v<char_type, char>` is `true`.
+*Effects:* Equivalent to:
+`return ignore(n, traits::to_int_type(delim));`
 ``` cpp
 int_type peek();
 ```
 *Effects:* Behaves as an unformatted input function (as described
   class basic_iostream
     : public basic_istream<charT, traits>,
       public basic_ostream<charT, traits> {
   public:
     using char_type   = charT;
+    using int_type    = traits::int_type;
+    using pos_type    = traits::pos_type;
+    using off_type    = traits::off_type;
     using traits_type = traits;
     // [iostream.cons], constructor
     explicit basic_iostream(basic_streambuf<charT, traits>* sb);
 ``` cpp
 basic_iostream& operator=(basic_iostream&& rhs);
 ```
+*Effects:* Equivalent to `swap(rhs)`.
 ``` cpp
 void swap(basic_iostream& rhs);
 ```
   template<class charT, class traits = char_traits<charT>>
   class basic_ostream : virtual public basic_ios<charT, traits> {
   public:
     // types (inherited from basic_ios[ios])
     using char_type   = charT;
+    using int_type    = traits::int_type;
+    using pos_type    = traits::pos_type;
+    using off_type    = traits::off_type;
     using traits_type = traits;
     // [ostream.cons], constructor/destructor
     explicit basic_ostream(basic_streambuf<char_type, traits>* sb);
     virtual ~basic_ostream();
 ``` cpp
 basic_ostream& operator=(basic_ostream&& rhs);
 ```
+*Effects:* Equivalent to `swap(rhs)`.
 *Returns:* `*this`.
 ``` cpp
 void swap(basic_ostream& rhs);
 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();
 ```
 If
 `(os.flags() & ios_base::unitbuf) && !uncaught_exceptions() && os.good()`
+is `true`, calls `os.rdbuf()->pubsync()`. If that function returns -1 or
+exits via an exception, sets `badbit` in `os.rdstate()` without
+propagating an exception.
 ``` cpp
 explicit operator bool() const;
 ```
+*Effects:* Returns *ok\_*.
 ##### Seek members <a id="ostream.seeks">[[ostream.seeks]]</a>
 Each seek member function begins execution by constructing an object of
 class `sentry`. It returns by destroying the `sentry` object.
 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
 does so as follows. Given a `charT` character sequence `seq` where
+`charT` is the character container type of the stream, if the length of
+`seq` is less than `os.width()`, then enough copies of `os.fill()` are
+added to this sequence as necessary to pad to a width of `os.width()`
+characters. If `(os.flags() & ios_base::adjustfield) == ios_base::left`
+is `true`, 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
 basic_ostream& operator<<(bool val);
 `unsigned long long`, `double`, `long double`, or `const void*`, 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(), val).failed();
 ```
 When `val` is of type `short` the formatting conversion occurs as if it
 performed the following code fragment:
 ``` cpp
 ios_base::fmtflags baseflags = ios_base::flags() & ios_base::basefield;
+bool failed = use_facet<num_put<charT, ostreambuf_iterator<charT, traits>>>(
+ getloc()).put(*this, *this, fill(),
     baseflags == ios_base::oct || baseflags == ios_base::hex
       ? static_cast<long>(static_cast<unsigned short>(val))
       : static_cast<long>(val)).failed();
 ```
 When `val` is of type `int` the formatting conversion occurs as if it
 performed the following code fragment:
 ``` cpp
 ios_base::fmtflags baseflags = ios_base::flags() & ios_base::basefield;
+bool failed = use_facet<num_put<charT, ostreambuf_iterator<charT, traits>>>(
+ getloc()).put(*this, *this, fill(),
     baseflags == ios_base::oct || baseflags == ios_base::hex
       ? static_cast<long>(static_cast<unsigned int>(val))
       : static_cast<long>(val)).failed();
 ```
 When `val` is of type `unsigned short` or `unsigned int` 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<unsigned long>(val)).failed();
 ```
 When `val` is of type `float` 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();
 ```
 The first argument provides an object of the `ostreambuf_iterator<>`
 class which is an iterator for class `basic_ostream<>`. It bypasses
 `ostream`s and uses `streambuf`s directly. Class `locale` relies on
 *`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.
   basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>& out, unsigned char c);
 ```
 *Effects:* Behaves as a formatted output
 function [[ostream.formatted.reqmts]] of `out`. Constructs a character
+sequence `seq`. If `c` has type `char` and the character container type
+of the stream is not `char`, then `seq` consists of `out.widen(c)`;
+otherwise `seq` consists of `c`. Determines padding for `seq` as
+described in  [[ostream.formatted.reqmts]]. Inserts `seq` into `out`.
+Calls `os.width(0)`.
 *Returns:* `out`.
 ``` cpp
 template<class charT, class traits>
 *Effects:* If the ordinary literal encoding [[lex.charset]] is UTF-8,
 equivalent to:
 ``` cpp
+vprint_unicode(os, fmt.str, make_format_args(args...));
 ```
 Otherwise, equivalent to:
 ``` cpp
+vprint_nonunicode(os, fmt.str, make_format_args(args...));
 ```
 ``` cpp
 template<class... Args>
   void println(ostream& os, format_string<Args...> fmt, Args&&... args);
 ```
 *Effects:* Equivalent to:
 ``` cpp
+print(os, "{}\n", format(os.getloc(), fmt, std::forward<Args>(args)...));
+```
+``` cpp
+void println(ostream& os);
+```
+*Effects:* Equivalent to:
+``` cpp
+print(os, "\n");
 ```
 ``` cpp
 void vprint_unicode(ostream& os, string_view fmt, format_args args);
 void vprint_nonunicode(ostream& os, string_view fmt, format_args args);
 - 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 a
+variable with automatic storage duration 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 that is capable of displaying Unicode only via a native
+  Unicode API, which is determined in an implementation-defined manner,
+  flushes `os` and then writes `out` to the terminal using the native
+  Unicode API; if `out` contains invalid code units, the behavior is
+  undefined. Then establishes an observable
+  checkpoint [[intro.abstract]].
+- Otherwise 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.
 [[iostate.flags]]). Otherwise, if the `sentry` object returns `false`,
 does nothing.
 *Returns:* `*this`.
+#### Standard `basic_ostream` manipulators <a id="ostream.manip">[[ostream.manip]]</a>
 Each instantiation of any of the function templates specified in this
 subclause is a designated addressable function [[namespace.std]].
 ``` cpp
 manipulator has no effect.
 [*Note 1*: To work around the issue that the `Allocator` template
 argument cannot be deduced, implementations can introduce an
 intermediate base class to `basic_syncbuf` that manages its
+*emit-on-sync* flag. — *end note*]
 *Returns:* `os`.
 ``` cpp
 template<class charT, class traits>
 ``` cpp
 template<class... Args>
   void print(FILE* stream, format_string<Args...> fmt, Args&&... args);
 ```
+*Effects:* Let `locksafe` be
+`(enable_nonlocking_formatter_optimization<remove_cvref_t<Args>> && ...)`.
+If the ordinary literal encoding [[lex.charset]] is UTF-8, equivalent
+to:
 ``` cpp
+locksafe
+  ? vprint_unicode(stream, fmt.str, make_format_args(args...))
+  : vprint_unicode_buffered(stream, fmt.str, make_format_args(args...));
 ```
 Otherwise, equivalent to:
 ``` cpp
+locksafe
+  ? vprint_nonunicode(stream, fmt.str, make_format_args(args...))
+  : vprint_nonunicode_buffered(stream, fmt.str, make_format_args(args...));
 ```
 ``` cpp
 template<class... Args>
   void println(format_string<Args...> fmt, Args&&... args);
 ``` cpp
 println(stdout, fmt, std::forward<Args>(args)...);
 ```
+``` cpp
+void println();
+```
+*Effects:* Equivalent to:
+``` cpp
+println(stdout);
+```
 ``` cpp
 template<class... Args>
   void println(FILE* stream, format_string<Args...> fmt, Args&&... args);
 ```
 *Effects:* Equivalent to:
 ``` cpp
+print(stream, runtime_format(string(fmt.get()) + '\n'), std::forward<Args>(args)...);
+```
+``` cpp
+void println(FILE* stream);
+```
+*Effects:* Equivalent to:
+``` cpp
+print(stream, "\n");
 ```
 ``` cpp
 void vprint_unicode(string_view fmt, format_args args);
 ```
 ``` cpp
 vprint_unicode(stdout, fmt, args);
 ```
+``` cpp
+void vprint_unicode_buffered(FILE* stream, string_view fmt, format_args args);
+```
+*Effects:* Equivalent to:
+``` cpp
+string out = vformat(fmt, args);
+vprint_unicode(stream, "{}", make_format_args(out));
+```
 ``` cpp
 void vprint_unicode(FILE* stream, string_view fmt, format_args args);
 ```
 *Preconditions:* `stream` is a valid pointer to an output C stream.
+*Effects:* Locks `stream`. Let `out` denote the character representation
+of formatting arguments provided by `args` formatted according to
+specifications given in `fmt`.
+- If `stream` refers to a terminal that is capable of displaying Unicode
+  only via a native Unicode API, flushes `stream` and then writes `out`
+  to the terminal using the native Unicode API; if `out` contains
+  invalid code units, the behavior is undefined. Then establishes an
+  observable checkpoint [[intro.abstract]].
+- Otherwise writes `out` to `stream` unchanged.
+Unconditionally unlocks `stream` on function exit.
+See also: ISO C 7.23.2.
+[*Note 1*: On Windows the native Unicode API is `WriteConsoleW` and
+`stream` referring to a terminal means that
+`GetConsoleMode(_get_osfhandle(_fileno(stream)), ...)` returns
 nonzero. — *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
 ``` cpp
 vprint_nonunicode(stdout, fmt, args);
 ```
+``` cpp
+void vprint_nonunicode_buffered(FILE* stream, string_view fmt, format_args args);
+```
+*Effects:* Equivalent to:
+``` cpp
+string out = vformat(fmt, args);
+vprint_nonunicode("{}", make_format_args(out));
+```
 ``` cpp
 void vprint_nonunicode(FILE* stream, string_view fmt, format_args args);
 ```
 *Preconditions:* `stream` is a valid pointer to an output C stream.
+*Effects:* While holding the lock on `stream`, writes the character
+representation of formatting arguments provided by `args` formatted
+according to specifications given in `fmt` 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`.
 ### Header `<sstream>` synopsis <a id="sstream.syn">[[sstream.syn]]</a>
 ``` cpp
 namespace std {
+ // [stringbuf], class template basic_stringbuf
+  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>;
+ // [istringstream], class template basic_istringstream
+  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>;
+ // [ostringstream], class template basic_ostringstream
+  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>;
+ // [stringstream], class template basic_stringstream
+  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);
 #### 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> {
   public:
     using char_type      = charT;
+    using int_type       = traits::int_type;
+    using pos_type       = traits::pos_type;
+    using off_type       = traits::off_type;
     using traits_type    = traits;
     using allocator_type = Allocator;
     // [stringbuf.cons], constructors
     basic_stringbuf() : basic_stringbuf(ios_base::in | ios_base::out) {}
         ios_base::openmode which, const Allocator& a);
     template<class SAlloc>
       explicit basic_stringbuf(
         const basic_string<charT, traits, SAlloc>& s,
         ios_base::openmode which = ios_base::in | ios_base::out);
+    template<class T>
+      explicit basic_stringbuf(const T& t,
+                               ios_base::openmode which = ios_base::in | ios_base::out);
+    template<class T>
+      basic_stringbuf(const T& t, const Allocator& a);
+    template<class T>
+      basic_stringbuf(const T& t, ios_base::openmode which, const Allocator& a);
     basic_stringbuf(const basic_stringbuf&) = delete;
     basic_stringbuf(basic_stringbuf&& rhs);
     basic_stringbuf(basic_stringbuf&& rhs, const Allocator& a);
     // [stringbuf.assign], assignment and swap
     void str(const basic_string<charT, traits, Allocator>& s);
     template<class SAlloc>
       void str(const basic_string<charT, traits, SAlloc>& s);
     void str(basic_string<charT, traits, Allocator>&& s);
+    template<class T>
+      void str(const T& t);
   protected:
     // [stringbuf.virtuals], overridden virtual functions
     int_type underflow() override;
     int_type pbackfail(int_type c = traits::eof()) override;
                        = ios_base::in | ios_base::out) override;
   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
 - `ios_base::openmode mode`, has `in` set if the input sequence can be
   read, and `out` set if the output sequence can be written.
 - `basic_string<charT, traits, Allocator> buf` contains the underlying
   character sequence.
+- `init-buf-ptrs()` sets the base class’ get area [[streambuf.get.area]]
   and put area [[streambuf.put.area]] pointers after initializing,
+  moving from, or assigning to *`buf`* accordingly.
 #### Constructors <a id="stringbuf.cons">[[stringbuf.cons]]</a>
 ``` cpp
 explicit basic_stringbuf(ios_base::openmode which);
 ```
 *Effects:* Initializes the base class with `basic_streambuf()`
+[[streambuf.cons]], and *mode* with `which`. It is
 *implementation-defined* whether the sequence pointers (`eback()`,
 `gptr()`, `egptr()`, `pbase()`, `pptr()`, `epptr()`) are initialized to
 null pointers.
 *Ensures:* `str().empty()` is `true`.
   const basic_string<charT, traits, Allocator>& s,
   ios_base::openmode which = ios_base::in | ios_base::out);
 ```
 *Effects:* Initializes the base class with `basic_streambuf()`
+[[streambuf.cons]], *mode* with `which`, and *buf* with `s`, then calls
+*`init-buf-ptrs`*`()`.
 ``` cpp
 basic_stringbuf(ios_base::openmode which, const Allocator& a);
 ```
 *Effects:* Initializes the base class with `basic_streambuf()`
+[[streambuf.cons]], *mode* with `which`, and *buf* with `a`, then calls
+*`init-buf-ptrs`*`()`.
 *Ensures:* `str().empty()` is `true`.
 ``` cpp
 explicit basic_stringbuf(
   basic_string<charT, traits, Allocator>&& s,
   ios_base::openmode which = ios_base::in | ios_base::out);
 ```
 *Effects:* Initializes the base class with `basic_streambuf()`
+[[streambuf.cons]], *mode* with `which`, and *buf* with `std::move(s)`,
+then calls *`init-buf-ptrs`*`()`.
 ``` cpp
 template<class SAlloc>
   basic_stringbuf(
     const basic_string<charT, traits, SAlloc>& s,
     ios_base::openmode which, const Allocator& a);
 ```
 *Effects:* Initializes the base class with `basic_streambuf()`
+[[streambuf.cons]], *mode* with `which`, and *buf* with `{s,a}`, then
+calls *`init-buf-ptrs`*`()`.
 ``` cpp
 template<class SAlloc>
   explicit basic_stringbuf(
     const basic_string<charT, traits, SAlloc>& s,
 ```
 *Constraints:* `is_same_v<SAlloc, Allocator>` is `false`.
 *Effects:* Initializes the base class with `basic_streambuf()`
+[[streambuf.cons]], *mode* with `which`, and *buf* with `s`, then calls
+*`init-buf-ptrs`*`()`.
+``` cpp
+template<class T>
+  explicit basic_stringbuf(const T& t, ios_base::openmode which = ios_base::in | ios_base::out);
+template<class T>
+  basic_stringbuf(const T& t, const Allocator& a);
+template<class T>
+  basic_stringbuf(const T& t, ios_base::openmode which, const Allocator& a);
+```
+Let `which` be `ios_base::in | ios_base::out` for the overload with no
+parameter `which`, and `a` be `Allocator()` for the overload with no
+parameter `a`.
+*Constraints:*
+`is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+`true`.
+*Effects:* Creates a variable `sv` as if by
+`basic_string_view<charT, traits> sv = t`, then value-initializes the
+base class, initializes *mode* with `which`, and
+direct-non-list-initializes *buf* with `sv, a`, then calls
+*`init-buf-ptrs`*`()`.
 ``` cpp
 basic_stringbuf(basic_stringbuf&& rhs);
 basic_stringbuf(basic_stringbuf&& rhs, const Allocator& a);
 ```
 *Effects:* Copy constructs the base class from `rhs` and initializes
+*mode* with `rhs.mode`. In the first form `buf` is initialized from
+`std::move(rhs).str()`. In the second form *buf* is initialized from
 `{std::move(rhs).str(), a}`. It is *implementation-defined* whether the
 sequence pointers in `*this` (`eback()`, `gptr()`, `egptr()`, `pbase()`,
 `pptr()`, `epptr()`) obtain the values which `rhs` had.
 *Ensures:* Let `rhs_p` refer to the state of `rhs` just prior to this
 *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>
   void swap(basic_stringbuf<charT, traits, Allocator>& x,
             basic_stringbuf<charT, traits, Allocator>& y) noexcept(noexcept(x.swap(y)));
 ```
+*Effects:* Equivalent to `x.swap(y)`.
 #### Member functions <a id="stringbuf.members">[[stringbuf.members]]</a>
 The member functions getting the underlying character sequence all refer
 to a `high_mark` value, where `high_mark` represents the position one
 In the latter case, all characters initialized prior to the call are now
 considered uninitialized (except for those characters re-initialized by
 the new `basic_string`).
 ``` cpp
+void init-buf-ptrs();
 ```
+*Effects:* Initializes the input and output sequences from *buf*
+according to *mode*.
 *Ensures:*
+- If `ios_base::out` is set in *mode*, `pbase()` points to
+ *`buf`*`.front()` and `epptr() >= pbase() + `*`buf`*`.size()` is
+  `true`;
+  - in addition, if `ios_base::ate` is set in *mode*,
+    `pptr() == pbase() + `*`buf`*`.size()` is `true`,
   - 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
 allocator_type get_allocator() const noexcept;
 ```
+*Returns:* *`buf`*`.get_allocator()`.
 ``` cpp
 basic_string<charT, traits, Allocator> str() const &;
 ```
 template<class SAlloc>
   basic_string<charT, traits, SAlloc> str(const SAlloc& sa) const;
 ```
 *Constraints:* `SAlloc` is a type that qualifies as an
+allocator [[container.reqmts]].
 *Effects:* Equivalent to:
 ``` cpp
 return basic_string<charT, traits, SAlloc>(view(), sa);
 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()`.
 Let `sv` be `basic_string_view<charT, traits>`.
 *Returns:* A `sv` object referring to the `basic_stringbuf`’s underlying
 character sequence in `buf`:
+- If `ios_base::out` is set in *mode*, then
   `sv(pbase(), high_mark - pbase())` is returned.
+- Otherwise, if `ios_base::in` is set in *mode*, then
   `sv(eback(), egptr() - eback())` is returned.
 - Otherwise, `sv()` is returned.
 [*Note 2*: Using the returned `sv` object after destruction or
 invalidation of the character sequence underlying `*this` is undefined
 *Effects:* Equivalent to:
 ``` cpp
 buf = s;
+init-buf-ptrs();
 ```
 ``` cpp
 template<class SAlloc>
   void str(const basic_string<charT, traits, SAlloc>& s);
 *Effects:* Equivalent to:
 ``` cpp
 buf = s;
+init-buf-ptrs();
 ```
 ``` cpp
 void str(basic_string<charT, traits, Allocator>&& s);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 buf = std::move(s);
+init-buf-ptrs();
+```
+``` cpp
+template<class T>
+  void str(const T& t);
+```
+*Constraints:*
+`is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+`true`.
+*Effects:* Equivalent to:
+``` cpp
+basic_string_view<charT, traits> sv = t;
+buf = sv;
+init-buf-ptrs();
 ```
 #### Overridden virtual functions <a id="stringbuf.virtuals">[[stringbuf.virtuals]]</a>
 ``` cpp
 - If `traits::eq_int_type(c, traits::eof())` returns `false` and if the
   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)`.
 *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*,
 the function alters the read end pointer `egptr()` to point just past
 the new write position.
 ``` cpp
 pos_type seekoff(off_type off, ios_base::seekdir way,
 #### 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> {
   public:
     using char_type      = charT;
+    using int_type       = traits::int_type;
+    using pos_type       = traits::pos_type;
+    using off_type       = traits::off_type;
     using traits_type    = traits;
     using allocator_type = Allocator;
     // [istringstream.cons], constructors
     basic_istringstream() : basic_istringstream(ios_base::in) {}
         ios_base::openmode which, const Allocator& a);
     template<class SAlloc>
       explicit basic_istringstream(
         const basic_string<charT, traits, SAlloc>& s,
         ios_base::openmode which = ios_base::in);
+    template<class T>
+      explicit basic_istringstream(const T& t, ios_base::openmode which = ios_base::in);
+    template<class T>
+      basic_istringstream(const T& t, const Allocator& a);
+    template<class T>
+      basic_istringstream(const T& t, ios_base::openmode which, const Allocator& a);
     basic_istringstream(const basic_istringstream&) = delete;
     basic_istringstream(basic_istringstream&& rhs);
     basic_istringstream& operator=(const basic_istringstream&) = delete;
     basic_istringstream& operator=(basic_istringstream&& rhs);
     void str(const basic_string<charT, traits, Allocator>& s);
     template<class SAlloc>
       void str(const basic_string<charT, traits, SAlloc>& s);
     void str(basic_string<charT, traits, Allocator>&& s);
+    template<class T>
+      void str(const T& t);
   private:
     basic_stringbuf<charT, traits, Allocator> sb;   // exposition only
   };
 }
 reading objects of class `basic_string<{}charT, traits, Allocator>`. It
 uses a `basic_stringbuf<charT, traits, Allocator>` object to control the
 associated storage. For the sake of exposition, the maintained data is
 presented here as:
+- *`sb`*, the `stringbuf` object.
 #### Constructors <a id="istringstream.cons">[[istringstream.cons]]</a>
 ``` cpp
 explicit basic_istringstream(ios_base::openmode which);
 ```
 *Effects:* Initializes the base class with
+`basic_istream<charT, traits>(addressof(`*`sb`*`))` [[istream]] and *sb*
+with `basic_stringbuf<charT, traits, Allocator>(which | ios_base::in)`
 [[stringbuf.cons]].
 ``` cpp
 explicit basic_istringstream(
   const basic_string<charT, traits, Allocator>& s,
   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);
 ```
 *Effects:* Initializes the base class with
+`basic_istream<charT, traits>(addressof(`*`sb`*`))` [[istream]] and *sb*
+with
 `basic_stringbuf<charT, traits, Allocator>(which | ios_base::in, a)`
 [[stringbuf.cons]].
 ``` cpp
 explicit basic_istringstream(
   basic_string<charT, traits, Allocator>&& s,
   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>(std::move(s), which | ios_base::in)`
 [[stringbuf.cons]].
 ``` cpp
 template<class SAlloc>
     const basic_string<charT, traits, SAlloc>& s,
     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,
     ios_base::openmode which = ios_base::in);
 ```
+*Constraints:* `is_same_v<SAlloc, Allocator>` is `false`.
 *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
+template<class T>
+  explicit basic_istringstream(const T& t, ios_base::openmode which = ios_base::in);
+template<class T>
+  basic_istringstream(const T& t, const Allocator& a);
+template<class T>
+  basic_istringstream(const T& t, ios_base::openmode which, const Allocator& a);
+```
+Let `which` be `ios_base::in` for the overload with no parameter
+`which`, and `a` be `Allocator()` for the overload with no parameter
+`a`.
+*Constraints:*
+`is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+`true`.
+*Effects:* Initializes the base class with `addressof(`*`sb`*`)`, and
+direct-non-list-initializes *sb* with `t, which | ios_base::in, a`.
 ``` cpp
 basic_istringstream(basic_istringstream&& rhs);
 ```
 *Effects:* Move constructs from the rvalue `rhs`. This is accomplished
 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);
 template<class charT, class traits, class Allocator>
   void swap(basic_istringstream<charT, traits, Allocator>& x,
             basic_istringstream<charT, traits, Allocator>& y);
 ```
+*Effects:* Equivalent to `x.swap(y)`.
 #### Member functions <a id="istringstream.members">[[istringstream.members]]</a>
 ``` cpp
 basic_stringbuf<charT, traits, Allocator>* rdbuf() const;
 ```
 *Returns:*
+`const_cast<basic_stringbuf<charT, traits, Allocator>*>(addressof(`*`sb`*`))`.
 ``` cpp
 basic_string<charT, traits, Allocator> str() const &;
 ```
 void str(basic_string<charT, traits, Allocator>&& s);
 ```
 *Effects:* Equivalent to: `rdbuf()->str(std::move(s));`
+``` cpp
+template<class T>
+  void str(const T& t);
+```
+*Constraints:*
+`is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+`true`.
+*Effects:* Equivalent to: `rdbuf()->str(t);`
 ### 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> {
   public:
     using char_type      = charT;
+    using int_type       = traits::int_type;
+    using pos_type       = traits::pos_type;
+    using off_type       = traits::off_type;
     using traits_type    = traits;
     using allocator_type = Allocator;
     // [ostringstream.cons], constructors
     basic_ostringstream() : basic_ostringstream(ios_base::out) {}
         ios_base::openmode which, const Allocator& a);
     template<class SAlloc>
       explicit basic_ostringstream(
         const basic_string<charT, traits, SAlloc>& s,
         ios_base::openmode which = ios_base::out);
+    template<class T>
+      explicit basic_ostringstream(const T& t, ios_base::openmode which = ios_base::out);
+    template<class T>
+      basic_ostringstream(const T& t, const Allocator& a);
+    template<class T>
+      basic_ostringstream(const T& t, ios_base::openmode which, const Allocator& a);
     basic_ostringstream(const basic_ostringstream&) = delete;
     basic_ostringstream(basic_ostringstream&& rhs);
     basic_ostringstream& operator=(const basic_ostringstream&) = delete;
     basic_ostringstream& operator=(basic_ostringstream&& rhs);
     void str(const basic_string<charT, traits, Allocator>& s);
     template<class SAlloc>
       void str(const basic_string<charT, traits, SAlloc>& s);
     void str(basic_string<charT, traits, Allocator>&& s);
+    template<class T>
+      void str(const T& t);
    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
 uses a `basic_stringbuf` object to control the associated storage. For
 the sake of exposition, the maintained data is presented here as:
+- *`sb`*, the `stringbuf` object.
 #### Constructors <a id="ostringstream.cons">[[ostringstream.cons]]</a>
 ``` cpp
 explicit basic_ostringstream(ios_base::openmode which);
 ```
 *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)`
 [[stringbuf.cons]].
 ``` cpp
 explicit basic_ostringstream(
   const basic_string<charT, traits, Allocator>& s,
   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);
 ```
 *Effects:* Initializes the base class with
+`basic_ostream<charT, traits>(addressof(`*`sb`*`))` [[ostream]] and *sb*
+with
 `basic_stringbuf<charT, traits, Allocator>(std::move(s), which | ios_base::out)`
 [[stringbuf.cons]].
 ``` cpp
 template<class SAlloc>
     const basic_string<charT, traits, SAlloc>& s,
     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>
 ```
 *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
+template<class T>
+  explicit basic_ostringstream(const T& t, ios_base::openmode which = ios_base::out);
+template<class T>
+  basic_ostringstream(const T& t, const Allocator& a);
+template<class T>
+  basic_ostringstream(const T& t, ios_base::openmode which, const Allocator& a);
+```
+Let `which` be `ios_base::out` for the overload with no parameter
+`which`, and `a` be `Allocator()` for the overload with no parameter
+`a`.
+*Constraints:*
+`is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+`true`.
+*Effects:* Initializes the base class with `addressof(`*`sb`*`)`, and
+direct-non-list-initializes *sb* with `t, which | ios_base::out, a`.
 ``` cpp
 basic_ostringstream(basic_ostringstream&& rhs);
 ```
 *Effects:* Move constructs from the rvalue `rhs`. This is accomplished
 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);
 template<class charT, class traits, class Allocator>
   void swap(basic_ostringstream<charT, traits, Allocator>& x,
             basic_ostringstream<charT, traits, Allocator>& y);
 ```
+*Effects:* Equivalent to `x.swap(y)`.
 #### Member functions <a id="ostringstream.members">[[ostringstream.members]]</a>
 ``` cpp
 basic_stringbuf<charT, traits, Allocator>* rdbuf() const;
 ```
 *Returns:*
+`const_cast<basic_stringbuf<charT, traits, Allocator>*>(addressof(`*`sb`*`))`.
 ``` cpp
 basic_string<charT, traits, Allocator> str() const &;
 ```
 void str(basic_string<charT, traits, Allocator>&& s);
 ```
 *Effects:* Equivalent to: `rdbuf()->str(std::move(s));`
+``` cpp
+template<class T>
+  void str(const T& t);
+```
+*Constraints:*
+`is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+`true`.
+*Effects:* Equivalent to: `rdbuf()->str(t);`
 ### 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> {
   public:
     using char_type      = charT;
+    using int_type       = traits::int_type;
+    using pos_type       = traits::pos_type;
+    using off_type       = traits::off_type;
     using traits_type    = traits;
     using allocator_type = Allocator;
     // [stringstream.cons], constructors
     basic_stringstream() : basic_stringstream(ios_base::out | ios_base::in) {}
         ios_base::openmode which, const Allocator& a);
     template<class SAlloc>
       explicit basic_stringstream(
         const basic_string<charT, traits, SAlloc>& s,
         ios_base::openmode which = ios_base::out | ios_base::in);
+    template<class T>
+      explicit basic_stringstream(const T& t,
+                                  ios_base::openmode which = ios_base::out | ios_base::in);
+    template<class T>
+      basic_stringstream(const T& t, const Allocator& a);
+    template<class T>
+      basic_stringstream(const T& t, ios_base::openmode which, const Allocator& a);
     basic_stringstream(const basic_stringstream&) = delete;
     basic_stringstream(basic_stringstream&& rhs);
     basic_stringstream& operator=(const basic_stringstream&) = delete;
     basic_stringstream& operator=(basic_stringstream&& rhs);
     void str(const basic_string<charT, traits, Allocator>& s);
     template<class SAlloc>
       void str(const basic_string<charT, traits, SAlloc>& s);
     void str(basic_string<charT, traits, Allocator>&& s);
+    template<class T>
+      void str(const T& t);
   private:
+    basic_stringbuf<charT, traits, Allocator> sb; // exposition only
   };
 }
 ```
 The class template `basic_stringstream<charT, traits>` supports reading
 `basic_string<charT, traits, Allocator>`. It uses a
 `basic_stringbuf<charT, traits, Allocator>` object to control the
 associated sequence. For the sake of exposition, the maintained data is
 presented here as
+- *`sb`*, the `stringbuf` object.
 #### Constructors <a id="stringstream.cons">[[stringstream.cons]]</a>
 ``` cpp
 explicit basic_stringstream(ios_base::openmode which);
 ```
 *Effects:* Initializes the base class with
+`basic_iostream<charT, traits>(addressof(`*`sb`*`))` [[iostream.cons]]
+and *sb* with `basic_stringbuf<charT, traits, Allocator>(which)`.
 ``` cpp
 explicit basic_stringstream(
   const basic_string<charT, traits, Allocator>& s,
   ios_base::openmode which = ios_base::out | ios_base::in);
 ```
 *Effects:* Initializes the base class with
+`basic_iostream<charT, traits>(addressof(`*`sb`*`))` [[iostream.cons]]
+and *sb* with `basic_stringbuf<charT, traits, Allocator>(s, which)`.
 ``` cpp
 basic_stringstream(ios_base::openmode which, const Allocator& a);
 ```
 *Effects:* Initializes the base class with
+`basic_iostream<charT, traits>(addressof(`*`sb`*`))` [[iostream.cons]]
+and *sb* with `basic_stringbuf<charT, traits, Allocator>(which, a)`
 [[stringbuf.cons]].
 ``` cpp
 explicit basic_stringstream(
   basic_string<charT, traits, Allocator>&& s,
   ios_base::openmode which = ios_base::out | ios_base::in);
 ```
 *Effects:* Initializes the base class with
+`basic_iostream<charT, traits>(addressof(`*`sb`*`))` [[iostream.cons]]
+and *sb* with
 `basic_stringbuf<charT, traits, Allocator>(std::move(s), which)`
 [[stringbuf.cons]].
 ``` cpp
 template<class SAlloc>
     const basic_string<charT, traits, SAlloc>& s,
     ios_base::openmode which, const Allocator& a);
 ```
 *Effects:* Initializes the base class with
+`basic_iostream<charT, traits>(addressof(`*`sb`*`))` [[iostream.cons]]
+and *sb* with `basic_stringbuf<charT, traits, Allocator>(s, which, a)`
 [[stringbuf.cons]].
 ``` cpp
 template<class SAlloc>
   explicit basic_stringstream(
 ```
 *Constraints:* `is_same_v<SAlloc, Allocator>` is `false`.
 *Effects:* Initializes the base class with
+`basic_iostream<charT, traits>(addressof(`*`sb`*`))` [[iostream.cons]]
+and *sb* with `basic_stringbuf<charT, traits, Allocator>(s, which)`
 [[stringbuf.cons]].
+``` cpp
+template<class T>
+  explicit basic_stringstream(const T& t, ios_base::openmode which = ios_base::out | ios_base::in);
+template<class T>
+  basic_stringstream(const T& t, const Allocator& a);
+template<class T>
+  basic_stringstream(const T& t, ios_base::openmode which, const Allocator& a);
+```
+Let `which` be `ios_base::out | ios_base::in` for the overload with no
+parameter `which`, and `a` be `Allocator()` for the overload with no
+parameter `a`.
+*Constraints:*
+`is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+`true`.
+*Effects:* Initializes the base class with `addressof(`*`sb`*`)`, and
+direct-non-list-initializes *sb* with `t, which, a`.
 ``` cpp
 basic_stringstream(basic_stringstream&& rhs);
 ```
 *Effects:* Move constructs from the rvalue `rhs`. This is accomplished
 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);
 template<class charT, class traits, class Allocator>
   void swap(basic_stringstream<charT, traits, Allocator>& x,
             basic_stringstream<charT, traits, Allocator>& y);
 ```
+*Effects:* Equivalent to `x.swap(y)`.
 #### Member functions <a id="stringstream.members">[[stringstream.members]]</a>
 ``` cpp
 basic_stringbuf<charT, traits, Allocator>* rdbuf() const;
 ```
 *Returns:*
+`const_cast<basic_stringbuf<charT, traits, Allocator>*>(addressof(`*`sb`*`))`.
 ``` cpp
 basic_string<charT, traits, Allocator> str() const &;
 ```
 void str(basic_string<charT, traits, Allocator>&& s);
 ```
 *Effects:* Equivalent to: `rdbuf()->str(std::move(s));`
+``` cpp
+template<class T>
+  void str(const T& t);
+```
+*Constraints:*
+`is_convertible_v<const T&, basic_string_view<charT, traits>>` is
+`true`.
+*Effects:* Equivalent to: `rdbuf()->str(t);`
 ## 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 [[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 {
+  // [spanbuf], class template basic_spanbuf
   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>;
+  // [ispanstream], class template basic_ispanstream
   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>;
+  // [ospanstream], class template basic_ospanstream
   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>;
+  // [spanstream], class template basic_spanstream
   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);
   template<class charT, class traits = char_traits<charT>>
   class basic_spanbuf
     : public basic_streambuf<charT, traits> {
   public:
     using char_type   = charT;
+    using int_type    = traits::int_type;
+    using pos_type    = traits::pos_type;
+    using off_type    = 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)
 - `(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
   template<class charT, class traits = char_traits<charT>>
   class basic_ispanstream
     : public basic_istream<charT, traits> {
   public:
     using char_type   = charT;
+    using int_type    = traits::int_type;
+    using pos_type    = traits::pos_type;
+    using off_type    = traits::off_type;
     using traits_type = traits;
     // [ispanstream.cons], constructors
     explicit basic_ispanstream(std::span<charT> s,
                                ios_base::openmode which = ios_base::in);
 ``` 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()))
 ```
 *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>
   template<class charT, class traits = char_traits<charT>>
   class basic_ospanstream
     : public basic_ostream<charT, traits> {
   public:
     using char_type   = charT;
+    using int_type    = traits::int_type;
+    using pos_type    = traits::pos_type;
+    using off_type    = traits::off_type;
     using traits_type = traits;
     // [ospanstream.cons], constructors
     explicit basic_ospanstream(std::span<charT> s,
                                ios_base::openmode which = ios_base::out);
 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);
   template<class charT, class traits = char_traits<charT>>
   class basic_spanstream
     : public basic_iostream<charT, traits> {
   public:
     using char_type   = charT;
+    using int_type    = traits::int_type;
+    using pos_type    = traits::pos_type;
+    using off_type    = 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);
 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);
 ### Header `<fstream>` synopsis <a id="fstream.syn">[[fstream.syn]]</a>
 ``` cpp
 namespace std {
+  // [filebuf], class template basic_filebuf
   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>;
+  // [ifstream], class template basic_ifstream
   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>;
+  // [ofstream], class template basic_ofstream
   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>;
+  // [fstream], class template basic_fstream
   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);
 `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*]
+### Native handles <a id="file.native">[[file.native]]</a>
+Several classes described in [[file.streams]] have a member
+`native_handle_type`.
+The type `native_handle_type` represents a platform-specific
+*native handle* to a file. It is trivially copyable and models
+`semiregular`.
+[*Note 1*: For operating systems based on POSIX, `native_handle_type`
+is `int`. For Windows-based operating systems, `native_handle_type` is
+`HANDLE`. — *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:
     using char_type   = charT;
+    using int_type    = traits::int_type;
+    using pos_type    = traits::pos_type;
+    using off_type    = traits::off_type;
     using traits_type = traits;
+    using native_handle_type = implementation-defined  // type of native_handle_type;   // see [file.native]
     // [filebuf.cons], constructors/destructor
     basic_filebuf();
     basic_filebuf(const basic_filebuf&) = delete;
     basic_filebuf(basic_filebuf&& rhs);
     // [filebuf.members], members
     bool is_open() const;
     basic_filebuf* open(const char* s, ios_base::openmode mode);
     basic_filebuf* open(const filesystem::path::value_type* s,
                         ios_base::openmode mode);   // wide systems only; see [fstream.syn]
+    basic_filebuf* open(const string& s, ios_base::openmode mode);
+    basic_filebuf* open(const filesystem::path& s, ios_base::openmode mode);
     basic_filebuf* close();
+    native_handle_type native_handle() const noexcept;
   protected:
     // [filebuf.virtuals], overridden virtual functions
     streamsize showmanyc() override;
     int_type underflow() override;
     int_type uflow() override;
     int_type pbackfail(int_type c = traits::eof()) override;
     int_type overflow (int_type c = traits::eof()) override;
+    basic_streambuf<charT, traits>* setbuf(char_type* s, streamsize n) 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;
     int sync() override;
     void imbue(const locale& loc) override;
   };
 }
 ```
 An instance of `basic_filebuf` behaves as described in  [[filebuf]]
 provided `traits::pos_type` is `fpos<traits::{}state_type>`. Otherwise
 the behavior is undefined.
+The file associated with a `basic_filebuf` has an associated value of
+type `native_handle_type`, called the native handle [[file.native]] of
+that file. This native handle can be obtained by calling the member
+function `native_handle`.
+For any opened `basic_filebuf f`, the native handle returned by
+`f.native_handle()` is invalidated when `f.close()` is called, or `f` is
+destroyed.
 In order to support file I/O and multibyte/wide character conversion,
 conversions are performed using members of a facet, referred to as
 `a_codecvt` in following subclauses, obtained as if by
 ``` cpp
 ``` 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>
 ``` cpp
 bool is_open() const;
 basic_filebuf* open(const char* s, ios_base::openmode mode);
 basic_filebuf* open(const filesystem::path::value_type* s,
                     ios_base::openmode mode);  // wide systems only; see [fstream.syn]
 ```
+*Preconditions:* `s` points to an NTCTS [[defns.ntcts]].
 *Effects:* If `is_open() != false`, returns a null pointer. Otherwise,
 initializes the `filebuf` as required. It then opens the file to which
 `s` resolves, if possible, as if by a call to `fopen` with the second
 argument determined from `mode & ~ios_base::ate` as indicated in
 *Ensures:* `is_open() == false`.
 *Returns:* `this` on success, a null pointer otherwise.
+``` cpp
+native_handle_type native_handle() const noexcept;
+```
+*Preconditions:* `is_open()` is `true`.
+*Returns:* The native handle associated with `*this`.
 #### Overridden virtual functions <a id="filebuf.virtuals">[[filebuf.virtuals]]</a>
 ``` cpp
 streamsize showmanyc() override;
 ```
 reading from the associated file into an internal buffer (`extern_buf`)
 and then as if by doing:
 ``` cpp
 char         extern_buf[XSIZE];
+const char*  extern_end;
 charT        intern_buf[ISIZE];
 charT*       intern_end;
 codecvt_base::result r =
   a_codecvt.in(state, extern_buf, extern_buf+XSIZE, extern_end,
                intern_buf, intern_buf+ISIZE, intern_end);
 of “consuming characters” is performed by first converting as if by:
 ``` cpp
 charT*       b = pbase();
 charT*       p = pptr();
+const charT* end;
 char         xbuf[XSIZE];
 char*        xbuf_end;
 codecvt_base::result r =
   a_codecvt.out(state, b, p, end, xbuf, xbuf+XSIZE, xbuf_end);
 ```
   to `p`. If output fails, fail (without repeating).
 - Otherwise output from `xbuf` to `xbuf_end`, and fail if output fails.
   At this point if `b != p` and `b == end` (`xbuf` isn’t large enough)
   then increase `XSIZE` and repeat from the beginning.
+Then establishes an observable checkpoint [[intro.abstract]].
 *Returns:* `traits::not_eof(c)` to indicate success, and `traits::eof()`
 to indicate failure. If `is_open() == false`, the function always fails.
 ``` cpp
 basic_streambuf* setbuf(char_type* s, streamsize n) override;
 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` is 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
 for the argument `whence`, of type `int`, as indicated in
 [[filebuf.seekoff]].
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_ifstream : public basic_istream<charT, traits> {
   public:
     using char_type   = charT;
+    using int_type    = traits::int_type;
+    using pos_type    = traits::pos_type;
+    using off_type    = traits::off_type;
     using traits_type = traits;
+    using native_handle_type = basic_filebuf<charT, traits>::native_handle_type;
     // [ifstream.cons], constructors
     basic_ifstream();
     explicit basic_ifstream(const char* s,
                             ios_base::openmode mode = ios_base::in);
     // [ifstream.swap], swap
     void swap(basic_ifstream& rhs);
     // [ifstream.members], members
     basic_filebuf<charT, traits>* rdbuf() const;
+    native_handle_type native_handle() const noexcept;
     bool is_open() const;
     void open(const char* s, ios_base::openmode mode = ios_base::in);
     void open(const filesystem::path::value_type* s,
               ios_base::openmode mode = ios_base::in);  // wide systems only; see [fstream.syn]
 The class `basic_ifstream<charT, traits>` supports reading from named
 files. It uses a `basic_filebuf<{}charT, traits>` object to control the
 associated sequence. For the sake of exposition, the maintained data is
 presented here as:
+- *`sb`*, the `filebuf` object.
 #### Constructors <a id="ifstream.cons">[[ifstream.cons]]</a>
 ``` cpp
 basic_ifstream();
 ```
 *Effects:* Initializes the base class with
+`basic_istream<charT, traits>(addressof(`*`sb`*`))` [[istream.cons]] and
+*sb* with `basic_filebuf<charT, traits>()` [[filebuf.cons]].
 ``` cpp
 explicit basic_ifstream(const char* s,
                         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]
 ```
 *Effects:* Initializes the base class with
+`basic_istream<charT, traits>(addressof(`*`sb`*`))` [[istream.cons]] and
+*sb* with `basic_filebuf<charT, traits>()` [[filebuf.cons]], then calls
 `rdbuf()->open(s, mode | ios_base::in)`. If that function returns a null
 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>
 ``` cpp
 basic_filebuf<charT, traits>* rdbuf() const;
 ```
+*Returns:*
+`const_cast<basic_filebuf<charT, traits>*>(addressof(`*`sb`*`))`.
+``` cpp
+native_handle_type native_handle() const noexcept;
+```
+*Effects:* Equivalent to: `return rdbuf()->native_handle();`
 ``` cpp
 bool is_open() const;
 ```
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_ofstream : public basic_ostream<charT, traits> {
   public:
     using char_type   = charT;
+    using int_type    = traits::int_type;
+    using pos_type    = traits::pos_type;
+    using off_type    = traits::off_type;
     using traits_type = traits;
+    using native_handle_type = basic_filebuf<charT, traits>::native_handle_type;
     // [ofstream.cons], constructors
     basic_ofstream();
     explicit basic_ofstream(const char* s,
                             ios_base::openmode mode = ios_base::out);
     // [ofstream.swap], swap
     void swap(basic_ofstream& rhs);
     // [ofstream.members], members
     basic_filebuf<charT, traits>* rdbuf() const;
+    native_handle_type native_handle() const noexcept;
     bool is_open() const;
     void open(const char* s, ios_base::openmode mode = ios_base::out);
     void open(const filesystem::path::value_type* s,
               ios_base::openmode mode = ios_base::out);     // wide systems only; see [fstream.syn]
 The class `basic_ofstream<charT, traits>` supports writing to named
 files. It uses a `basic_filebuf<{}charT, traits>` object to control the
 associated sequence. For the sake of exposition, the maintained data is
 presented here as:
+- *`sb`*, the `filebuf` object.
 #### Constructors <a id="ofstream.cons">[[ofstream.cons]]</a>
 ``` cpp
 basic_ofstream();
 ```
 *Effects:* Initializes the base class with
+`basic_ostream<charT, traits>(addressof(`*`sb`*`))` [[ostream.cons]] and
+*sb* with `basic_filebuf<charT, traits>()` [[filebuf.cons]].
 ``` cpp
 explicit basic_ofstream(const char* s,
                         ios_base::openmode mode = ios_base::out);
 explicit basic_ofstream(const filesystem::path::value_type* s,
                         ios_base::openmode mode = ios_base::out); // wide systems only; see [fstream.syn]
 ```
 *Effects:* Initializes the base class with
+`basic_ostream<charT, traits>(addressof(`*`sb`*`))` [[ostream.cons]] and
+*sb* with `basic_filebuf<charT, traits>()` [[filebuf.cons]], then calls
 `rdbuf()->open(s, mode | ios_base::out)`. If that function returns a
 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>
 ``` cpp
 basic_filebuf<charT, traits>* rdbuf() const;
 ```
+*Returns:*
+`const_cast<basic_filebuf<charT, traits>*>(addressof(`*`sb`*`))`.
+``` cpp
+native_handle_type native_handle() const noexcept;
+```
+*Effects:* Equivalent to: `return rdbuf()->native_handle();`
 ``` cpp
 bool is_open() const;
 ```
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_fstream : public basic_iostream<charT, traits> {
   public:
     using char_type   = charT;
+    using int_type    = traits::int_type;
+    using pos_type    = traits::pos_type;
+    using off_type    = traits::off_type;
     using traits_type = traits;
+    using native_handle_type = basic_filebuf<charT, traits>::native_handle_type;
     // [fstream.cons], constructors
     basic_fstream();
     explicit basic_fstream(
       const char* s,
     // [fstream.swap], swap
     void swap(basic_fstream& rhs);
     // [fstream.members], members
     basic_filebuf<charT, traits>* rdbuf() const;
+    native_handle_type native_handle() const noexcept;
     bool is_open() const;
     void open(
       const char* s,
       ios_base::openmode mode = ios_base::in | ios_base::out);
     void open(
 The class template `basic_fstream<charT, traits>` supports reading and
 writing from named files. It uses a `basic_filebuf<charT, traits>`
 object to control the associated sequences. For the sake of exposition,
 the maintained data is presented here as:
+- *`sb`*, the `basic_filebuf` object.
 #### Constructors <a id="fstream.cons">[[fstream.cons]]</a>
 ``` cpp
 basic_fstream();
 ```
 *Effects:* Initializes the base class with
+`basic_iostream<charT, traits>(addressof(`*`sb`*`))` [[iostream.cons]]
+and *sb* with `basic_filebuf<charT, traits>()`.
 ``` cpp
 explicit basic_fstream(
   const char* s,
   ios_base::openmode mode = ios_base::in | ios_base::out);
   const filesystem::path::value_type* s,
   ios_base::openmode mode = ios_base::in | ios_base::out);  // wide systems only; see [fstream.syn]
 ```
 *Effects:* Initializes the base class with
+`basic_iostream<charT, traits>(addressof(`*`sb`*`))` [[iostream.cons]]
+and *sb* with `basic_filebuf<charT, traits>()`. Then calls
 `rdbuf()->open(s, mode)`. If that function returns a null pointer, calls
 `setstate(failbit)`.
 ``` 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);
 ```
 *Effects:* Exchanges the state of `*this` and `rhs` by calling
+`basic_iostream<charT,traits>::swap(rhs)` and
+*`sb`*`.swap(rhs.`*`sb`*`)`.
 ``` cpp
 template<class charT, class traits>
   void swap(basic_fstream<charT, traits>& x,
             basic_fstream<charT, traits>& y);
 ```
+*Effects:* Equivalent to `x.swap(y)`.
 #### Member functions <a id="fstream.members">[[fstream.members]]</a>
 ``` cpp
 basic_filebuf<charT, traits>* rdbuf() const;
 ```
+*Returns:*
+`const_cast<basic_filebuf<charT, traits>*>(addressof(`*`sb`*`))`.
+``` cpp
+native_handle_type native_handle() const noexcept;
+```
+*Effects:* Equivalent to: `return rdbuf()->native_handle();`
 ``` cpp
 bool is_open() const;
 ```
 ``` cpp
 #include <ostream>  // see [ostream.syn]
 namespace std {
+  // [syncstream.syncbuf], class template basic_syncbuf
   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>
               basic_syncbuf<charT, traits, Allocator>&);
   using syncbuf = basic_syncbuf<char>;
   using wsyncbuf = basic_syncbuf<wchar_t>;
+  // [syncstream.osyncstream], class template basic_osyncstream
   template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
     class basic_osyncstream;
   using osyncstream = basic_osyncstream<char>;
   using wosyncstream = basic_osyncstream<wchar_t>;
 namespace std {
   template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
   class basic_syncbuf : public basic_streambuf<charT, traits> {
   public:
     using char_type      = charT;
+    using int_type       = traits::int_type;
+    using pos_type       = traits::pos_type;
+    using off_type       = traits::off_type;
     using traits_type    = traits;
     using allocator_type = Allocator;
     using streambuf_type = basic_streambuf<charT, traits>;
     // [syncstream.syncbuf.virtuals], overridden virtual functions
     int sync() override;
   private:
     streambuf_type* wrapped;    // exposition only
+    bool emit-on-sync{};        // exposition only
   };
 }
 ```
 Class template `basic_syncbuf` stores character data written to it,
 ``` cpp
 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
 ``` cpp
 bool emit();
 ```
 *Effects:* Atomically transfers the associated output of `*this` to the
+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()`
 *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;
 ```
+*Returns:* *wrapped*.
 ``` cpp
 allocator_type get_allocator() const noexcept;
 ```
 ``` cpp
 void set_emit_on_sync(bool b) noexcept;
 ```
+*Effects:* *`emit-on-sync`*` = b`.
 #### Overridden virtual functions <a id="syncstream.syncbuf.virtuals">[[syncstream.syncbuf.virtuals]]</a>
 ``` cpp
 int sync() override;
 ```
 *Effects:* Records that the wrapped stream buffer is to be flushed.
+Then, if *emit-on-sync* is `true`, calls `emit()`.
+[*Note 1*: If *emit-on-sync* is `false`, the actual flush is delayed
 until a call to `emit()`. — *end note*]
 *Returns:* If `emit()` was called and returned `false`, returns `-1`;
 otherwise `0`.
 namespace std {
   template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
   class basic_osyncstream : public basic_ostream<charT, traits> {
   public:
     using char_type   = charT;
+    using int_type    = traits::int_type;
+    using pos_type    = traits::pos_type;
+    using off_type    = traits::off_type;
     using traits_type = traits;
     using allocator_type = Allocator;
     using streambuf_type = basic_streambuf<charT, traits>;
     using syncbuf_type   = basic_syncbuf<charT, traits, Allocator>;
 ``` cpp
 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 can be
 called from `emit()` while a lock is held, which might result in a
 deadlock if used incautiously. — *end note*]
 ``` 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`.
 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:
 ``` cpp
 streambuf_type* get_wrapped() const noexcept;
 ```
+*Returns:* *`sb`*`.get_wrapped()`.
 [*Example 3*:
 Obtaining the wrapped stream buffer with `get_wrapped()` allows wrapping
 it again with an `osyncstream`. For example,
   path weakly_canonical(const path& p);
   path weakly_canonical(const path& p, error_code& ec);
 }
+namespace std {
+  // [fs.path.fmtr], formatting support
+  template<class charT> struct formatter<filesystem::path, charT>;
   // [fs.path.hash], hash support
   template<class T> struct hash;
   template<> struct hash<filesystem::path>;
 }
 namespace std::ranges {
   template<>
+    inline constexpr bool \libspec{enable_borrowed_range}{directory_iterator}<filesystem::directory_iterator> = true;
   template<>
+    inline constexpr bool \libspec{enable_borrowed_range}{recursive_directory_iterator}<filesystem::recursive_directory_iterator> = true;
   template<>
+    inline constexpr bool \libspec{enable_view}{directory_iterator}<filesystem::directory_iterator> = true;
   template<>
+    inline constexpr bool \libspec{enable_view}{recursive_directory_iterator}<filesystem::recursive_directory_iterator> = true;
 }
 ```
 Implementations should ensure that the resolution and range of
 `file_time_type` reflect the operating system dependent resolution and
 *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*: For POSIX-based operating systems, this mechanism is
+specified in POSIX, section 4.12, Pathname resolution. — *end example*]
 ``` cpp
 namespace std::filesystem {
   class path {
   public:
     template<class EcharT, class traits = char_traits<EcharT>,
              class Allocator = allocator<EcharT>>
       basic_string<EcharT, traits, Allocator>
         string(const Allocator& a = Allocator()) const;
+    std::string    display_string() const;
+    std::string    system_encoded_string() const;
     std::wstring   wstring() const;
     std::u8string  u8string() const;
     std::u16string u16string() const;
     std::u32string u32string() const;
     // [fs.path.generic.obs], generic format observers
     template<class EcharT, class traits = char_traits<EcharT>,
              class Allocator = allocator<EcharT>>
       basic_string<EcharT, traits, Allocator>
         generic_string(const Allocator& a = Allocator()) const;
+    std::string    generic_display_string() const;
+    std::string    generic_system_encoded_string() const;
     std::wstring   generic_wstring() const;
     std::u8string  generic_u8string() const;
     std::u16string generic_u16string() const;
     std::u32string generic_u32string() const;
     path filename() const;
     path stem() const;
     path extension() const;
     // [fs.path.query], query
+    bool empty() const noexcept;
     bool has_root_name() const;
     bool has_root_directory() const;
     bool has_root_path() const;
     bool has_relative_path() const;
     bool has_parent_path() const;
 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. It is possible that an implementation for an operating
+system where disambiguation is needed distinguishes between the
 formats. — *end note*]
 Pathnames are converted as needed between the generic and native formats
 in an operating-system-dependent manner. Let *G(n)* and *N(g)* in a
 mathematical sense be the implementation’s functions that convert
   \[`source.begin()`, `source.end()`).
 - `basic_string_view<EcharT, traits>`. A function argument
   `const Source&` `source` shall have an effective range
   \[`source.begin()`, `source.end()`).
 - A type meeting the *Cpp17InputIterator* requirements that iterates
+  over an NTCTS. The value type shall be an encoded character type. A
   function argument `const Source&` `source` shall have an effective
   range \[`source`, `end`) where `end` is the first iterator value with
   an element value equal to `iterator_traits<Source>::value_type()`.
 - A character array that after array-to-pointer decay results in a
+  pointer to the start of an NTCTS. The value type shall be an encoded
   character type. A function argument `const Source&` `source` shall
   have an effective range \[`source`, `end`) where `end` is the first
   iterator value with an element value equal to
   `iterator_traits<decay_t<Source>>::value_type()`.
 ``` cpp
 path() noexcept;
 ```
+*Ensures:* `empty()` is `true`.
 ``` cpp
 path(const path& p);
 path(path&& p) noexcept;
 ```
 ``` cpp
 void clear() noexcept;
 ```
+*Ensures:* `empty()` is `true`.
 ``` cpp
 path& make_preferred();
 ```
 ```
 *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;
 ```
 *Returns:* `native()`.
 *Remarks:* All memory allocation, including for the return value, shall
 be performed by `a`. Conversion, if any, is specified by
 [[fs.path.cvt]].
 ``` cpp
+std::string system_encoded_string() const;
 std::wstring wstring() const;
 std::u8string u8string() const;
 std::u16string u16string() const;
 std::u32string u32string() const;
 ```
 *Returns:* `native()`.
 *Remarks:* Conversion, if any, is performed as specified by
 [[fs.path.cvt]].
+``` cpp
+std::string display_string() const;
+```
+*Returns:* `std::format("{}", *this)`.
+[*Note 3*: The returned string is suitable for use with
+formatting [[format.functions]] and print
+functions [[print.fun]]. — *end note*]
 ##### Generic format observers <a id="fs.path.generic.obs">[[fs.path.generic.obs]]</a>
 Generic format observer functions return strings formatted according to
 the generic pathname format [[fs.path.generic]]. A single slash (`'/'`)
 character is used as the *directory-separator*.
 returns `"foo/bar"`.
 — *end example*]
 ``` cpp
+template<class EcharT, class traits = char_traits<EcharT>, class Allocator = allocator<EcharT>>
+  basic_string<EcharT, traits, Allocator> generic_string(const Allocator& a = Allocator()) const;
 ```
 *Returns:* The pathname in the generic format.
 *Remarks:* All memory allocation, including for the return value, shall
 be performed by `a`. Conversion, if any, is specified by
 [[fs.path.cvt]].
 ``` cpp
+std::string generic_system_encoded_string() const;
 std::wstring generic_wstring() const;
 std::u8string generic_u8string() const;
 std::u16string generic_u16string() const;
 std::u32string generic_u32string() const;
 ```
 *Returns:* The pathname in the generic format.
 *Remarks:* Conversion, if any, is specified by  [[fs.path.cvt]].
+``` cpp
+std::string generic_display_string() const;
+```
+*Returns:* `std::format("{:g}", *this)`.
+[*Note 4*: The returned string is suitable for use with
+formatting [[format.functions]] and print
+functions [[print.fun]]. — *end note*]
 ##### Compare <a id="fs.path.compare">[[fs.path.compare]]</a>
 ``` cpp
 int compare(const path& p) const noexcept;
 ```
 path("..bar").extension();              // yields ".bar" and stem() is "."
 ```
 — *end example*]
+[*Note 5*: 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 6*: 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
+bool empty() const noexcept;
 ```
 *Returns:* `true` if the pathname in the generic format is empty,
 otherwise `false`.
 - any *filename* in `relative_path()` or `base.relative_path()` can be
   interpreted as a *root-name*,
 returns `path()`.
+[*Note 7*: 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
 *directory-separator* characters will be backslashes rather than
 slashes, but that does not affect `path` equality.
 — *end example*]
+[*Note 8*: If symlink following semantics are desired, use the
 operational function `relative()`. — *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*]
 ``` 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 10*: If symlink following semantics are desired, use the
 operational function `proximate()`. — *end note*]
+[*Note 11*: 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>
 For the elements of the pathname in the generic format, the forward
 traversal order is as follows:
 - The *root-name* element, if present.
+- The *root-directory* element, if present. \[*Note 1*: It is possible
+ that the use of the generic format is needed to ensure correct
+ lexicographical comparison. — *end note*]
 - Each successive *filename* element, if present.
 - An empty element, if a trailing non-root *directory-separator* is
   present.
 The backward traversal order is the reverse of forward traversal.
 friend path operator/(const path& lhs, const path& rhs);
 ```
 *Effects:* Equivalent to: `return path(lhs) /= rhs;`
+#### Formatting support <a id="fs.path.fmtr">[[fs.path.fmtr]]</a>
+##### Formatting support overview <a id="fs.path.fmtr.general">[[fs.path.fmtr.general]]</a>
+``` cpp
+namespace std {
+  template<class charT> struct formatter<filesystem::path, charT> {
+    constexpr void set_debug_format();
+    constexpr typename basic_format_parse_context<charT>::iterator
+      parse(basic_format_parse_context<charT>& ctx);
+    template<class FormatContext>
+      typename FormatContext::iterator
+        format(const filesystem::path& path, FormatContext& ctx) const;
+  };
+}
+```
+##### Formatting support functions <a id="fs.path.fmtr.funcs">[[fs.path.fmtr.funcs]]</a>
+Formatting of paths uses formatting specifiers of the form
+``` bnf
+path-format-spec:
+    fill-and-alignₒₚₜ widthₒₚₜ '?'ₒₚₜ 'g'ₒₚₜ
+```
+where the productions *fill-and-align* and *width* are described in
+[[format.string]]. If the `?` option is used then the path is formatted
+as an escaped string [[format.string.escaped]].
+``` cpp
+constexpr void set_debug_format();
+```
+*Effects:* Modifies the state of the `formatter` to be as if the
+*path-format-spec* parsed by the last call to `parse` contained the `?`
+option.
+``` cpp
+constexpr typename basic_format_parse_context<charT>::iterator
+  parse(basic_format_parse_context<charT>& ctx);
+```
+*Effects:* Parses the format specifier as a *path-format-spec* and
+stores the parsed specifiers in `*this`.
+*Returns:* An iterator past the end of the *path-format-spec*.
+``` cpp
+template<class FormatContext>
+  typename FormatContext::iterator
+    format(const filesystem::path& p, FormatContext& ctx) const;
+```
+*Effects:* Let `s` be `p.generic_string<filesystem::path::value_type>()`
+if the `g` option is used, otherwise `p.native()`. Writes `s` into
+`ctx.out()`, adjusted according to the *path-format-spec*. If `charT` is
+`char`, `path::value_type` is `wchar_t`, and the literal encoding is
+UTF-8, then the escaped path is transcoded from the native encoding for
+wide character strings to UTF-8 with maximal subparts of ill-formed
+subsequences substituted with ‘U+fffd‘ replacement character per the
+Unicode Standard, Chapter 3.9 ‘U+fffd‘ Substitution in Conversion. If
+`charT` and `path::value_type` are the same then no transcoding is
+performed. Otherwise, transcoding is *implementation-defined*.
+*Returns:* An iterator past the end of the output range.
 #### Hash support <a id="fs.path.hash">[[fs.path.hash]]</a>
 ``` cpp
 template<> struct hash<filesystem::path>;
 ```
 filesystem_error(const string& what_arg, error_code ec);
 ```
 *Ensures:*
+- `code() == ec` is `true`,
+- `path1().empty()` is `true`,
+- `path2().empty()` is `true`, and
+- `string_view(what()).find(what_arg.c_str())` `!= string_view::npos` is
+  `true`.
 ``` cpp
 filesystem_error(const string& what_arg, const path& p1, error_code ec);
 ```
 *Ensures:*
+- `code() == ec` is `true`,
 - `path1()` returns a reference to the stored copy of `p1`,
+- `path2().empty()` is `true`, and
+- `string_view(what()).find(what_arg.c_str())` `!= string_view::npos` is
+  `true`.
 ``` cpp
 filesystem_error(const string& what_arg, const path& p1, const path& p2, error_code ec);
 ```
 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                                                                                                                                                                                                          |
 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}                   |
 meanings listed in [[fs.enum.perms]].
 **Table: Enum class `perms`** <a id="fs.enum.perms">[fs.enum.perms]</a>
 | Name                              | Value (octal) | POSIX macro | Definition or notes                                                                                              |
+| --------------------------------- | ------------- | ----------- | ---------------------------------------------------------------------------------------------------------------- |
 | `none`         | `0`           |             | There are no permissions set for the file.                                                                       |
 | `owner_read`   | `0400`        | `S_IRUSR`   | Read permission, owner                                                                                           |
 | `owner_write`  | `0200`        | `S_IWUSR`   | Write permission, owner                                                                                          |
 | `owner_exec`   | `0100`        | `S_IXUSR`   | Execute/search permission, owner                                                                                 |
 | `owner_all`    | `0700`        | `S_IRWXU`   | Read, write, execute/search by owner;<br> `owner_read | owner_write | owner_exec`                                |
 `permissions`.
 **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.                      |
 every other constant in the table represents a distinct bitmask element.
 **Table: Enum class `directory_options`** <a id="fs.enum.dir.opts">[fs.enum.dir.opts]</a>
 | Name                                                      | Meaning                                                            |
+| --------------------------------------------------------- | ------------------------------------------------------------------ |
 | `none`                     | (Default) Skip directory symlinks, permission denied is an error.  |
 | `follow_directory_symlink` | Follow rather than skip directory symlinks.                        |
 | `skip_permission_denied`   | Skip directories that would otherwise result in permission denied. |
     template<class charT, class traits>
       friend basic_ostream<charT, traits>&
         operator<<(basic_ostream<charT, traits>& os, const directory_entry& d);
   private:
+    filesystem::path path-object;        // exposition only
   };
 }
 ```
 A `directory_entry` object stores a `path` object and may store
 directory iteration if their values are available and storing the values
 would allow the implementation to eliminate file system accesses by
 `directory_entry` observer functions [[fs.op.funcs]]. Such stored file
 attribute values are said to be *cached*.
+[*Note 1*: `directory_iterator` can cache already available attribute
+values directly into a `directory_entry` object without the cost of a
+call to `refresh()`. — *end note*]
 [*Example 1*:
 ``` cpp
 using namespace std::filesystem;
 ``` cpp
 void assign(const filesystem::path& p);
 void assign(const filesystem::path& p, error_code& ec);
 ```
+*Effects:* Equivalent to *`path-object`*` = p`, then `refresh()` or
 `refresh(ec)`, respectively. If an error occurs, the values of any
 cached attributes are unspecified.
 *Throws:* As specified in  [[fs.err.report]].
 ``` cpp
 void replace_filename(const filesystem::path& p);
 void replace_filename(const filesystem::path& p, error_code& ec);
 ```
+*Effects:* Equivalent to *`path-object`*`.replace_filename(p)`, then
 `refresh()` or `refresh(ec)`, respectively. If an error occurs, the
 values of any cached attributes are unspecified.
 *Throws:* As specified in  [[fs.err.report]].
 ``` cpp
 const filesystem::path& path() const noexcept;
 operator const filesystem::path&() const noexcept;
 ```
+*Returns:* *path-object*.
 ``` cpp
 bool exists() const;
 bool exists(error_code& ec) const noexcept;
 ```
 ``` cpp
 bool operator==(const directory_entry& rhs) const noexcept;
 ```
+*Returns:* *`path-object`*` == rhs.`*`path-object`*.
 ``` cpp
 strong_ordering operator<=>(const directory_entry& rhs) const noexcept;
 ```
+*Returns:* *`path-object`*` <=> rhs.`*`path-object`*.
 #### Inserter <a id="fs.dir.entry.io">[[fs.dir.entry.io]]</a>
 ``` cpp
 template<class charT, class traits>
 `directory_entry` element returned by `operator*()`.
 `directory_iterator` member functions shall not directly or indirectly
 call any `directory_entry` `refresh` function.
 [*Note 2*: The exact mechanism for storing cached attribute values is
+not exposed to users. — *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
 void disable_recursion_pending();
 ```
 *Ensures:* `recursion_pending() == false`.
+[*Note 4*: `disable_recursion_pending()` is used to prevent unwanted
 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
 Effects are then as follows:
 - If `f.type()` or `t.type()` is an implementation-defined file
   type [[fs.enum.file.type]], then the effects are
   *implementation-defined*.
+- Otherwise, an error is reported as specified in  [[fs.err.report]] if
   - `exists(f)` is `false`, or
   - `equivalent(from, to)` is `true`, or
   - `is_other(f) || is_other(t)` is `true`, or
   - `is_directory(f) && is_regular_file(t)` is `true`.
 - Otherwise, if `is_symlink(f)`, then:
 [*Example 1*:
 Given this directory structure:
+``` text
 /dir1
   file1
   file2
   dir2
     file3
 ```
 Calling `copy("/dir1", "/dir3")` would result in:
+``` text
 /dir1
   file1
   file2
   dir2
     file3
 ```
 Alternatively, calling `copy("/dir1", "/dir3", copy_options::recursive)`
 would result in:
+``` text
 /dir1
   file1
   file2
   dir2
     file3
 *Preconditions:* At most one element from each option
 group [[fs.enum.copy.opts]] is set in `options`.
 *Effects:* As follows:
+- Report an error as specified in  [[fs.err.report]] if
   - `is_regular_file(from)` is `false`, or
   - `exists(to)` is `true` and `is_regular_file(to)` is `false`, or
   - `exists(to)` is `true` and `equivalent(from, to)` is `true`, or
   - `exists(to)` is `true` and
     ``` cpp
     (options & (copy_options::skip_existing |
                 copy_options::overwrite_existing |
                 copy_options::update_existing)) == copy_options::none
     ```
 - Otherwise, copy the contents and attributes of the file `from`
+  resolves to, to the file `to` resolves to, if
   - `exists(to)` is `false`, or
   - `(options & copy_options::overwrite_existing) != copy_options::none`,
     or
   - `(options & copy_options::update_existing) `` `` != copy_options::none`
     and `from` is more recent than `to`, determined as if by use of the
 ``` 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.
 *Returns:* `true` if a new directory was created for the directory `p`
 resolves to, otherwise `false`.
 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`.
 *Ensures:* `new_symlink` resolves to a symbolic link file that contains
 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*]
 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`.
 *Ensures:*
 - `exists(to) && exists(new_hard_link) && equivalent(to, new_hard_link)`
 - The contents of the file or directory `to` resolves to are unchanged.
 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`.
 *Ensures:* `new_symlink` resolves to a symbolic link file that contains
 an unspecified representation of `to`.
 *Throws:* As specified in  [[fs.err.report]].
 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.
 *Throws:* As specified in  [[fs.err.report]].
 *Remarks:* The current working directory is the directory, associated
 with the process, that is used as the starting location in pathname
 resolution for relative paths.
+[*Note 1*: 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 2*: 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>
 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.
 *Returns:*
 - If `is_regular_file(p)`, the size in bytes of the file `p` resolves
   to, determined as if by the value of the POSIX `stat` class member
+  `st_size` obtained as if by POSIX `stat`.
 - Otherwise, the result is *implementation-defined*.
 The signature with argument `ec` returns `static_cast<uintmax_t>(-1)` if
 an error occurs.
 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,
                      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
 `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]].
 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`.
 [*Note 1*: A symbolic link is itself removed, rather than the file it
 resolves to. — *end note*]
 *Ensures:* `exists(symlink_status(p))` is `false`.
+*Returns:* `true` if a file `p` has been removed and `false` otherwise.
+[*Note 2*: Absence of a file `p` is not an error. — *end note*]
 *Throws:* As specified in  [[fs.err.report]].
 #### Remove all <a id="fs.op.remove.all">[[fs.op.remove.all]]</a>
 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`.
 [*Note 1*: A symbolic link is itself removed, rather than the file it
 resolves to. — *end note*]
 *Ensures:* `exists(symlink_status(p))` is `false`.
 ``` 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.
 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
 file_status filesystem::status(const path& p);
 ```
+*Effects:* As if by:
 ``` cpp
 error_code ec;
 file_status result = status(p, ec);
 if (result.type() == file_type::none)
 ``` 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
 system API reports an error, sets `ec` to indicate the specific error
 reported. Otherwise, `ec.clear()`.
 [*Note 2*: This allows users to inspect the specifics of underlying API
+errors even when the value returned by `status` is not
 `file_status(file_type::none)`. — *end note*]
 Let `prms` denote the result of `(m & perms::mask)`, where `m` is
 determined as if by converting the `st_mode` member of the obtained
 `struct stat` to the type `perms`.
 ``` 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`.
 Let `prms` denote the result of `(m & perms::mask)`, where `m` is
 determined as if by converting the `st_mode` member of the obtained
 `struct stat` to the type `perms`.
+*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]].
 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 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]].
 *Returns:* `p` with symlinks resolved and the result
 normalized [[fs.path.generic]].
 ## C library files <a id="c.files">[[c.files]]</a>
 ### Header `<cstdio>` synopsis <a id="cstdio.syn">[[cstdio.syn]]</a>
 ``` cpp
+#define __STDC_VERSION_STDIO_H__ 202311L
 namespace std {
   using size_t = see [support.types.layout];
   using FILE = see below;
   using fpos_t = see below;
 }
 #define _IONBF see below
 #define BUFSIZ see below
 #define EOF see below
 #define FOPEN_MAX see below
 #define FILENAME_MAX see below
+#define _PRINTF_NAN_LEN_MAX see below
 #define L_tmpnam see below
 #define SEEK_CUR see below
 #define SEEK_END see below
 #define SEEK_SET see below
 #define TMP_MAX see below
 ```
 The contents and meaning of the header `<cstdio>` are the same as the C
 standard library header `<stdio.h>`.
+The return from each function call that delivers data to the host
+environment to be written to a file (See also: ISO C 7.23.3) is an
+observable checkpoint [[intro.abstract]].
 Calls to the function `tmpnam` with an argument that is a null pointer
 value may introduce a data race [[res.on.data.races]] with other calls
 to `tmpnam` with an argument that is a null pointer value.
+See also: ISO C 7.23
 ### Header `<cinttypes>` synopsis <a id="cinttypes.syn">[[cinttypes.syn]]</a>
 ``` cpp
 #include <cstdint>  // see [cstdint.syn]
   constexpr intmax_t abs(intmax_t);             // optional, see below
   constexpr imaxdiv_t div(intmax_t, intmax_t);  // optional, see below
 }
+#define __STDC_VERSION_INTTYPES_H__ 202311L
 #define PRIdN see below
 #define PRIiN see below
 #define PRIoN see below
 #define PRIuN see below
 #define PRIxN see below
 #define PRIXN see below
+#define PRIbN see below
+#define PRIBN see below
 #define SCNdN see below
 #define SCNiN see below
 #define SCNoN see below
 #define SCNuN see below
 #define SCNxN see below
+#define SCNbN see below
 #define PRIdLEASTN see below
 #define PRIiLEASTN see below
 #define PRIoLEASTN see below
 #define PRIuLEASTN see below
 #define PRIxLEASTN see below
 #define PRIXLEASTN see below
+#define PRIbLEASTN see below
+#define PRIBLEASTN see below
 #define SCNdLEASTN see below
 #define SCNiLEASTN see below
 #define SCNoLEASTN see below
 #define SCNuLEASTN see below
 #define SCNxLEASTN see below
+#define SCNbLEASTN see below
 #define PRIdFASTN see below
 #define PRIiFASTN see below
 #define PRIoFASTN see below
 #define PRIuFASTN see below
 #define PRIxFASTN see below
 #define PRIXFASTN see below
+#define PRIbFASTN see below
+#define PRIBFASTN see below
 #define SCNdFASTN see below
 #define SCNiFASTN see below
 #define SCNoFASTN see below
 #define SCNuFASTN see below
 #define SCNxFASTN see below
+#define SCNbFASTN see below
 #define PRIdMAX see below
 #define PRIiMAX see below
 #define PRIoMAX see below
 #define PRIuMAX see below
 #define PRIxMAX see below
 #define PRIXMAX see below
+#define PRIbMAX see below
+#define PRIBMAX see below
 #define SCNdMAX see below
 #define SCNiMAX see below
 #define SCNoMAX see below
 #define SCNuMAX see below
 #define SCNxMAX see below
+#define SCNbMAX see below
 #define PRIdPTR see below
 #define PRIiPTR see below
 #define PRIoPTR see below
 #define PRIuPTR see below
 #define PRIxPTR see below
 #define PRIXPTR see below
+#define PRIbPTR see below
+#define PRIBPTR see below
 #define SCNdPTR see below
 #define SCNiPTR see below
 #define SCNoPTR see below
 #define SCNuPTR see below
 #define SCNxPTR see below
+#define SCNbPTR 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
 - 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);
 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. Each of the `PRIB` macros listed in this
+subclause is defined if and only if `fprintf` supports the `B`
+conversion specifier.
 <!-- Link reference definitions -->
 [adjustfield.manip]: #adjustfield.manip
 [allocator.requirements.general]: library.md#allocator.requirements.general
 [basefield.manip]: #basefield.manip
 [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.reqmts]: containers.md#container.reqmts
 [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.character.container]: intro.md#defns.character.container
 [defns.ntcts]: intro.md#defns.ntcts
 [enumerated.types]: library.md#enumerated.types
 [error.reporting]: #error.reporting
 [ext.manip]: #ext.manip
+[file.native]: #file.native
 [file.streams]: #file.streams
 [filebuf]: #filebuf
 [filebuf.assign]: #filebuf.assign
 [filebuf.cons]: #filebuf.cons
 [filebuf.general]: #filebuf.general
 [filebuf.virtuals]: #filebuf.virtuals
 [filesystems]: #filesystems
 [floatfield.manip]: #floatfield.manip
 [fmtflags.manip]: #fmtflags.manip
 [fmtflags.state]: #fmtflags.state
+[format.err.report]: text.md#format.err.report
+[format.functions]: text.md#format.functions
+[format.string]: text.md#format.string
+[format.string.escaped]: text.md#format.string.escaped
 [fpos]: #fpos
+[fpos.general]: #fpos.general
 [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.path.concat]: #fs.path.concat
 [fs.path.construct]: #fs.path.construct
 [fs.path.cvt]: #fs.path.cvt
 [fs.path.decompose]: #fs.path.decompose
 [fs.path.fmt.cvt]: #fs.path.fmt.cvt
+[fs.path.fmtr]: #fs.path.fmtr
+[fs.path.fmtr.funcs]: #fs.path.fmtr.funcs
+[fs.path.fmtr.general]: #fs.path.fmtr.general
 [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
 [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.abstract]: intro.md#intro.abstract
 [intro.multithread]: basic.md#intro.multithread
 [intro.races]: basic.md#intro.races
 [iomanip.syn]: #iomanip.syn
 [ios]: #ios
 [ios.base]: #ios.base
 [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]: text.md#locale.codecvt.virtuals
+[locale.num.get]: text.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
 [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 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.
     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.
     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 affects 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

Diff to HTML by rtfpessoa