<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN">
<html>
  <head>
    <meta content="text/html;charset=UTF-8" http-equiv="Content-Type">
    <title>Synopses for the C library</title>
    <style type="text/css">
      html { margin: 0; padding: 0; color: black; background-color: white; }
      body { padding: 2em; font-size: medium; font-family: "DejaVu Serif", serif; line-height: 150%; }
      code { font-family: "DejaVu Sans Mono", monospace; color: #006; }

      h1, h2, h3 { margin: 1.5em 0 .75em 0; line-height: 125%; }

      div.code { white-space: pre-line; font-family: "DejaVu Sans Mono", monospace;
                 border: thin solid #E0E0E0; background-color: #F8F8F8; padding: 1em;
                 border-radius: 4px; }

      div.strictpre { white-space: pre; }

      .docinfo { float: right }
      .docinfo p { margin: 0; text-align:right; }
      .docinfo address { font-style: normal; }

      .quote { display: inline-block; clear: both; margin-left: 1ex;
               border: thin solid #E0E0E0; background-color: #F8F8F8; padding: 1ex; }

      /*  Use DIV[insert] and DIV[delete] if the entire paragraph is added or removed; otherwise
       *  use DIV[modify] and use INS/DEL elements to mark up individual changes.
       */

      div.insert { border-left: thick solid #0A0; border-right: thick solid #0A0; padding: 0 1em; }
      div.modify { border-left: thick solid #999; border-right: thick solid #999; padding: 0 1em; }
      div.delete { border-left: thick solid #A00; border-right: thick solid #A00; padding: 0 1em; }

      del { color: #A00; text-decoration: line-through; }
      ins { color: #090; }
      ins code, del code { color: inherit; }
    </style>
  </head>
  <body>
    <div class="docinfo">
      <p>ISO/IEC JTC1 SC22 WG21 P00175r0</p>
      <p>Date: 2016-02-13</p>
      <p>To: LWG</p>
      <address>
        Thomas K&ouml;ppe &lt;<a href="mailto:tkoeppe@google.com">tkoeppe@google.com</a>&gt;<br>
        Richard Smith &lt;<a href="mailto:richard@metafoo.co.uk">richard@metafoo.co.uk</a>&gt;
      </address>
    </div>

    <h1>Synopses for the C library</h1>

    <h2>Revision history</h2>
    <ul>
      <li>13 Feb 2016: Initial proposal</li>
    </ul>

    <h2>Contents</h2>
    <!-- fgrep -e "<h2 id=" c-synopses.html | sed -e 's/.*id="\(.*\)">\(.*\)<\/h2>/<li><a href="#\1">\2<\/a><\/li>/g' -->
    <ol>
      <li><a href="#proposal">Proposal</a></li>
      <li><a href="#impact">Impact on the standard</a></li>
      <li><a href="#wording18">Proposed wording, Clause 18</a></li>
      <li><a href="#wording19">Proposed wording, Clause 19</a></li>
      <li><a href="#wording20">Proposed wording, Clause 20</a></li>
      <li><a href="#wording21">Proposed wording, Clause 21</a></li>
      <li><a href="#wording26">Proposed wording, Clause 26</a></li>
      <li><a href="#wording27">Proposed wording, Clause 27</a></li>
    </ol>

    <h2 id="proposal">Proposal</h2>

    <p>In this editorial paper we propose to add to the working draft the
      complete synopses of the C library headers that are included in C++
      by reference to the C standard (see Table 15). These synopses will
      replace the various tables captioned &ldquo;Header <code>&lt;cfoo&gt;</code>
      synopsis&rdquo;.</p>

    <p>The changes can roughly be summarized as follows.</p>

    <ul>
      <li>Each C header <code>&lt;cfoo&gt;</code> whose synopsis is being added gets its own
        subsection &ldquo;[cfoo.syn]&rdquo;. If necessary (usually that means that the synopsis
        says &ldquo;see below&rdquo;), the subsection starts with a new
        paragraph saying that the meaning of the contents of the header is the same as in C.
        Former &ldquo;see also&rdquo; references to the C standard may be moved into such a
        paragraph.</li>
      <li>The corresponding synopsis tables are deleted.</li>
      <li>Sections which describe multiple C headers may have their paragraphs moved into the
        appropriate new subsections.</li>
      <li>In two places ([c.strings] and [c.math]), wording that describes changes of signatures
        and addition of overloads is deleted and the overloads are directly given in the synopsis.
        The former wording is replaced with a note saying that the meaning of the functions is as
        in C, even though we have different signatures.</li>
    </ul>

    <p><em>Drafting note.</em> The synopses are largely copied from Annex B (library summary) of the C standard.</p>

    <p><em>Presentational note.</em> Insertions of entire code blocks are not underlined;
      the entire inserted block is decorated with vertical green rules.</p>

    <p><em>Drafting note.</em> Many of the existing &ldquo;see also&rdquo; references to the C
      standard appear to be incorrect (perhaps referring to the earlier C89).</p>

    <h2 id="impact">Impact on the standard</h2>

    <p>The change is purely editorial. Most internal references in the working draft are
      unaffected, with a few exceptions (e.g. references to <code>&lt;cstdio&gt;</code>).</p>

    <h2 id="wording18">Proposed wording, Clause 18</h2>

    <p>In 18.2, rename the heading.</p>

    <div class="modify">
      <h3>18.2 <del>Types</del><ins>Common definitions</ins> [support.types]</h3>
    </div>

    <p>Delete Table 30 and paragraphs 1 and 2. Move the remaining content to new subsections
      as described below. Insert a new subsection.</p>

    <div class="insert">
      <h3><ins>18.2.x Header &lt;cstddef&gt; synopsis [cstddef.syn]</ins></h3>

      <div class="code"><!-- "Common definitions <stddef.h>"
-->     namespace std {
        &nbsp;&nbsp;typedef <em>see below</em> ptrdiff_t;
        &nbsp;&nbsp;typedef <em>see below</em> size_t;
        &nbsp;&nbsp;typedef <em>see below</em> max_align_t;
        &nbsp;&nbsp;typedef decltype(nullptr) nullptr_t;
        }

        #define NULL <em>see below</em>

        #define offsetof(P, D) <em>see below</em>
      </div>
    </div>

    <p>Insert a new subsection.</p>

    <div class="insert">
      <h3><ins>18.2.x Null pointers [support.types.nullptr]</ins></h3>
    </div>

    <p>Move the former paragraph 9 of 18.2 into this subsection with the following change.</p>

    <div class="modify">
      <p><del><code>nullptr_t</code> is defined as follows:</del></p>
      <div class="code"><del>namespace std {
          &nbsp;&nbsp;typedef decltype(nullptr) nullptr_t;
          }</del></div>
      <p>The type <del>for which</del> <code>nullptr_t</code> is a synonym <ins>for the type of a <code>nullptr</code> expression,
        and it</ins> has the characteristics described in [...].</p>
    </div>

    <p>Move the former paragraph 3 of 18.2 into this subsection. Insert a new subsection.</p>

    <div class="insert">
      <h3><ins>18.2.x Sizes, alignments, and offsets [support.types.layout]</ins></h3>
    </div>

    <p>Move the former paragraphs 4 to 8 and the &ldquo;see also&rdquo; of 18.2 into this subsection,
      with the following change in the former paragraph 4.</p>

    <div class="modify">
      <p>[...] the <del>results are</del><ins>behavior is</ins> undefined [...]</p>
    </div>

    <p>In 18.3.1, change paragraph 1 as follows.</p>

    <div class="modify">
      <p>The headers <code>&lt;limits&gt;</code> (18.3.2), <code>&lt;climits&gt;</code><ins> (18.3.3.1)</ins>,
        and <code>&lt;cfloat&gt;</code> (18.3.3<ins>.2</ins>) supply characteristics of implementation-dependent
        arithmetic types (3.9.1).</p>
    </div>

    <p>In 18.3.3, delete Tables 31 and 32 and all paragraphs. Change the former paragraph 2 as follows. Insert a new subsection 18.3.3.1.</p>

    <div class="insert">
      <h3><ins>18.3.3.1 Header &lt;climits&gt; synopsis [climits.syn]</ins></h3>

      <div class="code"><!-- "Sizes of integer types <limits.h>"
-->     #define CHAR_BIT <em>see below</em>
        #define SCHAR_MIN <em>see below</em>
        #define SCHAR_MAX <em>see below</em>
        #define UCHAR_MAX <em>see below</em>
        #define CHAR_MIN <em>see below</em>
        #define CHAR_MAX <em>see below</em>
        #define MB_LEN_MAX <em>see below</em>
        #define SHRT_MIN <em>see below</em>
        #define SHRT_MAX <em>see below</em>
        #define USHRT_MAX <em>see below</em>
        #define INT_MIN <em>see below</em>
        #define INT_MAX <em>see below</em>
        #define UINT_MAX <em>see below</em>
        #define LONG_MIN <em>see below</em>
        #define LONG_MAX <em>see below</em>
        #define ULONG_MAX <em>see below</em>
        #define LLONG_MIN <em>see below</em>
        #define LLONG_MAX <em>see below</em>
        #define ULLONG_MAX <em>see below</em>
      </div>

      <p><ins>1. The header <code>&lt;climits&gt;</code> defines all macros the same as 5.2.4.2.1 in the C standard.</ins></p>
    </div>

    <p>Insert a new subsection 18.3.3.2.</p>

    <div class="insert">
      <h3><ins>18.3.3.2 Header &lt;cfloat&gt; synopsis [cfloat.syn]</ins></h3>

      <div class="code"><!-- "Characteristics of floating types <float.h>"
-->     #define FLT_ROUNDS <em>see below</em>
        #define FLT_EVAL_METHOD <em>see below</em>
        #define FLT_HAS_SUBNORM <em>see below</em>
        #define DBL_HAS_SUBNORM <em>see below</em>
        #define LDBL_HAS_SUBNORM <em>see below</em>
        #define FLT_RADIX <em>see below</em>
        #define FLT_MANT_DIG <em>see below</em>
        #define DBL_MANT_DIG <em>see below</em>
        #define LDBL_MANT_DIG <em>see below</em>
        #define FLT_DECIMAL_DIG <em>see below</em>
        #define DBL_DECIMAL_DIG <em>see below</em>
        #define LDBL_DECIMAL_DIG <em>see below</em>
        #define DECIMAL_DIG <em>see below</em>
        #define FLT_DIG <em>see below</em>
        #define DBL_DIG <em>see below</em>
        #define LDBL_DIG <em>see below</em>
        #define FLT_MIN_EXP <em>see below</em>
        #define DBL_MIN_EXP <em>see below</em>
        #define LDBL_MIN_EXP <em>see below</em>
        #define FLT_MIN_10_EXP <em>see below</em>
        #define DBL_MIN_10_EXP <em>see below</em>
        #define LDBL_MIN_10_EXP <em>see below</em>
        #define FLT_MAX_EXP <em>see below</em>
        #define DBL_MAX_EXP <em>see below</em>
        #define LDBL_MAX_EXP <em>see below</em>
        #define FLT_MAX_10_EXP <em>see below</em>
        #define DBL_MAX_10_EXP <em>see below</em>
        #define LDBL_MAX_10_EXP <em>see below</em>
        #define FLT_MAX <em>see below</em>
        #define DBL_MAX <em>see below</em>
        #define LDBL_MAX <em>see below</em>
        #define FLT_EPSILON <em>see below</em>
        #define DBL_EPSILON <em>see below</em>
        #define LDBL_EPSILON <em>see below</em>
        #define FLT_MIN <em>see below</em>
        #define DBL_MIN <em>see below</em>
        #define LDBL_MIN <em>see below</em>
        #define FLT_TRUE_MIN <em>see below</em>
        #define DBL_TRUE_MIN <em>see below</em>
        #define LDBL_TRUE_MIN <em>see below</em>
      </div>

      <p><ins>1. The header <code>&lt;cfloat&gt;</code> defines all macros the same as 5.2.4.2.2 in the C standard.</ins></p>
    </div>

    <p>In 18.10, delete paragraph 2.</p>

    <div class="delete">
      <p><del>The contents of these headers are the same as the Standard C library headers
        <code>&lt;setjmp.h&gt;</code>, <code>&lt;signal.h&gt;</code>, <code>&lt;stdalign.h&gt;</code>,
        <code>&lt;stdarg.h&gt;</code>, <code>&lt;stdbool.h&gt;</code>, <code>&lt;stdlib.h&gt;</code>,
        and <code>&lt;time.h&gt;</code>, respectively, with the following changes:</del></p>
    </div>

    <p>Insert new subsections after paragraph 1 and move paragraphs 3, 4, 8 and 9 into the new
      subsections as described below. Insert a new subsection at the new end of 18.10.</p>

    <div class="insert">
      <h3><ins>18.10.x Header &lt;cstdarg&gt; synopsis [cstdarg.h]</ins></h3>

      <div class="code"><!-- "Variable arguments <stdarg.h>"
-->     namespace std {
        &nbsp;&nbsp;typedef <em>see below</em> va_list;
        }

        #define va_arg(V, P) <em>see below</em>
        #define va_copy(VDST, VSRC) <em>see below</em>
        #define va_end(V) <em>see below</em>
        #define va_start(V, P) <em>see below</em>
      </div>

      <p><ins>1. The contents of the header <code>&lt;cstdarg&gt;</code> are the same as the Standard C library header <code>&lt;stdarg.h&gt;</code>,
        with the following changes:</ins></p>
    </div>

    <p>Append the former paragraph 3 of 18.10 to paragraph 1 above. Strike the subsequent &ldquo;see also&rdquo;. Insert a new subsection.</p>

    <div class="insert">
      <h3><ins>18.10.x Header &lt;csetjmp&gt; synopsis [csetjmp.syn]</ins></h3>

      <div class="code"><!-- "Nonlocal jumps <setjmp.h>"
-->     namespace std {
        &nbsp;&nbsp;typedef <em>see below</em> jmp_buf;
        }

        #define setjmp(env) <em>see below</em>

        namespace std {
        &nbsp;&nbsp;[[noreturn]] void longjmp(jmp_buf env, int val);
        }
      </div>

      <p><ins>1. The contents of the header <code>&lt;csetjmp&gt;</code> are the same as the Standard C library header <code>&lt;setjmp.h&gt;</code>.</ins></p>
    </div>

    <p><em>Drafting note.</em> Note the newly inserted <code>[[noreturn]]</code>.</p>

    <p>Move the former paragraph 4 of 18.10 to this subsection. Strike the subsequent &ldquo;see also&rdquo;. Insert a new subsection.</p>

    <div class="insert">
      <h3><ins>18.10.x Header &lt;cstdbool&gt; synopsis [cstdbool.syn]</ins></h3>

      <div class="code"><!-- "Boolean type and values <stdbool.h>"
-->     #define __bool_true_false_are_defined 1
      </div>

      <p><ins>1. The contents of the header <code>&lt;cstdbool&gt;</code> are the same as the Standard C library header <code>&lt;stdbool.h&gt;</code>,
        with the following changes:</ins></p>
    </div>

    <p>Append the former paragraph 8 of 18.10 to paragraph 1 above. Insert a new subsection.</p>

    <div class="insert">
      <h3><ins>18.10.x Header &lt;csignal&gt; synopsis [csignal.syn]</ins></h3>

      <div class="code"><!-- "Signal handling <signal.h>"
-->     namespace std {
        &nbsp;&nbsp;typedef <em>see below</em> sig_atomic_t;
        }

        #define SIG_DFL <em>see below</em>
        #define SIG_ERR <em>see below</em>
        #define SIG_IGN <em>see below</em>
        #define SIGABRT <em>see below</em>
        #define SIGFPE <em>see below</em>
        #define SIGILL <em>see below</em>
        #define SIGINT <em>see below</em>
        #define SIGSEGV <em>see below</em>
        #define SIGTERM <em>see below</em>

        namespace std {
        &nbsp;&nbsp;void (*signal(int sig, void (*func)(int)))(int);
        &nbsp;&nbsp;int raise(int sig);
        }
      </div>

      <p><ins>1. The contents of the header <code>&lt;csignal&gt;</code> are the same as the Standard C library header <code>&lt;signal.h&gt;</code>.</ins></p>
    </div>

    <p>Move the former paragraph 9 of 18.10 into this subsection. Insert a new subsection.</p>

    <div class="insert">
      <h3><ins>18.10.x Header &lt;ctime&gt; synopsis [ctime.syn]</ins></h3>

      <div class="code"><!-- "Date and time <time.h>"
-->     #define NULL <em>see below</em>
        #define CLOCKS_PER_SEC <em>see below</em>
        #define TIME_UTC <em>see below</em>

        namespace std {
        &nbsp;&nbsp;typedef <em>see below</em> size_t;
        &nbsp;&nbsp;typedef <em>see below</em> clock_t;
        &nbsp;&nbsp;typedef <em>see below</em> time_t;

        &nbsp;&nbsp;struct timespec;
        &nbsp;&nbsp;struct tm;

        &nbsp;&nbsp;clock_t clock(void);
        &nbsp;&nbsp;double difftime(time_t time1, time_t time0);
        &nbsp;&nbsp;time_t mktime(struct tm* timeptr);
        &nbsp;&nbsp;time_t time(time_t* timer);
        &nbsp;&nbsp;int timespec_get(timespec* ts, int base);
        &nbsp;&nbsp;char* asctime(const struct tm* timeptr);
        &nbsp;&nbsp;char* ctime(const time_t* timer);
        &nbsp;&nbsp;struct tm* gmtime(const time_t* timer);
        &nbsp;&nbsp;struct tm* localtime(const time_t* timer);
        &nbsp;&nbsp;size_t strftime(char* s, size_t maxsize, const char* format, const struct tm* timeptr);
        }
      </div>

      <p><ins>1. The contents of the header <code>&lt;ctime&gt;</code> are the same as the Standard C library header <code>&lt;time.h&gt;</code>.</ins></p>
    </div>

    <h2 id="wording19">Proposed wording, Clause 19</h2>

    <p>Split section 19.3 [assertions]. Delete table 42 and change paragraph 1:</p>

    <div class="modify">
      <p>The header <code>&lt;cassert&gt;</code><del>, described in (Table 42),</del>
        provides a macro for documenting C++ program assertions and a mechanism for disabling the
        assertion checks.</p>
    </div>

    <p>After paragraph 1, insert a new section:</p>

    <div class="insert">
      <h3><ins>19.3.1 Header &lt;cassert&gt; synopsis [cassert.syn]</ins></h3>

      <div class="code"><!-- "Diagnostics <assert.h>"
-->     #define assert(E) <em>see below</em>
      </div>

    </div>

    <p>The former paragraphs 2 and 3 of 19.3 become paragraphs 1 and 2 of a new subsection:</p>

    <div class="insert">
      <h3><ins>19.3.2 The <code>assert</code> macro [assertions.assert]</ins></h3>
    </div>

    <p>In 19.4 [errno], delete Table 43 and change paragraph 1 as follows.</p>

    <div class="modify">
      <p><del>The header <code>&lt;cerrno&gt;</code> is described in Table 43. Its contents</del><ins>The
        contents of the header <code>&lt;cerrno&gt;</code></ins> are the same as the POSIX header
        <code>&lt;errno.h&gt;</code>, except that <code>errno</code> shall be defined as a macro. [...]</p>
    </div>

    <p>Insert a new section 19.4.1.</p>

    <div class="insert">
      <h3><ins>19.4.1 Header &lt;cerrno&gt; synopsis [cerrno.syn]</ins></h3>

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

        #define errno <em>see below</em>
      </div>

      <p><ins>1. The meaning of the macros in this header is defined by the POSIX standard.</ins></p>
    </div>

    <h2 id="wording20">Proposed wording, Clause 20</h2>

    <p>In 20.7.13 [c.malloc], delete Table 46 and remove the original paragraph 6.</p>

    <div class="delete">
      <p><del>Table 46 describes the header <code>&lt;cstring&gt;</code>.</del></p>
    </div>

    <p>Change the next paragraph as follows.</p>

    <div class="modify">
      <p>The contents <ins>of the header <code>&lt;cstring&gt;</code> (see 21.8.x)</ins> are
        the same as the Standard C library header <code>&lt;string.h&gt;</code>, with the
        change to <code>memchr()</code> specified in 21.8.</p>
    </div>

    <h2 id="wording21">Proposed wording, Clause 21</h2>

    <p>In 21.8 [c.strings], delete Tables 73, 74, 75, 76, 77, and 78 and remove paragraph 1.</p>

    <div class="delete">
      <p><del>Tables 73, 74, 75, 76, 77, and 78 describe headers
        <code>&lt;cctype&gt;</code>, <code>&lt;cwctype&gt;</code>,
        <code>&lt;cstring&gt;</code>, <code>&lt;cwchar&gt;</code>,
        <code>&lt;cstdlib&gt;</code> (character conversions), and
        <code>&lt;cuchar&gt;</code>, respectively.</del></p>
    </div>

    <p>Modify the next paragraph as follows.</p>

    <div class="modify">
      <p>The contents of <del>these headers</del> <ins>the headers
        <code>&lt;cctype&gt;</code>, <code>&lt;cwctype&gt;</code>,
        <code>&lt;cstring&gt;</code>, <code>&lt;cwchar&gt;</code>,
        <code>&lt;cstdlib&gt;</code> (see 26.8.2), and <code>&lt;cuchar&gt;</code></ins>
        shall be the same as the Standard C Library headers <code>&lt;ctype.h&gt;</code>,
        <code>&lt;wctype.h&gt;</code>, <code>&lt;string.h&gt;</code>,
        <code>&lt;wchar.h&gt;</code>, and <code>&lt;stdlib.h&gt;</code>
        and the C Unicode TR header <code>&lt;uchar.h&gt;</code>, respectively,
        with the following modifications:</p>
    </div>

    <p>Delete paragraphs 4 to 13 (deletions not shown here) and in their stead insert a note.</p>

    <div class="insert">
      <p><ins>[<em>Note</em>: The functions <code>strchr</code>, <code>strpbrk</code>, <code>strrchr</code>,
        <code>strstr</code>, <code>memchr</code>, <code>wcschr</code>, <code>wcspbrk</code>, <code>wcsrchr</code>,
        <code>wcsstr</code> and <code>wmemchr</code> have different signatures in this International Standard,
        but they have the same behavior as in the C standard. &ndash; <em>end note</em>]</ins></p>
    </div>

    <p>Append a series of new subsections at the end of 21.8.</p>

    <div class="insert">
      <h3><ins>21.8.x Header &lt;cctype&gt; synopsis [cctype.syn]</ins></h3>

      <div class="code"><!-- "Character handling <ctype.h>"
-->     namespace std {
        &nbsp;&nbsp;int isalnum(int c);
        &nbsp;&nbsp;int isalpha(int c);
        &nbsp;&nbsp;int isblank(int c);
        &nbsp;&nbsp;int iscntrl(int c);
        &nbsp;&nbsp;int isdigit(int c);
        &nbsp;&nbsp;int isgraph(int c);
        &nbsp;&nbsp;int islower(int c);
        &nbsp;&nbsp;int isprint(int c);
        &nbsp;&nbsp;int ispunct(int c);
        &nbsp;&nbsp;int isspace(int c);
        &nbsp;&nbsp;int isupper(int c);
        &nbsp;&nbsp;int isxdigit(int c);
        &nbsp;&nbsp;int tolower(int c);
        &nbsp;&nbsp;int toupper(int c);
      }
      </div>

      <h3><ins>21.8.x Header &lt;cwctype&gt; synopsis [cwctype.syn]</ins></h3>

      <div class="code"><!-- "Wide character classification and mapping utilities <wctype.h>"
-->     namespace std {
        &nbsp;&nbsp;typedef <em>see below</em> wint_t;
        &nbsp;&nbsp;typedef <em>see below</em> wctrans_t;
        &nbsp;&nbsp;typedef <em>see below</em> wctype_t;
        }

        #define WEOF <em>see below</em>

        namespace std {
        &nbsp;&nbsp;int iswalnum(wint_t wc);
        &nbsp;&nbsp;int iswalpha(wint_t wc);
        &nbsp;&nbsp;int iswblank(wint_t wc);
        &nbsp;&nbsp;int iswcntrl(wint_t wc);
        &nbsp;&nbsp;int iswdigit(wint_t wc);
        &nbsp;&nbsp;int iswgraph(wint_t wc);
        &nbsp;&nbsp;int iswlower(wint_t wc);
        &nbsp;&nbsp;int iswprint(wint_t wc);
        &nbsp;&nbsp;int iswpunct(wint_t wc);
        &nbsp;&nbsp;int iswspace(wint_t wc);
        &nbsp;&nbsp;int iswupper(wint_t wc);
        &nbsp;&nbsp;int iswxdigit(wint_t wc);
        &nbsp;&nbsp;int iswctype(wint_t wc, wctype_t desc);
        &nbsp;&nbsp;wctype_t wctype(const char* property);
        &nbsp;&nbsp;wint_t towlower(wint_t wc);
        &nbsp;&nbsp;wint_t towupper(wint_t wc);
        &nbsp;&nbsp;wint_t towctrans(wint_t wc, wctrans_t desc);
        &nbsp;&nbsp;wctrans_t wctrans(const char* property);
        }
      </div>

      <p><ins>1. The meaning of the contents of this header is the same as the Standard C library header <code>&lt;wctype.h&gt;</code>.</ins></p>

      <h3><ins>21.8.x Header &lt;cstring&gt; synopsis [cstring.syn]</ins></h3>

      <div class="code"><!-- "String handling <string.h>"
-->     namespace std {
        &nbsp;&nbsp;typedef <em>see below</em> size_t;
        }
        #define NULL <em>see below</em>;

        namespace std {
        &nbsp;&nbsp;void* memcpy(void* s1, const void* s2, size_t n);
        &nbsp;&nbsp;void* memmove(void* s1, const void* s2, size_t n);
        &nbsp;&nbsp;char* strcpy(char* s1, const char* s2);
        &nbsp;&nbsp;char* strncpy(char* s1, const char* s2, size_t n);
        &nbsp;&nbsp;char* strcat(char* s1, const char* s2);
        &nbsp;&nbsp;char* strncat(char* s1, const char* s2, size_t n);
        &nbsp;&nbsp;int memcmp(const void* s1, const void* s2, size_t n);
        &nbsp;&nbsp;int strcmp(const char* s1, const char* s2);
        &nbsp;&nbsp;int strcoll(const char* s1, const char* s2);
        &nbsp;&nbsp;int strncmp(const char* s1, const char* s2, size_t n);
        &nbsp;&nbsp;size_t strxfrm(char* s1, const char* s2, size_t n);
        &nbsp;&nbsp;const void* memchr(const void* s, int c, size_t n);
        &nbsp;&nbsp;void* memchr(void* s, int c, size_t n);
        &nbsp;&nbsp;const char* strchr(const char* s, int c);
        &nbsp;&nbsp;char* strchr(char* s, int c);
        &nbsp;&nbsp;size_t strcspn(const char* s1, const char* s2);
        &nbsp;&nbsp;const char* strpbrk(const char* s1, const char* s2);
        &nbsp;&nbsp;char* strpbrk(char* s1, const char* s2);
        &nbsp;&nbsp;const char* strrchr(const char* s, int c);
        &nbsp;&nbsp;char* strrchr(char* s, int c);
        &nbsp;&nbsp;size_t strspn(const char* s1, const char* s2);
        &nbsp;&nbsp;const char* strstr(const char* s1, const char* s2);
        &nbsp;&nbsp;char* strstr(char* s1, const char* s2);
        &nbsp;&nbsp;char* strtok(char* s1, const char* s2);
        &nbsp;&nbsp;void* memset(void* s, int c, size_t n);
        &nbsp;&nbsp;char* strerror(int errnum);
        &nbsp;&nbsp;size_t strlen(const char* s);
      }
      </div>

      <p><ins>1. The meaning of the contents of this header is the same as the Standard C library header <code>&lt;string.h&gt;</code>.</ins></p>

      <h3><ins>21.8.x Header &lt;cwchar&gt; synopsis [cwchar.syn]</ins></h3>

      <div class="code"><!-- "Extended multibyte/wide character utilities <wchar.h>"
-->     namespace std {
        &nbsp;&nbsp;typedef <em>see below</em> wchar_t;
        &nbsp;&nbsp;typedef <em>see below</em> size_t;
        &nbsp;&nbsp;typedef <em>see below</em> mbstate_t;
        &nbsp;&nbsp;typedef <em>see below</em> wint_t;

        &nbsp;&nbsp;struct tm;
        }

        #define NULL <em>see below</em>
        #define WCHAR_MAX <em>see below</em>
        #define WCHAR_MIN <em>see below</em>
        #define WEOF <em>see below</em>

        namespace std {
        &nbsp;&nbsp;int fwprintf(FILE* stream, const wchar_t* format, ...);
        &nbsp;&nbsp;int fwscanf(FILE* stream, const wchar_t* format, ...);
        &nbsp;&nbsp;int swprintf(wchar_t* s, size_t n, const wchar_t* format, ...);
        &nbsp;&nbsp;int swscanf(const wchar_t* s, const wchar_t* format, ...);
        &nbsp;&nbsp;int vfwprintf(FILE* stream, const wchar_t* format, va_list arg);
        &nbsp;&nbsp;int vfwscanf(FILE* stream, const wchar_t* format, va_list arg);
        &nbsp;&nbsp;int vswprintf(wchar_t* s, size_t n, const wchar_t* format, va_list arg);
        &nbsp;&nbsp;int vswscanf(const wchar_t* s, const wchar_t* format, va_list arg);
        &nbsp;&nbsp;int vwprintf(const wchar_t* format, va_list arg);
        &nbsp;&nbsp;int vwscanf(const wchar_t* format, va_list arg);
        &nbsp;&nbsp;int wprintf(const wchar_t* format, ...);
        &nbsp;&nbsp;int wscanf(const wchar_t* format, ...);
        &nbsp;&nbsp;wint_t fgetwc(FILE* stream);
        &nbsp;&nbsp;wchar_t* fgetws(wchar_t* s, int n, FILE* stream);
        &nbsp;&nbsp;wint_t fputwc(wchar_t c, FILE* stream);
        &nbsp;&nbsp;int fputws(const wchar_t* s, FILE* stream);
        &nbsp;&nbsp;int fwide(FILE* stream, int mode);
        &nbsp;&nbsp;wint_t getwc(FILE* stream);
        &nbsp;&nbsp;wint_t getwchar(void);
        &nbsp;&nbsp;wint_t putwc(wchar_t c, FILE* stream);
        &nbsp;&nbsp;wint_t putwchar(wchar_t c);
        &nbsp;&nbsp;wint_t ungetwc(wint_t c, FILE* stream);
        &nbsp;&nbsp;double wcstod(const wchar_t* nptr, wchar_t** endptr);
        &nbsp;&nbsp;float wcstof(const wchar_t* nptr, wchar_t** endptr);
        &nbsp;&nbsp;long double wcstold(const wchar_t* nptr, wchar_t** endptr);
        &nbsp;&nbsp;long int wcstol(const wchar_t* nptr, wchar_t** endptr, int base);
        &nbsp;&nbsp;long long int wcstoll(const wchar_t* nptr, wchar_t** endptr, int base);
        &nbsp;&nbsp;unsigned long int wcstoul(const wchar_t* nptr, wchar_t** endptr, int base);
        &nbsp;&nbsp;unsigned long long int wcstoull(const wchar_t* nptr, wchar_t** endptr, int base);
        &nbsp;&nbsp;wchar_t* wcscpy(wchar_t* s1, const wchar_t* s2);
        &nbsp;&nbsp;wchar_t* wcsncpy(wchar_t* s1, const wchar_t* s2, size_t n);
        &nbsp;&nbsp;wchar_t* wmemcpy(wchar_t* s1, const wchar_t* s2, size_t n);
        &nbsp;&nbsp;wchar_t* wmemmove(wchar_t* s1, const wchar_t* s2, size_t n);
        &nbsp;&nbsp;wchar_t* wcscat(wchar_t* s1, const wchar_t* s2);
        &nbsp;&nbsp;wchar_t* wcsncat(wchar_t* s1, const wchar_t* s2, size_t n);
        &nbsp;&nbsp;int wcscmp(const wchar_t* s1, const wchar_t* s2);
        &nbsp;&nbsp;int wcscoll(const wchar_t* s1, const wchar_t* s2);
        &nbsp;&nbsp;int wcsncmp(const wchar_t* s1, const wchar_t* s2, size_t n);
        &nbsp;&nbsp;size_t wcsxfrm(wchar_t* s1, const wchar_t* s2, size_t n);
        &nbsp;&nbsp;int wmemcmp(const wchar_t* s1, const wchar_t* s2, size_t n);
        &nbsp;&nbsp;const wchar_t* wcschr(const wchar_t* s, wchar_t c);
        &nbsp;&nbsp;wchar_t* wcschr(wchar_t* s, wchar_t c);
        &nbsp;&nbsp;size_t wcscspn(const wchar_t* s1, const wchar_t* s2);
        &nbsp;&nbsp;const wchar_t* wcspbrk(const wchar_t* s1, const wchar_t* s2);
        &nbsp;&nbsp;wchar_t* wcspbrk(wchar_t* s1, const wchar_t* s2);
        &nbsp;&nbsp;const wchar_t* wcsrchr(const wchar_t* s, wchar_t c);
        &nbsp;&nbsp;wchar_t* wcsrchr(wchar_t* s, wchar_t c);
        &nbsp;&nbsp;size_t wcsspn(const wchar_t* s1, const wchar_t* s2);
        &nbsp;&nbsp;const wchar_t* wcsstr(const wchar_t* s1, const wchar_t* s2);
        &nbsp;&nbsp;wchar_t* wcsstr(wchar_t* s1, const wchar_t* s2);
        &nbsp;&nbsp;wchar_t* wcstok(wchar_t* s1, const wchar_t* s2, wchar_t** ptr);
        &nbsp;&nbsp;const wchar_t* wmemchr(const wchar_t* s, wchar_t c, size_t n);
        &nbsp;&nbsp;wchar_t* wmemchr(wchar_t* s, wchar_t c, size_t n);
        &nbsp;&nbsp;size_t wcslen(const wchar_t* s);
        &nbsp;&nbsp;wchar_t* wmemset(wchar_t* s, wchar_t c, size_t n);
        &nbsp;&nbsp;size_t wcsftime(wchar_t* s, size_t maxsize, const wchar_t* format, const struct tm* timeptr);
        &nbsp;&nbsp;wint_t btowc(int c);
        &nbsp;&nbsp;int wctob(wint_t c);
        &nbsp;&nbsp;int mbsinit(const mbstate_t* ps);
        &nbsp;&nbsp;size_t mbrlen(const char* s, size_t n, mbstate_t* ps);
        &nbsp;&nbsp;size_t mbrtowc(wchar_t* pwc, const char* s, size_t n, mbstate_t* ps);
        &nbsp;&nbsp;size_t wcrtomb(char* s, wchar_t wc, mbstate_t* ps);
        &nbsp;&nbsp;size_t mbsrtowcs(wchar_t* dst, const char** src, size_t len, mbstate_t* ps);
        &nbsp;&nbsp;size_t wcsrtombs(char* dst, const wchar_t** src, size_t len, mbstate_t* ps);
        }
      </div>

      <p><ins>1. The meaning of the contents of this header is the same as the Standard C library header <code>&lt;wchar.h&gt;</code>.</ins></p>

      <h3><ins>21.8.x Header &lt;cuchar&gt; synopsis [cuchar.syn]</ins></h3>

      <div class="code"><!-- "Unicode utilities <uchar.h>"
-->     namespace std {
        &nbsp;&nbsp;typedef <em>see below</em> mbstate_t;
        &nbsp;&nbsp;typedef <em>see below</em> size_t;

        &nbsp;&nbsp;size_t mbrtoc16(char16_t* pc16, const char* s, size_t n, mbstate_t* ps);
        &nbsp;&nbsp;size_t c16rtomb(char* s, char16_t c16, mbstate_t* ps);
        &nbsp;&nbsp;size_t mbrtoc32(char32_t* pc32, const char* s, size_t n, mbstate_t* ps);
        &nbsp;&nbsp;size_t c32rtomb(char* s, char32_t c32, mbstate_t* ps);
        }
      </div>

      <p><ins>1. The meaning of the contents of this header is the same as the C Unicode TR header <code>&lt;uchar.h&gt;</code>.</ins></p>
    </div>

    <p>In 22.6, delete Table 92 and paragraph 1.</p>

    <div class="delete">
      <p><del>Table 92 describes header <code>&lt;clocale&gt;</code>.</del></p>
    </div>

    <p>Change paragraph 2 as follows.</p>

    <div class="modify">
      <p>The contents <ins>of the header <code>&lt;clocale&gt;</code></ins> are the same as the Standard C library header <code>&lt;locale.h&gt;</code>.</p>
    </div>

    <p>Strike the &ldquo;see also&rdquo;. Add a new subsection 22.6.1.</p>

    <div class="insert">
      <h3><ins>Header &lt;clocale&gt; synopsis [clocale.syn]</ins></h3>

      <div class="code"><!-- "Localization <locale.h>"
-->     namespace std {
        &nbsp;&nbsp;struct lconv;
        }

        #define NULL <em>see below</em>
        #define LC_ALL <em>see below</em>
        #define LC_COLLATE <em>see below</em>
        #define LC_CTYPE <em>see below</em>
        #define LC_MONETARY <em>see below</em>
        #define LC_NUMERIC <em>see below</em>
        #define LC_TIME <em>see below</em>

        namespace std {
        &nbsp;&nbsp;char* setlocale(int category, const char* locale);

        &nbsp;&nbsp;lconv* localeconv();
        }
      </div>

      <p><ins>1. The meaning of the content of this header is the same as in 7.11 in the C standard.</ins></p>
    </div>

    <h2 id="wording26">Proposed wording, Clause 26</h2>

    <p>In 26.8, delete Tables 118 and 119 and paragraph 3.</p>

    <div class="delete">
      <p><del>Tables 118 and 119 describe headers <code>&lt;cmath&gt;</code> and <code>&lt;cstdlib&gt;</code>, respectively.</del></p>
    </div>

    <p>Change the former paragraph 4 as follows.</p>

    <div class="modify">
      <p>The contents of <del>these headers</del><ins>the headers <code>&lt;cmath&gt;</code> and <code>&lt;cstdlib&gt;</code></ins> are the same as [...]</p>
    </div>

    <p>Delete paragraphs 6 to 9 (deletions not shown here), and in their stead insert a note.</p>

    <div class="insert">
      <p><ins>[<em>Note</em>: Several functions have additional overloads in this International Standard,
        but they have the same behavior as in the C standard. &ndash; <em>end note</em>]</ins></p>
    </div>

    <p>From the former paragraph 10, delete the code listing (not shown fully).</p>

    <div class="modify">
      <p>[...] overloaded for the three floating-point types<ins>.</ins><del>, as follows:</del></p>
      <p>[<em>delete remainder of paragraph</em>]</p>
    </div>

    <p>Change the former paragraph 11 as follows.</p>
    <div class="modify">
      <p><del>Moreover,</del><ins>For each set of overloaded functions within <code>&lt;cmath&gt;</code>,</ins>
        there shall be additional overloads [...]</p>
    </div>

    <p>Insert a new subsection 26.8.1.</p>

    <div class="insert">
      <h3><ins>26.8.1 Header &lt;cmath&gt; synopsis [cmath.syn]</ins></h3>

      <div class="code"><!-- "Mathematics <math.h>"
-->     namespace std {
        &nbsp;&nbsp;typedef <em>see below</em> float_t;
        &nbsp;&nbsp;typedef <em>see below</em> double_t;
        }

        #define HUGE_VAL  <em>see below</em>
        #define HUGE_VALF  <em>see below</em>
        #define HUGE_VALL  <em>see below</em>
        #define INFINITY  <em>see below</em>
        #define NAN  <em>see below</em>
        #define FP_INFINITE  <em>see below</em>
        #define FP_NAN  <em>see below</em>
        #define FP_NORMAL  <em>see below</em>
        #define FP_SUBNORMAL  <em>see below</em>
        #define FP_ZERO  <em>see below</em>
        #define FP_FAST_FMA  <em>see below</em>
        #define FP_FAST_FMAF  <em>see below</em>
        #define FP_FAST_FMAL  <em>see below</em>
        #define FP_ILOGB0  <em>see below</em>
        #define FP_ILOGBNAN  <em>see below</em>
        #define MATH_ERRNO  <em>see below</em>
        #define MATH_ERREXCEPT  <em>see below</em>

        #define math_errhandling <em>see below</em>

        namespace std {
        &nbsp;&nbsp;float acos(float x);
        &nbsp;&nbsp;double acos(double x);
        &nbsp;&nbsp;long double acos(long double x);
        &nbsp;&nbsp;float acosf(float x);
        &nbsp;&nbsp;long double acosl(long double x);

        &nbsp;&nbsp;float asin(float x);
        &nbsp;&nbsp;double asin(double x);
        &nbsp;&nbsp;long double asin(long double x);
        &nbsp;&nbsp;float asinf(float x);
        &nbsp;&nbsp;long double asinl(long double x);

        &nbsp;&nbsp;float atan(float x);
        &nbsp;&nbsp;double atan(double x);
        &nbsp;&nbsp;long double atan(long double x);
        &nbsp;&nbsp;float atanf(float x);
        &nbsp;&nbsp;long double atanl(long double x);

        &nbsp;&nbsp;float atan2(float y, float x);
        &nbsp;&nbsp;double atan2(double y, double x);
        &nbsp;&nbsp;long double atan2(long double y, long double x);
        &nbsp;&nbsp;float atan2f(float y, float x);
        &nbsp;&nbsp;long double atan2l(long double y, long double x);

        &nbsp;&nbsp;float cos(float x);
        &nbsp;&nbsp;double cos(double x);
        &nbsp;&nbsp;long double cos(long double x);
        &nbsp;&nbsp;float cosf(float x);
        &nbsp;&nbsp;long double cosl(long double x);

        &nbsp;&nbsp;float sin(float x);
        &nbsp;&nbsp;double sin(double x);
        &nbsp;&nbsp;long double sin(long double x);
        &nbsp;&nbsp;float sinf(float x);
        &nbsp;&nbsp;long double sinl(long double x);

        &nbsp;&nbsp;float tan(float x);
        &nbsp;&nbsp;double tan(double x);
        &nbsp;&nbsp;long double tan(long double x);
        &nbsp;&nbsp;float tanf(float x);
        &nbsp;&nbsp;long double tanl(long double x);

        &nbsp;&nbsp;float acosh(float x);
        &nbsp;&nbsp;double acosh(double x);
        &nbsp;&nbsp;long double acosh(long double x);
        &nbsp;&nbsp;float acoshf(float x);
        &nbsp;&nbsp;long double acoshl(long double x);

        &nbsp;&nbsp;float asinh(float x);
        &nbsp;&nbsp;double asinh(double x);
        &nbsp;&nbsp;long double asinh(long double x);
        &nbsp;&nbsp;float asinhf(float x);
        &nbsp;&nbsp;long double asinhl(long double x);

        &nbsp;&nbsp;float atanh(float x);
        &nbsp;&nbsp;double atanh(double x);
        &nbsp;&nbsp;long double atanh(long double x);
        &nbsp;&nbsp;float atanhf(float x);
        &nbsp;&nbsp;long double atanhl(long double x);

        &nbsp;&nbsp;float cosh(float x);
        &nbsp;&nbsp;double cosh(double x);
        &nbsp;&nbsp;long double cosh(long double x);
        &nbsp;&nbsp;float coshf(float x);
        &nbsp;&nbsp;long double coshl(long double x);

        &nbsp;&nbsp;float sinh(float x);
        &nbsp;&nbsp;double sinh(double x);
        &nbsp;&nbsp;long double sinh(long double x);
        &nbsp;&nbsp;float sinhf(float x);
        &nbsp;&nbsp;long double sinhl(long double x);

        &nbsp;&nbsp;float tanh(float x);
        &nbsp;&nbsp;double tanh(double x);
        &nbsp;&nbsp;long double tanh(long double x);
        &nbsp;&nbsp;float tanhf(float x);
        &nbsp;&nbsp;long double tanhl(long double x);

        &nbsp;&nbsp;float exp(float x);
        &nbsp;&nbsp;double exp(double x);
        &nbsp;&nbsp;long double exp(long double x);
        &nbsp;&nbsp;float expf(float x);
        &nbsp;&nbsp;long double expl(long double x);

        &nbsp;&nbsp;float exp2(float x);
        &nbsp;&nbsp;double exp2(double x);
        &nbsp;&nbsp;long double exp2(long double x);
        &nbsp;&nbsp;float exp2f(float x);
        &nbsp;&nbsp;long double exp2l(long double x);

        &nbsp;&nbsp;float expm1(float x);
        &nbsp;&nbsp;double expm1(double x);
        &nbsp;&nbsp;long double expm1(long double x);
        &nbsp;&nbsp;float expm1f(float x);
        &nbsp;&nbsp;long double expm1l(long double x);

        &nbsp;&nbsp;float frexp(float value, int* exp);
        &nbsp;&nbsp;double frexp(double value, int* exp);
        &nbsp;&nbsp;long double frexp(long double value, int* exp);
        &nbsp;&nbsp;float frexpf(float value, int* exp);
        &nbsp;&nbsp;long double frexpl(long double value, int* exp);

        &nbsp;&nbsp;int ilogb(float x);
        &nbsp;&nbsp;int ilogb(double x);
        &nbsp;&nbsp;int ilogb(long double x);
        &nbsp;&nbsp;int ilogbf(float x);
        &nbsp;&nbsp;int ilogbl(long double x);

        &nbsp;&nbsp;float ldexp(float x, int exp);
        &nbsp;&nbsp;double ldexp(double x, int exp);
        &nbsp;&nbsp;long double ldexp(long double x, int exp);
        &nbsp;&nbsp;float ldexpf(float x, int exp);
        &nbsp;&nbsp;long double ldexpl(long double x, int exp);

        &nbsp;&nbsp;float log(float x);
        &nbsp;&nbsp;double log(double x);
        &nbsp;&nbsp;long double log(long double x);
        &nbsp;&nbsp;float logf(float x);
        &nbsp;&nbsp;long double logl(long double x);

        &nbsp;&nbsp;float log10(float x);
        &nbsp;&nbsp;double log10(double x);
        &nbsp;&nbsp;long double log10(long double x);
        &nbsp;&nbsp;float log10f(float x);
        &nbsp;&nbsp;long double log10l(long double x);

        &nbsp;&nbsp;float log1p(float x);
        &nbsp;&nbsp;double log1p(double x);
        &nbsp;&nbsp;long double log1p(long double x);
        &nbsp;&nbsp;float log1pf(float x);
        &nbsp;&nbsp;long double log1pl(long double x);

        &nbsp;&nbsp;float log2(float x);
        &nbsp;&nbsp;double log2(double x);
        &nbsp;&nbsp;long double log2(long double x);
        &nbsp;&nbsp;float log2f(float x);
        &nbsp;&nbsp;long double log2l(long double x);

        &nbsp;&nbsp;float logb(float x);
        &nbsp;&nbsp;double logb(double x);
        &nbsp;&nbsp;long double logb(long double x);
        &nbsp;&nbsp;float logbf(float x);
        &nbsp;&nbsp;long double logbl(long double x);

        &nbsp;&nbsp;float modf(float value, float* iptr);
        &nbsp;&nbsp;double modf(double value, double* iptr);
        &nbsp;&nbsp;long double modf(long double value, long double* iptr);
        &nbsp;&nbsp;float modff(float value, float* iptr);
        &nbsp;&nbsp;long double modfl(long double value, long double* iptr);

        &nbsp;&nbsp;float scalbn(float x, int n);
        &nbsp;&nbsp;double scalbn(double x, int n);
        &nbsp;&nbsp;long double scalbn(long double x, int n);
        &nbsp;&nbsp;float scalbnf(float x, int n);
        &nbsp;&nbsp;long double scalbnl(long double x, int n);

        &nbsp;&nbsp;float scalbln(float x, long int n);
        &nbsp;&nbsp;double scalbln(double x, long int n);
        &nbsp;&nbsp;long double scalbln(long double x, long int n);
        &nbsp;&nbsp;float scalblnf(float x, long int n);
        &nbsp;&nbsp;long double scalblnl(long double x, long int n);

        &nbsp;&nbsp;float cbrt(float x);
        &nbsp;&nbsp;double cbrt(double x);
        &nbsp;&nbsp;long double cbrt(long double x);
        &nbsp;&nbsp;float cbrtf(float x);
        &nbsp;&nbsp;long double cbrtl(long double x);

        &nbsp;&nbsp;float abs(float j);
        &nbsp;&nbsp;double abs(double j);
        &nbsp;&nbsp;long double abs(long double j);
        &nbsp;&nbsp;float fabs(float x);
        &nbsp;&nbsp;double fabs(double x);
        &nbsp;&nbsp;long double fabs(long double x);
        &nbsp;&nbsp;float fabsf(float x);
        &nbsp;&nbsp;long double fabsl(long double x);

        &nbsp;&nbsp;float hypot(float x, float y);
        &nbsp;&nbsp;double hypot(double x, double y);
        &nbsp;&nbsp;long double hypot(double x, double y);
        &nbsp;&nbsp;float hypotf(float x, float y);
        &nbsp;&nbsp;long double hypotl(long double x, long double y);

        &nbsp;&nbsp;float pow(float x, float y);
        &nbsp;&nbsp;double pow(double x, double y);
        &nbsp;&nbsp;long double pow(long double x, long double y);
        &nbsp;&nbsp;float powf(float x, float y);
        &nbsp;&nbsp;long double powl(long double x, long double y);

        &nbsp;&nbsp;float sqrt(float x);
        &nbsp;&nbsp;double sqrt(double x);
        &nbsp;&nbsp;long double sqrt(long double x);
        &nbsp;&nbsp;float sqrtf(float x);
        &nbsp;&nbsp;long double sqrtl(long double x);

        &nbsp;&nbsp;float erf(float x);
        &nbsp;&nbsp;double erf(double x);
        &nbsp;&nbsp;long double erf(long double x);
        &nbsp;&nbsp;float erff(float x);
        &nbsp;&nbsp;long double erfl(long double x);

        &nbsp;&nbsp;float erfc(float x);
        &nbsp;&nbsp;double erfc(double x);
        &nbsp;&nbsp;long double erfc(long double x);
        &nbsp;&nbsp;float erfcf(float x);
        &nbsp;&nbsp;long double erfcl(long double x);

        &nbsp;&nbsp;float lgamma(float x);
        &nbsp;&nbsp;double lgamma(double x);
        &nbsp;&nbsp;long double lgamma(long double x);
        &nbsp;&nbsp;float lgammaf(float x);
        &nbsp;&nbsp;long double lgammal(long double x);

        &nbsp;&nbsp;float tgamma(float x);
        &nbsp;&nbsp;double tgamma(double x);
        &nbsp;&nbsp;long double tgamma(long double x);
        &nbsp;&nbsp;float tgammaf(float x);
        &nbsp;&nbsp;long double tgammal(long double x);

        &nbsp;&nbsp;float ceil(float x);
        &nbsp;&nbsp;double ceil(double x);
        &nbsp;&nbsp;long double ceil(long double x);
        &nbsp;&nbsp;float ceilf(float x);
        &nbsp;&nbsp;long double ceill(long double x);

        &nbsp;&nbsp;float floor(float x);
        &nbsp;&nbsp;double floor(double x);
        &nbsp;&nbsp;long double floor(long double x);
        &nbsp;&nbsp;float floorf(float x);
        &nbsp;&nbsp;long double floorl(long double x);

        &nbsp;&nbsp;float nearbyint(float x);
        &nbsp;&nbsp;double nearbyint(double x);
        &nbsp;&nbsp;long double nearbyint(long double x);
        &nbsp;&nbsp;float nearbyintf(float x);
        &nbsp;&nbsp;long double nearbyintl(long double x);

        &nbsp;&nbsp;float rint(float x);
        &nbsp;&nbsp;double rint(double x);
        &nbsp;&nbsp;long double rint(long double x);
        &nbsp;&nbsp;float rintf(float x);
        &nbsp;&nbsp;long double rintl(long double x);

        &nbsp;&nbsp;long int lrint(float x);
        &nbsp;&nbsp;long int lrint(double x);
        &nbsp;&nbsp;long int lrint(long double x);
        &nbsp;&nbsp;long int lrintf(float x);
        &nbsp;&nbsp;long int lrintl(long double x);

        &nbsp;&nbsp;long long int llrint(float x);
        &nbsp;&nbsp;long long int llrint(double x);
        &nbsp;&nbsp;long long int llrint(long double x);
        &nbsp;&nbsp;long long int llrintf(float x);
        &nbsp;&nbsp;long long int llrintl(long double x);

        &nbsp;&nbsp;float round(float x);
        &nbsp;&nbsp;double round(double x);
        &nbsp;&nbsp;long double round(long double x);
        &nbsp;&nbsp;float roundf(float x);
        &nbsp;&nbsp;long double roundl(long double x);

        &nbsp;&nbsp;long int lround(float x);
        &nbsp;&nbsp;long int lround(double x);
        &nbsp;&nbsp;long int lround(long double x);
        &nbsp;&nbsp;long int lroundf(float x);
        &nbsp;&nbsp;long int lroundl(long double x);

        &nbsp;&nbsp;long long int llround(float x);
        &nbsp;&nbsp;long long int llround(double x);
        &nbsp;&nbsp;long long int llround(long double x);
        &nbsp;&nbsp;long long int llroundf(float x);
        &nbsp;&nbsp;long long int llroundl(long double x);

        &nbsp;&nbsp;float trunc(float x);
        &nbsp;&nbsp;double trunc(double x);
        &nbsp;&nbsp;long double trunc(long double x);
        &nbsp;&nbsp;float truncf(float x);
        &nbsp;&nbsp;long double truncl(long double x);

        &nbsp;&nbsp;float fmod(float x, float y);
        &nbsp;&nbsp;double fmod(double x, double y);
        &nbsp;&nbsp;long double fmod(long double x, long double y);
        &nbsp;&nbsp;float fmodf(float x, float y);
        &nbsp;&nbsp;long double fmodl(long double x, long double y);

        &nbsp;&nbsp;float remainder(float x, float y);
        &nbsp;&nbsp;double remainder(double x, double y);
        &nbsp;&nbsp;long double remainder(long double x, long double y);
        &nbsp;&nbsp;float remainderf(float x, float y);
        &nbsp;&nbsp;long double remainderl(long double x, long double y);

        &nbsp;&nbsp;float remquo(float x, float y, int* quo);
        &nbsp;&nbsp;double remquo(double x, double y, int* quo);
        &nbsp;&nbsp;long double remquo(long double x, long double y, int* quo);
        &nbsp;&nbsp;float remquof(float x, float y, int* quo);
        &nbsp;&nbsp;long double remquol(long double x, long double y, int* quo);

        &nbsp;&nbsp;float copysign(float x, float y);
        &nbsp;&nbsp;double copysign(double x, double y);
        &nbsp;&nbsp;long double copysign(long double x, long double y);
        &nbsp;&nbsp;float copysignf(float x, float y);
        &nbsp;&nbsp;long double copysignl(long double x, long double y);

        &nbsp;&nbsp;double nan(const char* tagp);
        &nbsp;&nbsp;float nanf(const char* tagp);
        &nbsp;&nbsp;long double nanl(const char* tagp);

        &nbsp;&nbsp;float nextafter(float x, float y);
        &nbsp;&nbsp;double nextafter(double x, double y);
        &nbsp;&nbsp;long double nextafter(long double x, long double y);
        &nbsp;&nbsp;float nextafterf(float x, float y);
        &nbsp;&nbsp;long double nextafterl(long double x, long double y);

        &nbsp;&nbsp;float nexttoward(float x, long double y);
        &nbsp;&nbsp;double nexttoward(double x, long double y);
        &nbsp;&nbsp;long double nexttoward(long double x, long double y);
        &nbsp;&nbsp;float nexttowardf(float x, long double y);
        &nbsp;&nbsp;long double nexttowardl(long double x, long double y);

        &nbsp;&nbsp;float fdim(float x, float y);
        &nbsp;&nbsp;double fdim(double x, double y);
        &nbsp;&nbsp;long double fdim(long double x, long double y);
        &nbsp;&nbsp;float fdimf(float x, float y);
        &nbsp;&nbsp;long double fdiml(long double x, long double y);

        &nbsp;&nbsp;float fmax(float x, float y);
        &nbsp;&nbsp;double fmax(double x, double y);
        &nbsp;&nbsp;long double fmax(long double x, long double y);
        &nbsp;&nbsp;float fmaxf(float x, float y);
        &nbsp;&nbsp;long double fmaxl(long double x, long double y);

        &nbsp;&nbsp;float fmin(float x, float y);
        &nbsp;&nbsp;double fmin(double x, double y);
        &nbsp;&nbsp;long double fmin(long double x, long double y);
        &nbsp;&nbsp;float fminf(float x, float y);
        &nbsp;&nbsp;long double fminl(long double x, long double y);

        &nbsp;&nbsp;float fma(float x, float y, float z);
        &nbsp;&nbsp;double fma(double x, double y, double z);
        &nbsp;&nbsp;long double fma(long double x, long double y, long double z);
        &nbsp;&nbsp;float fmaf(float x, float y, float z);
        &nbsp;&nbsp;long double fmal(long double x, long double y, long double z);

        &nbsp;&nbsp;// <em>Classification/comparison functions:</em>
        &nbsp;&nbsp;int fpclassify(float x);
        &nbsp;&nbsp;int fpclassify(double x);
        &nbsp;&nbsp;int fpclassify(long double x);

        &nbsp;&nbsp;int isfinite(float x);
        &nbsp;&nbsp;int isfinite(double x);
        &nbsp;&nbsp;int isfinite(long double x);

        &nbsp;&nbsp;int isinf(float x);
        &nbsp;&nbsp;int isinf(double x);
        &nbsp;&nbsp;int isinf(long double x);

        &nbsp;&nbsp;int isnan(float x);
        &nbsp;&nbsp;int isnan(double x);
        &nbsp;&nbsp;int isnan(long double x);

        &nbsp;&nbsp;int isnormal(float x);
        &nbsp;&nbsp;int isnormal(double x);
        &nbsp;&nbsp;int isnormal(long double x);

        &nbsp;&nbsp;int signbit(float x);
        &nbsp;&nbsp;int signbit(double x);
        &nbsp;&nbsp;int signbit(long double x);

        &nbsp;&nbsp;int isgreater(float x, float y);
        &nbsp;&nbsp;int isgreater(double x, double y);
        &nbsp;&nbsp;int isgreater(long double x, long double y);

        &nbsp;&nbsp;int isgreaterequal(float x, float y);
        &nbsp;&nbsp;int isgreaterequal(double x, double y);
        &nbsp;&nbsp;int isgreaterequal(long double x, long double y);

        &nbsp;&nbsp;int isless(float x, float y);
        &nbsp;&nbsp;int isless(double x, double y);
        &nbsp;&nbsp;int isless(long double x, long double y);

        &nbsp;&nbsp;int islessequal(float x, float y);
        &nbsp;&nbsp;int islessequal(double x, double y);
        &nbsp;&nbsp;int islessequal(long double x, long double y);

        &nbsp;&nbsp;int islessgreater(float x, float y);
        &nbsp;&nbsp;int islessgreater(double x, double y);
        &nbsp;&nbsp;int islessgreater(long double x, long double y);

        &nbsp;&nbsp;int isunordered(float x, float y);
        &nbsp;&nbsp;int isunordered(double x, double y);
        &nbsp;&nbsp;int isunordered(long double x, long double y);
        }
      </div>

      <p><ins>1. The meaning of the contents of this header is the same as in 7.20 in the C standard.</ins></p>
    </div>

    <p>Insert a new subsection 26.8.2.</p>

    <div class="insert">
      <h3><ins>26.8.2 Header &lt;cstdlib&gt; synopsis [cstdlib.syn]</ins></h3>

      <div class="code"><!-- "General utilities <stdlib.h>"
-->     namespace std {
        &nbsp;&nbsp;typedef <em>see below</em> size_t;
        &nbsp;&nbsp;typedef <em>see below</em> div_t;
        &nbsp;&nbsp;typedef <em>see below</em> ldiv_t;
        &nbsp;&nbsp;typedef <em>see below</em> lldiv_t;
        }

        #define NULL <em>see below</em>
        #define EXIT_FAILURE <em>see below</em>
        #define EXIT_SUCCESS <em>see below</em>
        #define RAND_MAX <em>see below</em>
        #define MB_CUR_MAX <em>see below</em>

        namespace std {
        &nbsp;&nbsp;double atof(const char* nptr);
        &nbsp;&nbsp;int atoi(const char* nptr);
        &nbsp;&nbsp;long int atol(const char* nptr);
        &nbsp;&nbsp;long long int atoll(const char* nptr);
        &nbsp;&nbsp;double strtod(const char* nptr, char** endptr);
        &nbsp;&nbsp;float strtof(const char* nptr, char** endptr);
        &nbsp;&nbsp;long double strtold(const char* nptr, char** endptr);
        &nbsp;&nbsp;long int strtol(const char* nptr, char** endptr, int base);
        &nbsp;&nbsp;long long int strtoll(const char* nptr, char** endptr, int base);
        &nbsp;&nbsp;unsigned long int strtoul(const char* nptr, char** endptr, int base);
        &nbsp;&nbsp;unsigned long long int strtoull(const char* nptr, char** endptr, int base);
        &nbsp;&nbsp;int rand(void);
        &nbsp;&nbsp;void srand(unsigned int seed);
        &nbsp;&nbsp;void* aligned_alloc(size_t alignment, size_t size);
        &nbsp;&nbsp;void* calloc(size_t nmemb, size_t size);
        &nbsp;&nbsp;void free(void* ptr);
        &nbsp;&nbsp;void* malloc(size_t size);
        &nbsp;&nbsp;void* realloc(void* ptr, size_t size);
        &nbsp;&nbsp;[[noreturn]] void abort(void);
        &nbsp;&nbsp;int atexit(void (*func)(void));
        &nbsp;&nbsp;int at_quick_exit(void (*func)(void));
        &nbsp;&nbsp;[[noreturn]] void exit(int status);
        &nbsp;&nbsp;[[noreturn]] void _Exit(int status);
        &nbsp;&nbsp;char* getenv(const char* name);
        &nbsp;&nbsp;[[noreturn]] void quick_exit(int status);
        &nbsp;&nbsp;int system(const char* string);
        &nbsp;&nbsp;void* bsearch(const void* key, const void* base, size_t nmemb, size_t size, int (*compar)(const void* , const void*));
        &nbsp;&nbsp;void qsort(void* base, size_t nmemb, size_t size, int (*compar)(const void* , const void*));

        &nbsp;&nbsp;int abs(int j);
        &nbsp;&nbsp;long int abs(long int j);
        &nbsp;&nbsp;long long int abs(long long int j);
        &nbsp;&nbsp;long int labs(long int j);
        &nbsp;&nbsp;long long int llabs(long long int j);

        &nbsp;&nbsp;div_t div(int numer, int denom);
        &nbsp;&nbsp;ldiv_t div(long int numer, long int denom);
        &nbsp;&nbsp;lldiv_t div(long long int numer, long long int denom);
        &nbsp;&nbsp;ldiv_t ldiv(long int numer, long int denom);
        &nbsp;&nbsp;lldiv_t lldiv(long long int numer, long long int denom);

        &nbsp;&nbsp;int mblen(const char* s, size_t n);
        &nbsp;&nbsp;int mbtowc(wchar_t* pwc, const char* s, size_t n);
        &nbsp;&nbsp;int wctomb(char* s, wchar_t wchar);
        &nbsp;&nbsp;size_t mbstowcs(wchar_t* pwcs, const char* s, size_t n);
        &nbsp;&nbsp;size_t wcstombs(char* s, const wchar_t* pwcs, size_t n);
        }
      </div>

      <p><ins>1. The meaning of the contents of this header is the same as in 7.12 in the C standard.</ins></p>
    </div>

    <h2 id="wording27">Proposed wording, Clause 27</h2>

    <p>In 27.9.2, delete Tables 133 and 134, and move all paragraphs as described below.
      Insert a new subsection 27.9.2.1.</p>

    <div class="insert">
      <h3>27.9.2.1 Header &lt;cstdio&gt; synopsis [cstdio.syn]</h3>

      <div class="code"><!-- "Input/output <stdio.h>"
-->     namespace std {
        &nbsp;&nbsp;typedef <em>see below</em> size_t;
        &nbsp;&nbsp;typedef <em>see below</em> FILE;
        &nbsp;&nbsp;typedef <em>see below</em> fpos_t;
        }

        #define NULL <em>see below</em>
        #define _IOFBF <em>see below</em>
        #define _IOLBF <em>see below</em>
        #define _IONBF <em>see below</em>
        #define BUFSIZ <em>see below</em>
        #define EOF <em>see below</em>
        #define FOPEN_MAX <em>see below</em>
        #define FILENAME_MAX <em>see below</em>
        #define L_tmpnam <em>see below</em>
        #define SEEK_CUR <em>see below</em>
        #define SEEK_END <em>see below</em>
        #define SEEK_SET <em>see below</em>
        #define TMP_MAX <em>see below</em>
        #define stderr <em>see below</em>
        #define stdin <em>see below</em>
        #define stdout <em>see below</em>

        namespace {
        &nbsp;&nbsp;int remove(const char* filename);
        &nbsp;&nbsp;int rename(const char* old, const char* new);
        &nbsp;&nbsp;FILE* tmpfile(void);
        &nbsp;&nbsp;char* tmpnam(char* s);
        &nbsp;&nbsp;int fclose(FILE* stream);
        &nbsp;&nbsp;int fflush(FILE* stream);
        &nbsp;&nbsp;FILE* fopen(const char* filename, const char* mode);
        &nbsp;&nbsp;FILE* freopen(const char* filename, const char* mode, FILE* stream);
        &nbsp;&nbsp;void setbuf(FILE* stream, char* buf);
        &nbsp;&nbsp;int setvbuf(FILE* stream, char* buf, int mode, size_t size);
        &nbsp;&nbsp;int fprintf(FILE* stream, const char* format, ...);
        &nbsp;&nbsp;int fscanf(FILE* stream, const char* format, ...);
        &nbsp;&nbsp;int printf(const char* format, ...);
        &nbsp;&nbsp;int scanf(const char* format, ...);
        &nbsp;&nbsp;int snprintf(char* s, size_t n, const char* format, ...);
        &nbsp;&nbsp;int sprintf(char* s, const char* format, ...);
        &nbsp;&nbsp;int sscanf(const char* s, const char* format, ...);
        &nbsp;&nbsp;int vfprintf(FILE* stream, const char* format, va_list arg);
        &nbsp;&nbsp;int vfscanf(FILE* stream, const char* format, va_list arg);
        &nbsp;&nbsp;int vprintf(const char* format, va_list arg);
        &nbsp;&nbsp;int vscanf(const char* format, va_list arg);
        &nbsp;&nbsp;int vsnprintf(char* s, size_t n, const char* format, va_list arg);
        &nbsp;&nbsp;int vsprintf(char* s, const char* format, va_list arg);
        &nbsp;&nbsp;int vsscanf(const char* s, const char* format, va_list arg);
        &nbsp;&nbsp;int fgetc(FILE* stream);
        &nbsp;&nbsp;char* fgets(char* s, int n, FILE* stream);
        &nbsp;&nbsp;int fputc(int c, FILE* stream);
        &nbsp;&nbsp;int fputs(const char* s, FILE* stream);
        &nbsp;&nbsp;int getc(FILE* stream);
        &nbsp;&nbsp;int getchar(void);
        &nbsp;&nbsp;int putc(int c, FILE* stream);
        &nbsp;&nbsp;int putchar(int c);
        &nbsp;&nbsp;int puts(const char* s);
        &nbsp;&nbsp;int ungetc(int c, FILE* stream);
        &nbsp;&nbsp;size_t fread(void* ptr, size_t size, size_t nmemb, FILE* stream);
        &nbsp;&nbsp;size_t fwrite(const void* ptr, size_t size, size_t nmemb, FILE* stream);
        &nbsp;&nbsp;int fgetpos(FILE* stream, fpos_t* pos);
        &nbsp;&nbsp;int fseek(FILE* stream, long int offset, int whence);
        &nbsp;&nbsp;int fsetpos(FILE* stream, const fpos_t* pos);
        &nbsp;&nbsp;long int ftell(FILE* stream);
        &nbsp;&nbsp;void rewind(FILE* stream);
        &nbsp;&nbsp;void clearerr(FILE* stream);
        &nbsp;&nbsp;int feof(FILE* stream);
        &nbsp;&nbsp;int ferror(FILE* stream);
        &nbsp;&nbsp;void perror(const char* s);
        }
      </div>
    </div>

    <p>Move the former paragraph 1 of 27.9.2 into this subsection with the following change.</p>

    <div class="modify">
      <p><del>Table 133 describes header <code>&lt;cstdio&gt;</code>.</del><ins>The meaning
        of the content of this header is the same as in 7.19 in the C standard.</ins>
        [<em>Note</em>: C++ does not define the function <code>gets</code>. &ndash; <em>end note</em>]</p>
    </div>

    <p>Move the former paragraph 2 of 27.9.2 into this subsection. Strike the &ldquo;see also&rdquo;. Insert a new subsection 27.9.2.2.</p>

    <div class="insert">
      <h3>27.9.2.2 Header &lt;cinttypes&gt; synopsis [cinttypes.syn]</h3>

      <div class="code"><!-- "Format conversion of integer types <inttypes.h>"
-->     namespace std {
        &nbsp;&nbsp;typedef <em>see below</em> imaxdiv_t;
        }

        #define PRId<em>N</em> <em>see below</em>
        #define PRIi<em>N</em> <em>see below</em>
        #define PRIo<em>N</em> <em>see below</em>
        #define PRIu<em>N</em> <em>see below</em>
        #define PRIx<em>N</em> <em>see below</em>
        #define PRIX<em>N</em> <em>see below</em>
        #define SCNd<em>N</em> <em>see below</em>
        #define SCNi<em>N</em> <em>see below</em>
        #define SCNo<em>N</em> <em>see below</em>
        #define SCNu<em>N</em> <em>see below</em>
        #define SCNx<em>N</em> <em>see below</em>

        #define PRIdLEAST<em>N</em> <em>see below</em>
        #define PRIiLEAST<em>N</em> <em>see below</em>
        #define PRIoLEAST<em>N</em> <em>see below</em>
        #define PRIuLEAST<em>N</em> <em>see below</em>
        #define PRIxLEAST<em>N</em> <em>see below</em>
        #define PRIXLEAST<em>N</em> <em>see below</em>
        #define SCNdLEAST<em>N</em> <em>see below</em>
        #define SCNiLEAST<em>N</em> <em>see below</em>
        #define SCNoLEAST<em>N</em> <em>see below</em>
        #define SCNuLEAST<em>N</em> <em>see below</em>
        #define SCNxLEAST<em>N</em> <em>see below</em>

        #define PRIdFAST<em>N</em> <em>see below</em>
        #define PRIiFAST<em>N</em> <em>see below</em>
        #define PRIoFAST<em>N</em> <em>see below</em>
        #define PRIuFAST<em>N</em> <em>see below</em>
        #define PRIxFAST<em>N</em> <em>see below</em>
        #define PRIXFAST<em>N</em> <em>see below</em>
        #define SCNdFAST<em>N</em> <em>see below</em>
        #define SCNiFAST<em>N</em> <em>see below</em>
        #define SCNoFAST<em>N</em> <em>see below</em>
        #define SCNuFAST<em>N</em> <em>see below</em>
        #define SCNxFAST<em>N</em> <em>see below</em>

        #define PRIdMAX <em>see below</em>
        #define PRIiMAX <em>see below</em>
        #define PRIoMAX <em>see below</em>
        #define PRIuMAX <em>see below</em>
        #define PRIxMAX <em>see below</em>
        #define PRIXMAX <em>see below</em>
        #define SCNdMAX <em>see below</em>
        #define SCNiMAX <em>see below</em>
        #define SCNoMAX <em>see below</em>
        #define SCNuMAX <em>see below</em>
        #define SCNxMAX <em>see below</em>

        #define PRIdPTR <em>see below</em>
        #define PRIiPTR <em>see below</em>
        #define PRIoPTR <em>see below</em>
        #define PRIuPTR <em>see below</em>
        #define PRIxPTR <em>see below</em>
        #define PRIXPTR <em>see below</em>
        #define SCNdPTR <em>see below</em>
        #define SCNiPTR <em>see below</em>
        #define SCNoPTR <em>see below</em>
        #define SCNuPTR <em>see below</em>
        #define SCNxPTR <em>see below</em>

        namespace std {
        &nbsp;&nbsp;intmax_t imaxabs(intmax_t j);
        &nbsp;&nbsp;imaxdiv_t imaxdiv(intmax_t numer, intmax_t denom);
        &nbsp;&nbsp;intmax_t strtoimax(const char* nptr, char** endptr, int base);
        &nbsp;&nbsp;uintmax_t strtoumax(const char* nptr, char** endptr, int base);
        &nbsp;&nbsp;intmax_t wcstoimax(const wchar_t* nptr, wchar_t** endptr, int base);
        &nbsp;&nbsp;uintmax_t wcstoumax(const wchar_t* nptr, wchar_t** endptr, int base);
        }
      </div>
    </div>

    <p>Move the former paragraph 3 of 27.9.2 to the new subsection with the following changes.</p>

    <div class="modify">
      <p><del>Table 134 describes header <code>&lt;cinttypes&gt;</code>.</del> [<em>Note</em>: [...]</p>
    </div>

    <p>Move the former paragraph 4 of 27.9.2 to the new subsection.</p>

    <p>Update references of the form &ldquo;<code>&lt;cstdio&gt;</code> (27.9.2)&rdquo; to say &ldquo;27.9.2.1&rdquo;
      in the following places: 27.4.1p1, 27.4.2p3,4,6, 27.4.3p3,4,6, 27.5.3.1.6p1, 27.9.1p2, Footnote 332. Add the
      missing reference to 27.4.2p1 and 27.4.3p1.</p>

  </body>
</html>
